Article BCIALG_4, MML version 4.99.1005

:: BCIALG_4:structnot 1 => BCIALG_4:struct 1
definition
  struct(BCIStr_0ZeroStr) BCIStr_1(#
    carrier -> set,
    ExternalDiff -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    InternalDiff -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    ZeroF -> Element of the carrier of it
  #);
end;

:: BCIALG_4:attrnot 1 => BCIALG_4:attr 1
definition
  let a1 be BCIStr_1;
  attr a1 is strict;
end;

:: BCIALG_4:exreg 1
registration
  cluster strict BCIStr_1;
end;

:: BCIALG_4:aggrnot 1 => BCIALG_4:aggr 1
definition
  let a1 be set;
  let a2, a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a4 be Element of a1;
  aggr BCIStr_1(#a1,a2,a3,a4#) -> strict BCIStr_1;
end;

:: BCIALG_4:selnot 1 => BCIALG_4:sel 1
definition
  let a1 be BCIStr_1;
  sel the ExternalDiff of a1 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a1:],the carrier of a1;
end;

:: BCIALG_4:exreg 2
registration
  cluster non empty strict BCIStr_1;
end;

:: BCIALG_4:funcnot 1 => BCIALG_4:func 1
definition
  let a1 be BCIStr_1;
  let a2, a3 be Element of the carrier of a1;
  func A2 * A3 -> Element of the carrier of a1 equals
    (the ExternalDiff of a1) .(a2,a3);
end;

:: BCIALG_4:def 1
theorem
for b1 being BCIStr_1
for b2, b3 being Element of the carrier of b1 holds
b2 * b3 = (the ExternalDiff of b1) .(b2,b3);

:: BCIALG_4:attrnot 2 => BCIALG_4:attr 2
definition
  let a1 be non empty BCIStr_1;
  attr a1 is with_condition_S means
    for b1, b2, b3 being Element of the carrier of a1 holds
    (b1 \ b2) \ b3 = b1 \ (b2 * b3);
end;

:: BCIALG_4:dfs 2
definiens
  let a1 be non empty BCIStr_1;
To prove
     a1 is with_condition_S
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1 holds
    (b1 \ b2) \ b3 = b1 \ (b2 * b3);

:: BCIALG_4:def 2
theorem
for b1 being non empty BCIStr_1 holds
      b1 is with_condition_S
   iff
      for b2, b3, b4 being Element of the carrier of b1 holds
      (b2 \ b3) \ b4 = b2 \ (b3 * b4);

:: BCIALG_4:funcnot 2 => BCIALG_4:func 2
definition
  func BCI_S-EXAMPLE -> BCIStr_1 equals
    BCIStr_1(#1,op2,op2,op0#);
end;

:: BCIALG_4:def 3
theorem
BCI_S-EXAMPLE = BCIStr_1(#1,op2,op2,op0#);

:: BCIALG_4:funcreg 1
registration
  cluster BCI_S-EXAMPLE -> non empty trivial strict;
end;

:: BCIALG_4:funcreg 2
registration
  cluster BCI_S-EXAMPLE -> being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S;
end;

:: BCIALG_4:exreg 3
registration
  cluster non empty being_B being_C being_I being_BCI-4 strict with_condition_S BCIStr_1;
end;

:: BCIALG_4:modenot 1
definition
  mode BCI-Algebra_with_Condition(S) is non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1;
end;

:: BCIALG_4:funcnot 3 => BCIALG_4:func 3
definition
  let a1 be non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1;
  let a2, a3 be Element of the carrier of a1;
  func Condition_S(A2,A3) -> non empty Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: b1 \ a2 <= a3};
end;

:: BCIALG_4:def 4
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3 being Element of the carrier of b1 holds
Condition_S(b2,b3) = {b4 where b4 is Element of the carrier of b1: b4 \ b2 <= b3};

:: BCIALG_4:th 1
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3, b4, b5 being Element of the carrier of b1
      st b4 in Condition_S(b2,b3) & b5 <= b4
   holds b5 in Condition_S(b2,b3);

:: BCIALG_4:th 2
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3 being Element of the carrier of b1 holds
ex b4 being Element of Condition_S(b2,b3) st
   for b5 being Element of Condition_S(b2,b3) holds
      b5 <= b4;

:: BCIALG_4:th 3
theorem
for b1 being non empty BCIStr_1 holds
      b1 is non empty being_B being_C being_I being_BCI-4 BCIStr_0 &
       (for b2, b3 being Element of the carrier of b1 holds
       (b2 * b3) \ b2 <= b3 &
        (for b4 being Element of the carrier of b1
              st b4 \ b2 <= b3
           holds b4 <= b2 * b3))
   iff
      b1 is non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1;

:: BCIALG_4:th 4
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3 being Element of the carrier of b1 holds
ex b4 being Element of Condition_S(b2,b3) st
   for b5 being Element of Condition_S(b2,b3) holds
      b5 <= b4;

:: BCIALG_4:funcnot 4 => BCIALG_4:func 4
definition
  let a1 be non empty being_B being_C being_I being_BCI-4 p-Semisimple BCIStr_0;
  func Adjoint_pGroup A1 -> non empty strict right_complementable Abelian add-associative right_zeroed addLoopStr means
    the carrier of it = the carrier of a1 &
     (for b1, b2 being Element of the carrier of a1 holds
     (the addF of it) .(b1,b2) = b1 \ ((0. a1) \ b2)) &
     0. it = 0. a1;
end;

:: BCIALG_4:def 5
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 p-Semisimple BCIStr_0
for b2 being non empty strict right_complementable Abelian add-associative right_zeroed addLoopStr holds
      b2 = Adjoint_pGroup b1
   iff
      the carrier of b2 = the carrier of b1 &
       (for b3, b4 being Element of the carrier of b1 holds
       (the addF of b2) .(b3,b4) = b3 \ ((0. b1) \ b4)) &
       0. b2 = 0. b1;

:: BCIALG_4:th 5
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 BCIStr_0 holds
      b1 is p-Semisimple
   iff
      for b2, b3 being Element of the carrier of b1
            st b2 \ b3 = 0. b1
         holds b2 = b3;

:: BCIALG_4:th 6
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
   st b1 is p-Semisimple
for b2, b3 being Element of the carrier of b1 holds
b2 * b3 = b2 \ ((0. b1) \ b3);

:: BCIALG_4:th 7
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3 being Element of the carrier of b1 holds
b2 * b3 = b3 * b2;

:: BCIALG_4:th 8
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3, b4 being Element of the carrier of b1
      st b2 <= b3
   holds b2 * b4 <= b3 * b4 & b4 * b2 <= b4 * b3;

:: BCIALG_4:th 9
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2 being Element of the carrier of b1 holds
   (0. b1) * b2 = b2 & b2 * 0. b1 = b2;

:: BCIALG_4:th 10
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 * b3) * b4 = b2 * (b3 * b4);

:: BCIALG_4:th 11
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 * b3) * b4 = (b2 * b4) * b3;

:: BCIALG_4:th 12
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 \ b3) \ b4 = b2 \ (b3 * b4);

:: BCIALG_4:th 13
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3 being Element of the carrier of b1 holds
b3 <= b2 * (b3 \ b2);

:: BCIALG_4:th 14
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 * b4) \ (b3 * b4) <= b2 \ b3;

:: BCIALG_4:th 15
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3, b4 being Element of the carrier of b1 holds
   b2 \ b3 <= b4
iff
   b2 <= b3 * b4;

:: BCIALG_4:th 16
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3, b4 being Element of the carrier of b1 holds
b2 \ b3 <= (b2 \ b4) * (b4 \ b3);

:: BCIALG_4:funcreg 3
registration
  let a1 be non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1;
  cluster the ExternalDiff of a1 -> Function-like quasi_total commutative associative;
end;

:: BCIALG_4:th 17
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1 holds
   0. b1 is_a_unity_wrt the ExternalDiff of b1;

:: BCIALG_4:th 18
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1 holds
   the_unity_wrt the ExternalDiff of b1 = 0. b1;

:: BCIALG_4:th 19
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1 holds
   the ExternalDiff of b1 is having_a_unity(the carrier of b1);

:: BCIALG_4:funcnot 5 => BCIALG_4:func 5
definition
  let a1 be non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1;
  func power A1 -> Function-like quasi_total Relation of [:the carrier of a1,NAT:],the carrier of a1 means
    for b1 being Element of the carrier of a1 holds
       it .(b1,0) = 0. a1 &
        (for b2 being Element of NAT holds
           it .(b1,b2 + 1) = (it .(b1,b2)) * b1);
end;

:: BCIALG_4:def 6
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2 being Function-like quasi_total Relation of [:the carrier of b1,NAT:],the carrier of b1 holds
      b2 = power b1
   iff
      for b3 being Element of the carrier of b1 holds
         b2 .(b3,0) = 0. b1 &
          (for b4 being Element of NAT holds
             b2 .(b3,b4 + 1) = (b2 .(b3,b4)) * b3);

:: BCIALG_4:funcnot 6 => BCIALG_4:func 6
definition
  let a1 be non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1;
  let a2 be Element of the carrier of a1;
  let a3 be Element of NAT;
  func A2 |^ A3 -> Element of the carrier of a1 equals
    (power a1) .(a2,a3);
end;

:: BCIALG_4:def 7
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2 being Element of the carrier of b1
for b3 being Element of NAT holds
   b2 |^ b3 = (power b1) .(b2,b3);

:: BCIALG_4:th 20
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2 being Element of the carrier of b1 holds
   b2 |^ 0 = 0. b1;

:: BCIALG_4:th 21
theorem
for b1 being Element of NAT
for b2 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b3 being Element of the carrier of b2 holds
   b3 |^ (b1 + 1) = (b3 |^ b1) * b3;

:: BCIALG_4:th 22
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2 being Element of the carrier of b1 holds
   b2 |^ 1 = b2;

:: BCIALG_4:th 23
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2 being Element of the carrier of b1 holds
   b2 |^ 2 = b2 * b2;

:: BCIALG_4:th 24
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2 being Element of the carrier of b1 holds
   b2 |^ 3 = (b2 * b2) * b2;

:: BCIALG_4:th 25
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1 holds
   (0. b1) |^ 2 = 0. b1;

:: BCIALG_4:th 26
theorem
for b1 being Element of NAT
for b2 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1 holds
   (0. b2) |^ b1 = 0. b2;

:: BCIALG_4:th 27
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3 being Element of the carrier of b1 holds
((b2 \ b3) \ b3) \ b3 = b2 \ (b3 |^ 3);

:: BCIALG_4:th 28
theorem
for b1 being Element of NAT
for b2 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b3, b4 being Element of the carrier of b2 holds
(b3,b4)to_power b1 = b3 \ (b4 |^ b1);

:: BCIALG_4:funcnot 7 => BCIALG_4:func 7
definition
  let a1 be non empty BCIStr_1;
  let a2 be FinSequence of the carrier of a1;
  func Product_S A2 -> Element of the carrier of a1 equals
    (the ExternalDiff of a1) "**" a2;
end;

:: BCIALG_4:def 8
theorem
for b1 being non empty BCIStr_1
for b2 being FinSequence of the carrier of b1 holds
   Product_S b2 = (the ExternalDiff of b1) "**" b2;

:: BCIALG_4:th 29
theorem
for b1 being non empty BCIStr_1
for b2 being Element of the carrier of b1 holds
   (the ExternalDiff of b1) "**" <*b2*> = b2;

:: BCIALG_4:th 30
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3 being FinSequence of the carrier of b1 holds
Product_S (b2 ^ b3) = (Product_S b2) * Product_S b3;

:: BCIALG_4:th 31
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2 being FinSequence of the carrier of b1
for b3 being Element of the carrier of b1 holds
   Product_S (b2 ^ <*b3*>) = (Product_S b2) * b3;

:: BCIALG_4:th 32
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2 being FinSequence of the carrier of b1
for b3 being Element of the carrier of b1 holds
   Product_S (<*b3*> ^ b2) = b3 * Product_S b2;

:: BCIALG_4:th 33
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3 being Element of the carrier of b1 holds
Product_S <*b2,b3*> = b2 * b3;

:: BCIALG_4:th 34
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3, b4 being Element of the carrier of b1 holds
Product_S <*b2,b3,b4*> = (b2 * b3) * b4;

:: BCIALG_4:th 35
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 \ b3) \ b4 = b2 \ Product_S <*b3,b4*>;

:: BCIALG_4:th 36
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3, b4, b5 being Element of the carrier of b1 holds
((b2 \ b3) \ b4) \ b5 = b2 \ Product_S <*b3,b4,b5*>;

:: BCIALG_4:th 37
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 with_condition_S BCIStr_1
for b2, b3 being Element of AtomSet b1
for b4 being Element of the carrier of b1
      st for b5 being Element of BranchV b2 holds
           b5 <= b4
   holds ex b5 being Element of the carrier of b1 st
      for b6 being Element of BranchV b3 holds
         b6 <= b5;

:: BCIALG_4:exreg 4
registration
  cluster non empty being_B being_C being_I being_BCI-4 being_BCK-5 strict with_condition_S BCIStr_1;
end;

:: BCIALG_4:modenot 2
definition
  mode BCK-Algebra_with_Condition(S) is non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1;
end;

:: BCIALG_4:th 38
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1
for b2, b3 being Element of the carrier of b1 holds
b2 <= b2 * b3 & b3 <= b2 * b3;

:: BCIALG_4:th 39
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1
for b2, b3, b4 being Element of the carrier of b1 holds
((b2 * b3) \ (b3 * b4)) \ (b4 * b2) = 0. b1;

:: BCIALG_4:th 40
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1
for b2, b3 being Element of the carrier of b1 holds
(b2 \ b3) * (b3 \ b2) <= b2 * b3;

:: BCIALG_4:th 41
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1
for b2 being Element of the carrier of b1 holds
   (b2 \ 0. b1) * ((0. b1) \ b2) = b2;

:: BCIALG_4:attrnot 3 => BCIALG_4:attr 3
definition
  let a1 be non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1;
  attr a1 is commutative means
    for b1, b2 being Element of the carrier of a1 holds
    b1 \ (b1 \ b2) = b2 \ (b2 \ b1);
end;

:: BCIALG_4:dfs 9
definiens
  let a1 be non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1;
To prove
     a1 is commutative
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    b1 \ (b1 \ b2) = b2 \ (b2 \ b1);

:: BCIALG_4:def 9
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1 holds
      b1 is commutative
   iff
      for b2, b3 being Element of the carrier of b1 holds
      b2 \ (b2 \ b3) = b3 \ (b3 \ b2);

:: BCIALG_4:exreg 5
registration
  cluster non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S commutative BCIStr_1;
end;

:: BCIALG_4:th 42
theorem
for b1 being non empty BCIStr_1 holds
      b1 is non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S commutative BCIStr_1
   iff
      for b2, b3, b4 being Element of the carrier of b1 holds
      b2 \ ((0. b1) \ b3) = b2 &
       (b2 \ b4) \ (b2 \ b3) = (b3 \ b4) \ (b3 \ b2) &
       (b2 \ b3) \ b4 = b2 \ (b3 * b4);

:: BCIALG_4:th 43
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S commutative BCIStr_1
for b2 being Element of the carrier of b1
   st b2 is greatest(b1)
for b3, b4 being Element of the carrier of b1 holds
b3 * b4 = b2 \ ((b2 \ b3) \ b4);

:: BCIALG_4:funcnot 8 => BCIALG_4:func 8
definition
  let a1 be non empty being_B being_C being_I being_BCI-4 BCIStr_0;
  let a2 be Element of the carrier of a1;
  func Initial_section A2 -> non empty Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: b1 <= a2};
end;

:: BCIALG_4:def 10
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 BCIStr_0
for b2 being Element of the carrier of b1 holds
   Initial_section b2 = {b3 where b3 is Element of the carrier of b1: b3 <= b2};

:: BCIALG_4:th 44
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S commutative BCIStr_1
for b2, b3, b4 being Element of the carrier of b1
   st Condition_S(b2,b3) c= Initial_section b4
for b5 being Element of Condition_S(b2,b3) holds
   b5 <= b4 \ ((b4 \ b2) \ b3);

:: BCIALG_4:attrnot 4 => BCIALG_4:attr 4
definition
  let a1 be non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1;
  attr a1 is positive-implicative means
    for b1, b2 being Element of the carrier of a1 holds
    (b1 \ b2) \ b2 = b1 \ b2;
end;

:: BCIALG_4:dfs 11
definiens
  let a1 be non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1;
To prove
     a1 is positive-implicative
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    (b1 \ b2) \ b2 = b1 \ b2;

:: BCIALG_4:def 11
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1 holds
      b1 is positive-implicative
   iff
      for b2, b3 being Element of the carrier of b1 holds
      (b2 \ b3) \ b3 = b2 \ b3;

:: BCIALG_4:exreg 6
registration
  cluster non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S positive-implicative BCIStr_1;
end;

:: BCIALG_4:th 45
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1 holds
      b1 is positive-implicative
   iff
      for b2 being Element of the carrier of b1 holds
         b2 * b2 = b2;

:: BCIALG_4:th 46
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1 holds
      b1 is positive-implicative
   iff
      for b2, b3 being Element of the carrier of b1
            st b2 <= b3
         holds b2 * b3 = b3;

:: BCIALG_4:th 47
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1 holds
      b1 is positive-implicative
   iff
      for b2, b3, b4 being Element of the carrier of b1 holds
      (b2 * b3) \ b4 = (b2 \ b4) * (b3 \ b4);

:: BCIALG_4:th 48
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1 holds
      b1 is positive-implicative
   iff
      for b2, b3 being Element of the carrier of b1 holds
      b2 * b3 = b2 * (b3 \ b2);

:: BCIALG_4:th 49
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S positive-implicative BCIStr_1
for b2, b3 being Element of the carrier of b1 holds
b2 = (b2 \ b3) * (b2 \ (b2 \ b3));

:: BCIALG_4:attrnot 5 => BCIALG_4:attr 5
definition
  let a1 be non empty BCIStr_1;
  attr a1 is being_SB-1 means
    for b1 being Element of the carrier of a1 holds
       b1 * b1 = b1;
end;

:: BCIALG_4:dfs 12
definiens
  let a1 be non empty BCIStr_1;
To prove
     a1 is being_SB-1
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 * b1 = b1;

:: BCIALG_4:def 12
theorem
for b1 being non empty BCIStr_1 holds
      b1 is being_SB-1
   iff
      for b2 being Element of the carrier of b1 holds
         b2 * b2 = b2;

:: BCIALG_4:attrnot 6 => BCIALG_4:attr 6
definition
  let a1 be non empty BCIStr_1;
  attr a1 is being_SB-2 means
    for b1, b2 being Element of the carrier of a1 holds
    b1 * b2 = b2 * b1;
end;

:: BCIALG_4:dfs 13
definiens
  let a1 be non empty BCIStr_1;
To prove
     a1 is being_SB-2
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    b1 * b2 = b2 * b1;

:: BCIALG_4:def 13
theorem
for b1 being non empty BCIStr_1 holds
      b1 is being_SB-2
   iff
      for b2, b3 being Element of the carrier of b1 holds
      b2 * b3 = b3 * b2;

:: BCIALG_4:attrnot 7 => BCIALG_4:attr 7
definition
  let a1 be non empty BCIStr_1;
  attr a1 is being_SB-4 means
    for b1, b2 being Element of the carrier of a1 holds
    (b1 \ b2) * b2 = b1 * b2;
end;

:: BCIALG_4:dfs 14
definiens
  let a1 be non empty BCIStr_1;
To prove
     a1 is being_SB-4
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    (b1 \ b2) * b2 = b1 * b2;

:: BCIALG_4:def 14
theorem
for b1 being non empty BCIStr_1 holds
      b1 is being_SB-4
   iff
      for b2, b3 being Element of the carrier of b1 holds
      (b2 \ b3) * b3 = b2 * b3;

:: BCIALG_4:funcreg 4
registration
  cluster BCI_S-EXAMPLE -> being_I with_condition_S being_SB-1 being_SB-2 being_SB-4;
end;

:: BCIALG_4:exreg 7
registration
  cluster non empty being_I strict with_condition_S being_SB-1 being_SB-2 being_SB-4 BCIStr_1;
end;

:: BCIALG_4:modenot 3
definition
  mode semi-Brouwerian-algebra is non empty being_I with_condition_S being_SB-1 being_SB-2 being_SB-4 BCIStr_1;
end;

:: BCIALG_4:th 50
theorem
for b1 being non empty BCIStr_1 holds
      b1 is non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S positive-implicative BCIStr_1
   iff
      b1 is non empty being_I with_condition_S being_SB-1 being_SB-2 being_SB-4 BCIStr_1;

:: BCIALG_4:attrnot 8 => BCIALG_4:attr 8
definition
  let a1 be non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1;
  attr a1 is implicative means
    for b1, b2 being Element of the carrier of a1 holds
    b1 \ (b2 \ b1) = b1;
end;

:: BCIALG_4:dfs 15
definiens
  let a1 be non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1;
To prove
     a1 is implicative
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    b1 \ (b2 \ b1) = b1;

:: BCIALG_4:def 15
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1 holds
      b1 is implicative
   iff
      for b2, b3 being Element of the carrier of b1 holds
      b2 \ (b3 \ b2) = b2;

:: BCIALG_4:exreg 8
registration
  cluster non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S implicative BCIStr_1;
end;

:: BCIALG_4:th 51
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1 holds
      b1 is implicative
   iff
      b1 is commutative & b1 is positive-implicative;

:: BCIALG_4:th 52
theorem
for b1 being non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S BCIStr_1 holds
      b1 is implicative
   iff
      for b2, b3, b4 being Element of the carrier of b1 holds
      b2 \ (b3 \ b4) = ((b2 \ b3) \ b4) * (b4 \ (b4 \ b2));