:: Binary Operations on Numbers :: by Library Committee :: :: Received June 21, 2004 :: Copyright (c) 2004-2018 Association of Mizar Users :: (Stowarzyszenie Uzytkownikow Mizara, Bialystok, Poland). :: This code can be distributed under the GNU General Public Licence :: version 3.0 or later, or the Creative Commons Attribution-ShareAlike :: License version 3.0 or later, subject to the binding interpretation :: detailed in file COPYING.interpretation. :: See COPYING.GPL and COPYING.CC-BY-SA for the full text of these :: licenses, or see http://www.gnu.org/licenses/gpl.html and :: http://creativecommons.org/licenses/by-sa/3.0/. environ vocabularies XBOOLE_0, SUBSET_1, FUNCT_1, BINOP_1, XCMPLX_0, NUMBERS, XREAL_0, RAT_1, INT_1, ZFMISC_1, ARYTM_1, RELAT_1, ARYTM_3, CARD_1, SETWISEO, BINOP_2, NAT_1, VALUED_0, FUNCT_7, REAL_1; notations XBOOLE_0, ZFMISC_1, SUBSET_1, FUNCT_1, FUNCT_2, BINOP_1, SETWISEO, ORDINAL1, XCMPLX_0, XREAL_0, NAT_1, INT_1, NUMBERS, RAT_1, VALUED_0; constructors BINOP_1, SETWISEO, XCMPLX_0, RAT_1, RELSET_1, VALUED_0, NUMBERS; registrations ORDINAL1, NUMBERS, XCMPLX_0, XREAL_0, NAT_1, INT_1, RAT_1, RELSET_1, VALUED_0; requirements BOOLE, SUBSET, ARITHM, NUMERALS; begin scheme :: BINOP_2:sch 1 FuncDefUniq{C, D()->non empty set, F(Element of C())->object}: for f1,f2 being Function of C(),D() st (for x being Element of C() holds f1.x = F(x)) & (for x being Element of C() holds f2.x = F(x)) holds f1 = f2; scheme :: BINOP_2:sch 2 BinOpDefuniq{A()->non empty set, O(Element of A(),Element of A())->object}: for o1,o2 being BinOp of A() st (for a,b being Element of A() holds o1.(a,b) = O(a,b)) & (for a,b being Element of A() holds o2.(a,b) = O(a,b)) holds o1 = o2; scheme :: BINOP_2:sch 3 CFuncDefUniq{F(object)->object}: for f1,f2 being Function of COMPLEX,COMPLEX st (for x being Complex holds f1.x = F(x)) & (for x being Complex holds f2.x = F(x)) holds f1 = f2; scheme :: BINOP_2:sch 4 RFuncDefUniq{F(Real)->object}: for f1,f2 being Function of REAL,REAL st (for x being Real holds f1.x = F(x)) & (for x being Real holds f2.x = F(x)) holds f1 = f2; registration cluster -> rational for Element of RAT; end; scheme :: BINOP_2:sch 5 WFuncDefUniq{F(Rational)->object}: for f1,f2 being Function of RAT,RAT st (for x being Rational holds f1.x = F(x)) & (for x being Rational holds f2.x = F(x)) holds f1 = f2; scheme :: BINOP_2:sch 6 IFuncDefUniq{F(Integer)->object}: for f1,f2 being Function of INT,INT st (for x being Integer holds f1.x = F(x)) & (for x being Integer holds f2.x = F(x)) holds f1 = f2; scheme :: BINOP_2:sch 7 NFuncDefUniq{F(Nat)->object}: for f1,f2 being sequence of NAT st (for x being Nat holds f1.x = F(x)) & (for x being Nat holds f2.x = F(x)) holds f1 = f2; scheme :: BINOP_2:sch 8 CBinOpDefuniq{O(Complex,Complex)->object}: for o1,o2 being BinOp of COMPLEX st (for a,b being Complex holds o1.(a,b) = O(a,b)) & (for a,b being Complex holds o2.(a,b) = O(a,b)) holds o1 = o2; scheme :: BINOP_2:sch 9 RBinOpDefuniq{O(Real,Real)->object}: for o1,o2 being BinOp of REAL st (for a,b being Real holds o1.(a,b) = O(a,b)) & (for a,b being Real holds o2.(a,b) = O(a,b)) holds o1 = o2; scheme :: BINOP_2:sch 10 WBinOpDefuniq{O(Rational,Rational)->object}: for o1,o2 being BinOp of RAT st (for a,b being Rational holds o1.(a,b) = O(a,b)) & (for a,b being Rational holds o2.(a,b) = O(a,b)) holds o1 = o2; scheme :: BINOP_2:sch 11 IBinOpDefuniq{O(Integer,Integer)->object}: for o1,o2 being BinOp of INT st (for a,b being Integer holds o1.(a,b) = O(a,b)) & (for a,b being Integer holds o2.(a,b) = O(a,b)) holds o1 = o2; scheme :: BINOP_2:sch 12 NBinOpDefuniq{O(Nat,Nat)->object}: for o1,o2 being BinOp of NAT st (for a,b being Nat holds o1.(a,b) = O(a,b)) & (for a,b being Nat holds o2.(a,b) = O(a,b)) holds o1 = o2; scheme :: BINOP_2:sch 13 CLambda2D{F(Complex,Complex) -> Complex}: ex f being Function of [:COMPLEX,COMPLEX:],COMPLEX st for x,y being Complex holds f.(x,y)=F(x,y); scheme :: BINOP_2:sch 14 RLambda2D{F(Real,Real) -> Real}: ex f being Function of [:REAL,REAL:],REAL st for x,y being Real holds f.(x,y)=F(x,y); scheme :: BINOP_2:sch 15 WLambda2D{F(Rational,Rational) -> Rational}: ex f being Function of [:RAT,RAT:],RAT st for x,y being Rational holds f.(x,y)=F(x,y); scheme :: BINOP_2:sch 16 ILambda2D{F(Integer,Integer) -> Integer}: ex f being Function of [:INT,INT:],INT st for x,y being Integer holds f.(x,y)=F(x,y); scheme :: BINOP_2:sch 17 NLambda2D{F(Nat,Nat) -> Nat}: ex f being Function of [:NAT,NAT:],NAT st for x,y being Nat holds f.(x,y)=F(x,y); scheme :: BINOP_2:sch 18 CLambdaD{F(Complex) -> Complex }: ex f being Function of COMPLEX,COMPLEX st for x being Complex holds f.x = F(x); scheme :: BINOP_2:sch 19 RLambdaD{F(Real) -> Real }: ex f being Function of REAL,REAL st for x being Real holds f.x = F(x); scheme :: BINOP_2:sch 20 WLambdaD{F(Rational) -> Rational }: ex f being Function of RAT,RAT st for x being Rational holds f.x = F(x); scheme :: BINOP_2:sch 21 ILambdaD{F(Integer) -> Integer }: ex f being Function of INT,INT st for x being Integer holds f.x = F(x); scheme :: BINOP_2:sch 22 NLambdaD{F(Nat) -> Nat }: ex f being sequence of NAT st for x being Nat holds f.x = F(x); reserve c,c1,c2 for Complex; reserve r,r1,r2 for Real; reserve w,w1,w2 for Rational; reserve i,i1,i2 for Integer; reserve n1,n2 for Nat; :: definition :: let n1,n2; :: redefine func n1+n2 -> Element of NAT; :: coherence by ORDINAL1:def 12; :: redefine func n1*n2 -> Element of NAT; :: coherence by ORDINAL1:def 12; :: end; definition func compcomplex -> UnOp of COMPLEX means :: BINOP_2:def 1 for c holds it.c = -c; func invcomplex -> UnOp of COMPLEX means :: BINOP_2:def 2 for c holds it.c = c"; func addcomplex -> BinOp of COMPLEX means :: BINOP_2:def 3 for c1,c2 holds it.(c1,c2) = c1 + c2; func diffcomplex -> BinOp of COMPLEX means :: BINOP_2:def 4 for c1,c2 holds it.(c1,c2) = c1 - c2; func multcomplex -> BinOp of COMPLEX means :: BINOP_2:def 5 for c1,c2 holds it.(c1,c2) = c1 * c2; func divcomplex -> BinOp of COMPLEX means :: BINOP_2:def 6 for c1,c2 holds it.(c1,c2) = c1 / c2; end; definition func compreal -> UnOp of REAL means :: BINOP_2:def 7 for r holds it.r = -r; func invreal -> UnOp of REAL means :: BINOP_2:def 8 for r holds it.r = r"; func addreal -> BinOp of REAL means :: BINOP_2:def 9 for r1,r2 holds it.(r1,r2) = r1 + r2; func diffreal -> BinOp of REAL means :: BINOP_2:def 10 for r1,r2 holds it.(r1,r2) = r1 - r2; func multreal -> BinOp of REAL means :: BINOP_2:def 11 for r1,r2 holds it.(r1,r2) = r1 * r2; func divreal -> BinOp of REAL means :: BINOP_2:def 12 for r1,r2 holds it.(r1,r2) = r1 / r2; end; definition func comprat -> UnOp of RAT means :: BINOP_2:def 13 for w holds it.w = -w; func invrat -> UnOp of RAT means :: BINOP_2:def 14 for w holds it.w = w"; func addrat -> BinOp of RAT means :: BINOP_2:def 15 for w1,w2 holds it.(w1,w2) = w1 + w2; func diffrat -> BinOp of RAT means :: BINOP_2:def 16 for w1,w2 holds it.(w1,w2) = w1 - w2; func multrat -> BinOp of RAT means :: BINOP_2:def 17 for w1,w2 holds it.(w1,w2) = w1 * w2; func divrat -> BinOp of RAT means :: BINOP_2:def 18 for w1,w2 holds it.(w1,w2) = w1 / w2; end; definition func compint -> UnOp of INT means :: BINOP_2:def 19 for i holds it.i = -i; func addint -> BinOp of INT means :: BINOP_2:def 20 for i1,i2 holds it.(i1,i2) = i1 + i2; func diffint -> BinOp of INT means :: BINOP_2:def 21 for i1,i2 holds it.(i1,i2) = i1 - i2; func multint -> BinOp of INT means :: BINOP_2:def 22 for i1,i2 holds it.(i1,i2) = i1 * i2; end; definition func addnat -> BinOp of NAT means :: BINOP_2:def 23 for n1,n2 holds it.(n1,n2) = n1 + n2; func multnat -> BinOp of NAT means :: BINOP_2:def 24 for n1,n2 holds it.(n1,n2) = n1 * n2; end; registration cluster addcomplex -> commutative associative; cluster multcomplex -> commutative associative; cluster addreal -> commutative associative; cluster multreal -> commutative associative; cluster addrat -> commutative associative; cluster multrat -> commutative associative; cluster addint -> commutative associative; cluster multint -> commutative associative; cluster addnat -> commutative associative; cluster multnat -> commutative associative; end; registration cluster addcomplex -> having_a_unity; cluster addreal -> having_a_unity; cluster addrat -> having_a_unity; cluster addint -> having_a_unity; cluster addnat -> having_a_unity; cluster multcomplex -> having_a_unity; cluster multreal -> having_a_unity; cluster multrat -> having_a_unity; cluster multint -> having_a_unity; cluster multnat -> having_a_unity; end; theorem :: BINOP_2:1 the_unity_wrt addcomplex = 0; theorem :: BINOP_2:2 the_unity_wrt addreal = 0; theorem :: BINOP_2:3 the_unity_wrt addrat = 0; theorem :: BINOP_2:4 the_unity_wrt addint = 0; theorem :: BINOP_2:5 the_unity_wrt addnat = 0; theorem :: BINOP_2:6 the_unity_wrt multcomplex = 1; theorem :: BINOP_2:7 the_unity_wrt multreal = 1; theorem :: BINOP_2:8 the_unity_wrt multrat = 1; theorem :: BINOP_2:9 the_unity_wrt multint = 1; theorem :: BINOP_2:10 the_unity_wrt multnat = 1; registration let f be real-valued Function; let a,b be object; cluster f.(a,b) -> real; end;