:: CIRCCMB3 semantic presentation

theorem Th1: :: CIRCCMB3:1
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty Circuit of b1
for b3 being State of b2
for b4 being set st b4 in InputVertices b1 holds
for b5 being Nat holds (Following b3,b5) . b4 = b3 . b4
proof end;

definition
let c1 be non empty non void Circuit-like ManySortedSign ;
let c2 be non-empty Circuit of c1;
let c3 be State of c2;
attr a3 is stabilizing means :Def1: :: CIRCCMB3:def 1
ex b1 being Nat st Following a3,b1 is stable;
end;

:: deftheorem Def1 defines stabilizing CIRCCMB3:def 1 :
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty Circuit of b1
for b3 being State of b2 holds
( b3 is stabilizing iff ex b4 being Nat st Following b3,b4 is stable );

definition
let c1 be non empty non void Circuit-like ManySortedSign ;
let c2 be non-empty Circuit of c1;
attr a2 is stabilizing means :Def2: :: CIRCCMB3:def 2
for b1 being State of a2 holds b1 is stabilizing;
attr a2 is with_stabilization-limit means :: CIRCCMB3:def 3
ex b1 being Nat st
for b2 being State of a2 holds Following b2,b1 is stable;
end;

:: deftheorem Def2 defines stabilizing CIRCCMB3:def 2 :
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty Circuit of b1 holds
( b2 is stabilizing iff for b3 being State of b2 holds b3 is stabilizing );

:: deftheorem Def3 defines with_stabilization-limit CIRCCMB3:def 3 :
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty Circuit of b1 holds
( b2 is with_stabilization-limit iff ex b3 being Nat st
for b4 being State of b2 holds Following b4,b3 is stable );

registration
let c1 be non empty non void Circuit-like ManySortedSign ;
cluster non-empty with_stabilization-limit -> non-empty stabilizing MSAlgebra of a1;
coherence
for b1 being non-empty Circuit of c1 st b1 is with_stabilization-limit holds
b1 is stabilizing
proof end;
end;

definition
let c1 be non empty non void Circuit-like ManySortedSign ;
let c2 be non-empty Circuit of c1;
let c3 be State of c2;
assume E4: c3 is stabilizing ;
func Result c3 -> State of a2 means :Def4: :: CIRCCMB3:def 4
( a4 is stable & ex b1 being Nat st a4 = Following a3,b1 );
existence
ex b1 being State of c2 st
( b1 is stable & ex b2 being Nat st b1 = Following c3,b2 )
proof end;
uniqueness
for b1, b2 being State of c2 st b1 is stable & ex b3 being Nat st b1 = Following c3,b3 & b2 is stable & ex b3 being Nat st b2 = Following c3,b3 holds
b1 = b2
proof end;
end;

:: deftheorem Def4 defines Result CIRCCMB3:def 4 :
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty Circuit of b1
for b3 being State of b2 st b3 is stabilizing holds
for b4 being State of b2 holds
( b4 = Result b3 iff ( b4 is stable & ex b5 being Nat st b4 = Following b3,b5 ) );

definition
let c1 be non empty non void Circuit-like ManySortedSign ;
let c2 be non-empty Circuit of c1;
let c3 be State of c2;
assume E5: c3 is stabilizing ;
func stabilization-time c3 -> Nat means :Def5: :: CIRCCMB3:def 5
( Following a3,a4 is stable & ( for b1 being Nat st b1 < a4 holds
not Following a3,b1 is stable ) );
existence
ex b1 being Nat st
( Following c3,b1 is stable & ( for b2 being Nat st b2 < b1 holds
not Following c3,b2 is stable ) )
proof end;
uniqueness
for b1, b2 being Nat st Following c3,b1 is stable & ( for b3 being Nat st b3 < b1 holds
not Following c3,b3 is stable ) & Following c3,b2 is stable & ( for b3 being Nat st b3 < b2 holds
not Following c3,b3 is stable ) holds
b1 = b2
proof end;
end;

:: deftheorem Def5 defines stabilization-time CIRCCMB3:def 5 :
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty Circuit of b1
for b3 being State of b2 st b3 is stabilizing holds
for b4 being Nat holds
( b4 = stabilization-time b3 iff ( Following b3,b4 is stable & ( for b5 being Nat st b5 < b4 holds
not Following b3,b5 is stable ) ) );

theorem Th2: :: CIRCCMB3:2
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty Circuit of b1
for b3 being State of b2 st b3 is stabilizing holds
Result b3 = Following b3,(stabilization-time b3)
proof end;

theorem Th3: :: CIRCCMB3:3
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty Circuit of b1
for b3 being State of b2
for b4 being Nat st Following b3,b4 is stable holds
stabilization-time b3 <= b4
proof end;

theorem Th4: :: CIRCCMB3:4
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty Circuit of b1
for b3 being State of b2
for b4 being Nat st Following b3,b4 is stable holds
Result b3 = Following b3,b4
proof end;

theorem Th5: :: CIRCCMB3:5
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty Circuit of b1
for b3 being State of b2
for b4 being Nat st b3 is stabilizing & b4 >= stabilization-time b3 holds
Result b3 = Following b3,b4
proof end;

theorem Th6: :: CIRCCMB3:6
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty Circuit of b1
for b3 being State of b2 st b3 is stabilizing holds
for b4 being set st b4 in InputVertices b1 holds
(Result b3) . b4 = b3 . b4
proof end;

theorem Th7: :: CIRCCMB3:7
canceled;

theorem Th8: :: CIRCCMB3:8
for b1, b2 being non empty non void Circuit-like ManySortedSign st InputVertices b1 misses InnerVertices b2 & InputVertices b2 misses InnerVertices b1 holds
for b3 being non empty non void Circuit-like ManySortedSign st b3 = b1 +* b2 holds
for b4 being non-empty Circuit of b1
for b5 being non-empty Circuit of b2 st b4 tolerates b5 holds
for b6 being non-empty Circuit of b3 st b6 = b4 +* b5 holds
for b7 being State of b6
for b8 being State of b4
for b9 being State of b5 st b8 = b7 | the carrier of b1 & b9 = b7 | the carrier of b2 & b8 is stabilizing & b9 is stabilizing holds
b7 is stabilizing
proof end;

theorem Th9: :: CIRCCMB3:9
for b1, b2 being non empty non void Circuit-like ManySortedSign st InputVertices b1 misses InnerVertices b2 & InputVertices b2 misses InnerVertices b1 holds
for b3 being non empty non void Circuit-like ManySortedSign st b3 = b1 +* b2 holds
for b4 being non-empty Circuit of b1
for b5 being non-empty Circuit of b2 st b4 tolerates b5 holds
for b6 being non-empty Circuit of b3 st b6 = b4 +* b5 holds
for b7 being State of b6
for b8 being State of b4 st b8 = b7 | the carrier of b1 & b8 is stabilizing holds
for b9 being State of b5 st b9 = b7 | the carrier of b2 & b9 is stabilizing holds
stabilization-time b7 = max (stabilization-time b8),(stabilization-time b9)
proof end;

theorem Th10: :: CIRCCMB3:10
for b1, b2 being non empty non void Circuit-like ManySortedSign st InputVertices b1 misses InnerVertices b2 holds
for b3 being non empty non void Circuit-like ManySortedSign st b3 = b1 +* b2 holds
for b4 being non-empty Circuit of b1
for b5 being non-empty Circuit of b2 st b4 tolerates b5 holds
for b6 being non-empty Circuit of b3 st b6 = b4 +* b5 holds
for b7 being State of b6
for b8 being State of b4 st b8 = b7 | the carrier of b1 & b8 is stabilizing holds
for b9 being State of b5 st b9 = (Following b7,(stabilization-time b8)) | the carrier of b2 & b9 is stabilizing holds
b7 is stabilizing
proof end;

theorem Th11: :: CIRCCMB3:11
for b1, b2 being non empty non void Circuit-like ManySortedSign st InputVertices b1 misses InnerVertices b2 holds
for b3 being non empty non void Circuit-like ManySortedSign st b3 = b1 +* b2 holds
for b4 being non-empty Circuit of b1
for b5 being non-empty Circuit of b2 st b4 tolerates b5 holds
for b6 being non-empty Circuit of b3 st b6 = b4 +* b5 holds
for b7 being State of b6
for b8 being State of b4 st b8 = b7 | the carrier of b1 & b8 is stabilizing holds
for b9 being State of b5 st b9 = (Following b7,(stabilization-time b8)) | the carrier of b2 & b9 is stabilizing holds
stabilization-time b7 = (stabilization-time b8) + (stabilization-time b9)
proof end;

theorem Th12: :: CIRCCMB3:12
for b1, b2, b3 being non empty non void Circuit-like ManySortedSign st InputVertices b1 misses InnerVertices b2 & b3 = b1 +* b2 holds
for b4 being non-empty Circuit of b1
for b5 being non-empty Circuit of b2
for b6 being non-empty Circuit of b3 st b4 tolerates b5 & b6 = b4 +* b5 holds
for b7 being State of b6
for b8 being State of b4 st b8 = b7 | the carrier of b1 & b8 is stabilizing holds
for b9 being State of b5 st b9 = (Following b7,(stabilization-time b8)) | the carrier of b2 & b9 is stabilizing holds
(Result b7) | the carrier of b1 = Result b8
proof end;

theorem Th13: :: CIRCCMB3:13
for b1 being set
for b2 being non empty finite set
for b3 being Nat
for b4 being FinSeqLen of b3
for b5 being Function of b3 -tuples_on b2,b2
for b6 being State of (1GateCircuit b4,b5) holds b6 * b4 is Element of b3 -tuples_on b2
proof end;

theorem Th14: :: CIRCCMB3:14
for b1, b2, b3, b4 being set holds rng <*b1,b2,b3,b4*> = {b1,b2,b3,b4}
proof end;

theorem Th15: :: CIRCCMB3:15
for b1, b2, b3, b4, b5 being set holds rng <*b1,b2,b3,b4,b5*> = {b1,b2,b3,b4,b5}
proof end;

definition
let c1, c2, c3, c4 be set ;
redefine func <* as <*c1,c2,c3,c4*> -> FinSeqLen of 4;
coherence
<*c1,c2,c3,c4*> is FinSeqLen of 4
proof end;
let c5 be set ;
redefine func <* as <*c1,c2,c3,c4,c5*> -> FinSeqLen of 5;
coherence
<*c1,c2,c3,c4,c5*> is FinSeqLen of 5
proof end;
end;

definition
let c1 be ManySortedSign ;
attr a1 is one-gate means :Def6: :: CIRCCMB3:def 6
ex b1 being non empty finite set ex b2 being Natex b3 being FinSeqLen of b2ex b4 being Function of b2 -tuples_on b1,b1 st a1 = 1GateCircStr b3,b4;
end;

:: deftheorem Def6 defines one-gate CIRCCMB3:def 6 :
for b1 being ManySortedSign holds
( b1 is one-gate iff ex b2 being non empty finite set ex b3 being Natex b4 being FinSeqLen of b3ex b5 being Function of b3 -tuples_on b2,b2 st b1 = 1GateCircStr b4,b5 );

definition
let c1 be non empty ManySortedSign ;
let c2 be MSAlgebra of c1;
attr a2 is one-gate means :Def7: :: CIRCCMB3:def 7
ex b1 being non empty finite set ex b2 being Natex b3 being FinSeqLen of b2ex b4 being Function of b2 -tuples_on b1,b1 st
( a1 = 1GateCircStr b3,b4 & a2 = 1GateCircuit b3,b4 );
end;

:: deftheorem Def7 defines one-gate CIRCCMB3:def 7 :
for b1 being non empty ManySortedSign
for b2 being MSAlgebra of b1 holds
( b2 is one-gate iff ex b3 being non empty finite set ex b4 being Natex b5 being FinSeqLen of b4ex b6 being Function of b4 -tuples_on b3,b3 st
( b1 = 1GateCircStr b5,b6 & b2 = 1GateCircuit b5,b6 ) );

registration
let c1 be FinSequence;
let c2 be set ;
cluster 1GateCircStr a1,a2 -> finite ;
coherence
1GateCircStr c1,c2 is finite
proof end;
end;

registration
cluster one-gate -> non empty finite strict non void unsplit gate`1=arity ManySortedSign ;
coherence
for b1 being ManySortedSign st b1 is one-gate holds
( b1 is strict & not b1 is void & not b1 is empty & b1 is unsplit & b1 is gate`1=arity & b1 is finite )
proof end;
end;

registration
cluster non empty one-gate -> non empty gate`2=den ManySortedSign ;
coherence
for b1 being non empty ManySortedSign st b1 is one-gate holds
b1 is gate`2=den
proof end;
end;

registration
let c1 be non empty finite set ;
let c2 be Nat;
let c3 be FinSeqLen of c2;
let c4 be Function of c2 -tuples_on c1,c1;
cluster 1GateCircStr a3,a4 -> finite one-gate ;
coherence
1GateCircStr c3,c4 is one-gate
by Def6;
end;

registration
cluster non empty finite strict non void unsplit gate`1=arity gate`2=den one-gate ManySortedSign ;
existence
ex b1 being ManySortedSign st b1 is one-gate
proof end;
end;

registration
let c1 be one-gate ManySortedSign ;
cluster one-gate -> strict non-empty MSAlgebra of a1;
coherence
for b1 being Circuit of c1 st b1 is one-gate holds
( b1 is strict & b1 is non-empty )
proof end;
end;

registration
let c1 be non empty finite set ;
let c2 be Nat;
let c3 be FinSeqLen of c2;
let c4 be Function of c2 -tuples_on c1,c1;
cluster 1GateCircuit a3,a4 -> one-gate ;
coherence
1GateCircuit c3,c4 is one-gate
by Def7;
end;

registration
let c1 be one-gate ManySortedSign ;
cluster strict non-empty one-gate MSAlgebra of a1;
existence
ex b1 being Circuit of c1 st
( b1 is one-gate & b1 is non-empty )
proof end;
end;

definition
let c1 be one-gate ManySortedSign ;
func Output c1 -> Vertex of a1 equals :: CIRCCMB3:def 8
union the OperSymbols of a1;
coherence
union the OperSymbols of c1 is Vertex of c1
proof end;
end;

:: deftheorem Def8 defines Output CIRCCMB3:def 8 :
for b1 being one-gate ManySortedSign holds Output b1 = union the OperSymbols of b1;

registration
let c1 be one-gate ManySortedSign ;
cluster Output a1 -> pair ;
coherence
Output c1 is pair
proof end;
end;

theorem Th16: :: CIRCCMB3:16
for b1 being one-gate ManySortedSign
for b2 being FinSequence
for b3 being set st b1 = 1GateCircStr b2,b3 holds
Output b1 = [b2,b3]
proof end;

theorem Th17: :: CIRCCMB3:17
for b1 being one-gate ManySortedSign holds InnerVertices b1 = {(Output b1)}
proof end;

theorem Th18: :: CIRCCMB3:18
for b1 being one-gate ManySortedSign
for b2 being one-gate Circuit of b1
for b3 being Nat
for b4 being non empty finite set
for b5 being Function of b3 -tuples_on b4,b4
for b6 being FinSeqLen of b3 st b2 = 1GateCircuit b6,b5 holds
b1 = 1GateCircStr b6,b5
proof end;

theorem Th19: :: CIRCCMB3:19
for b1 being Nat
for b2 being non empty finite set
for b3 being Function of b1 -tuples_on b2,b2
for b4 being FinSeqLen of b1
for b5 being State of (1GateCircuit b4,b3) holds (Following b5) . (Output (1GateCircStr b4,b3)) = b3 . (b5 * b4)
proof end;

theorem Th20: :: CIRCCMB3:20
for b1 being one-gate ManySortedSign
for b2 being one-gate Circuit of b1
for b3 being State of b2 holds Following b3 is stable
proof end;

registration
let c1 be non empty non void Circuit-like ManySortedSign ;
cluster non-empty one-gate -> non-empty stabilizing with_stabilization-limit MSAlgebra of a1;
coherence
for b1 being non-empty Circuit of c1 st b1 is one-gate holds
b1 is with_stabilization-limit
proof end;
end;

theorem Th21: :: CIRCCMB3:21
for b1 being one-gate ManySortedSign
for b2 being one-gate Circuit of b1
for b3 being State of b2 holds Result b3 = Following b3
proof end;

theorem Th22: :: CIRCCMB3:22
for b1 being one-gate ManySortedSign
for b2 being one-gate Circuit of b1
for b3 being State of b2 holds stabilization-time b3 <= 1
proof end;

scheme :: CIRCCMB3:sch 1
s1{ F1() -> set , F2() -> non empty finite set , F3( set ) -> Element of F2() } :
ex b1 being one-gate ManySortedSign ex b2 being one-gate Circuit of b1 st
( InputVertices b1 = {F1()} & ( for b3 being State of b2 holds (Result b3) . (Output b1) = F3((b3 . F1())) ) )
proof end;

scheme :: CIRCCMB3:sch 2
s2{ F1() -> set , F2() -> set , F3() -> non empty finite set , F4( set , set ) -> Element of F3() } :
ex b1 being one-gate ManySortedSign ex b2 being one-gate Circuit of b1 st
( InputVertices b1 = {F1(),F2()} & ( for b3 being State of b2 holds (Result b3) . (Output b1) = F4((b3 . F1()),(b3 . F2())) ) )
proof end;

scheme :: CIRCCMB3:sch 3
s3{ F1() -> set , F2() -> set , F3() -> set , F4() -> non empty finite set , F5( set , set , set ) -> Element of F4() } :
ex b1 being one-gate ManySortedSign ex b2 being one-gate Circuit of b1 st
( InputVertices b1 = {F1(),F2(),F3()} & ( for b3 being State of b2 holds (Result b3) . (Output b1) = F5((b3 . F1()),(b3 . F2()),(b3 . F3())) ) )
proof end;

scheme :: CIRCCMB3:sch 4
s4{ F1() -> set , F2() -> set , F3() -> set , F4() -> set , F5() -> non empty finite set , F6( set , set , set , set ) -> Element of F5() } :
ex b1 being one-gate ManySortedSign ex b2 being one-gate Circuit of b1 st
( InputVertices b1 = {F1(),F2(),F3(),F4()} & ( for b3 being State of b2 holds (Result b3) . (Output b1) = F6((b3 . F1()),(b3 . F2()),(b3 . F3()),(b3 . F4())) ) )
proof end;

scheme :: CIRCCMB3:sch 5
s5{ F1() -> set , F2() -> set , F3() -> set , F4() -> set , F5() -> set , F6() -> non empty finite set , F7( set , set , set , set , set ) -> Element of F6() } :
ex b1 being one-gate ManySortedSign ex b2 being one-gate Circuit of b1 st
( InputVertices b1 = {F1(),F2(),F3(),F4(),F5()} & ( for b3 being State of b2 holds (Result b3) . (Output b1) = F7((b3 . F1()),(b3 . F2()),(b3 . F3()),(b3 . F4()),(b3 . F5())) ) )
proof end;

theorem Th23: :: CIRCCMB3:23
for b1 being constant Function holds b1 = (dom b1) --> (the_value_of b1)
proof end;

theorem Th24: :: CIRCCMB3:24
for b1, b2 being non empty set
for b3, b4 being Nat st b3 <> 0 & b3 -tuples_on b1 = b4 -tuples_on b2 holds
( b1 = b2 & b3 = b4 )
proof end;

theorem Th25: :: CIRCCMB3:25
for b1, b2 being non empty ManySortedSign
for b3 being Vertex of b1 holds b3 is Vertex of (b1 +* b2)
proof end;

theorem Th26: :: CIRCCMB3:26
for b1, b2 being non empty ManySortedSign
for b3 being Vertex of b2 holds b3 is Vertex of (b1 +* b2)
proof end;

definition
let c1 be non empty finite set ;
mode Signature of c1 -> non empty non void unsplit gate`1=arity gate`2=den ManySortedSign means :Def9: :: CIRCCMB3:def 9
ex b1 being Circuit of a2 st
( the Sorts of b1 is constant & the_value_of the Sorts of b1 = a1 & b1 is gate`2=den );
existence
ex b1 being non empty non void unsplit gate`1=arity gate`2=den ManySortedSign ex b2 being Circuit of b1 st
( the Sorts of b2 is constant & the_value_of the Sorts of b2 = c1 & b2 is gate`2=den )
proof end;
end;

:: deftheorem Def9 defines Signature CIRCCMB3:def 9 :
for b1 being non empty finite set
for b2 being non empty non void unsplit gate`1=arity gate`2=den ManySortedSign holds
( b2 is Signature of b1 iff ex b3 being Circuit of b2 st
( the Sorts of b3 is constant & the_value_of the Sorts of b3 = b1 & b3 is gate`2=den ) );

theorem Th27: :: CIRCCMB3:27
for b1 being Nat
for b2 being non empty finite set
for b3 being Function of b1 -tuples_on b2,b2
for b4 being FinSeqLen of b1 holds 1GateCircStr b4,b3 is Signature of b2
proof end;

registration
let c1 be non empty finite set ;
cluster non empty finite strict non void unsplit gate`1=arity gate`2=den one-gate Signature of a1;
existence
ex b1 being Signature of c1 st
( b1 is strict & b1 is one-gate )
proof end;
end;

definition
let c1 be Nat;
let c2 be non empty finite set ;
let c3 be Function of c1 -tuples_on c2,c2;
let c4 be FinSeqLen of c1;
redefine func 1GateCircStr as 1GateCircStr c4,c3 -> strict Signature of a2;
coherence
1GateCircStr c4,c3 is strict Signature of c2
by Th27;
end;

definition
let c1 be non empty finite set ;
let c2 be Signature of c1;
mode Circuit of c1,c2 -> Circuit of a2 means :Def10: :: CIRCCMB3:def 10
( a3 is gate`2=den & the Sorts of a3 is constant & the_value_of the Sorts of a3 = a1 );
existence
ex b1 being Circuit of c2 st
( b1 is gate`2=den & the Sorts of b1 is constant & the_value_of the Sorts of b1 = c1 )
proof end;
end;

:: deftheorem Def10 defines Circuit CIRCCMB3:def 10 :
for b1 being non empty finite set
for b2 being Signature of b1
for b3 being Circuit of b2 holds
( b3 is Circuit of b1,b2 iff ( b3 is gate`2=den & the Sorts of b3 is constant & the_value_of the Sorts of b3 = b1 ) );

registration
let c1 be non empty finite set ;
let c2 be Signature of c1;
cluster -> non-empty gate`2=den Circuit of a1,a2;
coherence
for b1 being Circuit of c1,c2 holds
( b1 is gate`2=den & b1 is non-empty )
proof end;
end;

theorem Th28: :: CIRCCMB3:28
for b1 being Nat
for b2 being non empty finite set
for b3 being Function of b1 -tuples_on b2,b2
for b4 being FinSeqLen of b1 holds 1GateCircuit b4,b3 is Circuit of b2, 1GateCircStr b4,b3
proof end;

registration
let c1 be non empty finite set ;
let c2 be one-gate Signature of c1;
cluster strict non-empty gate`2=den stabilizing with_stabilization-limit one-gate Circuit of a1,a2;
existence
ex b1 being Circuit of c1,c2 st
( b1 is strict & b1 is one-gate )
proof end;
end;

registration
let c1 be non empty finite set ;
let c2 be Signature of c1;
cluster strict non-empty gate`2=den Circuit of a1,a2;
existence
ex b1 being Circuit of c1,c2 st b1 is strict
proof end;
end;

definition
let c1 be Nat;
let c2 be non empty finite set ;
let c3 be Function of c1 -tuples_on c2,c2;
let c4 be FinSeqLen of c1;
redefine func 1GateCircuit as 1GateCircuit c4,c3 -> strict Circuit of a2, 1GateCircStr a4,a3;
coherence
1GateCircuit c4,c3 is strict Circuit of c2, 1GateCircStr c4,c3
by Th28;
end;

theorem Th29: :: CIRCCMB3:29
canceled;

theorem Th30: :: CIRCCMB3:30
for b1 being non empty finite set
for b2, b3 being Signature of b1
for b4 being Circuit of b1,b2
for b5 being Circuit of b1,b3 holds b4 tolerates b5
proof end;

theorem Th31: :: CIRCCMB3:31
for b1 being non empty finite set
for b2, b3 being Signature of b1
for b4 being Circuit of b1,b2
for b5 being Circuit of b1,b3 holds b4 +* b5 is Circuit of b2 +* b3
proof end;

theorem Th32: :: CIRCCMB3:32
for b1 being non empty finite set
for b2, b3 being Signature of b1
for b4 being Circuit of b1,b2
for b5 being Circuit of b1,b3 holds b4 +* b5 is gate`2=den
proof end;

theorem Th33: :: CIRCCMB3:33
for b1 being non empty finite set
for b2, b3 being Signature of b1
for b4 being Circuit of b1,b2
for b5 being Circuit of b1,b3 holds
( the Sorts of (b4 +* b5) is constant & the_value_of the Sorts of (b4 +* b5) = b1 )
proof end;

registration
let c1, c2 be non empty finite ManySortedSign ;
cluster a1 +* a2 -> finite ;
coherence
c1 +* c2 is finite
proof end;
end;

registration
let c1 be non empty finite set ;
let c2, c3 be Signature of c1;
cluster a2 +* a3 -> gate`2=den ;
coherence
c2 +* c3 is gate`2=den
proof end;
end;

definition
let c1 be non empty finite set ;
let c2, c3 be Signature of c1;
redefine func +* as c2 +* c3 -> strict Signature of a1;
coherence
c2 +* c3 is strict Signature of c1
proof end;
end;

definition
let c1 be non empty finite set ;
let c2, c3 be Signature of c1;
let c4 be Circuit of c1,c2;
let c5 be Circuit of c1,c3;
redefine func +* as c4 +* c5 -> strict Circuit of a1,a2 +* a3;
coherence
c4 +* c5 is strict Circuit of c1,c2 +* c3
proof end;
end;

theorem Th34: :: CIRCCMB3:34
for b1, b2 being set holds
( the_rank_of b1 in the_rank_of [b1,b2] & the_rank_of b2 in the_rank_of [b1,b2] )
proof end;

theorem Th35: :: CIRCCMB3:35
for b1 being non empty finite non void unsplit gate`1=arity gate`2=den ManySortedSign
for b2 being non-empty Circuit of b1 st b2 is gate`2=den holds
b2 is with_stabilization-limit
proof end;

registration
let c1 be non empty finite set ;
let c2 be finite Signature of c1;
cluster -> non-empty gate`2=den with_stabilization-limit Circuit of a1,a2;
coherence
for b1 being Circuit of c1,c2 holds b1 is with_stabilization-limit
by Th35;
end;

scheme :: CIRCCMB3:sch 6
s6{ F1() -> non empty set , F2( set ) -> Element of F1() } :
( ex b1 being Function of 1 -tuples_on F1(),F1() st
for b2 being Element of F1() holds b1 . <*b2*> = F2(b2) & ( for b1, b2 being Function of 1 -tuples_on F1(),F1() st ( for b3 being Element of F1() holds b1 . <*b3*> = F2(b3) ) & ( for b3 being Element of F1() holds b2 . <*b3*> = F2(b3) ) holds
b1 = b2 ) )
proof end;

scheme :: CIRCCMB3:sch 7
s7{ F1() -> non empty set , F2( set , set ) -> Element of F1() } :
( ex b1 being Function of 2 -tuples_on F1(),F1() st
for b2, b3 being Element of F1() holds b1 . <*b2,b3*> = F2(b2,b3) & ( for b1, b2 being Function of 2 -tuples_on F1(),F1() st ( for b3, b4 being Element of F1() holds b1 . <*b3,b4*> = F2(b3,b4) ) & ( for b3, b4 being Element of F1() holds b2 . <*b3,b4*> = F2(b3,b4) ) holds
b1 = b2 ) )
proof end;

scheme :: CIRCCMB3:sch 8
s8{ F1() -> non empty set , F2( set , set , set ) -> Element of F1() } :
( ex b1 being Function of 3 -tuples_on F1(),F1() st
for b2, b3, b4 being Element of F1() holds b1 . <*b2,b3,b4*> = F2(b2,b3,b4) & ( for b1, b2 being Function of 3 -tuples_on F1(),F1() st ( for b3, b4, b5 being Element of F1() holds b1 . <*b3,b4,b5*> = F2(b3,b4,b5) ) & ( for b3, b4, b5 being Element of F1() holds b2 . <*b3,b4,b5*> = F2(b3,b4,b5) ) holds
b1 = b2 ) )
proof end;

theorem Th36: :: CIRCCMB3:36
for b1 being Function
for b2 being set st b2 in dom b1 holds
b1 * <*b2*> = <*(b1 . b2)*>
proof end;

theorem Th37: :: CIRCCMB3:37
for b1 being Function
for b2, b3, b4, b5 being set st b2 in dom b1 & b3 in dom b1 & b4 in dom b1 & b5 in dom b1 holds
b1 * <*b2,b3,b4,b5*> = <*(b1 . b2),(b1 . b3),(b1 . b4),(b1 . b5)*>
proof end;

theorem Th38: :: CIRCCMB3:38
for b1 being Function
for b2, b3, b4, b5, b6 being set st b2 in dom b1 & b3 in dom b1 & b4 in dom b1 & b5 in dom b1 & b6 in dom b1 holds
b1 * <*b2,b3,b4,b5,b6*> = <*(b1 . b2),(b1 . b3),(b1 . b4),(b1 . b5),(b1 . b6)*>
proof end;

scheme :: CIRCCMB3:sch 9
s9{ F1() -> set , F2() -> non empty finite set , F3( set ) -> Element of F2(), F4() -> Function of 1 -tuples_on F2(),F2() } :
for b1 being State of (1GateCircuit <*F1()*>,F4())
for b2 being Element of F2() st b2 = b1 . F1() holds
(Result b1) . (Output (1GateCircStr <*F1()*>,F4())) = F3(b2)
provided
E37: for b1 being Function of 1 -tuples_on F2(),F2() holds
( b1 = F4() iff for b2 being Element of F2() holds b1 . <*b2*> = F3(b2) )
proof end;

scheme :: CIRCCMB3:sch 10
s10{ F1() -> set , F2() -> set , F3() -> non empty finite set , F4( set , set ) -> Element of F3(), F5() -> Function of 2 -tuples_on F3(),F3() } :
for b1 being State of (1GateCircuit <*F1(),F2()*>,F5())
for b2, b3 being Element of F3() st b2 = b1 . F1() & b3 = b1 . F2() holds
(Result b1) . (Output (1GateCircStr <*F1(),F2()*>,F5())) = F4(b2,b3)
provided
E37: for b1 being Function of 2 -tuples_on F3(),F3() holds
( b1 = F5() iff for b2, b3 being Element of F3() holds b1 . <*b2,b3*> = F4(b2,b3) )
proof end;

scheme :: CIRCCMB3:sch 11
s11{ F1() -> set , F2() -> set , F3() -> set , F4() -> non empty finite set , F5( set , set , set ) -> Element of F4(), F6() -> Function of 3 -tuples_on F4(),F4() } :
for b1 being State of (1GateCircuit <*F1(),F2(),F3()*>,F6())
for b2, b3, b4 being Element of F4() st b2 = b1 . F1() & b3 = b1 . F2() & b4 = b1 . F3() holds
(Result b1) . (Output (1GateCircStr <*F1(),F2(),F3()*>,F6())) = F5(b2,b3,b4)
provided
E37: for b1 being Function of 3 -tuples_on F4(),F4() holds
( b1 = F6() iff for b2, b3, b4 being Element of F4() holds b1 . <*b2,b3,b4*> = F5(b2,b3,b4) )
proof end;

scheme :: CIRCCMB3:sch 12
s12{ F1() -> set , F2() -> set , F3() -> set , F4() -> set , F5() -> non empty finite set , F6( set , set , set , set ) -> Element of F5(), F7() -> Function of 4 -tuples_on F5(),F5() } :
for b1 being State of (1GateCircuit <*F1(),F2(),F3(),F4()*>,F7())
for b2, b3, b4, b5 being Element of F5() st b2 = b1 . F1() & b3 = b1 . F2() & b4 = b1 . F3() & b5 = b1 . F4() holds
(Result b1) . (Output (1GateCircStr <*F1(),F2(),F3(),F4()*>,F7())) = F6(b2,b3,b4,b5)
provided
E37: for b1 being Function of 4 -tuples_on F5(),F5() holds
( b1 = F7() iff for b2, b3, b4, b5 being Element of F5() holds b1 . <*b2,b3,b4,b5*> = F6(b2,b3,b4,b5) )
proof end;

scheme :: CIRCCMB3:sch 13
s13{ F1() -> set , F2() -> set , F3() -> set , F4() -> set , F5() -> set , F6() -> non empty finite set , F7( set , set , set , set , set ) -> Element of F6(), F8() -> Function of 5 -tuples_on F6(),F6() } :
for b1 being State of (1GateCircuit <*F1(),F2(),F3(),F4(),F5()*>,F8())
for b2, b3, b4, b5, b6 being Element of F6() st b2 = b1 . F1() & b3 = b1 . F2() & b4 = b1 . F3() & b5 = b1 . F4() & b6 = b1 . F5() holds
(Result b1) . (Output (1GateCircStr <*F1(),F2(),F3(),F4(),F5()*>,F8())) = F7(b2,b3,b4,b5,b6)
provided
E37: for b1 being Function of 5 -tuples_on F6(),F6() holds
( b1 = F8() iff for b2, b3, b4, b5, b6 being Element of F6() holds b1 . <*b2,b3,b4,b5,b6*> = F7(b2,b3,b4,b5,b6) )
proof end;

theorem Th39: :: CIRCCMB3:39
for b1 being Nat
for b2 being non empty finite set
for b3 being Function of b1 -tuples_on b2,b2
for b4 being FinSeqLen of b1
for b5 being Signature of b2 st rng b4 c= the carrier of b5 & not Output (1GateCircStr b4,b3) in InputVertices b5 holds
InputVertices (b5 +* (1GateCircStr b4,b3)) = InputVertices b5
proof end;

theorem Th40: :: CIRCCMB3:40
for b1, b2 being set
for b3 being non empty finite set
for b4 being Nat
for b5 being Function of b4 -tuples_on b3,b3
for b6 being FinSeqLen of b4
for b7 being Signature of b3 st rng b6 = b1 \/ b2 & b1 c= the carrier of b7 & b2 misses InnerVertices b7 & not Output (1GateCircStr b6,b5) in InputVertices b7 holds
InputVertices (b7 +* (1GateCircStr b6,b5)) = (InputVertices b7) \/ b2
proof end;

theorem Th41: :: CIRCCMB3:41
for b1 being set
for b2 being non empty finite set
for b3 being Function of 1 -tuples_on b2,b2
for b4 being Signature of b2 st b1 in the carrier of b4 & not Output (1GateCircStr <*b1*>,b3) in InputVertices b4 holds
InputVertices (b4 +* (1GateCircStr <*b1*>,b3)) = InputVertices b4
proof end;

theorem Th42: :: CIRCCMB3:42
for b1, b2 being set
for b3 being non empty finite set
for b4 being Function of 2 -tuples_on b3,b3
for b5 being Signature of b3 st b1 in the carrier of b5 & not b2 in InnerVertices b5 & not Output (1GateCircStr <*b1,b2*>,b4) in InputVertices b5 holds
InputVertices (b5 +* (1GateCircStr <*b1,b2*>,b4)) = (InputVertices b5) \/ {b2}
proof end;

theorem Th43: :: CIRCCMB3:43
for b1, b2 being set
for b3 being non empty finite set
for b4 being Function of 2 -tuples_on b3,b3
for b5 being Signature of b3 st b2 in the carrier of b5 & not b1 in InnerVertices b5 & not Output (1GateCircStr <*b1,b2*>,b4) in InputVertices b5 holds
InputVertices (b5 +* (1GateCircStr <*b1,b2*>,b4)) = (InputVertices b5) \/ {b1}
proof end;

theorem Th44: :: CIRCCMB3:44
for b1, b2 being set
for b3 being non empty finite set
for b4 being Function of 2 -tuples_on b3,b3
for b5 being Signature of b3 st b1 in the carrier of b5 & b2 in the carrier of b5 & not Output (1GateCircStr <*b1,b2*>,b4) in InputVertices b5 holds
InputVertices (b5 +* (1GateCircStr <*b1,b2*>,b4)) = InputVertices b5
proof end;

theorem Th45: :: CIRCCMB3:45
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function of 3 -tuples_on b4,b4
for b6 being Signature of b4 st b1 in the carrier of b6 & not b2 in InnerVertices b6 & not b3 in InnerVertices b6 & not Output (1GateCircStr <*b1,b2,b3*>,b5) in InputVertices b6 holds
InputVertices (b6 +* (1GateCircStr <*b1,b2,b3*>,b5)) = (InputVertices b6) \/ {b2,b3}
proof end;

theorem Th46: :: CIRCCMB3:46
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function of 3 -tuples_on b4,b4
for b6 being Signature of b4 st b2 in the carrier of b6 & not b1 in InnerVertices b6 & not b3 in InnerVertices b6 & not Output (1GateCircStr <*b1,b2,b3*>,b5) in InputVertices b6 holds
InputVertices (b6 +* (1GateCircStr <*b1,b2,b3*>,b5)) = (InputVertices b6) \/ {b1,b3}
proof end;

theorem Th47: :: CIRCCMB3:47
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function of 3 -tuples_on b4,b4
for b6 being Signature of b4 st b3 in the carrier of b6 & not b1 in InnerVertices b6 & not b2 in InnerVertices b6 & not Output (1GateCircStr <*b1,b2,b3*>,b5) in InputVertices b6 holds
InputVertices (b6 +* (1GateCircStr <*b1,b2,b3*>,b5)) = (InputVertices b6) \/ {b1,b2}
proof end;

theorem Th48: :: CIRCCMB3:48
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function of 3 -tuples_on b4,b4
for b6 being Signature of b4 st b1 in the carrier of b6 & b2 in the carrier of b6 & not b3 in InnerVertices b6 & not Output (1GateCircStr <*b1,b2,b3*>,b5) in InputVertices b6 holds
InputVertices (b6 +* (1GateCircStr <*b1,b2,b3*>,b5)) = (InputVertices b6) \/ {b3}
proof end;

theorem Th49: :: CIRCCMB3:49
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function of 3 -tuples_on b4,b4
for b6 being Signature of b4 st b1 in the carrier of b6 & b3 in the carrier of b6 & not b2 in InnerVertices b6 & not Output (1GateCircStr <*b1,b2,b3*>,b5) in InputVertices b6 holds
InputVertices (b6 +* (1GateCircStr <*b1,b2,b3*>,b5)) = (InputVertices b6) \/ {b2}
proof end;

theorem Th50: :: CIRCCMB3:50
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function of 3 -tuples_on b4,b4
for b6 being Signature of b4 st b2 in the carrier of b6 & b3 in the carrier of b6 & not b1 in InnerVertices b6 & not Output (1GateCircStr <*b1,b2,b3*>,b5) in InputVertices b6 holds
InputVertices (b6 +* (1GateCircStr <*b1,b2,b3*>,b5)) = (InputVertices b6) \/ {b1}
proof end;

theorem Th51: :: CIRCCMB3:51
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function of 3 -tuples_on b4,b4
for b6 being Signature of b4 st b1 in the carrier of b6 & b2 in the carrier of b6 & b3 in the carrier of b6 & not Output (1GateCircStr <*b1,b2,b3*>,b5) in InputVertices b6 holds
InputVertices (b6 +* (1GateCircStr <*b1,b2,b3*>,b5)) = InputVertices b6
proof end;

theorem Th52: :: CIRCCMB3:52
for b1 being non empty finite set
for b2 being finite Signature of b1
for b3 being Circuit of b1,b2
for b4 being Nat
for b5 being Function of b4 -tuples_on b1,b1
for b6 being FinSeqLen of b4 st not Output (1GateCircStr b6,b5) in InputVertices b2 holds
for b7 being State of (b3 +* (1GateCircuit b6,b5))
for b8 being State of b3 st b8 = b7 | the carrier of b2 holds
stabilization-time b7 <= 1 + (stabilization-time b8)
proof end;

scheme :: CIRCCMB3:sch 14
s14{ F1() -> set , F2() -> non empty finite set , F3( set ) -> Element of F2(), F4() -> finite Signature of F2(), F5() -> Circuit of F2(),F4(), F6() -> Function of 1 -tuples_on F2(),F2() } :
for b1 being State of (F5() +* (1GateCircuit <*F1()*>,F6()))
for b2 being State of F5() st b2 = b1 | the carrier of F4() holds
for b3 being Element of F2() st ( F1() in InnerVertices F4() implies b3 = (Result b2) . F1() ) & ( not F1() in InnerVertices F4() implies b3 = b1 . F1() ) holds
(Result b1) . (Output (1GateCircStr <*F1()*>,F6())) = F3(b3)
provided
E51: for b1 being Function of 1 -tuples_on F2(),F2() holds
( b1 = F6() iff for b2 being Element of F2() holds b1 . <*b2*> = F3(b2) ) and
E52: not Output (1GateCircStr <*F1()*>,F6()) in InputVertices F4()
proof end;

scheme :: CIRCCMB3:sch 15
s15{ F1() -> set , F2() -> set , F3() -> non empty finite set , F4( set , set ) -> Element of F3(), F5() -> finite Signature of F3(), F6() -> Circuit of F3(),F5(), F7() -> Function of 2 -tuples_on F3(),F3() } :
for b1 being State of (F6() +* (1GateCircuit <*F1(),F2()*>,F7()))
for b2 being State of F6() st b2 = b1 | the carrier of F5() holds
for b3, b4 being Element of F3() st ( F1() in InnerVertices F5() implies b3 = (Result b2) . F1() ) & ( not F1() in InnerVertices F5() implies b3 = b1 . F1() ) & ( F2() in InnerVertices F5() implies b4 = (Result b2) . F2() ) & ( not F2() in InnerVertices F5() implies b4 = b1 . F2() ) holds
(Result b1) . (Output (1GateCircStr <*F1(),F2()*>,F7())) = F4(b3,b4)
provided
E51: for b1 being Function of 2 -tuples_on F3(),F3() holds
( b1 = F7() iff for b2, b3 being Element of F3() holds b1 . <*b2,b3*> = F4(b2,b3) ) and
E52: not Output (1GateCircStr <*F1(),F2()*>,F7()) in InputVertices F5()
proof end;

scheme :: CIRCCMB3:sch 16
s16{ F1() -> set , F2() -> set , F3() -> set , F4() -> non empty finite set , F5( set , set , set ) -> Element of F4(), F6() -> finite Signature of F4(), F7() -> Circuit of F4(),F6(), F8() -> Function of 3 -tuples_on F4(),F4() } :
for b1 being State of (F7() +* (1GateCircuit <*F1(),F2(),F3()*>,F8()))
for b2 being State of F7() st b2 = b1 | the carrier of F6() holds
for b3, b4, b5 being Element of F4() st ( F1() in InnerVertices F6() implies b3 = (Result b2) . F1() ) & ( not F1() in InnerVertices F6() implies b3 = b1 . F1() ) & ( F2() in InnerVertices F6() implies b4 = (Result b2) . F2() ) & ( not F2() in InnerVertices F6() implies b4 = b1 . F2() ) & ( F3() in InnerVertices F6() implies b5 = (Result b2) . F3() ) & ( not F3() in InnerVertices F6() implies b5 = b1 . F3() ) holds
(Result b1) . (Output (1GateCircStr <*F1(),F2(),F3()*>,F8())) = F5(b3,b4,b5)
provided
E51: for b1 being Function of 3 -tuples_on F4(),F4() holds
( b1 = F8() iff for b2, b3, b4 being Element of F4() holds b1 . <*b2,b3,b4*> = F5(b2,b3,b4) ) and
E52: not Output (1GateCircStr <*F1(),F2(),F3()*>,F8()) in InputVertices F6()
proof end;

scheme :: CIRCCMB3:sch 17
s17{ F1() -> set , F2() -> set , F3() -> set , F4() -> set , F5() -> non empty finite set , F6( set , set , set , set ) -> Element of F5(), F7() -> finite Signature of F5(), F8() -> Circuit of F5(),F7(), F9() -> Function of 4 -tuples_on F5(),F5() } :
for b1 being State of (F8() +* (1GateCircuit <*F1(),F2(),F3(),F4()*>,F9()))
for b2 being State of F8() st b2 = b1 | the carrier of F7() holds
for b3, b4, b5, b6 being Element of F5() st ( F1() in InnerVertices F7() implies b3 = (Result b2) . F1() ) & ( not F1() in InnerVertices F7() implies b3 = b1 . F1() ) & ( F2() in InnerVertices F7() implies b4 = (Result b2) . F2() ) & ( not F2() in InnerVertices F7() implies b4 = b1 . F2() ) & ( F3() in InnerVertices F7() implies b5 = (Result b2) . F3() ) & ( not F3() in InnerVertices F7() implies b5 = b1 . F3() ) & ( F4() in InnerVertices F7() implies b6 = (Result b2) . F4() ) & ( not F4() in InnerVertices F7() implies b6 = b1 . F4() ) holds
(Result b1) . (Output (1GateCircStr <*F1(),F2(),F3(),F4()*>,F9())) = F6(b3,b4,b5,b6)
provided
E51: for b1 being Function of 4 -tuples_on F5(),F5() holds
( b1 = F9() iff for b2, b3, b4, b5 being Element of F5() holds b1 . <*b2,b3,b4,b5*> = F6(b2,b3,b4,b5) ) and
E52: not Output (1GateCircStr <*F1(),F2(),F3(),F4()*>,F9()) in InputVertices F7()
proof end;

scheme :: CIRCCMB3:sch 18
s18{ F1() -> set , F2() -> set , F3() -> set , F4() -> set , F5() -> set , F6() -> non empty finite set , F7( set , set , set , set , set ) -> Element of F6(), F8() -> finite Signature of F6(), F9() -> Circuit of F6(),F8(), F10() -> Function of 5 -tuples_on F6(),F6() } :
for b1 being State of (F9() +* (1GateCircuit <*F1(),F2(),F3(),F4(),F5()*>,F10()))
for b2 being State of F9() st b2 = b1 | the carrier of F8() holds
for b3, b4, b5, b6, b7 being Element of F6() st ( F1() in InnerVertices F8() implies b3 = (Result b2) . F1() ) & ( not F1() in InnerVertices F8() implies b3 = b1 . F1() ) & ( F2() in InnerVertices F8() implies b4 = (Result b2) . F2() ) & ( not F2() in InnerVertices F8() implies b4 = b1 . F2() ) & ( F3() in InnerVertices F8() implies b5 = (Result b2) . F3() ) & ( not F3() in InnerVertices F8() implies b5 = b1 . F3() ) & ( F4() in InnerVertices F8() implies b6 = (Result b2) . F4() ) & ( not F4() in InnerVertices F8() implies b6 = b1 . F4() ) & ( F5() in InnerVertices F8() implies b7 = (Result b2) . F5() ) & ( not F5() in InnerVertices F8() implies b7 = b1 . F5() ) holds
(Result b1) . (Output (1GateCircStr <*F1(),F2(),F3(),F4(),F5()*>,F10())) = F7(b3,b4,b5,b6,b7)
provided
E51: for b1 being Function of 5 -tuples_on F6(),F6() holds
( b1 = F10() iff for b2, b3, b4, b5, b6 being Element of F6() holds b1 . <*b2,b3,b4,b5,b6*> = F7(b2,b3,b4,b5,b6) ) and
E52: not Output (1GateCircStr <*F1(),F2(),F3(),F4(),F5()*>,F10()) in InputVertices F8()
proof end;

definition
let c1 be non empty ManySortedSign ;
attr a1 is with_nonpair_inputs means :Def11: :: CIRCCMB3:def 11
not InputVertices a1 is with_pair;
end;

:: deftheorem Def11 defines with_nonpair_inputs CIRCCMB3:def 11 :
for b1 being non empty ManySortedSign holds
( b1 is with_nonpair_inputs iff not InputVertices b1 is with_pair );

registration
cluster NAT -> without_pairs ;
coherence
not NAT is with_pair
proof end;
let c1 be without_pairs set ;
cluster -> without_pairs Element of bool a1;
coherence
for b1 being Subset of c1 holds not b1 is with_pair
proof end;
end;

registration
cluster natural-yielding -> nonpair-yielding set ;
coherence
for b1 being Function st b1 is natural-yielding holds
b1 is nonpair-yielding
proof end;
end;

registration
cluster -> natural-yielding FinSequence of NAT ;
coherence
for b1 being FinSequence of NAT holds b1 is natural-yielding
proof end;
end;

registration
cluster one-to-one nonpair-yielding natural-yielding set ;
existence
ex b1 being FinSequence st
( b1 is one-to-one & b1 is natural-yielding )
proof end;
end;

registration
let c1 be Nat;
cluster one-to-one nonpair-yielding natural-yielding FinSeqLen of a1;
existence
ex b1 being FinSeqLen of c1 st
( b1 is one-to-one & b1 is natural-yielding )
proof end;
end;

registration
let c1 be nonpair-yielding FinSequence;
let c2 be set ;
cluster 1GateCircStr a1,a2 -> finite with_nonpair_inputs ;
coherence
1GateCircStr c1,c2 is with_nonpair_inputs
proof end;
end;

registration
cluster non empty finite strict non void unsplit gate`1=arity gate`2=den one-gate with_nonpair_inputs ManySortedSign ;
existence
ex b1 being one-gate ManySortedSign st b1 is with_nonpair_inputs
proof end;
let c1 be non empty finite set ;
cluster non empty finite strict non void unsplit gate`1=arity gate`2=den one-gate with_nonpair_inputs Signature of a1;
existence
ex b1 being one-gate Signature of c1 st b1 is with_nonpair_inputs
proof end;
end;

registration
let c1 be non empty with_nonpair_inputs ManySortedSign ;
cluster InputVertices a1 -> without_pairs ;
coherence
not InputVertices c1 is with_pair
by Def11;
end;

theorem Th53: :: CIRCCMB3:53
for b1 being non empty with_nonpair_inputs ManySortedSign
for b2 being Vertex of b1 st b2 is pair holds
b2 in InnerVertices b1
proof end;

registration
let c1 be non empty unsplit gate`1=arity ManySortedSign ;
cluster InnerVertices a1 -> Relation-like ;
coherence
InnerVertices c1 is Relation-like
proof end;
end;

registration
let c1 be non empty non void unsplit gate`2=den ManySortedSign ;
cluster InnerVertices a1 -> Relation-like ;
coherence
InnerVertices c1 is Relation-like
proof end;
end;

registration
let c1, c2 be non empty unsplit gate`1=arity with_nonpair_inputs ManySortedSign ;
cluster a1 +* a2 -> with_nonpair_inputs ;
coherence
c1 +* c2 is with_nonpair_inputs
proof end;
end;

theorem Th54: :: CIRCCMB3:54
for b1 being non pair set
for b2 being Relation holds not b1 in b2
proof end;

theorem Th55: :: CIRCCMB3:55
for b1 being set
for b2 being non empty finite set
for b3 being Function of 1 -tuples_on b2,b2
for b4 being with_nonpair_inputs Signature of b2 st ( b1 in the carrier of b4 or not b1 is pair ) holds
b4 +* (1GateCircStr <*b1*>,b3) is with_nonpair_inputs
proof end;

registration
let c1 be non empty finite set ;
let c2 be with_nonpair_inputs Signature of c1;
let c3 be Vertex of c2;
let c4 be Function of 1 -tuples_on c1,c1;
cluster a2 +* (1GateCircStr <*a3*>,a4) -> with_nonpair_inputs ;
coherence
c2 +* (1GateCircStr <*c3*>,c4) is with_nonpair_inputs
by Th55;
end;

registration
let c1 be non empty finite set ;
let c2 be with_nonpair_inputs Signature of c1;
let c3 be non pair set ;
let c4 be Function of 1 -tuples_on c1,c1;
cluster a2 +* (1GateCircStr <*a3*>,a4) -> gate`2=den with_nonpair_inputs ;
coherence
c2 +* (1GateCircStr <*c3*>,c4) is with_nonpair_inputs
;
end;

Lemma53: for b1 being non pair set holds not {b1} is with_pair
;

Lemma54: for b1, b2 being without_pairs set holds not b1 \/ b2 is with_pair
;

theorem Th56: :: CIRCCMB3:56
for b1, b2 being set
for b3 being non empty finite set
for b4 being Function of 2 -tuples_on b3,b3
for b5 being with_nonpair_inputs Signature of b3 st ( b1 in the carrier of b5 or not b1 is pair ) & ( b2 in the carrier of b5 or not b2 is pair ) holds
b5 +* (1GateCircStr <*b1,b2*>,b4) is with_nonpair_inputs
proof end;

registration
let c1 be non empty finite set ;
let c2 be with_nonpair_inputs Signature of c1;
let c3 be Vertex of c2;
let c4 be non pair set ;
let c5 be Function of 2 -tuples_on c1,c1;
cluster a2 +* (1GateCircStr <*a3,a4*>,a5) -> gate`2=den with_nonpair_inputs ;
coherence
c2 +* (1GateCircStr <*c3,c4*>,c5) is with_nonpair_inputs
by Th56;
cluster a2 +* (1GateCircStr <*a4,a3*>,a5) -> gate`2=den with_nonpair_inputs ;
coherence
c2 +* (1GateCircStr <*c4,c3*>,c5) is with_nonpair_inputs
by Th56;
end;

registration
let c1 be non empty finite set ;
let c2 be with_nonpair_inputs Signature of c1;
let c3, c4 be Vertex of c2;
let c5 be Function of 2 -tuples_on c1,c1;
cluster a2 +* (1GateCircStr <*a3,a4*>,a5) -> gate`2=den with_nonpair_inputs ;
coherence
c2 +* (1GateCircStr <*c3,c4*>,c5) is with_nonpair_inputs
by Th56;
end;

Lemma56: for b1, b2 being non pair set holds not {b1,b2} is with_pair
;

theorem Th57: :: CIRCCMB3:57
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function of 3 -tuples_on b4,b4
for b6 being with_nonpair_inputs Signature of b4 st ( b1 in the carrier of b6 or not b1 is pair ) & ( b2 in the carrier of b6 or not b2 is pair ) & ( b3 in the carrier of b6 or not b3 is pair ) holds
b6 +* (1GateCircStr <*b1,b2,b3*>,b5) is with_nonpair_inputs
proof end;

registration
let c1 be non empty finite set ;
let c2 be with_nonpair_inputs Signature of c1;
let c3, c4 be Vertex of c2;
let c5 be non pair set ;
let c6 be Function of 3 -tuples_on c1,c1;
cluster a2 +* (1GateCircStr <*a3,a4,a5*>,a6) -> gate`2=den with_nonpair_inputs ;
coherence
c2 +* (1GateCircStr <*c3,c4,c5*>,c6) is with_nonpair_inputs
by Th57;
cluster a2 +* (1GateCircStr <*a3,a5,a4*>,a6) -> gate`2=den with_nonpair_inputs ;
coherence
c2 +* (1GateCircStr <*c3,c5,c4*>,c6) is with_nonpair_inputs
by Th57;
cluster a2 +* (1GateCircStr <*a5,a3,a4*>,a6) -> gate`2=den with_nonpair_inputs ;
coherence
c2 +* (1GateCircStr <*c5,c3,c4*>,c6) is with_nonpair_inputs
by Th57;
end;

registration
let c1 be non empty finite set ;
let c2 be with_nonpair_inputs Signature of c1;
let c3 be Vertex of c2;
let c4, c5 be non pair set ;
let c6 be Function of 3 -tuples_on c1,c1;
cluster a2 +* (1GateCircStr <*a3,a4,a5*>,a6) -> gate`2=den with_nonpair_inputs ;
coherence
c2 +* (1GateCircStr <*c3,c4,c5*>,c6) is with_nonpair_inputs
by Th57;
cluster a2 +* (1GateCircStr <*a4,a3,a5*>,a6) -> gate`2=den with_nonpair_inputs ;
coherence
c2 +* (1GateCircStr <*c4,c3,c5*>,c6) is with_nonpair_inputs
by Th57;
cluster a2 +* (1GateCircStr <*a4,a5,a3*>,a6) -> gate`2=den with_nonpair_inputs ;
coherence
c2 +* (1GateCircStr <*c4,c5,c3*>,c6) is with_nonpair_inputs
by Th57;
end;

registration
let c1 be non empty finite set ;
let c2 be with_nonpair_inputs Signature of c1;
let c3, c4, c5 be Vertex of c2;
let c6 be Function of 3 -tuples_on c1,c1;
cluster a2 +* (1GateCircStr <*a3,a4,a5*>,a6) -> gate`2=den with_nonpair_inputs ;
coherence
c2 +* (1GateCircStr <*c3,c4,c5*>,c6) is with_nonpair_inputs
by Th57;
end;