:: BCI-Algebras with Condition (S) and Their Properties
:: by Tao Sun , Junjie Zhao and Xiquan Liang
::
:: Received November 24, 2007
:: Copyright (c) 2007-2011 Association of Mizar Users

begin

definition

attr c₁ is strict ;
struct BCIStr_1 -> BCIStr_0 , ZeroStr ;
aggr BCIStr_1(# carrier, ExternalDiff, InternalDiff, ZeroF #) -> BCIStr_1 ;
sel ExternalDiff c₁ -> BinOp of the carrier of c₁;

end;

registration

cluster non empty strict BCIStr_1 ;
existence
ex b₁ being BCIStr_1 st
( not b₁ is empty & b₁ is strict )

proof end;

end;

definition

let A be BCIStr_1 ;
let x, y be Element of A;
func x * y -> Element of A equals :: BCIALG_4:def 1
the ExternalDiff of A . (x,y);
coherence
the ExternalDiff of A . (x,y) is Element of A ;

end;

:: deftheorem defines * BCIALG_4:def 1 :
for A being BCIStr_1
for x, y being Element of A holds x * y = the ExternalDiff of A . (x,y);

definition

let IT be non empty BCIStr_1 ;
attr IT is with_condition_S means :Def2: :: BCIALG_4:def 2
for x, y, z being Element of IT holds (x \ y) \ z = x \ (y * z);

end;

:: deftheorem Def2 defines with_condition_S BCIALG_4:def 2 :
for IT being non empty BCIStr_1 holds
( IT is with_condition_S iff for x, y, z being Element of IT holds (x \ y) \ z = x \ (y * z) );

definition

func BCI_S-EXAMPLE -> BCIStr_1 equals :: BCIALG_4:def 3
BCIStr_1(# 1,op2,op2,op0 #);
coherence
BCIStr_1(# 1,op2,op2,op0 #) is BCIStr_1 ;

end;

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

registration

cluster BCI_S-EXAMPLE -> non empty trivial strict ;
coherence
( BCI_S-EXAMPLE is strict & not BCI_S-EXAMPLE is empty & BCI_S-EXAMPLE is trivial ) by CARD_1:87;

end;

Lm1: ( BCI_S-EXAMPLE is being_B & BCI_S-EXAMPLE is being_C & BCI_S-EXAMPLE is being_I & BCI_S-EXAMPLE is being_BCI-4 & BCI_S-EXAMPLE is being_BCK-5 & BCI_S-EXAMPLE is with_condition_S )

proof end;

registration

cluster BCI_S-EXAMPLE -> being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S ;
coherence
( BCI_S-EXAMPLE is being_B & BCI_S-EXAMPLE is being_C & BCI_S-EXAMPLE is being_I & BCI_S-EXAMPLE is being_BCI-4 & BCI_S-EXAMPLE is being_BCK-5 & BCI_S-EXAMPLE is with_condition_S ) by Lm1;

end;

registration

cluster non empty being_B being_C being_I being_BCI-4 strict with_condition_S BCIStr_1 ;
existence
ex b₁ being non empty BCIStr_1 st
( b₁ is strict & b₁ is being_B & b₁ is being_C & b₁ is being_I & b₁ is being_BCI-4 & b₁ is with_condition_S ) by Lm1;

end;

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;

definition

let X be BCI-Algebra_with_Condition(S);
let x, y be Element of X;
func Condition_S (x,y) -> non empty Subset of X equals :: BCIALG_4:def 4
{ t where t is Element of X : t \ x <= y } ;
coherence
{ t where t is Element of X : t \ x <= y } is non empty Subset of X

proof end;

end;

:: deftheorem defines Condition_S BCIALG_4:def 4 :
for X being BCI-Algebra_with_Condition(S)
for x, y being Element of X holds Condition_S (x,y) = { t where t is Element of X : t \ x <= y } ;

theorem :: BCIALG_4:1

for X being BCI-Algebra_with_Condition(S)
for x, y, u, v being Element of X st u in Condition_S (x,y) & v <= u holds
v in Condition_S (x,y)

proof end;

theorem :: BCIALG_4:2

for X being BCI-Algebra_with_Condition(S)
for x, y being Element of X ex a being Element of Condition_S (x,y) st
for z being Element of Condition_S (x,y) holds z <= a

proof end;

Lm2: for X being BCI-Algebra_with_Condition(S)
for x, y being Element of X holds
( (x * y) \ x <= y & ( for t being Element of X st t \ x <= y holds
t <= x * y ) )

proof end;

Lm3: for X being non empty BCIStr_1 st X is BCI-algebra & ( for x, y being Element of X holds
( (x * y) \ x <= y & ( for t being Element of X st t \ x <= y holds
t <= x * y ) ) ) holds
X is BCI-Algebra_with_Condition(S)

proof end;

theorem :: BCIALG_4:3

for X being non empty BCIStr_1 holds
( ( X is BCI-algebra & ( for x, y being Element of X holds
( (x * y) \ x <= y & ( for t being Element of X st t \ x <= y holds
t <= x * y ) ) ) ) iff X is BCI-Algebra_with_Condition(S) ) by Lm2, Lm3;

theorem :: BCIALG_4:4

for X being BCI-Algebra_with_Condition(S)
for x, y being Element of X ex a being Element of Condition_S (x,y) st
for z being Element of Condition_S (x,y) holds z <= a

proof end;

definition

let X be p-Semisimple BCI-algebra;
func Adjoint_pGroup X -> strict AbGroup means :: BCIALG_4:def 5
( the carrier of it = the carrier of X & ( for x, y being Element of X holds the addF of it . (x,y) = x \ ((0. X) \ y) ) & 0. it = 0. X );
existence
ex b₁ being strict AbGroup st
( the carrier of b₁ = the carrier of X & ( for x, y being Element of X holds the addF of b₁ . (x,y) = x \ ((0. X) \ y) ) & 0. b₁ = 0. X )

proof end;

uniqueness
for b₁, b₂ being strict AbGroup st the carrier of b₁ = the carrier of X & ( for x, y being Element of X holds the addF of b₁ . (x,y) = x \ ((0. X) \ y) ) & 0. b₁ = 0. X & the carrier of b₂ = the carrier of X & ( for x, y being Element of X holds the addF of b₂ . (x,y) = x \ ((0. X) \ y) ) & 0. b₂ = 0. X holds
b₁ = b₂

proof end;

end;

:: deftheorem defines Adjoint_pGroup BCIALG_4:def 5 :
for X being p-Semisimple BCI-algebra
for b₂ being strict AbGroup holds
( b₂ = Adjoint_pGroup X iff ( the carrier of b₂ = the carrier of X & ( for x, y being Element of X holds the addF of b₂ . (x,y) = x \ ((0. X) \ y) ) & 0. b₂ = 0. X ) );

theorem Th5: :: BCIALG_4:5

for X being BCI-algebra holds
( X is p-Semisimple iff for x, y being Element of X st x \ y = 0. X holds
x = y )

proof end;

theorem :: BCIALG_4:6

for X being BCI-Algebra_with_Condition(S) st X is p-Semisimple holds
for x, y being Element of X holds x * y = x \ ((0. X) \ y)

proof end;

theorem Th7: :: BCIALG_4:7

for X being BCI-Algebra_with_Condition(S)
for x, y being Element of X holds x * y = y * x

proof end;

theorem Th8: :: BCIALG_4:8

for X being BCI-Algebra_with_Condition(S)
for x, y, z being Element of X st x <= y holds
( x * z <= y * z & z * x <= z * y )

proof end;

theorem Th9: :: BCIALG_4:9

for X being BCI-Algebra_with_Condition(S)
for x being Element of X holds
( (0. X) * x = x & x * (0. X) = x )

proof end;

theorem Th10: :: BCIALG_4:10

for X being BCI-Algebra_with_Condition(S)
for x, y, z being Element of X holds (x * y) * z = x * (y * z)

proof end;

theorem Th11: :: BCIALG_4:11

for X being BCI-Algebra_with_Condition(S)
for x, y, z being Element of X holds (x * y) * z = (x * z) * y

proof end;

theorem Th12: :: BCIALG_4:12

for X being BCI-Algebra_with_Condition(S)
for x, y, z being Element of X holds (x \ y) \ z = x \ (y * z)

proof end;

theorem Th13: :: BCIALG_4:13

for X being BCI-Algebra_with_Condition(S)
for x, y being Element of X holds y <= x * (y \ x)

proof end;

theorem :: BCIALG_4:14

for X being BCI-Algebra_with_Condition(S)
for x, y, z being Element of X holds (x * z) \ (y * z) <= x \ y

proof end;

theorem :: BCIALG_4:15

for X being BCI-Algebra_with_Condition(S)
for x, y, z being Element of X holds
( x \ y <= z iff x <= y * z )

proof end;

theorem :: BCIALG_4:16

for X being BCI-Algebra_with_Condition(S)
for x, y, z being Element of X holds x \ y <= (x \ z) * (z \ y)

proof end;

Lm4: for X being BCI-Algebra_with_Condition(S) holds the ExternalDiff of X is commutative

proof end;

Lm5: for X being BCI-Algebra_with_Condition(S) holds the ExternalDiff of X is associative

proof end;

registration

let X be BCI-Algebra_with_Condition(S);
cluster the ExternalDiff of X -> commutative associative ;
coherence
( the ExternalDiff of X is commutative & the ExternalDiff of X is associative ) by Lm4, Lm5;

end;

theorem Th17: :: BCIALG_4:17

for X being BCI-Algebra_with_Condition(S) holds 0. X is_a_unity_wrt the ExternalDiff of X

proof end;

theorem :: BCIALG_4:18

for X being BCI-Algebra_with_Condition(S) holds the_unity_wrt the ExternalDiff of X = 0. X

proof end;

theorem Th19: :: BCIALG_4:19

for X being BCI-Algebra_with_Condition(S) holds the ExternalDiff of X is having_a_unity

proof end;

definition

let X be BCI-Algebra_with_Condition(S);
func power X -> Function of [: the carrier of X,NAT:], the carrier of X means :Def6: :: BCIALG_4:def 6
for h being Element of X holds
( it . (h,0) = 0. X & ( for n being Element of NAT holds it . (h,(n + 1)) = (it . (h,n)) * h ) );
existence
ex b₁ being Function of [: the carrier of X,NAT:], the carrier of X st
for h being Element of X holds
( b₁ . (h,0) = 0. X & ( for n being Element of NAT holds b₁ . (h,(n + 1)) = (b₁ . (h,n)) * h ) )

proof end;

uniqueness
for b₁, b₂ being Function of [: the carrier of X,NAT:], the carrier of X st ( for h being Element of X holds
( b₁ . (h,0) = 0. X & ( for n being Element of NAT holds b₁ . (h,(n + 1)) = (b₁ . (h,n)) * h ) ) ) & ( for h being Element of X holds
( b₂ . (h,0) = 0. X & ( for n being Element of NAT holds b₂ . (h,(n + 1)) = (b₂ . (h,n)) * h ) ) ) holds
b₁ = b₂

proof end;

end;

:: deftheorem Def6 defines power BCIALG_4:def 6 :
for X being BCI-Algebra_with_Condition(S)
for b₂ being Function of [: the carrier of X,NAT:], the carrier of X holds
( b₂ = power X iff for h being Element of X holds
( b₂ . (h,0) = 0. X & ( for n being Element of NAT holds b₂ . (h,(n + 1)) = (b₂ . (h,n)) * h ) ) );

definition

let X be BCI-Algebra_with_Condition(S);
let x be Element of X;
let n be Element of NAT ;
func x |^ n -> Element of X equals :: BCIALG_4:def 7
(power X) . (x,n);
correctness
coherence
(power X) . (x,n) is Element of X;
;

end;

:: deftheorem defines |^ BCIALG_4:def 7 :
for X being BCI-Algebra_with_Condition(S)
for x being Element of X
for n being Element of NAT holds x |^ n = (power X) . (x,n);

theorem :: BCIALG_4:20

for X being BCI-Algebra_with_Condition(S)
for x being Element of X holds x |^ 0 = 0. X by Def6;

theorem :: BCIALG_4:21

for n being Element of NAT
for X being BCI-Algebra_with_Condition(S)
for x being Element of X holds x |^ (n + 1) = (x |^ n) * x by Def6;

theorem Th22: :: BCIALG_4:22

for X being BCI-Algebra_with_Condition(S)
for x being Element of X holds x |^ 1 = x

proof end;

theorem Th23: :: BCIALG_4:23

for X being BCI-Algebra_with_Condition(S)
for x being Element of X holds x |^ 2 = x * x

proof end;

theorem :: BCIALG_4:24

for X being BCI-Algebra_with_Condition(S)
for x being Element of X holds x |^ 3 = (x * x) * x

proof end;

theorem Th25: :: BCIALG_4:25

for X being BCI-Algebra_with_Condition(S) holds (0. X) |^ 2 = 0. X

proof end;

Lm6: for n being Element of NAT
for X being BCI-Algebra_with_Condition(S) holds (0. X) |^ (n + 1) = 0. X

proof end;

theorem :: BCIALG_4:26

for n being Element of NAT
for X being BCI-Algebra_with_Condition(S) holds (0. X) |^ n = 0. X

proof end;

theorem :: BCIALG_4:27

for X being BCI-Algebra_with_Condition(S)
for x, a being Element of X holds ((x \ a) \ a) \ a = x \ (a |^ 3)

proof end;

Lm7: for X being BCI-Algebra_with_Condition(S)
for x, a being Element of X holds (x,a) to_power 0 = x \ (a |^ 0)

proof end;

theorem :: BCIALG_4:28

for n being Element of NAT
for X being BCI-Algebra_with_Condition(S)
for x, a being Element of X holds (x,a) to_power n = x \ (a |^ n)

proof end;

definition

let X be non empty BCIStr_1 ;
let F be FinSequence of the carrier of X;
func Product_S F -> Element of X equals :: BCIALG_4:def 8
the ExternalDiff of X "**" F;
correctness
coherence
the ExternalDiff of X "**" F is Element of X;
;

end;

:: deftheorem defines Product_S BCIALG_4:def 8 :
for X being non empty BCIStr_1
for F being FinSequence of the carrier of X holds Product_S F = the ExternalDiff of X "**" F;

theorem :: BCIALG_4:29

for X being non empty BCIStr_1
for d being Element of X holds the ExternalDiff of X "**" <*d*> = d

proof end;

theorem :: BCIALG_4:30

for X being BCI-Algebra_with_Condition(S)
for F1, F2 being FinSequence of the carrier of X holds Product_S (F1 ^ F2) = (Product_S F1) * (Product_S F2) by Th19, FINSOP_1:6;

theorem :: BCIALG_4:31

for X being BCI-Algebra_with_Condition(S)
for F being FinSequence of the carrier of X
for a being Element of X holds Product_S (F ^ <*a*>) = (Product_S F) * a by Th19, FINSOP_1:5;

theorem :: BCIALG_4:32

for X being BCI-Algebra_with_Condition(S)
for F being FinSequence of the carrier of X
for a being Element of X holds Product_S (<*a*> ^ F) = a * (Product_S F) by Th19, FINSOP_1:7;

theorem Th33: :: BCIALG_4:33

for X being BCI-Algebra_with_Condition(S)
for a1, a2 being Element of X holds Product_S <*a1,a2*> = a1 * a2

proof end;

theorem Th34: :: BCIALG_4:34

for X being BCI-Algebra_with_Condition(S)
for a1, a2, a3 being Element of X holds Product_S <*a1,a2,a3*> = (a1 * a2) * a3

proof end;

theorem :: BCIALG_4:35

for X being BCI-Algebra_with_Condition(S)
for x, a1, a2 being Element of X holds (x \ a1) \ a2 = x \ (Product_S <*a1,a2*>)

proof end;

theorem :: BCIALG_4:36

for X being BCI-Algebra_with_Condition(S)
for x, a1, a2, a3 being Element of X holds ((x \ a1) \ a2) \ a3 = x \ (Product_S <*a1,a2,a3*>)

proof end;

theorem :: BCIALG_4:37

for X being BCI-Algebra_with_Condition(S)
for a, b being Element of AtomSet X
for ma being Element of X st ( for x being Element of BranchV a holds x <= ma ) holds
ex mb being Element of X st
for y being Element of BranchV b holds y <= mb

proof end;

registration

cluster non empty being_B being_C being_I being_BCI-4 being_BCK-5 strict with_condition_S BCIStr_1 ;
existence
ex b₁ being BCI-Algebra_with_Condition(S) st
( b₁ is strict & b₁ is being_BCK-5 ) by Lm1;

end;

definition

mode BCK-Algebra_with_Condition(S) is being_BCK-5 BCI-Algebra_with_Condition(S);

end;

theorem Th38: :: BCIALG_4:38

for X being BCK-Algebra_with_Condition(S)
for x, y being Element of X holds
( x <= x * y & y <= x * y )

proof end;

theorem :: BCIALG_4:39

for X being BCK-Algebra_with_Condition(S)
for x, y, z being Element of X holds ((x * y) \ (y * z)) \ (z * x) = 0. X

proof end;

theorem :: BCIALG_4:40

for X being BCK-Algebra_with_Condition(S)
for x, y being Element of X holds (x \ y) * (y \ x) <= x * y

proof end;

theorem :: BCIALG_4:41

for X being BCK-Algebra_with_Condition(S)
for x being Element of X holds (x \ (0. X)) * ((0. X) \ x) = x

proof end;

definition

let IT be BCK-Algebra_with_Condition(S);
attr IT is commutative means :Def9: :: BCIALG_4:def 9
for x, y being Element of IT holds x \ (x \ y) = y \ (y \ x);

end;

:: deftheorem Def9 defines commutative BCIALG_4:def 9 :
for IT being BCK-Algebra_with_Condition(S) holds
( IT is commutative iff for x, y being Element of IT holds x \ (x \ y) = y \ (y \ x) );

registration

cluster non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S commutative BCIStr_1 ;
existence
ex b₁ being BCK-Algebra_with_Condition(S) st b₁ is commutative

proof end;

end;

theorem :: BCIALG_4:42

for X being non empty BCIStr_1 holds
( X is commutative BCK-Algebra_with_Condition(S) iff for x, y, z being Element of X holds
( x \ ((0. X) \ y) = x & (x \ z) \ (x \ y) = (y \ z) \ (y \ x) & (x \ y) \ z = x \ (y * z) ) )

proof end;

theorem :: BCIALG_4:43

for X being commutative BCK-Algebra_with_Condition(S)
for a being Element of X st a is greatest holds
for x, y being Element of X holds x * y = a \ ((a \ x) \ y)

proof end;

definition

let X be BCI-algebra;
let a be Element of X;
func Initial_section a -> non empty Subset of X equals :: BCIALG_4:def 10
{ t where t is Element of X : t <= a } ;
coherence
{ t where t is Element of X : t <= a } is non empty Subset of X

proof end;

end;

:: deftheorem defines Initial_section BCIALG_4:def 10 :
for X being BCI-algebra
for a being Element of X holds Initial_section a = { t where t is Element of X : t <= a } ;

theorem :: BCIALG_4:44

for X being commutative BCK-Algebra_with_Condition(S)
for a, b, c being Element of X st Condition_S (a,b) c= Initial_section c holds
for x being Element of Condition_S (a,b) holds x <= c \ ((c \ a) \ b)

proof end;

definition

let IT be BCK-Algebra_with_Condition(S);
attr IT is positive-implicative means :Def11: :: BCIALG_4:def 11
for x, y being Element of IT holds (x \ y) \ y = x \ y;

end;

:: deftheorem Def11 defines positive-implicative BCIALG_4:def 11 :
for IT being BCK-Algebra_with_Condition(S) holds
( IT is positive-implicative iff for x, y being Element of IT holds (x \ y) \ y = x \ y );

registration

cluster non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S positive-implicative BCIStr_1 ;
existence
ex b₁ being BCK-Algebra_with_Condition(S) st b₁ is positive-implicative

proof end;

end;

theorem Th45: :: BCIALG_4:45

for X being BCK-Algebra_with_Condition(S) holds
( X is positive-implicative iff for x being Element of X holds x * x = x )

proof end;

theorem Th46: :: BCIALG_4:46

for X being BCK-Algebra_with_Condition(S) holds
( X is positive-implicative iff for x, y being Element of X st x <= y holds
x * y = y )

proof end;

theorem Th47: :: BCIALG_4:47

for X being BCK-Algebra_with_Condition(S) holds
( X is positive-implicative iff for x, y, z being Element of X holds (x * y) \ z = (x \ z) * (y \ z) )

proof end;

theorem Th48: :: BCIALG_4:48

for X being BCK-Algebra_with_Condition(S) holds
( X is positive-implicative iff for x, y being Element of X holds x * y = x * (y \ x) )

proof end;

theorem Th49: :: BCIALG_4:49

for X being positive-implicative BCK-Algebra_with_Condition(S)
for x, y being Element of X holds x = (x \ y) * (x \ (x \ y))

proof end;

definition

let IT be non empty BCIStr_1 ;
attr IT is being_SB-1 means :Def12: :: BCIALG_4:def 12
for x being Element of IT holds x * x = x;
attr IT is being_SB-2 means :Def13: :: BCIALG_4:def 13
for x, y being Element of IT holds x * y = y * x;
attr IT is being_SB-4 means :Def14: :: BCIALG_4:def 14
for x, y being Element of IT holds (x \ y) * y = x * y;

end;

:: deftheorem Def12 defines being_SB-1 BCIALG_4:def 12 :
for IT being non empty BCIStr_1 holds
( IT is being_SB-1 iff for x being Element of IT holds x * x = x );

:: deftheorem Def13 defines being_SB-2 BCIALG_4:def 13 :
for IT being non empty BCIStr_1 holds
( IT is being_SB-2 iff for x, y being Element of IT holds x * y = y * x );

:: deftheorem Def14 defines being_SB-4 BCIALG_4:def 14 :
for IT being non empty BCIStr_1 holds
( IT is being_SB-4 iff for x, y being Element of IT holds (x \ y) * y = x * y );

Lm8: ( BCI_S-EXAMPLE is being_SB-1 & BCI_S-EXAMPLE is being_SB-2 & BCI_S-EXAMPLE is being_SB-4 & BCI_S-EXAMPLE is being_I & BCI_S-EXAMPLE is with_condition_S )

proof end;

registration

cluster BCI_S-EXAMPLE -> being_I with_condition_S being_SB-1 being_SB-2 being_SB-4 ;
coherence
( BCI_S-EXAMPLE is being_SB-1 & BCI_S-EXAMPLE is being_SB-2 & BCI_S-EXAMPLE is being_SB-4 & BCI_S-EXAMPLE is being_I & BCI_S-EXAMPLE is with_condition_S ) by Lm8;

end;

registration

cluster non empty being_I strict with_condition_S being_SB-1 being_SB-2 being_SB-4 BCIStr_1 ;
existence
ex b₁ being non empty BCIStr_1 st
( b₁ is strict & b₁ is being_SB-1 & b₁ is being_SB-2 & b₁ is being_SB-4 & b₁ is being_I & b₁ is with_condition_S ) by Lm8;

end;

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;

theorem :: BCIALG_4:50

for X being non empty BCIStr_1 holds
( X is positive-implicative BCK-Algebra_with_Condition(S) iff X is semi-Brouwerian-algebra )

proof end;

definition

let IT be BCK-Algebra_with_Condition(S);
attr IT is implicative means :Def15: :: BCIALG_4:def 15
for x, y being Element of IT holds x \ (y \ x) = x;

end;

:: deftheorem Def15 defines implicative BCIALG_4:def 15 :
for IT being BCK-Algebra_with_Condition(S) holds
( IT is implicative iff for x, y being Element of IT holds x \ (y \ x) = x );

registration

cluster non empty being_B being_C being_I being_BCI-4 being_BCK-5 with_condition_S implicative BCIStr_1 ;
existence
ex b₁ being BCK-Algebra_with_Condition(S) st b₁ is implicative

proof end;

end;

theorem Th51: :: BCIALG_4:51

for X being BCK-Algebra_with_Condition(S) holds
( X is implicative iff ( X is commutative & X is positive-implicative ) )

proof end;

theorem :: BCIALG_4:52

for X being BCK-Algebra_with_Condition(S) holds
( X is implicative iff for x, y, z being Element of X holds x \ (y \ z) = ((x \ y) \ z) * (z \ (z \ x)) )

proof end;