Article CIRCCMB3, MML version 4.99.1005

:: CIRCCMB3:th 1
theorem
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty locally-finite MSAlgebra over b1
for b3 being Element of product the Sorts of b2
for b4 being set
   st b4 in InputVertices b1
for b5 being Element of NAT holds
   (Following(b3,b5)) . b4 = b3 . b4;

:: CIRCCMB3:attrnot 1 => CIRCCMB3:attr 1
definition
  let a1 be non empty non void Circuit-like ManySortedSign;
  let a2 be non-empty locally-finite MSAlgebra over a1;
  let a3 be Element of product the Sorts of a2;
  attr a3 is stabilizing means
    ex b1 being Element of NAT st
       Following(a3,b1) is stable(a1, a2);
end;

:: CIRCCMB3:dfs 1
definiens
  let a1 be non empty non void Circuit-like ManySortedSign;
  let a2 be non-empty locally-finite MSAlgebra over a1;
  let a3 be Element of product the Sorts of a2;
To prove
     a3 is stabilizing
it is sufficient to prove
  thus ex b1 being Element of NAT st
       Following(a3,b1) is stable(a1, a2);

:: CIRCCMB3:def 1
theorem
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty locally-finite MSAlgebra over b1
for b3 being Element of product the Sorts of b2 holds
      b3 is stabilizing(b1, b2)
   iff
      ex b4 being Element of NAT st
         Following(b3,b4) is stable(b1, b2);

:: CIRCCMB3:attrnot 2 => CIRCCMB3:attr 2
definition
  let a1 be non empty non void Circuit-like ManySortedSign;
  let a2 be non-empty locally-finite MSAlgebra over a1;
  attr a2 is stabilizing means
    for b1 being Element of product the Sorts of a2 holds
       b1 is stabilizing(a1, a2);
end;

:: CIRCCMB3:dfs 2
definiens
  let a1 be non empty non void Circuit-like ManySortedSign;
  let a2 be non-empty locally-finite MSAlgebra over a1;
To prove
     a2 is stabilizing
it is sufficient to prove
  thus for b1 being Element of product the Sorts of a2 holds
       b1 is stabilizing(a1, a2);

:: CIRCCMB3:def 2
theorem
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty locally-finite MSAlgebra over b1 holds
      b2 is stabilizing(b1)
   iff
      for b3 being Element of product the Sorts of b2 holds
         b3 is stabilizing(b1, b2);

:: CIRCCMB3:attrnot 3 => CIRCCMB3:attr 3
definition
  let a1 be non empty non void Circuit-like ManySortedSign;
  let a2 be non-empty locally-finite MSAlgebra over a1;
  attr a2 is with_stabilization-limit means
    ex b1 being Element of NAT st
       for b2 being Element of product the Sorts of a2 holds
          Following(b2,b1) is stable(a1, a2);
end;

:: CIRCCMB3:dfs 3
definiens
  let a1 be non empty non void Circuit-like ManySortedSign;
  let a2 be non-empty locally-finite MSAlgebra over a1;
To prove
     a2 is with_stabilization-limit
it is sufficient to prove
  thus ex b1 being Element of NAT st
       for b2 being Element of product the Sorts of a2 holds
          Following(b2,b1) is stable(a1, a2);

:: CIRCCMB3:def 3
theorem
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty locally-finite MSAlgebra over b1 holds
      b2 is with_stabilization-limit(b1)
   iff
      ex b3 being Element of NAT st
         for b4 being Element of product the Sorts of b2 holds
            Following(b4,b3) is stable(b1, b2);

:: CIRCCMB3:condreg 1
registration
  let a1 be non empty non void Circuit-like ManySortedSign;
  cluster non-empty locally-finite with_stabilization-limit -> stabilizing (MSAlgebra over a1);
end;

:: CIRCCMB3:funcnot 1 => CIRCCMB3:func 1
definition
  let a1 be non empty non void Circuit-like ManySortedSign;
  let a2 be non-empty locally-finite MSAlgebra over a1;
  let a3 be Element of product the Sorts of a2;
  assume a3 is stabilizing(a1, a2);
  func Result A3 -> Element of product the Sorts of a2 means
    it is stable(a1, a2) &
     (ex b1 being Element of NAT st
        it = Following(a3,b1));
end;

:: CIRCCMB3:def 4
theorem
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty locally-finite MSAlgebra over b1
for b3 being Element of product the Sorts of b2
   st b3 is stabilizing(b1, b2)
for b4 being Element of product the Sorts of b2 holds
      b4 = Result b3
   iff
      b4 is stable(b1, b2) &
       (ex b5 being Element of NAT st
          b4 = Following(b3,b5));

:: CIRCCMB3:funcnot 2 => CIRCCMB3:func 2
definition
  let a1 be non empty non void Circuit-like ManySortedSign;
  let a2 be non-empty locally-finite MSAlgebra over a1;
  let a3 be Element of product the Sorts of a2;
  assume a3 is stabilizing(a1, a2);
  func stabilization-time A3 -> Element of NAT means
    Following(a3,it) is stable(a1, a2) &
     (for b1 being Element of NAT
           st b1 < it
        holds Following(a3,b1) is not stable(a1, a2));
end;

:: CIRCCMB3:def 5
theorem
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty locally-finite MSAlgebra over b1
for b3 being Element of product the Sorts of b2
   st b3 is stabilizing(b1, b2)
for b4 being Element of NAT holds
      b4 = stabilization-time b3
   iff
      Following(b3,b4) is stable(b1, b2) &
       (for b5 being Element of NAT
             st b5 < b4
          holds Following(b3,b5) is not stable(b1, b2));

:: CIRCCMB3:th 2
theorem
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty locally-finite MSAlgebra over b1
for b3 being Element of product the Sorts of b2
      st b3 is stabilizing(b1, b2)
   holds Result b3 = Following(b3,stabilization-time b3);

:: CIRCCMB3:th 3
theorem
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty locally-finite MSAlgebra over b1
for b3 being Element of product the Sorts of b2
for b4 being Element of NAT
      st Following(b3,b4) is stable(b1, b2)
   holds stabilization-time b3 <= b4;

:: CIRCCMB3:th 4
theorem
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty locally-finite MSAlgebra over b1
for b3 being Element of product the Sorts of b2
for b4 being Element of NAT
      st Following(b3,b4) is stable(b1, b2)
   holds Result b3 = Following(b3,b4);

:: CIRCCMB3:th 5
theorem
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty locally-finite MSAlgebra over b1
for b3 being Element of product the Sorts of b2
for b4 being Element of NAT
      st b3 is stabilizing(b1, b2) & stabilization-time b3 <= b4
   holds Result b3 = Following(b3,b4);

:: CIRCCMB3:th 6
theorem
for b1 being non empty non void Circuit-like ManySortedSign
for b2 being non-empty locally-finite MSAlgebra over b1
for b3 being Element of product the Sorts of b2
   st b3 is stabilizing(b1, b2)
for b4 being set
      st b4 in InputVertices b1
   holds (Result b3) . b4 = b3 . b4;

:: CIRCCMB3:th 8
theorem
for b1, b2 being non empty non void Circuit-like ManySortedSign
   st InputVertices b1 misses InnerVertices b2 & InputVertices b2 misses InnerVertices b1
for 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
   st b4 tolerates b5
for b6 being non-empty locally-finite MSAlgebra over b3
   st 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 & b8 is stabilizing(b1, b4) & b9 is stabilizing(b2, b5)
   holds b7 is stabilizing(b3, b6);

:: CIRCCMB3:th 9
theorem
for b1, b2 being non empty non void Circuit-like ManySortedSign
   st InputVertices b1 misses InnerVertices b2 & InputVertices b2 misses InnerVertices b1
for 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
   st b4 tolerates b5
for b6 being non-empty locally-finite MSAlgebra over b3
   st b6 = b4 +* b5
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 & b8 is stabilizing(b1, b4)
for b9 being Element of product the Sorts of b5
      st b9 = b7 | the carrier of b2 & b9 is stabilizing(b2, b5)
   holds stabilization-time b7 = max(stabilization-time b8,stabilization-time b9);

:: CIRCCMB3:th 10
theorem
for b1, b2 being non empty non void Circuit-like ManySortedSign
   st InputVertices b1 misses InnerVertices b2
for 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
   st b4 tolerates b5
for b6 being non-empty locally-finite MSAlgebra over b3
   st b6 = b4 +* b5
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 & b8 is stabilizing(b1, b4)
for b9 being Element of product the Sorts of b5
      st b9 = (Following(b7,stabilization-time b8)) | the carrier of b2 &
         b9 is stabilizing(b2, b5)
   holds b7 is stabilizing(b3, b6);

:: CIRCCMB3:th 11
theorem
for b1, b2 being non empty non void Circuit-like ManySortedSign
   st InputVertices b1 misses InnerVertices b2
for 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
   st b4 tolerates b5
for b6 being non-empty locally-finite MSAlgebra over b3
   st b6 = b4 +* b5
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 & b8 is stabilizing(b1, b4)
for b9 being Element of product the Sorts of b5
      st b9 = (Following(b7,stabilization-time b8)) | the carrier of b2 &
         b9 is stabilizing(b2, b5)
   holds stabilization-time b7 = (stabilization-time b8) + stabilization-time b9;

:: CIRCCMB3:th 12
theorem
for b1, b2, b3 being non empty non void Circuit-like ManySortedSign
   st InputVertices b1 misses InnerVertices 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
   st b8 = b7 | the carrier of b1 & b8 is stabilizing(b1, b4)
for b9 being Element of product the Sorts of b5
      st b9 = (Following(b7,stabilization-time b8)) | the carrier of b2 &
         b9 is stabilizing(b2, b5)
   holds (Result b7) | the carrier of b1 = Result b8;

:: CIRCCMB3:th 13
theorem
for b1 being set
for b2 being non empty finite set
for b3 being Element of NAT
for b4 being FinSeqLen of b3
for b5 being Function-like quasi_total Relation of b3 -tuples_on b2,b2
for b6 being Element of product the Sorts of 1GateCircuit(b4,b5) holds
   b4 * b6 is Element of b3 -tuples_on b2;

:: CIRCCMB3:th 14
theorem
for b1, b2, b3, b4 being set holds
proj2 <*b1,b2,b3,b4*> = {b1,b2,b3,b4};

:: CIRCCMB3:th 15
theorem
for b1, b2, b3, b4, b5 being set holds
proj2 <*b1,b2,b3,b4,b5*> = {b1,b2,b3,b4,b5};

:: CIRCCMB3:funcnot 3 => CIRCCMB3:func 3
definition
  let a1, a2, a3, a4 be set;
  redefine func <*a1, a2, a3, a4*> -> FinSeqLen of 4;
end;

:: CIRCCMB3:funcnot 4 => CIRCCMB3:func 4
definition
  let a1, a2, a3, a4, a5 be set;
  redefine func <*a1, a2, a3, a4, a5*> -> FinSeqLen of 5;
end;

:: CIRCCMB3:attrnot 4 => CIRCCMB3:attr 4
definition
  let a1 be ManySortedSign;
  attr a1 is one-gate means
    ex b1 being non empty finite set st
       ex b2 being Element of NAT st
          ex b3 being FinSeqLen of b2 st
             ex b4 being Function-like quasi_total Relation of b2 -tuples_on b1,b1 st
                a1 = 1GateCircStr(b3,b4);
end;

:: CIRCCMB3:dfs 6
definiens
  let a1 be ManySortedSign;
To prove
     a1 is one-gate
it is sufficient to prove
  thus ex b1 being non empty finite set st
       ex b2 being Element of NAT st
          ex b3 being FinSeqLen of b2 st
             ex b4 being Function-like quasi_total Relation of b2 -tuples_on b1,b1 st
                a1 = 1GateCircStr(b3,b4);

:: CIRCCMB3:def 6
theorem
for b1 being ManySortedSign holds
      b1 is one-gate
   iff
      ex b2 being non empty finite set st
         ex b3 being Element of NAT st
            ex b4 being FinSeqLen of b3 st
               ex b5 being Function-like quasi_total Relation of b3 -tuples_on b2,b2 st
                  b1 = 1GateCircStr(b4,b5);

:: CIRCCMB3:attrnot 5 => CIRCCMB3:attr 5
definition
  let a1 be non empty ManySortedSign;
  let a2 be MSAlgebra over a1;
  attr a2 is one-gate means
    ex b1 being non empty finite set st
       ex b2 being Element of NAT st
          ex b3 being FinSeqLen of b2 st
             ex b4 being Function-like quasi_total Relation of b2 -tuples_on b1,b1 st
                a1 = 1GateCircStr(b3,b4) & a2 = 1GateCircuit(b3,b4);
end;

:: CIRCCMB3:dfs 7
definiens
  let a1 be non empty ManySortedSign;
  let a2 be MSAlgebra over a1;
To prove
     a2 is one-gate
it is sufficient to prove
  thus ex b1 being non empty finite set st
       ex b2 being Element of NAT st
          ex b3 being FinSeqLen of b2 st
             ex b4 being Function-like quasi_total Relation of b2 -tuples_on b1,b1 st
                a1 = 1GateCircStr(b3,b4) & a2 = 1GateCircuit(b3,b4);

:: CIRCCMB3:def 7
theorem
for b1 being non empty ManySortedSign
for b2 being MSAlgebra over b1 holds
      b2 is one-gate(b1)
   iff
      ex b3 being non empty finite set st
         ex b4 being Element of NAT st
            ex b5 being FinSeqLen of b4 st
               ex b6 being Function-like quasi_total Relation of b4 -tuples_on b3,b3 st
                  b1 = 1GateCircStr(b5,b6) & b2 = 1GateCircuit(b5,b6);

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

:: CIRCCMB3:condreg 2
registration
  cluster one-gate -> non empty finite strict non void unsplit gate`1=arity (ManySortedSign);
end;

:: CIRCCMB3:condreg 3
registration
  cluster non empty one-gate -> gate`2=den (ManySortedSign);
end;

:: CIRCCMB3:funcreg 2
registration
  let a1 be non empty finite set;
  let a2 be Element of NAT;
  let a3 be FinSeqLen of a2;
  let a4 be Function-like quasi_total Relation of a2 -tuples_on a1,a1;
  cluster 1GateCircStr(a3,a4) -> strict non void one-gate;
end;

:: CIRCCMB3:exreg 1
registration
  cluster one-gate ManySortedSign;
end;

:: CIRCCMB3:condreg 4
registration
  let a1 be one-gate ManySortedSign;
  cluster locally-finite one-gate -> strict non-empty (MSAlgebra over a1);
end;

:: CIRCCMB3:funcreg 3
registration
  let a1 be non empty finite set;
  let a2 be Element of NAT;
  let a3 be FinSeqLen of a2;
  let a4 be Function-like quasi_total Relation of a2 -tuples_on a1,a1;
  cluster 1GateCircuit(a3,a4) -> strict non-empty one-gate;
end;

:: CIRCCMB3:exreg 2
registration
  let a1 be one-gate ManySortedSign;
  cluster non-empty locally-finite one-gate MSAlgebra over a1;
end;

:: CIRCCMB3:funcnot 5 => CIRCCMB3:func 5
definition
  let a1 be one-gate ManySortedSign;
  func Output A1 -> Element of the carrier of a1 equals
    union the OperSymbols of a1;
end;

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

:: CIRCCMB3:funcreg 4
registration
  let a1 be one-gate ManySortedSign;
  cluster Output a1 -> pair;
end;

:: CIRCCMB3:th 16
theorem
for b1 being one-gate ManySortedSign
for b2 being Relation-like Function-like FinSequence-like set
for b3 being set
      st b1 = 1GateCircStr(b2,b3)
   holds Output b1 = [b2,b3];

:: CIRCCMB3:th 17
theorem
for b1 being one-gate ManySortedSign holds
   InnerVertices b1 = {Output b1};

:: CIRCCMB3:th 18
theorem
for b1 being one-gate ManySortedSign
for b2 being locally-finite one-gate MSAlgebra over b1
for b3 being Element of NAT
for b4 being non empty finite set
for b5 being Function-like quasi_total Relation of b3 -tuples_on b4,b4
for b6 being FinSeqLen of b3
      st b2 = 1GateCircuit(b6,b5)
   holds b1 = 1GateCircStr(b6,b5);

:: CIRCCMB3:th 19
theorem
for b1 being Element of NAT
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) . Output 1GateCircStr(b4,b3) = b3 . (b4 * b5);

:: CIRCCMB3:th 20
theorem
for b1 being one-gate ManySortedSign
for b2 being locally-finite one-gate MSAlgebra over b1
for b3 being Element of product the Sorts of b2 holds
   Following b3 is stable(b1, b2);

:: CIRCCMB3:condreg 5
registration
  let a1 be non empty non void Circuit-like ManySortedSign;
  cluster non-empty locally-finite one-gate -> with_stabilization-limit (MSAlgebra over a1);
end;

:: CIRCCMB3:th 21
theorem
for b1 being one-gate ManySortedSign
for b2 being locally-finite one-gate MSAlgebra over b1
for b3 being Element of product the Sorts of b2 holds
   Result b3 = Following b3;

:: CIRCCMB3:th 22
theorem
for b1 being one-gate ManySortedSign
for b2 being locally-finite one-gate MSAlgebra over b1
for b3 being Element of product the Sorts of b2 holds
   stabilization-time b3 <= 1;

:: CIRCCMB3:sch 1
scheme CIRCCMB3:sch 1
{F1 -> set,
  F2 -> non empty finite set,
  F3 -> Element of F2()}:
ex b1 being one-gate ManySortedSign st
   ex b2 being locally-finite one-gate MSAlgebra over b1 st
      InputVertices b1 = {F1()} &
       (for b3 being Element of product the Sorts of b2 holds
          (Result b3) . Output b1 = F3(b3 . F1()))


:: CIRCCMB3:sch 2
scheme CIRCCMB3:sch 2
{F1 -> set,
  F2 -> set,
  F3 -> non empty finite set,
  F4 -> Element of F3()}:
ex b1 being one-gate ManySortedSign st
   ex b2 being locally-finite one-gate MSAlgebra over b1 st
      InputVertices b1 = {F1(),F2()} &
       (for b3 being Element of product the Sorts of b2 holds
          (Result b3) . Output b1 = F4(b3 . F1(), b3 . F2()))


:: CIRCCMB3:sch 3
scheme CIRCCMB3:sch 3
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> non empty finite set,
  F5 -> Element of F4()}:
ex b1 being one-gate ManySortedSign st
   ex b2 being locally-finite one-gate MSAlgebra over b1 st
      InputVertices b1 = {F1(),F2(),F3()} &
       (for b3 being Element of product the Sorts of b2 holds
          (Result b3) . Output b1 = F5(b3 . F1(), b3 . F2(), b3 . F3()))


:: CIRCCMB3:sch 4
scheme CIRCCMB3:sch 4
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> set,
  F5 -> non empty finite set,
  F6 -> Element of F5()}:
ex b1 being one-gate ManySortedSign st
   ex b2 being locally-finite one-gate MSAlgebra over b1 st
      InputVertices b1 = {F1(),F2(),F3(),F4()} &
       (for b3 being Element of product the Sorts of b2 holds
          (Result b3) . Output b1 = F6(b3 . F1(), b3 . F2(), b3 . F3(), b3 . F4()))


:: CIRCCMB3:sch 5
scheme CIRCCMB3:sch 5
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> set,
  F5 -> set,
  F6 -> non empty finite set,
  F7 -> Element of F6()}:
ex b1 being one-gate ManySortedSign st
   ex b2 being locally-finite one-gate MSAlgebra over b1 st
      InputVertices b1 = {F1(),F2(),F3(),F4(),F5()} &
       (for b3 being Element of product the Sorts of b2 holds
          (Result b3) . Output b1 = F7(b3 . F1(), b3 . F2(), b3 . F3(), b3 . F4(), b3 . F5()))


:: CIRCCMB3:th 23
theorem
for b1 being Relation-like Function-like constant set holds
   b1 = (proj1 b1) --> the_value_of b1;

:: CIRCCMB3:th 24
theorem
for b1, b2 being non empty set
for b3, b4 being Element of NAT
      st b3 <> 0 & b3 -tuples_on b1 = b4 -tuples_on b2
   holds b1 = b2 & b3 = b4;

:: CIRCCMB3:th 25
theorem
for b1, b2 being non empty ManySortedSign
for b3 being Element of the carrier of b1 holds
   b3 is Element of the carrier of b1 +* b2;

:: CIRCCMB3:th 26
theorem
for b1, b2 being non empty ManySortedSign
for b3 being Element of the carrier of b2 holds
   b3 is Element of the carrier of b1 +* b2;

:: CIRCCMB3:modenot 1 => CIRCCMB3:mode 1
definition
  let a1 be non empty finite set;
  mode Signature of A1 -> non empty non void unsplit gate`1=arity gate`2=den ManySortedSign means
    ex b1 being locally-finite MSAlgebra over it st
       the Sorts of b1 is constant & the_value_of the Sorts of b1 = a1 & b1 is gate`2=den(it);
end;

:: CIRCCMB3:dfs 9
definiens
  let a1 be non empty finite set;
  let a2 be non empty non void unsplit gate`1=arity gate`2=den ManySortedSign;
To prove
     a2 is Signature of a1
it is sufficient to prove
  thus ex b1 being locally-finite MSAlgebra over a2 st
       the Sorts of b1 is constant & the_value_of the Sorts of b1 = a1 & b1 is gate`2=den(a2);

:: CIRCCMB3:def 9
theorem
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 locally-finite MSAlgebra over b2 st
         the Sorts of b3 is constant & the_value_of the Sorts of b3 = b1 & b3 is gate`2=den(b2);

:: CIRCCMB3:th 27
theorem
for b1 being Element of NAT
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 holds
   1GateCircStr(b4,b3) is Signature of b2;

:: CIRCCMB3:exreg 3
registration
  let a1 be non empty finite set;
  cluster non empty strict non void Circuit-like unsplit gate`1=arity gate`2=den one-gate Signature of a1;
end;

:: CIRCCMB3:funcnot 6 => CIRCCMB3:func 6
definition
  let a1 be Element of NAT;
  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;
  redefine func 1GateCircStr(a4,a3) -> strict Signature of a2;
end;

:: CIRCCMB3:modenot 2 => CIRCCMB3:mode 2
definition
  let a1 be non empty finite set;
  let a2 be Signature of a1;
  mode Circuit of A1,A2 -> locally-finite MSAlgebra over a2 means
    it is gate`2=den(a2) & the Sorts of it is constant & the_value_of the Sorts of it = a1;
end;

:: CIRCCMB3:dfs 10
definiens
  let a1 be non empty finite set;
  let a2 be Signature of a1;
  let a3 be locally-finite MSAlgebra over a2;
To prove
     a3 is Circuit of a1,a2
it is sufficient to prove
  thus a3 is gate`2=den(a2) & the Sorts of a3 is constant & the_value_of the Sorts of a3 = a1;

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

:: CIRCCMB3:condreg 6
registration
  let a1 be non empty finite set;
  let a2 be Signature of a1;
  cluster -> non-empty gate`2=den (Circuit of a1,a2);
end;

:: CIRCCMB3:th 28
theorem
for b1 being Element of NAT
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 holds
   1GateCircuit(b4,b3) is Circuit of b2,1GateCircStr(b4,b3);

:: CIRCCMB3:exreg 4
registration
  let a1 be non empty finite set;
  let a2 be one-gate Signature of a1;
  cluster strict non-empty locally-finite gate`2=den one-gate Circuit of a1,a2;
end;

:: CIRCCMB3:exreg 5
registration
  let a1 be non empty finite set;
  let a2 be Signature of a1;
  cluster strict non-empty locally-finite gate`2=den Circuit of a1,a2;
end;

:: CIRCCMB3:funcnot 7 => CIRCCMB3:func 7
definition
  let a1 be Element of NAT;
  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;
  redefine func 1GateCircuit(a4,a3) -> strict Circuit of a2,1GateCircStr(a4,a3);
end;

:: CIRCCMB3:th 30
theorem
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;

:: CIRCCMB3:th 31
theorem
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 locally-finite MSAlgebra over b2 +* b3;

:: CIRCCMB3:th 32
theorem
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(b2 +* b3);

:: CIRCCMB3:th 33
theorem
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;

:: CIRCCMB3:funcreg 5
registration
  let a1, a2 be non empty finite ManySortedSign;
  cluster a1 +* a2 -> non empty finite strict;
end;

:: CIRCCMB3:funcreg 6
registration
  let a1 be non empty finite set;
  let a2, a3 be Signature of a1;
  cluster a2 +* a3 -> non empty strict gate`2=den;
end;

:: CIRCCMB3:funcnot 8 => CIRCCMB3:func 8
definition
  let a1 be non empty finite set;
  let a2, a3 be Signature of a1;
  redefine func a2 +* a3 -> strict Signature of a1;
end;

:: CIRCCMB3:funcnot 9 => CIRCCMB3:func 9
definition
  let a1 be non empty finite set;
  let a2, a3 be Signature of a1;
  let a4 be Circuit of a1,a2;
  let a5 be Circuit of a1,a3;
  redefine func a4 +* a5 -> strict Circuit of a1,a2 +* a3;
end;

:: CIRCCMB3:th 34
theorem
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];

:: CIRCCMB3:th 35
theorem
for b1 being non empty finite non void unsplit gate`1=arity gate`2=den ManySortedSign
for b2 being non-empty locally-finite MSAlgebra over b1
      st b2 is gate`2=den(b1)
   holds b2 is with_stabilization-limit(b1);

:: CIRCCMB3:condreg 7
registration
  let a1 be non empty finite set;
  let a2 be finite Signature of a1;
  cluster -> with_stabilization-limit (Circuit of a1,a2);
end;

:: CIRCCMB3:sch 6
scheme CIRCCMB3:sch 6
{F1 -> non empty set,
  F2 -> Element of F1()}:
(ex b1 being Function-like quasi_total Relation of 1 -tuples_on F1(),F1() st
    for b2 being Element of F1() holds
       b1 . <*b2*> = F2(b2)) &
 (for b1, b2 being Function-like quasi_total Relation 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)


:: CIRCCMB3:sch 7
scheme CIRCCMB3:sch 7
{F1 -> non empty set,
  F2 -> Element of F1()}:
(ex b1 being Function-like quasi_total Relation 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-like quasi_total Relation 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)


:: CIRCCMB3:sch 8
scheme CIRCCMB3:sch 8
{F1 -> non empty set,
  F2 -> Element of F1()}:
(ex b1 being Function-like quasi_total Relation 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-like quasi_total Relation 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)


:: CIRCCMB3:th 36
theorem
for b1 being Relation-like Function-like set
for b2 being set
      st b2 in proj1 b1
   holds <*b2*> * b1 = <*b1 . b2*>;

:: CIRCCMB3:th 37
theorem
for b1 being Relation-like Function-like set
for b2, b3, b4, b5 being set
      st b2 in proj1 b1 & b3 in proj1 b1 & b4 in proj1 b1 & b5 in proj1 b1
   holds <*b2,b3,b4,b5*> * b1 = <*b1 . b2,b1 . b3,b1 . b4,b1 . b5*>;

:: CIRCCMB3:th 38
theorem
for b1 being Relation-like Function-like set
for b2, b3, b4, b5, b6 being set
      st b2 in proj1 b1 & b3 in proj1 b1 & b4 in proj1 b1 & b5 in proj1 b1 & b6 in proj1 b1
   holds <*b2,b3,b4,b5,b6*> * b1 = <*b1 . b2,b1 . b3,b1 . b4,b1 . b5,b1 . b6*>;

:: CIRCCMB3:sch 9
scheme CIRCCMB3:sch 9
{F1 -> set,
  F2 -> non empty finite set,
  F3 -> Element of F2(),
  F4 -> Function-like quasi_total Relation of 1 -tuples_on F2(),F2()}:
for b1 being Element of product the Sorts of 1GateCircuit(<*F1()*>,F4())
for b2 being Element of F2()
      st b2 = b1 . F1()
   holds (Result b1) . Output 1GateCircStr(<*F1()*>,F4()) = F3(b2)
provided
   for b1 being Function-like quasi_total Relation of 1 -tuples_on F2(),F2() holds
         b1 = F4()
      iff
         for b2 being Element of F2() holds
            b1 . <*b2*> = F3(b2);


:: CIRCCMB3:sch 10
scheme CIRCCMB3:sch 10
{F1 -> set,
  F2 -> set,
  F3 -> non empty finite set,
  F4 -> Element of F3(),
  F5 -> Function-like quasi_total Relation of 2 -tuples_on F3(),F3()}:
for b1 being Element of product the Sorts 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
   for b1 being Function-like quasi_total Relation of 2 -tuples_on F3(),F3() holds
         b1 = F5()
      iff
         for b2, b3 being Element of F3() holds
         b1 . <*b2,b3*> = F4(b2, b3);


:: CIRCCMB3:sch 11
scheme CIRCCMB3:sch 11
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> non empty finite set,
  F5 -> Element of F4(),
  F6 -> Function-like quasi_total Relation of 3 -tuples_on F4(),F4()}:
for b1 being Element of product the Sorts 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
   for b1 being Function-like quasi_total Relation 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);


:: CIRCCMB3:sch 12
scheme CIRCCMB3:sch 12
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> set,
  F5 -> non empty finite set,
  F6 -> Element of F5(),
  F7 -> Function-like quasi_total Relation of 4 -tuples_on F5(),F5()}:
for b1 being Element of product the Sorts 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
   for b1 being Function-like quasi_total Relation 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);


:: CIRCCMB3:sch 13
scheme CIRCCMB3:sch 13
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> set,
  F5 -> set,
  F6 -> non empty finite set,
  F7 -> Element of F6(),
  F8 -> Function-like quasi_total Relation of 5 -tuples_on F6(),F6()}:
for b1 being Element of product the Sorts 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
   for b1 being Function-like quasi_total Relation 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);


:: CIRCCMB3:th 39
theorem
for b1 being Element of NAT
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 Signature of b2
      st proj2 b4 c= the carrier of b5 & not Output 1GateCircStr(b4,b3) in InputVertices b5
   holds InputVertices (b5 +* 1GateCircStr(b4,b3)) = InputVertices b5;

:: CIRCCMB3:th 40
theorem
for b1, b2 being set
for b3 being non empty finite set
for b4 being Element of NAT
for b5 being Function-like quasi_total Relation of b4 -tuples_on b3,b3
for b6 being FinSeqLen of b4
for b7 being Signature of b3
      st proj2 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;

:: CIRCCMB3:th 41
theorem
for b1 being set
for b2 being non empty finite set
for b3 being Function-like quasi_total Relation 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;

:: CIRCCMB3:th 42
theorem
for b1, b2 being set
for b3 being non empty finite set
for b4 being Function-like quasi_total Relation 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};

:: CIRCCMB3:th 43
theorem
for b1, b2 being set
for b3 being non empty finite set
for b4 being Function-like quasi_total Relation 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};

:: CIRCCMB3:th 44
theorem
for b1, b2 being set
for b3 being non empty finite set
for b4 being Function-like quasi_total Relation 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;

:: CIRCCMB3:th 45
theorem
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function-like quasi_total Relation 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};

:: CIRCCMB3:th 46
theorem
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function-like quasi_total Relation 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};

:: CIRCCMB3:th 47
theorem
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function-like quasi_total Relation 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};

:: CIRCCMB3:th 48
theorem
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function-like quasi_total Relation 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};

:: CIRCCMB3:th 49
theorem
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function-like quasi_total Relation 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};

:: CIRCCMB3:th 50
theorem
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function-like quasi_total Relation 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};

:: CIRCCMB3:th 51
theorem
for b1, b2, b3 being set
for b4 being non empty finite set
for b5 being Function-like quasi_total Relation 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;

:: CIRCCMB3:th 52
theorem
for b1 being non empty finite set
for b2 being finite Signature of b1
for b3 being Circuit of b1,b2
for b4 being Element of NAT
for b5 being Function-like quasi_total Relation of b4 -tuples_on b1,b1
for b6 being FinSeqLen of b4
   st not Output 1GateCircStr(b6,b5) in InputVertices b2
for b7 being Element of product the Sorts of b3 +* 1GateCircuit(b6,b5)
for b8 being Element of product the Sorts of b3
      st b8 = b7 | the carrier of b2
   holds stabilization-time b7 <= 1 + stabilization-time b8;

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


:: CIRCCMB3:sch 15
scheme CIRCCMB3:sch 15
{F1 -> set,
  F2 -> set,
  F3 -> non empty finite set,
  F4 -> Element of F3(),
  F5 -> finite Signature of F3(),
  F6 -> Circuit of F3(),F5(),
  F7 -> Function-like quasi_total Relation of 2 -tuples_on F3(),F3()}:
for b1 being Element of product the Sorts of F6() +* 1GateCircuit(<*F1(),F2()*>,F7())
for b2 being Element of product the Sorts of F6()
   st b2 = b1 | the carrier of F5()
for b3, b4 being Element of F3()
      st (F1() in InnerVertices F5() implies b3 = (Result b2) . F1()) & (F1() in InnerVertices F5() or b3 = b1 . F1()) & (F2() in InnerVertices F5() implies b4 = (Result b2) . F2()) & (F2() in InnerVertices F5() or b4 = b1 . F2())
   holds (Result b1) . Output 1GateCircStr(<*F1(),F2()*>,F7()) = F4(b3, b4)
provided
   for b1 being Function-like quasi_total Relation 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
   not Output 1GateCircStr(<*F1(),F2()*>,F7()) in InputVertices F5();


:: CIRCCMB3:sch 16
scheme CIRCCMB3:sch 16
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> non empty finite set,
  F5 -> Element of F4(),
  F6 -> finite Signature of F4(),
  F7 -> Circuit of F4(),F6(),
  F8 -> Function-like quasi_total Relation of 3 -tuples_on F4(),F4()}:
for b1 being Element of product the Sorts of F7() +* 1GateCircuit(<*F1(),F2(),F3()*>,F8())
for b2 being Element of product the Sorts of F7()
   st b2 = b1 | the carrier of F6()
for b3, b4, b5 being Element of F4()
      st (F1() in InnerVertices F6() implies b3 = (Result b2) . F1()) & (F1() in InnerVertices F6() or b3 = b1 . F1()) & (F2() in InnerVertices F6() implies b4 = (Result b2) . F2()) & (F2() in InnerVertices F6() or b4 = b1 . F2()) & (F3() in InnerVertices F6() implies b5 = (Result b2) . F3()) & (F3() in InnerVertices F6() or b5 = b1 . F3())
   holds (Result b1) . Output 1GateCircStr(<*F1(),F2(),F3()*>,F8()) = F5(b3, b4, b5)
provided
   for b1 being Function-like quasi_total Relation 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
   not Output 1GateCircStr(<*F1(),F2(),F3()*>,F8()) in InputVertices F6();


:: CIRCCMB3:sch 17
scheme CIRCCMB3:sch 17
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> set,
  F5 -> non empty finite set,
  F6 -> Element of F5(),
  F7 -> finite Signature of F5(),
  F8 -> Circuit of F5(),F7(),
  F9 -> Function-like quasi_total Relation of 4 -tuples_on F5(),F5()}:
for b1 being Element of product the Sorts of F8() +* 1GateCircuit(<*F1(),F2(),F3(),F4()*>,F9())
for b2 being Element of product the Sorts of F8()
   st b2 = b1 | the carrier of F7()
for b3, b4, b5, b6 being Element of F5()
      st (F1() in InnerVertices F7() implies b3 = (Result b2) . F1()) & (F1() in InnerVertices F7() or b3 = b1 . F1()) & (F2() in InnerVertices F7() implies b4 = (Result b2) . F2()) & (F2() in InnerVertices F7() or b4 = b1 . F2()) & (F3() in InnerVertices F7() implies b5 = (Result b2) . F3()) & (F3() in InnerVertices F7() or b5 = b1 . F3()) & (F4() in InnerVertices F7() implies b6 = (Result b2) . F4()) & (F4() in InnerVertices F7() or b6 = b1 . F4())
   holds (Result b1) . Output 1GateCircStr(<*F1(),F2(),F3(),F4()*>,F9()) = F6(b3, b4, b5, b6)
provided
   for b1 being Function-like quasi_total Relation 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
   not Output 1GateCircStr(<*F1(),F2(),F3(),F4()*>,F9()) in InputVertices F7();


:: CIRCCMB3:sch 18
scheme CIRCCMB3:sch 18
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> set,
  F5 -> set,
  F6 -> non empty finite set,
  F7 -> Element of F6(),
  F8 -> finite Signature of F6(),
  F9 -> Circuit of F6(),F8(),
  F10 -> Function-like quasi_total Relation of 5 -tuples_on F6(),F6()}:
for b1 being Element of product the Sorts of F9() +* 1GateCircuit(<*F1(),F2(),F3(),F4(),F5()*>,F10())
for b2 being Element of product the Sorts of F9()
   st b2 = b1 | the carrier of F8()
for b3, b4, b5, b6, b7 being Element of F6()
      st (F1() in InnerVertices F8() implies b3 = (Result b2) . F1()) & (F1() in InnerVertices F8() or b3 = b1 . F1()) & (F2() in InnerVertices F8() implies b4 = (Result b2) . F2()) & (F2() in InnerVertices F8() or b4 = b1 . F2()) & (F3() in InnerVertices F8() implies b5 = (Result b2) . F3()) & (F3() in InnerVertices F8() or b5 = b1 . F3()) & (F4() in InnerVertices F8() implies b6 = (Result b2) . F4()) & (F4() in InnerVertices F8() or b6 = b1 . F4()) & (F5() in InnerVertices F8() implies b7 = (Result b2) . F5()) & (F5() in InnerVertices F8() or b7 = b1 . F5())
   holds (Result b1) . Output 1GateCircStr(<*F1(),F2(),F3(),F4(),F5()*>,F10()) = F7(b3, b4, b5, b6, b7)
provided
   for b1 being Function-like quasi_total Relation 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
   not Output 1GateCircStr(<*F1(),F2(),F3(),F4(),F5()*>,F10()) in InputVertices F8();


:: CIRCCMB3:attrnot 6 => CIRCCMB3:attr 6
definition
  let a1 be non empty ManySortedSign;
  attr a1 is with_nonpair_inputs means
    InputVertices a1 is without_pairs;
end;

:: CIRCCMB3:dfs 11
definiens
  let a1 be non empty ManySortedSign;
To prove
     a1 is with_nonpair_inputs
it is sufficient to prove
  thus InputVertices a1 is without_pairs;

:: CIRCCMB3:def 11
theorem
for b1 being non empty ManySortedSign holds
      b1 is with_nonpair_inputs
   iff
      InputVertices b1 is without_pairs;

:: CIRCCMB3:funcreg 7
registration
  cluster omega -> without_pairs;
end;

:: CIRCCMB3:condreg 8
registration
  let a1 be without_pairs set;
  cluster -> without_pairs (Element of bool a1);
end;

:: CIRCCMB3:condreg 9
registration
  cluster Relation-like Function-like natural-valued -> nonpair-yielding (set);
end;

:: CIRCCMB3:exreg 6
registration
  cluster Relation-like Function-like one-to-one natural-valued finite FinSequence-like set;
end;

:: CIRCCMB3:exreg 7
registration
  let a1 be Element of NAT;
  cluster Relation-like Function-like one-to-one natural-valued finite FinSequence-like FinSeqLen of a1;
end;

:: CIRCCMB3:funcreg 8
registration
  let a1 be Relation-like Function-like FinSequence-like nonpair-yielding set;
  let a2 be set;
  cluster 1GateCircStr(a1,a2) -> strict non void with_nonpair_inputs;
end;

:: CIRCCMB3:exreg 8
registration
  cluster non empty finite strict non void Circuit-like unsplit gate`1=arity gate`2=den one-gate with_nonpair_inputs ManySortedSign;
end;

:: CIRCCMB3:exreg 9
registration
  let a1 be non empty finite set;
  cluster non empty finite strict non void Circuit-like unsplit gate`1=arity gate`2=den one-gate with_nonpair_inputs Signature of a1;
end;

:: CIRCCMB3:funcreg 9
registration
  let a1 be non empty with_nonpair_inputs ManySortedSign;
  cluster InputVertices a1 -> without_pairs;
end;

:: CIRCCMB3:th 53
theorem
for b1 being non empty with_nonpair_inputs ManySortedSign
for b2 being Element of the carrier of b1
      st b2 is pair
   holds b2 in InnerVertices b1;

:: CIRCCMB3:funcreg 10
registration
  let a1 be non empty unsplit gate`1=arity ManySortedSign;
  cluster InnerVertices a1 -> Relation-like;
end;

:: CIRCCMB3:funcreg 11
registration
  let a1 be non empty non void unsplit gate`2=den ManySortedSign;
  cluster InnerVertices a1 -> Relation-like;
end;

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

:: CIRCCMB3:th 54
theorem
for b1 being non pair set
for b2 being Relation-like set holds
   not b1 in b2;

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

:: CIRCCMB3:funcreg 13
registration
  let a1 be non empty finite set;
  let a2 be with_nonpair_inputs Signature of a1;
  let a3 be Element of the carrier of a2;
  let a4 be Function-like quasi_total Relation of 1 -tuples_on a1,a1;
  cluster a2 +* 1GateCircStr(<*a3*>,a4) -> non empty strict with_nonpair_inputs;
end;

:: CIRCCMB3:funcreg 14
registration
  let a1 be non empty finite set;
  let a2 be with_nonpair_inputs Signature of a1;
  let a3 be non pair set;
  let a4 be Function-like quasi_total Relation of 1 -tuples_on a1,a1;
  cluster a2 +* 1GateCircStr(<*a3*>,a4) -> non empty strict with_nonpair_inputs;
end;

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

:: CIRCCMB3:funcreg 15
registration
  let a1 be non empty finite set;
  let a2 be with_nonpair_inputs Signature of a1;
  let a3 be Element of the carrier of a2;
  let a4 be non pair set;
  let a5 be Function-like quasi_total Relation of 2 -tuples_on a1,a1;
  cluster a2 +* 1GateCircStr(<*a3,a4*>,a5) -> non empty strict with_nonpair_inputs;
end;

:: CIRCCMB3:funcreg 16
registration
  let a1 be non empty finite set;
  let a2 be with_nonpair_inputs Signature of a1;
  let a3 be Element of the carrier of a2;
  let a4 be non pair set;
  let a5 be Function-like quasi_total Relation of 2 -tuples_on a1,a1;
  cluster a2 +* 1GateCircStr(<*a4,a3*>,a5) -> non empty strict with_nonpair_inputs;
end;

:: CIRCCMB3:funcreg 17
registration
  let a1 be non empty finite set;
  let a2 be with_nonpair_inputs Signature of a1;
  let a3, a4 be Element of the carrier of a2;
  let a5 be Function-like quasi_total Relation of 2 -tuples_on a1,a1;
  cluster a2 +* 1GateCircStr(<*a3,a4*>,a5) -> non empty strict with_nonpair_inputs;
end;

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

:: CIRCCMB3:funcreg 18
registration
  let a1 be non empty finite set;
  let a2 be with_nonpair_inputs Signature of a1;
  let a3, a4 be Element of the carrier of a2;
  let a5 be non pair set;
  let a6 be Function-like quasi_total Relation of 3 -tuples_on a1,a1;
  cluster a2 +* 1GateCircStr(<*a3,a4,a5*>,a6) -> non empty strict with_nonpair_inputs;
end;

:: CIRCCMB3:funcreg 19
registration
  let a1 be non empty finite set;
  let a2 be with_nonpair_inputs Signature of a1;
  let a3, a4 be Element of the carrier of a2;
  let a5 be non pair set;
  let a6 be Function-like quasi_total Relation of 3 -tuples_on a1,a1;
  cluster a2 +* 1GateCircStr(<*a3,a5,a4*>,a6) -> non empty strict with_nonpair_inputs;
end;

:: CIRCCMB3:funcreg 20
registration
  let a1 be non empty finite set;
  let a2 be with_nonpair_inputs Signature of a1;
  let a3, a4 be Element of the carrier of a2;
  let a5 be non pair set;
  let a6 be Function-like quasi_total Relation of 3 -tuples_on a1,a1;
  cluster a2 +* 1GateCircStr(<*a5,a3,a4*>,a6) -> non empty strict with_nonpair_inputs;
end;

:: CIRCCMB3:funcreg 21
registration
  let a1 be non empty finite set;
  let a2 be with_nonpair_inputs Signature of a1;
  let a3 be Element of the carrier of a2;
  let a4, a5 be non pair set;
  let a6 be Function-like quasi_total Relation of 3 -tuples_on a1,a1;
  cluster a2 +* 1GateCircStr(<*a3,a4,a5*>,a6) -> non empty strict with_nonpair_inputs;
end;

:: CIRCCMB3:funcreg 22
registration
  let a1 be non empty finite set;
  let a2 be with_nonpair_inputs Signature of a1;
  let a3 be Element of the carrier of a2;
  let a4, a5 be non pair set;
  let a6 be Function-like quasi_total Relation of 3 -tuples_on a1,a1;
  cluster a2 +* 1GateCircStr(<*a4,a3,a5*>,a6) -> non empty strict with_nonpair_inputs;
end;

:: CIRCCMB3:funcreg 23
registration
  let a1 be non empty finite set;
  let a2 be with_nonpair_inputs Signature of a1;
  let a3 be Element of the carrier of a2;
  let a4, a5 be non pair set;
  let a6 be Function-like quasi_total Relation of 3 -tuples_on a1,a1;
  cluster a2 +* 1GateCircStr(<*a4,a5,a3*>,a6) -> non empty strict with_nonpair_inputs;
end;

:: CIRCCMB3:funcreg 24
registration
  let a1 be non empty finite set;
  let a2 be with_nonpair_inputs Signature of a1;
  let a3, a4, a5 be Element of the carrier of a2;
  let a6 be Function-like quasi_total Relation of 3 -tuples_on a1,a1;
  cluster a2 +* 1GateCircStr(<*a3,a4,a5*>,a6) -> non empty strict with_nonpair_inputs;
end;