:: CQC_SIM1 semantic presentation

theorem Th1: :: CQC_SIM1:1
for x, y being set
for f being Function holds (f +* ({x} --> y)) .: {x} = {y}
proof end;

theorem Th2: :: CQC_SIM1:2
for K, L, x, y being set
for f being Function holds (f +* (L --> y)) .: K c= (f .: K) \/ {y}
proof end;

theorem Th3: :: CQC_SIM1:3
for x, y being set
for g being Function
for A being set holds (g +* ({x} --> y)) .: (A \ {x}) = g .: (A \ {x})
proof end;

theorem Th4: :: CQC_SIM1:4
for x, y being set
for g being Function
for A being set st not y in g .: (A \ {x}) holds
(g +* ({x} --> y)) .: (A \ {x}) = ((g +* ({x} --> y)) .: A) \ {y}
proof end;

theorem Th5: :: CQC_SIM1:5
for p being Element of CQC-WFF st p is atomic holds
ex k being Element of NAT ex P being QC-pred_symbol of k ex ll being CQC-variable_list of k st p = P ! ll
proof end;

theorem Th6: :: CQC_SIM1:6
for p being Element of CQC-WFF st p is negative holds
ex q being Element of CQC-WFF st p = 'not' q
proof end;

theorem Th7: :: CQC_SIM1:7
for p being Element of CQC-WFF st p is conjunctive holds
ex q, r being Element of CQC-WFF st p = q '&' r
proof end;

theorem Th8: :: CQC_SIM1:8
for p being Element of CQC-WFF st p is universal holds
ex x being Element of bound_QC-variables ex q being Element of CQC-WFF st p = All x,q
proof end;

theorem Th9: :: CQC_SIM1:9
for l being FinSequence holds rng l = { (l . i) where i is Element of NAT : ( 1 <= i & i <= len l ) }
proof end;

scheme :: CQC_SIM1:sch 59
s59{ F1() -> non empty set , F2() -> Element of F1(), F3( set ) -> Element of F1(), F4( set , set ) -> Element of F1(), F5( set , set , set ) -> Element of F1(), F6( set , set ) -> Element of F1() } :
ex F being Function of QC-WFF ,F1() st
( F . VERUM = F2() & ( for p being Element of QC-WFF holds
( ( p is atomic implies F . p = F3(p) ) & ( p is negative implies F . p = F4((F . (the_argument_of p)),p) ) & ( p is conjunctive implies F . p = F5((F . (the_left_argument_of p)),(F . (the_right_argument_of p)),p) ) & ( p is universal implies F . p = F6((F . (the_scope_of p)),p) ) ) ) )
proof end;

scheme :: CQC_SIM1:sch 146
s146{ F1() -> non empty set , F2() -> non empty set , F3() -> Element of Funcs F1(),F2(), F4( set , set , set ) -> Element of Funcs F1(),F2(), F5( set , set ) -> Element of Funcs F1(),F2(), F6( set , set , set , set ) -> Element of Funcs F1(),F2(), F7( set , set , set ) -> Element of Funcs F1(),F2() } :
ex F being Function of CQC-WFF , Funcs F1(),F2() st
( F . VERUM = F3() & ( for k being Element of NAT
for l being CQC-variable_list of k
for P being QC-pred_symbol of k holds F . (P ! l) = F4(k,P,l) ) & ( for r, s being Element of CQC-WFF
for x being Element of bound_QC-variables holds
( F . ('not' r) = F5((F . r),r) & F . (r '&' s) = F6((F . r),(F . s),r,s) & F . (All x,r) = F7(x,(F . r),r) ) ) )
proof end;

scheme :: CQC_SIM1:sch 151
s151{ F1() -> non empty set , F2() -> non empty set , F3() -> Function of CQC-WFF , Funcs F1(),F2(), F4() -> Function of CQC-WFF , Funcs F1(),F2(), F5() -> Function of F1(),F2(), F6( set , set , set ) -> Function of F1(),F2(), F7( set , set ) -> Function of F1(),F2(), F8( set , set , set , set ) -> Function of F1(),F2(), F9( set , set , set ) -> Function of F1(),F2() } :
F3() = F4()
provided
E28: F3() . VERUM = F5() and
E29: for k being Element of NAT
for ll being CQC-variable_list of k
for P being QC-pred_symbol of k holds F3() . (P ! ll) = F6(k,P,ll) and
E33: for r, s being Element of CQC-WFF
for x being Element of bound_QC-variables holds
( F3() . ('not' r) = F7((F3() . r),r) & F3() . (r '&' s) = F8((F3() . r),(F3() . s),r,s) & F3() . (All x,r) = F9(x,(F3() . r),r) ) and
E38: F4() . VERUM = F5() and
E39: for k being Element of NAT
for ll being CQC-variable_list of k
for P being QC-pred_symbol of k holds F4() . (P ! ll) = F6(k,P,ll) and
E40: for r, s being Element of CQC-WFF
for x being Element of bound_QC-variables holds
( F4() . ('not' r) = F7((F4() . r),r) & F4() . (r '&' s) = F8((F4() . r),(F4() . s),r,s) & F4() . (All x,r) = F9(x,(F4() . r),r) )
proof end;

theorem Th10: :: CQC_SIM1:10
for p being Element of CQC-WFF holds p is_subformula_of 'not' p
proof end;

theorem Th11: :: CQC_SIM1:11
for p, q being Element of CQC-WFF holds
( p is_subformula_of p '&' q & q is_subformula_of p '&' q )
proof end;

theorem Th12: :: CQC_SIM1:12
for p being Element of CQC-WFF
for x being Element of bound_QC-variables holds p is_subformula_of All x,p
proof end;

theorem Th13: :: CQC_SIM1:13
for k being Element of NAT
for l being CQC-variable_list of k
for i being Element of NAT st 1 <= i & i <= len l holds
l . i in bound_QC-variables
proof end;

definition
let D be non empty set ;
let f be Function of D, CQC-WFF ;
func NEGATIVE c2 -> Element of Funcs a1,CQC-WFF means :Def1: :: CQC_SIM1:def 1
for a being Element of D
for p being Element of CQC-WFF st p = f . a holds
it . a = 'not' p;
existence
ex b1 being Element of Funcs D,CQC-WFF st
for a being Element of D
for p being Element of CQC-WFF st p = f . a holds
b1 . a = 'not' p
proof end;
uniqueness
for b1, b2 being Element of Funcs D,CQC-WFF st ( for a being Element of D
for p being Element of CQC-WFF st p = f . a holds
b1 . a = 'not' p ) & ( for a being Element of D
for p being Element of CQC-WFF st p = f . a holds
b2 . a = 'not' p ) holds
b1 = b2
proof end;
end;

:: deftheorem Def1 defines NEGATIVE CQC_SIM1:def 1 :
for D being non empty set
for f being Function of D, CQC-WFF
for b3 being Element of Funcs D,CQC-WFF holds
( b3 = NEGATIVE f iff for a being Element of D
for p being Element of CQC-WFF st p = f . a holds
b3 . a = 'not' p );

definition
let f be Function of [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):], CQC-WFF , g be Function of [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):], CQC-WFF ;
let n be Element of NAT ;
func CON c1,c2,c3 -> Element of Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF means :Def2: :: CQC_SIM1:def 2
for k being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables
for p, q being Element of CQC-WFF st p = f . k,h & q = g . (k + n),h holds
it . k,h = p '&' q;
existence
ex b1 being Element of Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF st
for k being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables
for p, q being Element of CQC-WFF st p = f . k,h & q = g . (k + n),h holds
b1 . k,h = p '&' q
proof end;
uniqueness
for b1, b2 being Element of Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF st ( for k being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables
for p, q being Element of CQC-WFF st p = f . k,h & q = g . (k + n),h holds
b1 . k,h = p '&' q ) & ( for k being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables
for p, q being Element of CQC-WFF st p = f . k,h & q = g . (k + n),h holds
b2 . k,h = p '&' q ) holds
b1 = b2
proof end;
end;

:: deftheorem Def2 defines CON CQC_SIM1:def 2 :
for f, g being Function of [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):], CQC-WFF
for n being Element of NAT
for b4 being Element of Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF holds
( b4 = CON f,g,n iff for k being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables
for p, q being Element of CQC-WFF st p = f . k,h & q = g . (k + n),h holds
b4 . k,h = p '&' q );

Lemma162: for x being Element of bound_QC-variables
for k being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables holds h +* ({x} --> (x. k)) is Function of bound_QC-variables , bound_QC-variables
proof end;

definition
let f be Function of [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):], CQC-WFF ;
let x be bound_QC-variable;
func UNIVERSAL c2,c1 -> Element of Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF means :Def3: :: CQC_SIM1:def 3
for k being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables
for p being Element of CQC-WFF st p = f . (k + 1),(h +* ({x} --> (x. k))) holds
it . k,h = All (x. k),p;
existence
ex b1 being Element of Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF st
for k being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables
for p being Element of CQC-WFF st p = f . (k + 1),(h +* ({x} --> (x. k))) holds
b1 . k,h = All (x. k),p
proof end;
uniqueness
for b1, b2 being Element of Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF st ( for k being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables
for p being Element of CQC-WFF st p = f . (k + 1),(h +* ({x} --> (x. k))) holds
b1 . k,h = All (x. k),p ) & ( for k being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables
for p being Element of CQC-WFF st p = f . (k + 1),(h +* ({x} --> (x. k))) holds
b2 . k,h = All (x. k),p ) holds
b1 = b2
proof end;
end;

:: deftheorem Def3 defines UNIVERSAL CQC_SIM1:def 3 :
for f being Function of [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):], CQC-WFF
for x being bound_QC-variable
for b3 being Element of Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF holds
( b3 = UNIVERSAL x,f iff for k being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables
for p being Element of CQC-WFF st p = f . (k + 1),(h +* ({x} --> (x. k))) holds
b3 . k,h = All (x. k),p );

Lemma165: for k being Element of NAT
for f being FinSequence of bound_QC-variables st len f = k holds
f is CQC-variable_list of k
proof end;

Lemma166: for k being Element of NAT
for f being CQC-variable_list of k holds f is FinSequence of bound_QC-variables
proof end;

definition
let k be Element of NAT ;
let l be CQC-variable_list of k;
let f be Element of Funcs bound_QC-variables ,bound_QC-variables ;
redefine func * as c3 * c2 -> CQC-variable_list of a1;
coherence
l * f is CQC-variable_list of k
proof end;
end;

definition
let k be Element of NAT ;
let P be QC-pred_symbol of k;
let l be CQC-variable_list of k;
func ATOMIC c2,c3 -> Element of Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF means :Def4: :: CQC_SIM1:def 4
for n being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables holds it . n,h = P ! (h * l);
existence
ex b1 being Element of Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF st
for n being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables holds b1 . n,h = P ! (h * l)
proof end;
uniqueness
for b1, b2 being Element of Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF st ( for n being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables holds b1 . n,h = P ! (h * l) ) & ( for n being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables holds b2 . n,h = P ! (h * l) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def4 defines ATOMIC CQC_SIM1:def 4 :
for k being Element of NAT
for P being QC-pred_symbol of k
for l being CQC-variable_list of k
for b4 being Element of Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF holds
( b4 = ATOMIC P,l iff for n being Element of NAT
for h being Element of Funcs bound_QC-variables ,bound_QC-variables holds b4 . n,h = P ! (h * l) );

deffunc H1( set , set , set ) -> Element of NAT = 0;

deffunc H2( Element of NAT ) -> Element of NAT = a1;

deffunc H3( Element of NAT , Element of NAT ) -> Element of NAT = a1 + a2;

deffunc H4( set , Element of NAT ) -> Element of NAT = a2 + 1;

definition
let p be Element of CQC-WFF ;
func QuantNbr c1 -> Element of NAT means :Def5: :: CQC_SIM1:def 5
ex F being Function of CQC-WFF , NAT st
( it = F . p & F . VERUM = 0 & ( for r, s being Element of CQC-WFF
for x being Element of bound_QC-variables
for k being Element of NAT
for l being CQC-variable_list of k
for P being QC-pred_symbol of k holds
( F . (P ! l) = 0 & F . ('not' r) = F . r & F . (r '&' s) = (F . r) + (F . s) & F . (All x,r) = (F . r) + 1 ) ) );
correctness
existence
ex b1 being Element of NAT ex F being Function of CQC-WFF , NAT st
( b1 = F . p & F . VERUM = 0 & ( for r, s being Element of CQC-WFF
for x being Element of bound_QC-variables
for k being Element of NAT
for l being CQC-variable_list of k
for P being QC-pred_symbol of k holds
( F . (P ! l) = 0 & F . ('not' r) = F . r & F . (r '&' s) = (F . r) + (F . s) & F . (All x,r) = (F . r) + 1 ) ) )
;
uniqueness
for b1, b2 being Element of NAT st ex F being Function of CQC-WFF , NAT st
( b1 = F . p & F . VERUM = 0 & ( for r, s being Element of CQC-WFF
for x being Element of bound_QC-variables
for k being Element of NAT
for l being CQC-variable_list of k
for P being QC-pred_symbol of k holds
( F . (P ! l) = 0 & F . ('not' r) = F . r & F . (r '&' s) = (F . r) + (F . s) & F . (All x,r) = (F . r) + 1 ) ) ) & ex F being Function of CQC-WFF , NAT st
( b2 = F . p & F . VERUM = 0 & ( for r, s being Element of CQC-WFF
for x being Element of bound_QC-variables
for k being Element of NAT
for l being CQC-variable_list of k
for P being QC-pred_symbol of k holds
( F . (P ! l) = 0 & F . ('not' r) = F . r & F . (r '&' s) = (F . r) + (F . s) & F . (All x,r) = (F . r) + 1 ) ) ) holds
b1 = b2
;
proof end;
end;

:: deftheorem Def5 defines QuantNbr CQC_SIM1:def 5 :
for p being Element of CQC-WFF
for b2 being Element of NAT holds
( b2 = QuantNbr p iff ex F being Function of CQC-WFF , NAT st
( b2 = F . p & F . VERUM = 0 & ( for r, s being Element of CQC-WFF
for x being Element of bound_QC-variables
for k being Element of NAT
for l being CQC-variable_list of k
for P being QC-pred_symbol of k holds
( F . (P ! l) = 0 & F . ('not' r) = F . r & F . (r '&' s) = (F . r) + (F . s) & F . (All x,r) = (F . r) + 1 ) ) ) );

definition
let f be Function of CQC-WFF , Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF ;
let x be Element of CQC-WFF ;
redefine func . as c1 . c2 -> Element of Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF ;
coherence
f . x is Element of Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF
proof end;
end;

definition
func SepFunc -> Function of CQC-WFF , Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF means :Def6: :: CQC_SIM1:def 6
( it . VERUM = [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):] --> VERUM & ( for k being Element of NAT
for l being CQC-variable_list of k
for P being QC-pred_symbol of k holds it . (P ! l) = ATOMIC P,l ) & ( for r, s being Element of CQC-WFF
for x being Element of bound_QC-variables holds
( it . ('not' r) = NEGATIVE (it . r) & it . (r '&' s) = CON (it . r),(it . s),(QuantNbr r) & it . (All x,r) = UNIVERSAL x,(it . r) ) ) );
existence
ex b1 being Function of CQC-WFF , Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF st
( b1 . VERUM = [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):] --> VERUM & ( for k being Element of NAT
for l being CQC-variable_list of k
for P being QC-pred_symbol of k holds b1 . (P ! l) = ATOMIC P,l ) & ( for r, s being Element of CQC-WFF
for x being Element of bound_QC-variables holds
( b1 . ('not' r) = NEGATIVE (b1 . r) & b1 . (r '&' s) = CON (b1 . r),(b1 . s),(QuantNbr r) & b1 . (All x,r) = UNIVERSAL x,(b1 . r) ) ) )
proof end;
uniqueness
for b1, b2 being Function of CQC-WFF , Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF st b1 . VERUM = [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):] --> VERUM & ( for k being Element of NAT
for l being CQC-variable_list of k
for P being QC-pred_symbol of k holds b1 . (P ! l) = ATOMIC P,l ) & ( for r, s being Element of CQC-WFF
for x being Element of bound_QC-variables holds
( b1 . ('not' r) = NEGATIVE (b1 . r) & b1 . (r '&' s) = CON (b1 . r),(b1 . s),(QuantNbr r) & b1 . (All x,r) = UNIVERSAL x,(b1 . r) ) ) & b2 . VERUM = [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):] --> VERUM & ( for k being Element of NAT
for l being CQC-variable_list of k
for P being QC-pred_symbol of k holds b2 . (P ! l) = ATOMIC P,l ) & ( for r, s being Element of CQC-WFF
for x being Element of bound_QC-variables holds
( b2 . ('not' r) = NEGATIVE (b2 . r) & b2 . (r '&' s) = CON (b2 . r),(b2 . s),(QuantNbr r) & b2 . (All x,r) = UNIVERSAL x,(b2 . r) ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def6 defines SepFunc CQC_SIM1:def 6 :
for b1 being Function of CQC-WFF , Funcs [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):],CQC-WFF holds
( b1 = SepFunc iff ( b1 . VERUM = [:NAT ,(Funcs bound_QC-variables ,bound_QC-variables ):] --> VERUM & ( for k being Element of NAT
for l being CQC-variable_list of k
for P being QC-pred_symbol of k holds b1 . (P ! l) = ATOMIC P,l ) & ( for r, s being Element of CQC-WFF
for x being Element of bound_QC-variables holds
( b1 . ('not' r) = NEGATIVE (b1 . r) & b1 . (r '&' s) = CON (b1 . r),(b1 . s),(QuantNbr r) & b1 . (All x,r) = UNIVERSAL x,(b1 . r) ) ) ) );

definition
let p be Element of CQC-WFF ;
let k be Element of NAT ;
let f be Element of Funcs bound_QC-variables ,bound_QC-variables ;
func SepFunc c1,c2,c3 -> Element of CQC-WFF equals :: CQC_SIM1:def 7
(SepFunc . p) . [k,f];
correctness
coherence
(SepFunc . p) . [k,f] is Element of CQC-WFF
;
;
end;

:: deftheorem Def7 defines SepFunc CQC_SIM1:def 7 :
for p being Element of CQC-WFF
for k being Element of NAT
for f being Element of Funcs bound_QC-variables ,bound_QC-variables holds SepFunc p,k,f = (SepFunc . p) . [k,f];

deffunc H5( Element of CQC-WFF ) -> Element of NAT = QuantNbr a1;

theorem Th14: :: CQC_SIM1:14
QuantNbr VERUM = 0
proof end;

theorem Th15: :: CQC_SIM1:15
for k being Element of NAT
for ll being CQC-variable_list of k
for P being QC-pred_symbol of k holds QuantNbr (P ! ll) = 0
proof end;

theorem Th16: :: CQC_SIM1:16
for p being Element of CQC-WFF holds QuantNbr ('not' p) = QuantNbr p
proof end;

theorem Th17: :: CQC_SIM1:17
for p, q being Element of CQC-WFF holds QuantNbr (p '&' q) = (QuantNbr p) + (QuantNbr q)
proof end;

theorem Th18: :: CQC_SIM1:18
for p being Element of CQC-WFF
for x being Element of bound_QC-variables holds QuantNbr (All x,p) = (QuantNbr p) + 1
proof end;

definition
let A be non empty Subset of NAT ;
func min c1 -> Element of NAT means :Def8: :: CQC_SIM1:def 8
( it in A & ( for k being Element of NAT st k in A holds
it <= k ) );
existence
ex b1 being Element of NAT st
( b1 in A & ( for k being Element of NAT st k in A holds
b1 <= k ) )
proof end;
uniqueness
for b1, b2 being Element of NAT st b1 in A & ( for k being Element of NAT st k in A holds
b1 <= k ) & b2 in A & ( for k being Element of NAT st k in A holds
b2 <= k ) holds
b1 = b2
proof end;
end;

:: deftheorem Def8 defines min CQC_SIM1:def 8 :
for A being non empty Subset of NAT
for b2 being Element of NAT holds
( b2 = min A iff ( b2 in A & ( for k being Element of NAT st k in A holds
b2 <= k ) ) );

theorem Th19: :: CQC_SIM1:19
for A, B being non empty Subset of NAT st A c= B holds
min B <= min A
proof end;

theorem Th20: :: CQC_SIM1:20
for p being Element of QC-WFF holds still_not-bound_in p is finite
proof end;

scheme :: CQC_SIM1:sch 178
s178{ F1() -> non empty set , F2() -> set , P1[ set , set ] } :
ex x being Element of F1() st
( x in F2() & ( for y being Element of F1() st y in F2() holds
P1[x,y] ) )
provided
E28: ( F2() is finite & F2() <> {} & F2() c= F1() ) and
E29: for x, y being Element of F1() holds
( P1[x,y] or P1[y,x] ) and
E33: for x, y, z being Element of F1() st P1[x,y] & P1[y,z] holds
P1[x,z]
proof end;

definition
let p be Element of CQC-WFF ;
func NBI c1 -> Subset of NAT equals :: CQC_SIM1:def 9
{ k where k is Element of NAT : for i being Element of NAT st k <= i holds
not x. i in still_not-bound_in p
}
;
coherence
{ k where k is Element of NAT : for i being Element of NAT st k <= i holds
not x. i in still_not-bound_in p
}
is Subset of NAT
proof end;
end;

:: deftheorem Def9 defines NBI CQC_SIM1:def 9 :
for p being Element of CQC-WFF holds NBI p = { k where k is Element of NAT : for i being Element of NAT st k <= i holds
not x. i in still_not-bound_in p
}
;

registration
let p be Element of CQC-WFF ;
cluster NBI a1 -> non empty ;
coherence
not NBI p is empty
proof end;
end;

definition
let p be Element of CQC-WFF ;
func index c1 -> Element of NAT equals :: CQC_SIM1:def 10
min (NBI p);
coherence
min (NBI p) is Element of NAT
;
end;

:: deftheorem Def10 defines index CQC_SIM1:def 10 :
for p being Element of CQC-WFF holds index p = min (NBI p);

theorem Th21: :: CQC_SIM1:21
for p being Element of CQC-WFF holds
( index p = 0 iff p is closed )
proof end;

theorem Th22: :: CQC_SIM1:22
for p being Element of CQC-WFF
for i being Element of NAT st x. i in still_not-bound_in p holds
i < index p
proof end;

theorem Th23: :: CQC_SIM1:23
index VERUM = 0 by , QC_LANG3:24;

theorem Th24: :: CQC_SIM1:24
for p being Element of CQC-WFF holds index ('not' p) = index p
proof end;

theorem Th25: :: CQC_SIM1:25
for p, q being Element of CQC-WFF holds
( index p <= index (p '&' q) & index q <= index (p '&' q) )
proof end;

definition
let X be non empty set ;
redefine func id as id c1 -> Element of Funcs a1,a1;
coherence
id X is Element of Funcs X,X
proof end;
end;

definition
let p be Element of CQC-WFF ;
func SepVar c1 -> Element of CQC-WFF equals :: CQC_SIM1:def 11
SepFunc p,(index p),(id bound_QC-variables );
coherence
SepFunc p,(index p),(id bound_QC-variables ) is Element of CQC-WFF
;
end;

:: deftheorem Def11 defines SepVar CQC_SIM1:def 11 :
for p being Element of CQC-WFF holds SepVar p = SepFunc p,(index p),(id bound_QC-variables );

theorem Th26: :: CQC_SIM1:26
SepVar VERUM = VERUM
proof end;

scheme :: CQC_SIM1:sch 186
s186{ P1[ set ] } :
for r being Element of CQC-WFF holds P1[r]
provided
E28: P1[ VERUM ] and
E29: for k being Element of NAT
for l being CQC-variable_list of k
for P being QC-pred_symbol of k holds P1[P ! l] and
E33: for r being Element of CQC-WFF st P1[r] holds
P1[ 'not' r] and
E38: for r, s being Element of CQC-WFF st P1[r] & P1[s] holds
P1[r '&' s] and
E39: for r being Element of CQC-WFF
for x being Element of bound_QC-variables st P1[r] holds
P1[ All x,r]
proof end;

theorem Th27: :: CQC_SIM1:27
for k being Element of NAT
for ll being CQC-variable_list of k
for P being QC-pred_symbol of k holds SepVar (P ! ll) = P ! ll
proof end;

theorem Th28: :: CQC_SIM1:28
for p being Element of CQC-WFF st p is atomic holds
SepVar p = p
proof end;

theorem Th29: :: CQC_SIM1:29
for p being Element of CQC-WFF holds SepVar ('not' p) = 'not' (SepVar p)
proof end;

theorem Th30: :: CQC_SIM1:30
for p, q being Element of CQC-WFF st p is negative & q = the_argument_of p holds
SepVar p = 'not' (SepVar q)
proof end;

definition
let p be Element of CQC-WFF ;
let X be Subset of [:CQC-WFF ,NAT ,(Fin bound_QC-variables ),(Funcs bound_QC-variables ,bound_QC-variables ):];
pred c2 is_Sep-closed_on c1 means :Def12: :: CQC_SIM1:def 12
( [p,(index p),({}. bound_QC-variables ),(id bound_QC-variables )] in X & ( for q being Element of CQC-WFF
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [('not' q),k,K,f] in X holds
[q,k,K,f] in X ) & ( for q, r being Element of CQC-WFF
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [(q '&' r),k,K,f] in X holds
( [q,k,K,f] in X & [r,(k + (QuantNbr q)),K,f] in X ) ) & ( for q being Element of CQC-WFF
for x being Element of bound_QC-variables
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [(All x,q),k,K,f] in X holds
[q,(k + 1),(K \/ {x}),(f +* ({x} --> (x. k)))] in X ) );
end;

:: deftheorem Def12 defines is_Sep-closed_on CQC_SIM1:def 12 :
for p being Element of CQC-WFF
for X being Subset of [:CQC-WFF ,NAT ,(Fin bound_QC-variables ),(Funcs bound_QC-variables ,bound_QC-variables ):] holds
( X is_Sep-closed_on p iff ( [p,(index p),({}. bound_QC-variables ),(id bound_QC-variables )] in X & ( for q being Element of CQC-WFF
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [('not' q),k,K,f] in X holds
[q,k,K,f] in X ) & ( for q, r being Element of CQC-WFF
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [(q '&' r),k,K,f] in X holds
( [q,k,K,f] in X & [r,(k + (QuantNbr q)),K,f] in X ) ) & ( for q being Element of CQC-WFF
for x being Element of bound_QC-variables
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [(All x,q),k,K,f] in X holds
[q,(k + 1),(K \/ {x}),(f +* ({x} --> (x. k)))] in X ) ) );

definition
let p be Element of CQC-WFF ;
func SepQuadruples c1 -> Subset of [:CQC-WFF ,NAT ,(Fin bound_QC-variables ),(Funcs bound_QC-variables ,bound_QC-variables ):] means :Def13: :: CQC_SIM1:def 13
( it is_Sep-closed_on p & ( for D being Subset of [:CQC-WFF ,NAT ,(Fin bound_QC-variables ),(Funcs bound_QC-variables ,bound_QC-variables ):] st D is_Sep-closed_on p holds
it c= D ) );
existence
ex b1 being Subset of [:CQC-WFF ,NAT ,(Fin bound_QC-variables ),(Funcs bound_QC-variables ,bound_QC-variables ):] st
( b1 is_Sep-closed_on p & ( for D being Subset of [:CQC-WFF ,NAT ,(Fin bound_QC-variables ),(Funcs bound_QC-variables ,bound_QC-variables ):] st D is_Sep-closed_on p holds
b1 c= D ) )
proof end;
uniqueness
for b1, b2 being Subset of [:CQC-WFF ,NAT ,(Fin bound_QC-variables ),(Funcs bound_QC-variables ,bound_QC-variables ):] st b1 is_Sep-closed_on p & ( for D being Subset of [:CQC-WFF ,NAT ,(Fin bound_QC-variables ),(Funcs bound_QC-variables ,bound_QC-variables ):] st D is_Sep-closed_on p holds
b1 c= D ) & b2 is_Sep-closed_on p & ( for D being Subset of [:CQC-WFF ,NAT ,(Fin bound_QC-variables ),(Funcs bound_QC-variables ,bound_QC-variables ):] st D is_Sep-closed_on p holds
b2 c= D ) holds
b1 = b2
proof end;
end;

:: deftheorem Def13 defines SepQuadruples CQC_SIM1:def 13 :
for p being Element of CQC-WFF
for b2 being Subset of [:CQC-WFF ,NAT ,(Fin bound_QC-variables ),(Funcs bound_QC-variables ,bound_QC-variables ):] holds
( b2 = SepQuadruples p iff ( b2 is_Sep-closed_on p & ( for D being Subset of [:CQC-WFF ,NAT ,(Fin bound_QC-variables ),(Funcs bound_QC-variables ,bound_QC-variables ):] st D is_Sep-closed_on p holds
b2 c= D ) ) );

theorem Th31: :: CQC_SIM1:31
for p being Element of CQC-WFF holds [p,(index p),({}. bound_QC-variables ),(id bound_QC-variables )] in SepQuadruples p
proof end;

theorem Th32: :: CQC_SIM1:32
for p, q being Element of CQC-WFF
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [('not' q),k,K,f] in SepQuadruples p holds
[q,k,K,f] in SepQuadruples p
proof end;

theorem Th33: :: CQC_SIM1:33
for p, q, r being Element of CQC-WFF
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [(q '&' r),k,K,f] in SepQuadruples p holds
( [q,k,K,f] in SepQuadruples p & [r,(k + (QuantNbr q)),K,f] in SepQuadruples p )
proof end;

theorem Th34: :: CQC_SIM1:34
for p, q being Element of CQC-WFF
for x being Element of bound_QC-variables
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [(All x,q),k,K,f] in SepQuadruples p holds
[q,(k + 1),(K \/ {x}),(f +* ({x} --> (x. k)))] in SepQuadruples p
proof end;

theorem Th35: :: CQC_SIM1:35
for q, p being Element of CQC-WFF
for k being Element of NAT
for f being Element of Funcs bound_QC-variables ,bound_QC-variables
for K being Finite_Subset of bound_QC-variables holds
( not [q,k,K,f] in SepQuadruples p or [q,k,K,f] = [p,(index p),({}. bound_QC-variables ),(id bound_QC-variables )] or [('not' q),k,K,f] in SepQuadruples p or ex r being Element of CQC-WFF st [(q '&' r),k,K,f] in SepQuadruples p or ex r being Element of CQC-WFF ex l being Element of NAT st
( k = l + (QuantNbr r) & [(r '&' q),l,K,f] in SepQuadruples p ) or ex x being Element of bound_QC-variables ex l being Element of NAT ex h being Element of Funcs bound_QC-variables ,bound_QC-variables st
( l + 1 = k & h +* ({x} --> (x. l)) = f & ( [(All x,q),l,K,h] in SepQuadruples p or [(All x,q),l,(K \ {x}),h] in SepQuadruples p ) ) )
proof end;

scheme :: CQC_SIM1:sch 203
s203{ F1() -> Element of CQC-WFF , P1[ set , set , set , set ] } :
for q being Element of CQC-WFF
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [q,k,K,f] in SepQuadruples F1() holds
P1[q,k,K,f]
provided
E28: P1[F1(), index F1(), {}. bound_QC-variables , id bound_QC-variables ] and
E29: for q being Element of CQC-WFF
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [('not' q),k,K,f] in SepQuadruples F1() & P1[ 'not' q,k,K,f] holds
P1[q,k,K,f] and
E33: for q, r being Element of CQC-WFF
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [(q '&' r),k,K,f] in SepQuadruples F1() & P1[q '&' r,k,K,f] holds
( P1[q,k,K,f] & P1[r,k + (QuantNbr q),K,f] ) and
E38: for q being Element of CQC-WFF
for x being Element of bound_QC-variables
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [(All x,q),k,K,f] in SepQuadruples F1() & P1[ All x,q,k,K,f] holds
P1[q,k + 1,K \/ {x},f +* ({x} --> (x. k))]
proof end;

theorem Th36: :: CQC_SIM1:36
for p, q being Element of CQC-WFF
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [q,k,K,f] in SepQuadruples p holds
q is_subformula_of p
proof end;

theorem Th37: :: CQC_SIM1:37
SepQuadruples VERUM = {[VERUM ,0,({}. bound_QC-variables ),(id bound_QC-variables )]}
proof end;

theorem Th38: :: CQC_SIM1:38
for k being Element of NAT
for l being CQC-variable_list of k
for P being QC-pred_symbol of k holds SepQuadruples (P ! l) = {[(P ! l),(index (P ! l)),({}. bound_QC-variables ),(id bound_QC-variables )]}
proof end;

theorem Th39: :: CQC_SIM1:39
for p, q being Element of CQC-WFF
for k being Element of NAT
for K being Finite_Subset of bound_QC-variables
for f being Element of Funcs bound_QC-variables ,bound_QC-variables st [q,k,K,f] in SepQuadruples p holds
still_not-bound_in q c= (still_not-bound_in p) \/ K
proof end;

theorem Th40: :: CQC_SIM1:40
for q, p being Element of CQC-WFF
for m, i being Element of NAT
for f being Element of Funcs bound_QC-variables ,bound_QC-variables
for K being Finite_Subset of bound_QC-variables st [q,m,K,f] in SepQuadruples p & x. i in f .: K holds
i < m
proof end;

theorem Th41: :: CQC_SIM1:41
for q, p being Element of CQC-WFF
for m being Element of NAT
for f being Element of Funcs bound_QC-variables ,bound_QC-variables
for K being Finite_Subset of bound_QC-variables st [q,m,K,f] in SepQuadruples p holds
not x. m in f .: K by ;

theorem Th42: :: CQC_SIM1:42
for q, p being Element of CQC-WFF
for m, i being Element of NAT
for f being Element of Funcs bound_QC-variables ,bound_QC-variables
for K being Finite_Subset of bound_QC-variables st [q,m,K,f] in SepQuadruples p & x. i in f .: (still_not-bound_in p) holds
i < m
proof end;

theorem Th43: :: CQC_SIM1:43
for q, p being Element of CQC-WFF
for m, i being Element of NAT
for f being Element of Funcs bound_QC-variables ,bound_QC-variables
for K being Finite_Subset of bound_QC-variables st [q,m,K,f] in SepQuadruples p & x. i in f .: (still_not-bound_in q) holds
i < m
proof end;

theorem Th44: :: CQC_SIM1:44
for q, p being Element of CQC-WFF
for m being Element of NAT
for f being Element of Funcs bound_QC-variables ,bound_QC-variables
for K being Finite_Subset of bound_QC-variables st [q,m,K,f] in SepQuadruples p holds
not x. m in f .: (still_not-bound_in q) by ;

theorem Th45: :: CQC_SIM1:45
for p being Element of CQC-WFF holds still_not-bound_in p = still_not-bound_in (SepVar p)
proof end;

theorem Th46: :: CQC_SIM1:46
for p being Element of CQC-WFF holds index p = index (SepVar p)
proof end;

definition
let p be Element of CQC-WFF ;
let q be Element of CQC-WFF ;
pred c1,c2 are_similar means :Def14: :: CQC_SIM1:def 14
SepVar p = SepVar q;
reflexivity
for p being Element of CQC-WFF holds SepVar p = SepVar p
;
symmetry
for p, q being Element of CQC-WFF st SepVar p = SepVar q holds
SepVar q = SepVar p
;
end;

:: deftheorem Def14 defines are_similar CQC_SIM1:def 14 :
for p, q being Element of CQC-WFF holds
( p,q are_similar iff SepVar p = SepVar q );

theorem Th47: :: CQC_SIM1:47
canceled;

theorem Th48: :: CQC_SIM1:48
canceled;

theorem Th49: :: CQC_SIM1:49
for p, q, r being Element of CQC-WFF st p,q are_similar & q,r are_similar holds
p,r are_similar
proof end;