Article CIRCCOMB, MML version 4.99.1005

:: CIRCCOMB:modenot 1
definition
  let a1 be ManySortedSign;
  mode Gate of a1 is Element of the OperSymbols of a1;
end;

:: CIRCCOMB:funcreg 1
registration
  let a1 be set;
  let a2 be Relation-like Function-like set;
  cluster a1 --> a2 -> Function-yielding;
end;

:: CIRCCOMB:funcreg 2
registration
  let a1, a2 be Relation-like non-empty Function-like set;
  cluster a1 +* a2 -> Relation-like non-empty Function-like;
end;

:: CIRCCOMB:funcnot 1 => CIRCCOMB:func 1
definition
  let a1, a2 be set;
  let a3 be ManySortedSet of a1;
  let a4 be ManySortedSet of a2;
  redefine func a3 +* a4 -> ManySortedSet of a1 \/ a2;
  idempotence;
::  for a1, a2 being set
::  for a3 being ManySortedSet of a1 holds
::     a3 +* a3 = a3;
end;

:: CIRCCOMB:th 2
theorem
for b1, b2, b3 being Relation-like Function-like set
      st proj2 b3 c= proj1 b1 & proj2 b3 c= proj1 b2 & b1 tolerates b2
   holds b3 * b1 = b3 * b2;

:: CIRCCOMB:th 3
theorem
for b1, b2 being set
for b3 being ManySortedSet of b1
for b4 being ManySortedSet of b2
      st b3 c= b4
   holds b3 # c= b4 #;

:: CIRCCOMB:th 4
theorem
for b1, b2, b3, b4 being set holds
   b1 --> b3 tolerates b2 --> b4
iff
   (b3 = b4 or b1 misses b2);

:: CIRCCOMB:th 5
theorem
for b1, b2, b3 being Relation-like Function-like set
      st b1 tolerates b2 & b2 tolerates b3 & b3 tolerates b1
   holds b1 +* b2 tolerates b3;

:: CIRCCOMB:th 6
theorem
for b1 being set
for b2 being non empty set
for b3 being FinSequence of b1 holds
   (b1 --> b2) # . b3 = (len b3) -tuples_on b2;

:: CIRCCOMB:funcnot 2 => CIRCCOMB:func 2
definition
  let a1 be set;
  let a2, a3 be non-empty ManySortedSet of a1;
  let a4 be set;
  let a5, a6 be non-empty ManySortedSet of a4;
  let a7 be ManySortedFunction of a2,a3;
  let a8 be ManySortedFunction of a5,a6;
  redefine func a7 +* a8 -> ManySortedFunction of a2 +* a5,a3 +* a6;
  idempotence;
::  for a1 being set
::  for a2, a3 being non-empty ManySortedSet of a1
::  for a4 being set
::  for a5, a6 being non-empty ManySortedSet of a4
::  for a7 being ManySortedFunction of a2,a3 holds
::     a7 +* a7 = a7;
end;

:: CIRCCOMB:prednot 1 => CIRCCOMB:pred 1
definition
  let a1, a2 be ManySortedSign;
  pred A1 tolerates A2 means
    the Arity of a1 tolerates the Arity of a2 & the ResultSort of a1 tolerates the ResultSort of a2;
  symmetry;
::  for a1, a2 being ManySortedSign
::        st a1 tolerates a2
::     holds a2 tolerates a1;
  reflexivity;
::  for a1 being ManySortedSign holds
::     a1 tolerates a1;
end;

:: CIRCCOMB:dfs 1
definiens
  let a1, a2 be ManySortedSign;
To prove
     a1 tolerates a2
it is sufficient to prove
  thus the Arity of a1 tolerates the Arity of a2 & the ResultSort of a1 tolerates the ResultSort of a2;

:: CIRCCOMB:def 1
theorem
for b1, b2 being ManySortedSign holds
   b1 tolerates b2
iff
   the Arity of b1 tolerates the Arity of b2 & the ResultSort of b1 tolerates the ResultSort of b2;

:: CIRCCOMB:funcnot 3 => CIRCCOMB:func 3
definition
  let a1, a2 be non empty ManySortedSign;
  func A1 +* A2 -> non empty strict ManySortedSign means
    the carrier of it = (the carrier of a1) \/ the carrier of a2 &
     the OperSymbols of it = (the OperSymbols of a1) \/ the OperSymbols of a2 &
     the Arity of it = (the Arity of a1) +* the Arity of a2 &
     the ResultSort of it = (the ResultSort of a1) +* the ResultSort of a2;
end;

:: CIRCCOMB:def 2
theorem
for b1, b2 being non empty ManySortedSign
for b3 being non empty strict ManySortedSign holds
      b3 = b1 +* b2
   iff
      the carrier of b3 = (the carrier of b1) \/ the carrier of b2 &
       the OperSymbols of b3 = (the OperSymbols of b1) \/ the OperSymbols of b2 &
       the Arity of b3 = (the Arity of b1) +* the Arity of b2 &
       the ResultSort of b3 = (the ResultSort of b1) +* the ResultSort of b2;

:: CIRCCOMB:th 7
theorem
for b1, b2, b3 being non empty ManySortedSign
      st b1 tolerates b2 & b2 tolerates b3 & b3 tolerates b1
   holds b1 +* b2 tolerates b3;

:: CIRCCOMB:th 8
theorem
for b1 being non empty ManySortedSign holds
   b1 +* b1 = ManySortedSign(#the carrier of b1,the OperSymbols of b1,the Arity of b1,the ResultSort of b1#);

:: CIRCCOMB:th 9
theorem
for b1, b2 being non empty ManySortedSign
      st b1 tolerates b2
   holds b1 +* b2 = b2 +* b1;

:: CIRCCOMB:th 10
theorem
for b1, b2, b3 being non empty ManySortedSign holds
(b1 +* b2) +* b3 = b1 +* (b2 +* b3);

:: CIRCCOMB:th 11
theorem
for b1 being Relation-like Function-like one-to-one set
for b2, b3 being non empty Circuit-like ManySortedSign
      st the ResultSort of b2 c= b1 & the ResultSort of b3 c= b1
   holds b2 +* b3 is Circuit-like;

:: CIRCCOMB:th 12
theorem
for b1, b2 being non empty Circuit-like ManySortedSign
      st InnerVertices b1 misses InnerVertices b2
   holds b1 +* b2 is Circuit-like;

:: CIRCCOMB:th 13
theorem
for b1, b2 being non empty ManySortedSign
      st (b1 is void implies b2 is not void)
   holds b1 +* b2 is not void;

:: CIRCCOMB:th 14
theorem
for b1, b2 being non empty finite ManySortedSign holds
b1 +* b2 is finite;

:: CIRCCOMB:funcreg 3
registration
  let a1 be non empty non void ManySortedSign;
  let a2 be non empty ManySortedSign;
  cluster a1 +* a2 -> non empty strict non void;
end;

:: CIRCCOMB:funcreg 4
registration
  let a1 be non empty non void ManySortedSign;
  let a2 be non empty ManySortedSign;
  cluster a2 +* a1 -> non empty strict non void;
end;

:: CIRCCOMB:th 15
theorem
for b1, b2 being non empty ManySortedSign
      st b1 tolerates b2
   holds InnerVertices (b1 +* b2) = (InnerVertices b1) \/ InnerVertices b2 &
    InputVertices (b1 +* b2) c= (InputVertices b1) \/ InputVertices b2;

:: CIRCCOMB:th 16
theorem
for b1, b2 being non empty ManySortedSign
for b3 being Element of the carrier of b2
      st b3 in InputVertices (b1 +* b2)
   holds b3 in InputVertices b2;

:: CIRCCOMB:th 17
theorem
for b1, b2 being non empty ManySortedSign
   st b1 tolerates b2
for b3 being Element of the carrier of b1
      st b3 in InputVertices (b1 +* b2)
   holds b3 in InputVertices b1;

:: CIRCCOMB:th 18
theorem
for b1 being non empty ManySortedSign
for b2 being non empty non void ManySortedSign
for b3 being Element of the OperSymbols of b2
for b4 being Element of the OperSymbols of b1 +* b2
      st b3 = b4
   holds the_arity_of b4 = the_arity_of b3 & the_result_sort_of b4 = the_result_sort_of b3;

:: CIRCCOMB:th 19
theorem
for b1 being non empty ManySortedSign
for b2, b3 being non empty non void Circuit-like ManySortedSign
   st b3 = b1 +* b2
for b4 being Element of the carrier of b2
   st b4 in InnerVertices b2
for b5 being Element of the carrier of b3
      st b4 = b5
   holds b5 in InnerVertices b3 & action_at b5 = action_at b4;

:: CIRCCOMB:th 20
theorem
for b1 being non empty non void ManySortedSign
for b2 being non empty ManySortedSign
   st b1 tolerates b2
for b3 being Element of the OperSymbols of b1
for b4 being Element of the OperSymbols of b1 +* b2
      st b3 = b4
   holds the_arity_of b4 = the_arity_of b3 & the_result_sort_of b4 = the_result_sort_of b3;

:: CIRCCOMB:th 21
theorem
for b1, b2 being non empty non void Circuit-like ManySortedSign
for b3 being non empty ManySortedSign
   st b1 tolerates b3 & b2 = b1 +* b3
for b4 being Element of the carrier of b1
   st b4 in InnerVertices b1
for b5 being Element of the carrier of b2
      st b4 = b5
   holds b5 in InnerVertices b2 & action_at b5 = action_at b4;

:: CIRCCOMB:prednot 2 => CIRCCOMB:pred 2
definition
  let a1, a2 be non empty ManySortedSign;
  let a3 be MSAlgebra over a1;
  let a4 be MSAlgebra over a2;
  pred A3 tolerates A4 means
    a1 tolerates a2 & the Sorts of a3 tolerates the Sorts of a4 & the Charact of a3 tolerates the Charact of a4;
end;

:: CIRCCOMB:dfs 3
definiens
  let a1, a2 be non empty ManySortedSign;
  let a3 be MSAlgebra over a1;
  let a4 be MSAlgebra over a2;
To prove
     a3 tolerates a4
it is sufficient to prove
  thus a1 tolerates a2 & the Sorts of a3 tolerates the Sorts of a4 & the Charact of a3 tolerates the Charact of a4;

:: CIRCCOMB:def 3
theorem
for b1, b2 being non empty ManySortedSign
for b3 being MSAlgebra over b1
for b4 being MSAlgebra over b2 holds
      b3 tolerates b4
   iff
      b1 tolerates b2 & the Sorts of b3 tolerates the Sorts of b4 & the Charact of b3 tolerates the Charact of b4;

:: CIRCCOMB:funcnot 4 => CIRCCOMB:func 4
definition
  let a1, a2 be non empty ManySortedSign;
  let a3 be non-empty MSAlgebra over a1;
  let a4 be non-empty MSAlgebra over a2;
  assume the Sorts of a3 tolerates the Sorts of a4;
  func A3 +* A4 -> strict non-empty MSAlgebra over a1 +* a2 means
    the Sorts of it = (the Sorts of a3) +* the Sorts of a4 &
     the Charact of it = (the Charact of a3) +* the Charact of a4;
end;

:: CIRCCOMB:def 4
theorem
for b1, b2 being non empty ManySortedSign
for b3 being non-empty MSAlgebra over b1
for b4 being non-empty MSAlgebra over b2
   st the Sorts of b3 tolerates the Sorts of b4
for b5 being strict non-empty MSAlgebra over b1 +* b2 holds
      b5 = b3 +* b4
   iff
      the Sorts of b5 = (the Sorts of b3) +* the Sorts of b4 &
       the Charact of b5 = (the Charact of b3) +* the Charact of b4;

:: CIRCCOMB:th 22
theorem
for b1 being non empty non void ManySortedSign
for b2 being MSAlgebra over b1 holds
   b2 tolerates b2;

:: CIRCCOMB:th 23
theorem
for b1, b2 being non empty non void ManySortedSign
for b3 being MSAlgebra over b1
for b4 being MSAlgebra over b2
      st b3 tolerates b4
   holds b4 tolerates b3;

:: CIRCCOMB:th 24
theorem
for b1, b2, b3 being non empty ManySortedSign
for b4 being non-empty MSAlgebra over b1
for b5 being non-empty MSAlgebra over b2
for b6 being MSAlgebra over b3
      st b4 tolerates b5 & b5 tolerates b6 & b6 tolerates b4
   holds b4 +* b5 tolerates b6;

:: CIRCCOMB:th 25
theorem
for b1 being non empty strict ManySortedSign
for b2 being non-empty MSAlgebra over b1 holds
   b2 +* b2 = MSAlgebra(#the Sorts of b2,the Charact of b2#);

:: CIRCCOMB:th 26
theorem
for b1, b2 being non empty ManySortedSign
for b3 being non-empty MSAlgebra over b1
for b4 being non-empty MSAlgebra over b2
      st b3 tolerates b4
   holds b3 +* b4 = b4 +* b3;

:: CIRCCOMB:th 27
theorem
for b1, b2, b3 being non empty ManySortedSign
for b4 being non-empty MSAlgebra over b1
for b5 being non-empty MSAlgebra over b2
for b6 being non-empty MSAlgebra over b3
      st the Sorts of b4 tolerates the Sorts of b5 & the Sorts of b5 tolerates the Sorts of b6 & the Sorts of b6 tolerates the Sorts of b4
   holds (b4 +* b5) +* b6 = b4 +* (b5 +* b6);

:: CIRCCOMB:th 28
theorem
for b1, b2 being non empty ManySortedSign
for b3 being non-empty locally-finite MSAlgebra over b1
for b4 being non-empty locally-finite MSAlgebra over b2
      st the Sorts of b3 tolerates the Sorts of b4
   holds b3 +* b4 is locally-finite(b1 +* b2);

:: CIRCCOMB:th 29
theorem
for b1, b2 being Relation-like non-empty Function-like set
for b3 being Element of product b1
for b4 being Element of product b2 holds
   b3 +* b4 in product (b1 +* b2);

:: CIRCCOMB:th 30
theorem
for b1, b2 being Relation-like non-empty Function-like set
for b3 being Element of product (b1 +* b2) holds
   b3 | proj1 b2 in product b2;

:: CIRCCOMB:th 31
theorem
for b1, b2 being Relation-like non-empty Function-like set
   st b1 tolerates b2
for b3 being Element of product (b1 +* b2) holds
   b3 | proj1 b1 in product b1;

:: CIRCCOMB:th 32
theorem
for b1, b2 being non empty ManySortedSign
for b3 being non-empty MSAlgebra over b1
for b4 being Element of product the Sorts of b3
for b5 being non-empty MSAlgebra over b2
for b6 being Element of product the Sorts of b5
      st the Sorts of b3 tolerates the Sorts of b5
   holds b4 +* b6 in product the Sorts of b3 +* b5;

:: CIRCCOMB:th 33
theorem
for b1, b2 being non empty ManySortedSign
for b3 being non-empty MSAlgebra over b1
for b4 being non-empty MSAlgebra over b2
   st the Sorts of b3 tolerates the Sorts of b4
for b5 being Element of product the Sorts of b3 +* b4 holds
   b5 | the carrier of b1 in product the Sorts of b3 & b5 | the carrier of b2 in product the Sorts of b4;

:: CIRCCOMB:th 34
theorem
for b1, b2 being non empty non void ManySortedSign
for b3 being non-empty MSAlgebra over b1
for b4 being non-empty MSAlgebra over b2
   st the Sorts of b3 tolerates the Sorts of b4
for b5 being Element of the OperSymbols of b1 +* b2
for b6 being Element of the OperSymbols of b2
      st b5 = b6
   holds Den(b5,b3 +* b4) = Den(b6,b4);

:: CIRCCOMB:th 35
theorem
for b1, b2 being non empty non void ManySortedSign
for b3 being non-empty MSAlgebra over b1
for b4 being non-empty MSAlgebra over b2
   st the Sorts of b3 tolerates the Sorts of b4 & the Charact of b3 tolerates the Charact of b4
for b5 being Element of the OperSymbols of b1 +* b2
for b6 being Element of the OperSymbols of b1
      st b5 = b6
   holds Den(b5,b3 +* b4) = Den(b6,b3);

:: CIRCCOMB:th 36
theorem
for b1, b2, b3 being non empty non void Circuit-like ManySortedSign
   st b3 = b1 +* b2
for b4 being non-empty locally-finite MSAlgebra over b1
for b5 being non-empty locally-finite MSAlgebra over b2
for b6 being non-empty locally-finite MSAlgebra over b3
for b7 being Element of product the Sorts of b6
for b8 being Element of product the Sorts of b5
   st b8 = b7 | the carrier of b2
for b9 being Element of the OperSymbols of b3
for b10 being Element of the OperSymbols of b2
      st b9 = b10
   holds b9 depends_on_in b7 = b10 depends_on_in b8;

:: CIRCCOMB:th 37
theorem
for b1, b2, b3 being non empty non void Circuit-like ManySortedSign
   st b3 = b1 +* b2 & b1 tolerates b2
for b4 being non-empty locally-finite MSAlgebra over b1
for b5 being non-empty locally-finite MSAlgebra over b2
for b6 being non-empty locally-finite MSAlgebra over b3
for b7 being Element of product the Sorts of b6
for b8 being Element of product the Sorts of b4
   st b8 = b7 | the carrier of b1
for b9 being Element of the OperSymbols of b3
for b10 being Element of the OperSymbols of b1
      st b9 = b10
   holds b9 depends_on_in b7 = b10 depends_on_in b8;

:: CIRCCOMB:th 38
theorem
for b1, b2, b3 being non empty non void Circuit-like ManySortedSign
   st b3 = b1 +* b2
for b4 being non-empty locally-finite MSAlgebra over b1
for b5 being non-empty locally-finite MSAlgebra over b2
for b6 being non-empty locally-finite MSAlgebra over b3
   st b4 tolerates b5 & b6 = b4 +* b5
for b7 being Element of product the Sorts of b6
for b8 being Element of the carrier of b3 holds
   (for b9 being Element of product the Sorts of b4
          st b9 = b7 | the carrier of b1 &
             (b8 in InnerVertices b1 or b8 in the carrier of b1 & b8 in InputVertices b3)
       holds (Following b7) . b8 = (Following b9) . b8) &
    (for b9 being Element of product the Sorts of b5
          st b9 = b7 | the carrier of b2 &
             (b8 in InnerVertices b2 or b8 in the carrier of b2 & b8 in InputVertices b3)
       holds (Following b7) . b8 = (Following b9) . b8);

:: CIRCCOMB:th 39
theorem
for b1, b2, b3 being non empty non void Circuit-like ManySortedSign
   st InnerVertices b1 misses InputVertices b2 & b3 = b1 +* b2
for b4 being non-empty locally-finite MSAlgebra over b1
for b5 being non-empty locally-finite MSAlgebra over b2
for b6 being non-empty locally-finite MSAlgebra over b3
   st b4 tolerates b5 & b6 = b4 +* b5
for b7 being Element of product the Sorts of b6
for b8 being Element of product the Sorts of b4
for b9 being Element of product the Sorts of b5
      st b8 = b7 | the carrier of b1 & b9 = b7 | the carrier of b2
   holds Following b7 = (Following b8) +* Following b9;

:: CIRCCOMB:th 40
theorem
for b1, b2, b3 being non empty non void Circuit-like ManySortedSign
   st InnerVertices b2 misses InputVertices b1 & b3 = b1 +* b2
for b4 being non-empty locally-finite MSAlgebra over b1
for b5 being non-empty locally-finite MSAlgebra over b2
for b6 being non-empty locally-finite MSAlgebra over b3
   st b4 tolerates b5 & b6 = b4 +* b5
for b7 being Element of product the Sorts of b6
for b8 being Element of product the Sorts of b4
for b9 being Element of product the Sorts of b5
      st b8 = b7 | the carrier of b1 & b9 = b7 | the carrier of b2
   holds Following b7 = (Following b9) +* Following b8;

:: CIRCCOMB:th 41
theorem
for b1, b2, b3 being non empty non void Circuit-like ManySortedSign
   st InputVertices b1 c= InputVertices b2 & b3 = b1 +* b2
for b4 being non-empty locally-finite MSAlgebra over b1
for b5 being non-empty locally-finite MSAlgebra over b2
for b6 being non-empty locally-finite MSAlgebra over b3
   st b4 tolerates b5 & b6 = b4 +* b5
for b7 being Element of product the Sorts of b6
for b8 being Element of product the Sorts of b4
for b9 being Element of product the Sorts of b5
      st b8 = b7 | the carrier of b1 & b9 = b7 | the carrier of b2
   holds Following b7 = (Following b9) +* Following b8;

:: CIRCCOMB:th 42
theorem
for b1, b2, b3 being non empty non void Circuit-like ManySortedSign
   st InputVertices b2 c= InputVertices b1 & b3 = b1 +* b2
for b4 being non-empty locally-finite MSAlgebra over b1
for b5 being non-empty locally-finite MSAlgebra over b2
for b6 being non-empty locally-finite MSAlgebra over b3
   st b4 tolerates b5 & b6 = b4 +* b5
for b7 being Element of product the Sorts of b6
for b8 being Element of product the Sorts of b4
for b9 being Element of product the Sorts of b5
      st b8 = b7 | the carrier of b1 & b9 = b7 | the carrier of b2
   holds Following b7 = (Following b8) +* Following b9;

:: CIRCCOMB:funcnot 5 => CIRCCOMB:func 5
definition
  let a1 be set;
  let a2 be Relation-like Function-like FinSequence-like set;
  let a3 be set;
  func 1GateCircStr(A2,A1,A3) -> strict non void ManySortedSign means
    the carrier of it = (proj2 a2) \/ {a3} &
     the OperSymbols of it = {[a2,a1]} &
     (the Arity of it) . [a2,a1] = a2 &
     (the ResultSort of it) . [a2,a1] = a3;
end;

:: CIRCCOMB:def 5
theorem
for b1 being set
for b2 being Relation-like Function-like FinSequence-like set
for b3 being set
for b4 being strict non void ManySortedSign holds
      b4 = 1GateCircStr(b2,b1,b3)
   iff
      the carrier of b4 = (proj2 b2) \/ {b3} &
       the OperSymbols of b4 = {[b2,b1]} &
       (the Arity of b4) . [b2,b1] = b2 &
       (the ResultSort of b4) . [b2,b1] = b3;

:: CIRCCOMB:funcreg 5
registration
  let a1 be set;
  let a2 be Relation-like Function-like FinSequence-like set;
  let a3 be set;
  cluster 1GateCircStr(a2,a1,a3) -> non empty strict non void;
end;

:: CIRCCOMB:th 43
theorem
for b1, b2 being set
for b3 being Relation-like Function-like FinSequence-like set holds
   the Arity of 1GateCircStr(b3,b1,b2) = {[b3,b1]} --> b3 &
    the ResultSort of 1GateCircStr(b3,b1,b2) = {[b3,b1]} --> b2;

:: CIRCCOMB:th 44
theorem
for b1, b2 being set
for b3 being Relation-like Function-like FinSequence-like set
for b4 being Element of the OperSymbols of 1GateCircStr(b3,b1,b2) holds
   b4 = [b3,b1] & the_arity_of b4 = b3 & the_result_sort_of b4 = b2;

:: CIRCCOMB:th 45
theorem
for b1, b2 being set
for b3 being Relation-like Function-like FinSequence-like set holds
   InputVertices 1GateCircStr(b3,b1,b2) = (proj2 b3) \ {b2} &
    InnerVertices 1GateCircStr(b3,b1,b2) = {b2};

:: CIRCCOMB:funcnot 6 => CIRCCOMB:func 6
definition
  let a1 be set;
  let a2 be Relation-like Function-like FinSequence-like set;
  func 1GateCircStr(A2,A1) -> strict non void ManySortedSign means
    the carrier of it = (proj2 a2) \/ {[a2,a1]} &
     the OperSymbols of it = {[a2,a1]} &
     (the Arity of it) . [a2,a1] = a2 &
     (the ResultSort of it) . [a2,a1] = [a2,a1];
end;

:: CIRCCOMB:def 6
theorem
for b1 being set
for b2 being Relation-like Function-like FinSequence-like set
for b3 being strict non void ManySortedSign holds
      b3 = 1GateCircStr(b2,b1)
   iff
      the carrier of b3 = (proj2 b2) \/ {[b2,b1]} &
       the OperSymbols of b3 = {[b2,b1]} &
       (the Arity of b3) . [b2,b1] = b2 &
       (the ResultSort of b3) . [b2,b1] = [b2,b1];

:: CIRCCOMB:funcreg 6
registration
  let a1 be set;
  let a2 be Relation-like Function-like FinSequence-like set;
  cluster 1GateCircStr(a2,a1) -> non empty strict non void;
end;

:: CIRCCOMB:th 46
theorem
for b1 being set
for b2 being Relation-like Function-like FinSequence-like set holds
   1GateCircStr(b2,b1) = 1GateCircStr(b2,b1,[b2,b1]);

:: CIRCCOMB:th 47
theorem
for b1 being set
for b2 being Relation-like Function-like FinSequence-like set holds
   the Arity of 1GateCircStr(b2,b1) = {[b2,b1]} --> b2 &
    the ResultSort of 1GateCircStr(b2,b1) = {[b2,b1]} --> [b2,b1];

:: CIRCCOMB:th 48
theorem
for b1 being set
for b2 being Relation-like Function-like FinSequence-like set
for b3 being Element of the OperSymbols of 1GateCircStr(b2,b1) holds
   b3 = [b2,b1] & the_arity_of b3 = b2 & the_result_sort_of b3 = b3;

:: CIRCCOMB:th 49
theorem
for b1 being set
for b2 being Relation-like Function-like FinSequence-like set holds
   InputVertices 1GateCircStr(b2,b1) = proj2 b2 &
    InnerVertices 1GateCircStr(b2,b1) = {[b2,b1]};

:: CIRCCOMB:th 50
theorem
for b1 being set
for b2 being Relation-like Function-like FinSequence-like set
for b3 being set
      st b3 in proj2 b2
   holds the_rank_of b3 in the_rank_of [b2,b1];

:: CIRCCOMB:th 51
theorem
for b1 being set
for b2, b3 being Relation-like Function-like FinSequence-like set holds
1GateCircStr(b2,b1) tolerates 1GateCircStr(b3,b1);

:: CIRCCOMB:attrnot 1 => CIRCCOMB:attr 1
definition
  let a1 be ManySortedSign;
  attr a1 is unsplit means
    the ResultSort of a1 = id the OperSymbols of a1;
end;

:: CIRCCOMB:dfs 7
definiens
  let a1 be ManySortedSign;
To prove
     a1 is unsplit
it is sufficient to prove
  thus the ResultSort of a1 = id the OperSymbols of a1;

:: CIRCCOMB:def 7
theorem
for b1 being ManySortedSign holds
      b1 is unsplit
   iff
      the ResultSort of b1 = id the OperSymbols of b1;

:: CIRCCOMB:attrnot 2 => CIRCCOMB:attr 2
definition
  let a1 be ManySortedSign;
  attr a1 is gate`1=arity means
    for b1 being set
          st b1 in the OperSymbols of a1
       holds b1 = [(the Arity of a1) . b1,b1 `2];
end;

:: CIRCCOMB:dfs 8
definiens
  let a1 be ManySortedSign;
To prove
     a1 is gate`1=arity
it is sufficient to prove
  thus for b1 being set
          st b1 in the OperSymbols of a1
       holds b1 = [(the Arity of a1) . b1,b1 `2];

:: CIRCCOMB:def 8
theorem
for b1 being ManySortedSign holds
      b1 is gate`1=arity
   iff
      for b2 being set
            st b2 in the OperSymbols of b1
         holds b2 = [(the Arity of b1) . b2,b2 `2];

:: CIRCCOMB:attrnot 3 => CIRCCOMB:attr 3
definition
  let a1 be ManySortedSign;
  attr a1 is gate`2isBoolean means
    for b1 being set
       st b1 in the OperSymbols of a1
    for b2 being Relation-like Function-like FinSequence-like set
          st b2 = (the Arity of a1) . b1
       holds ex b3 being Function-like quasi_total Relation of (len b2) -tuples_on BOOLEAN,BOOLEAN st
          b1 = [b1 `1,b3];
end;

:: CIRCCOMB:dfs 9
definiens
  let a1 be ManySortedSign;
To prove
     a1 is gate`2isBoolean
it is sufficient to prove
  thus for b1 being set
       st b1 in the OperSymbols of a1
    for b2 being Relation-like Function-like FinSequence-like set
          st b2 = (the Arity of a1) . b1
       holds ex b3 being Function-like quasi_total Relation of (len b2) -tuples_on BOOLEAN,BOOLEAN st
          b1 = [b1 `1,b3];

:: CIRCCOMB:def 9
theorem
for b1 being ManySortedSign holds
      b1 is gate`2isBoolean
   iff
      for b2 being set
         st b2 in the OperSymbols of b1
      for b3 being Relation-like Function-like FinSequence-like set
            st b3 = (the Arity of b1) . b2
         holds ex b4 being Function-like quasi_total Relation of (len b3) -tuples_on BOOLEAN,BOOLEAN st
            b2 = [b2 `1,b4];

:: CIRCCOMB:attrnot 4 => CIRCCOMB:attr 4
definition
  let a1 be non empty ManySortedSign;
  let a2 be MSAlgebra over a1;
  attr a2 is gate`2=den means
    for b1 being set
          st b1 in the OperSymbols of a1
       holds b1 = [b1 `1,(the Charact of a2) . b1];
end;

:: CIRCCOMB:dfs 10
definiens
  let a1 be non empty ManySortedSign;
  let a2 be MSAlgebra over a1;
To prove
     a2 is gate`2=den
it is sufficient to prove
  thus for b1 being set
          st b1 in the OperSymbols of a1
       holds b1 = [b1 `1,(the Charact of a2) . b1];

:: CIRCCOMB:def 10
theorem
for b1 being non empty ManySortedSign
for b2 being MSAlgebra over b1 holds
      b2 is gate`2=den(b1)
   iff
      for b3 being set
            st b3 in the OperSymbols of b1
         holds b3 = [b3 `1,(the Charact of b2) . b3];

:: CIRCCOMB:attrnot 5 => CIRCCOMB:attr 5
definition
  let a1 be non empty ManySortedSign;
  attr a1 is gate`2=den means
    ex b1 being MSAlgebra over a1 st
       b1 is gate`2=den(a1);
end;

:: CIRCCOMB:dfs 11
definiens
  let a1 be non empty ManySortedSign;
To prove
     a1 is gate`2=den
it is sufficient to prove
  thus ex b1 being MSAlgebra over a1 st
       b1 is gate`2=den(a1);

:: CIRCCOMB:def 11
theorem
for b1 being non empty ManySortedSign holds
      b1 is gate`2=den
   iff
      ex b2 being MSAlgebra over b1 st
         b2 is gate`2=den(b1);

:: CIRCCOMB:sch 1
scheme CIRCCOMB:sch 1
{F1 -> set,
  F2 -> set,
  F3 -> Function-like quasi_total Relation of F1(),F2(),
  F4 -> set}:
ex b1 being ManySortedSet of F1() st
   for b2 being set
   for b3 being Element of F2()
         st b2 in F1() & b3 = F3() . b2
      holds b1 . b2 = F4(b2, b3)


:: CIRCCOMB:sch 2
scheme CIRCCOMB:sch 2
{F1 -> non empty ManySortedSign,
  F2 -> set}:
ex b1 being strict MSAlgebra over F1() st
   the Sorts of b1 = (the carrier of F1()) --> BOOLEAN &
    (for b2 being set
    for b3 being Element of (the carrier of F1()) *
          st b2 in the OperSymbols of F1() & b3 = (the Arity of F1()) . b2
       holds (the Charact of b1) . b2 = F2(b2, b3))
provided
   for b1 being set
   for b2 being Element of (the carrier of F1()) *
         st b1 in the OperSymbols of F1() & b2 = (the Arity of F1()) . b1
      holds F2(b1, b2) is Function-like quasi_total Relation of (len b2) -tuples_on BOOLEAN,BOOLEAN;


:: CIRCCOMB:condreg 1
registration
  cluster non empty gate`2isBoolean -> gate`2=den (ManySortedSign);
end;

:: CIRCCOMB:th 52
theorem
for b1 being non empty ManySortedSign holds
      b1 is unsplit
   iff
      for b2 being set
            st b2 in the OperSymbols of b1
         holds (the ResultSort of b1) . b2 = b2;

:: CIRCCOMB:th 53
theorem
for b1 being non empty ManySortedSign
      st b1 is unsplit
   holds the OperSymbols of b1 c= the carrier of b1;

:: CIRCCOMB:condreg 2
registration
  cluster non empty unsplit -> Circuit-like (ManySortedSign);
end;

:: CIRCCOMB:th 54
theorem
for b1 being set
for b2 being Relation-like Function-like FinSequence-like set holds
   1GateCircStr(b2,b1) is unsplit & 1GateCircStr(b2,b1) is gate`1=arity;

:: CIRCCOMB:funcreg 7
registration
  let a1 be set;
  let a2 be Relation-like Function-like FinSequence-like set;
  cluster 1GateCircStr(a2,a1) -> strict non void unsplit gate`1=arity;
end;

:: CIRCCOMB:exreg 1
registration
  cluster non empty strict non void unsplit gate`1=arity ManySortedSign;
end;

:: CIRCCOMB:th 55
theorem
for b1, b2 being non empty unsplit gate`1=arity ManySortedSign holds
b1 tolerates b2;

:: CIRCCOMB:th 56
theorem
for b1, b2 being non empty ManySortedSign
for b3 being MSAlgebra over b1
for b4 being MSAlgebra over b2
      st b3 is gate`2=den(b1) & b4 is gate`2=den(b2)
   holds the Charact of b3 tolerates the Charact of b4;

:: CIRCCOMB:th 57
theorem
for b1, b2 being non empty unsplit ManySortedSign holds
b1 +* b2 is unsplit;

:: CIRCCOMB:funcreg 8
registration
  let a1, a2 be non empty unsplit ManySortedSign;
  cluster a1 +* a2 -> non empty strict unsplit;
end;

:: CIRCCOMB:th 58
theorem
for b1, b2 being non empty gate`1=arity ManySortedSign holds
b1 +* b2 is gate`1=arity;

:: CIRCCOMB:funcreg 9
registration
  let a1, a2 be non empty gate`1=arity ManySortedSign;
  cluster a1 +* a2 -> non empty strict gate`1=arity;
end;

:: CIRCCOMB:th 59
theorem
for b1, b2 being non empty ManySortedSign
      st b1 is gate`2isBoolean & b2 is gate`2isBoolean
   holds b1 +* b2 is gate`2isBoolean;

:: CIRCCOMB:modenot 2 => CIRCCOMB:mode 1
definition
  let a1 be natural set;
  mode FinSeqLen of A1 -> Relation-like Function-like FinSequence-like set means
    len it = a1;
end;

:: CIRCCOMB:dfs 12
definiens
  let a1 be natural set;
  let a2 be Relation-like Function-like FinSequence-like set;
To prove
     a2 is FinSeqLen of a1
it is sufficient to prove
  thus len a2 = a1;

:: CIRCCOMB:def 12
theorem
for b1 being natural set
for b2 being Relation-like Function-like FinSequence-like set holds
      b2 is FinSeqLen of b1
   iff
      len b2 = b1;

:: CIRCCOMB:funcnot 7 => CIRCCOMB:func 7
definition
  let a1 be natural set;
  let a2, a3 be non empty set;
  let a4 be Function-like quasi_total Relation of a1 -tuples_on a2,a3;
  let a5 be FinSeqLen of a1;
  let a6 be set;
  assume (a6 in proj2 a5 implies a2 = a3);
  func 1GateCircuit(A5,A4,A6) -> strict non-empty MSAlgebra over 1GateCircStr(a5,a4,a6) means
    the Sorts of it = ((proj2 a5) --> a2) +* ({a6} --> a3) &
     (the Charact of it) . [a5,a4] = a4;
end;

:: CIRCCOMB:def 13
theorem
for b1 being natural set
for b2, b3 being non empty set
for b4 being Function-like quasi_total Relation of b1 -tuples_on b2,b3
for b5 being FinSeqLen of b1
for b6 being set
   st (b6 in proj2 b5 implies b2 = b3)
for b7 being strict non-empty MSAlgebra over 1GateCircStr(b5,b4,b6) holds
      b7 = 1GateCircuit(b5,b4,b6)
   iff
      the Sorts of b7 = ((proj2 b5) --> b2) +* ({b6} --> b3) &
       (the Charact of b7) . [b5,b4] = b4;

:: CIRCCOMB:funcnot 8 => CIRCCOMB:func 8
definition
  let a1 be natural set;
  let a2 be non empty set;
  let a3 be Function-like quasi_total Relation of a1 -tuples_on a2,a2;
  let a4 be FinSeqLen of a1;
  func 1GateCircuit(A4,A3) -> strict non-empty MSAlgebra over 1GateCircStr(a4,a3) means
    the Sorts of it = (the carrier of 1GateCircStr(a4,a3)) --> a2 &
     (the Charact of it) . [a4,a3] = a3;
end;

:: CIRCCOMB:def 14
theorem
for b1 being natural set
for b2 being non empty set
for b3 being Function-like quasi_total Relation of b1 -tuples_on b2,b2
for b4 being FinSeqLen of b1
for b5 being strict non-empty MSAlgebra over 1GateCircStr(b4,b3) holds
      b5 = 1GateCircuit(b4,b3)
   iff
      the Sorts of b5 = (the carrier of 1GateCircStr(b4,b3)) --> b2 &
       (the Charact of b5) . [b4,b3] = b3;

:: CIRCCOMB:th 60
theorem
for b1 being natural set
for b2 being non empty set
for b3 being Function-like quasi_total Relation of b1 -tuples_on b2,b2
for b4 being FinSeqLen of b1 holds
   1GateCircuit(b4,b3) is gate`2=den(1GateCircStr(b4,b3)) & 1GateCircStr(b4,b3) is gate`2=den;

:: CIRCCOMB:funcreg 10
registration
  let a1 be natural set;
  let a2 be non empty set;
  let a3 be Function-like quasi_total Relation of a1 -tuples_on a2,a2;
  let a4 be FinSeqLen of a1;
  cluster 1GateCircuit(a4,a3) -> strict non-empty gate`2=den;
end;

:: CIRCCOMB:funcreg 11
registration
  let a1 be natural set;
  let a2 be non empty set;
  let a3 be Function-like quasi_total Relation of a1 -tuples_on a2,a2;
  let a4 be FinSeqLen of a1;
  cluster 1GateCircStr(a4,a3) -> strict non void gate`2=den;
end;

:: CIRCCOMB:th 61
theorem
for b1 being natural set
for b2 being FinSeqLen of b1
for b3 being Function-like quasi_total Relation of b1 -tuples_on BOOLEAN,BOOLEAN holds
   1GateCircStr(b2,b3) is gate`2isBoolean;

:: CIRCCOMB:funcreg 12
registration
  let a1 be natural set;
  let a2 be Function-like quasi_total Relation of a1 -tuples_on BOOLEAN,BOOLEAN;
  let a3 be FinSeqLen of a1;
  cluster 1GateCircStr(a3,a2) -> strict non void gate`2isBoolean;
end;

:: CIRCCOMB:exreg 2
registration
  cluster non empty gate`2isBoolean ManySortedSign;
end;

:: CIRCCOMB:funcreg 13
registration
  let a1, a2 be non empty gate`2isBoolean ManySortedSign;
  cluster a1 +* a2 -> non empty strict gate`2isBoolean;
end;

:: CIRCCOMB:th 62
theorem
for b1 being natural set
for b2 being non empty set
for b3 being Function-like quasi_total Relation of b1 -tuples_on b2,b2
for b4 being FinSeqLen of b1 holds
   the Charact of 1GateCircuit(b4,b3) = {[b4,b3]} --> b3 &
    (for b5 being Element of the carrier of 1GateCircStr(b4,b3) holds
       (the Sorts of 1GateCircuit(b4,b3)) . b5 = b2);

:: CIRCCOMB:funcreg 14
registration
  let a1 be natural set;
  let a2 be non empty finite set;
  let a3 be Function-like quasi_total Relation of a1 -tuples_on a2,a2;
  let a4 be FinSeqLen of a1;
  cluster 1GateCircuit(a4,a3) -> strict non-empty locally-finite;
end;

:: CIRCCOMB:th 63
theorem
for b1 being natural set
for b2 being non empty set
for b3 being Function-like quasi_total Relation of b1 -tuples_on b2,b2
for b4, b5 being FinSeqLen of b1 holds
1GateCircuit(b4,b3) tolerates 1GateCircuit(b5,b3);

:: CIRCCOMB:th 64
theorem
for b1 being natural set
for b2 being non empty finite set
for b3 being Function-like quasi_total Relation of b1 -tuples_on b2,b2
for b4 being FinSeqLen of b1
for b5 being Element of product the Sorts of 1GateCircuit(b4,b3) holds
   (Following b5) . [b4,b3] = b3 . (b4 * b5);

:: CIRCCOMB:funcnot 9 => CIRCCOMB:func 9
definition
  redefine func BOOLEAN -> non empty finite Element of bool NAT;
end;

:: CIRCCOMB:attrnot 6 => CIRCCOMB:attr 6
definition
  let a1 be non empty ManySortedSign;
  let a2 be MSAlgebra over a1;
  attr a2 is Boolean means
    for b1 being Element of the carrier of a1 holds
       (the Sorts of a2) . b1 = BOOLEAN;
end;

:: CIRCCOMB:dfs 15
definiens
  let a1 be non empty ManySortedSign;
  let a2 be MSAlgebra over a1;
To prove
     a2 is Boolean
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       (the Sorts of a2) . b1 = BOOLEAN;

:: CIRCCOMB:def 15
theorem
for b1 being non empty ManySortedSign
for b2 being MSAlgebra over b1 holds
      b2 is Boolean(b1)
   iff
      for b3 being Element of the carrier of b1 holds
         (the Sorts of b2) . b3 = BOOLEAN;

:: CIRCCOMB:th 65
theorem
for b1 being non empty ManySortedSign
for b2 being MSAlgebra over b1 holds
      b2 is Boolean(b1)
   iff
      the Sorts of b2 = (the carrier of b1) --> BOOLEAN;

:: CIRCCOMB:condreg 3
registration
  let a1 be non empty ManySortedSign;
  cluster Boolean -> non-empty locally-finite (MSAlgebra over a1);
end;

:: CIRCCOMB:th 66
theorem
for b1 being non empty ManySortedSign
for b2 being MSAlgebra over b1 holds
      b2 is Boolean(b1)
   iff
      proj2 the Sorts of b2 c= {BOOLEAN};

:: CIRCCOMB:th 67
theorem
for b1, b2 being non empty ManySortedSign
for b3 being MSAlgebra over b1
for b4 being MSAlgebra over b2
      st b3 is Boolean(b1) & b4 is Boolean(b2)
   holds the Sorts of b3 tolerates the Sorts of b4;

:: CIRCCOMB:th 68
theorem
for b1, b2 being non empty unsplit gate`1=arity ManySortedSign
for b3 being MSAlgebra over b1
for b4 being MSAlgebra over b2
      st b3 is Boolean(b1) & b3 is gate`2=den(b1) & b4 is Boolean(b2) & b4 is gate`2=den(b2)
   holds b3 tolerates b4;

:: CIRCCOMB:exreg 3
registration
  let a1 be non empty ManySortedSign;
  cluster strict Boolean MSAlgebra over a1;
end;

:: CIRCCOMB:th 69
theorem
for b1 being natural set
for b2 being Function-like quasi_total Relation of b1 -tuples_on BOOLEAN,BOOLEAN
for b3 being FinSeqLen of b1 holds
   1GateCircuit(b3,b2) is Boolean(1GateCircStr(b3,b2));

:: CIRCCOMB:th 70
theorem
for b1, b2 being non empty ManySortedSign
for b3 being Boolean MSAlgebra over b1
for b4 being Boolean MSAlgebra over b2 holds
   b3 +* b4 is Boolean(b1 +* b2);

:: CIRCCOMB:th 71
theorem
for b1, b2 being non empty ManySortedSign
for b3 being non-empty MSAlgebra over b1
for b4 being non-empty MSAlgebra over b2
      st b3 is gate`2=den(b1) & b4 is gate`2=den(b2) & the Sorts of b3 tolerates the Sorts of b4
   holds b3 +* b4 is gate`2=den(b1 +* b2);

:: CIRCCOMB:exreg 4
registration
  cluster non empty strict non void unsplit gate`1=arity gate`2isBoolean gate`2=den ManySortedSign;
end;

:: CIRCCOMB:exreg 5
registration
  let a1 be non empty gate`2isBoolean ManySortedSign;
  cluster strict gate`2=den Boolean MSAlgebra over a1;
end;

:: CIRCCOMB:funcreg 15
registration
  let a1, a2 be non empty non void unsplit gate`2isBoolean ManySortedSign;
  let a3 be locally-finite gate`2=den Boolean MSAlgebra over a1;
  let a4 be locally-finite gate`2=den Boolean MSAlgebra over a2;
  cluster a3 +* a4 -> strict non-empty gate`2=den Boolean;
end;

:: CIRCCOMB:exreg 6
registration
  let a1 be natural set;
  let a2 be non empty finite set;
  let a3 be Function-like quasi_total Relation of a1 -tuples_on a2,a2;
  let a4 be FinSeqLen of a1;
  cluster strict non-empty locally-finite gate`2=den MSAlgebra over 1GateCircStr(a4,a3);
end;

:: CIRCCOMB:funcreg 16
registration
  let a1 be natural set;
  let a2 be non empty finite set;
  let a3 be Function-like quasi_total Relation of a1 -tuples_on a2,a2;
  let a4 be FinSeqLen of a1;
  cluster 1GateCircuit(a4,a3) -> strict non-empty gate`2=den;
end;

:: CIRCCOMB:th 72
theorem
for b1, b2 being non empty non void unsplit gate`1=arity gate`2isBoolean ManySortedSign
for b3 being locally-finite gate`2=den Boolean MSAlgebra over b1
for b4 being locally-finite gate`2=den Boolean MSAlgebra over b2
for b5 being Element of product the Sorts of b3 +* b4
for b6 being Element of the carrier of b1 +* b2 holds
   (for b7 being Element of product the Sorts of b3
          st b7 = b5 | the carrier of b1 &
             (b6 in InnerVertices b1 or b6 in the carrier of b1 & b6 in InputVertices (b1 +* b2))
       holds (Following b5) . b6 = (Following b7) . b6) &
    (for b7 being Element of product the Sorts of b4
          st b7 = b5 | the carrier of b2 &
             (b6 in InnerVertices b2 or b6 in the carrier of b2 & b6 in InputVertices (b1 +* b2))
       holds (Following b5) . b6 = (Following b7) . b6);