Article BINOP_2, MML version 4.99.1005

:: BINOP_2:sch 1
scheme BINOP_2:sch 1
{F1 -> non empty set,
  F2 -> non empty set,
  F3 -> set}:
for b1, b2 being Function-like quasi_total Relation of F1(),F2()
      st (for b3 being Element of F1() holds
            b1 . b3 = F3(b3)) &
         (for b3 being Element of F1() holds
            b2 . b3 = F3(b3))
   holds b1 = b2


:: BINOP_2:sch 2
scheme BINOP_2:sch 2
{F1 -> non empty set,
  F2 -> set}:
for b1, b2 being Function-like quasi_total Relation of [:F1(),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


:: BINOP_2:condreg 1
registration
  cluster -> rational (Element of RAT);
end;

:: BINOP_2:funcnot 1 => BINOP_2:func 1
definition
  let a1 be Element of COMPLEX;
  redefine func - a1 -> Element of COMPLEX;
  involutiveness;
::  for a1 being Element of COMPLEX holds
::     - - a1 = a1;
end;

:: BINOP_2:funcnot 2 => BINOP_2:func 2
definition
  let a1 be Element of COMPLEX;
  redefine func a1 " -> Element of COMPLEX;
  involutiveness;
::  for a1 being Element of COMPLEX holds
::     a1 " " = a1;
end;

:: BINOP_2:funcnot 3 => BINOP_2:func 3
definition
  let a1, a2 be Element of COMPLEX;
  redefine func a1 + a2 -> Element of COMPLEX;
  commutativity;
::  for a1, a2 being Element of COMPLEX holds
::  a1 + a2 = a2 + a1;
end;

:: BINOP_2:funcnot 4 => BINOP_2:func 4
definition
  let a1, a2 be Element of COMPLEX;
  redefine func a1 - a2 -> Element of COMPLEX;
end;

:: BINOP_2:funcnot 5 => BINOP_2:func 5
definition
  let a1, a2 be Element of COMPLEX;
  redefine func a1 * a2 -> Element of COMPLEX;
  commutativity;
::  for a1, a2 being Element of COMPLEX holds
::  a1 * a2 = a2 * a1;
end;

:: BINOP_2:funcnot 6 => BINOP_2:func 6
definition
  let a1, a2 be Element of COMPLEX;
  redefine func a1 / a2 -> Element of COMPLEX;
end;

:: BINOP_2:funcnot 7 => BINOP_2:func 7
definition
  let a1 be Element of REAL;
  redefine func - a1 -> Element of REAL;
  involutiveness;
::  for a1 being Element of REAL holds
::     - - a1 = a1;
end;

:: BINOP_2:funcnot 8 => BINOP_2:func 8
definition
  let a1 be Element of REAL;
  redefine func a1 " -> Element of REAL;
  involutiveness;
::  for a1 being Element of REAL holds
::     a1 " " = a1;
end;

:: BINOP_2:funcnot 9 => BINOP_2:func 9
definition
  let a1, a2 be Element of REAL;
  redefine func a1 + a2 -> Element of REAL;
  commutativity;
::  for a1, a2 being Element of REAL holds
::  a1 + a2 = a2 + a1;
end;

:: BINOP_2:funcnot 10 => BINOP_2:func 10
definition
  let a1, a2 be Element of REAL;
  redefine func a1 - a2 -> Element of REAL;
end;

:: BINOP_2:funcnot 11 => BINOP_2:func 11
definition
  let a1, a2 be Element of REAL;
  redefine func a1 * a2 -> Element of REAL;
  commutativity;
::  for a1, a2 being Element of REAL holds
::  a1 * a2 = a2 * a1;
end;

:: BINOP_2:funcnot 12 => BINOP_2:func 12
definition
  let a1, a2 be Element of REAL;
  redefine func a1 / a2 -> Element of REAL;
end;

:: BINOP_2:funcnot 13 => BINOP_2:func 13
definition
  let a1 be Element of RAT;
  redefine func - a1 -> Element of RAT;
  involutiveness;
::  for a1 being Element of RAT holds
::     - - a1 = a1;
end;

:: BINOP_2:funcnot 14 => BINOP_2:func 14
definition
  let a1 be Element of RAT;
  redefine func a1 " -> Element of RAT;
  involutiveness;
::  for a1 being Element of RAT holds
::     a1 " " = a1;
end;

:: BINOP_2:funcnot 15 => BINOP_2:func 15
definition
  let a1, a2 be Element of RAT;
  redefine func a1 + a2 -> Element of RAT;
  commutativity;
::  for a1, a2 being Element of RAT holds
::  a1 + a2 = a2 + a1;
end;

:: BINOP_2:funcnot 16 => BINOP_2:func 16
definition
  let a1, a2 be Element of RAT;
  redefine func a1 - a2 -> Element of RAT;
end;

:: BINOP_2:funcnot 17 => BINOP_2:func 17
definition
  let a1, a2 be Element of RAT;
  redefine func a1 * a2 -> Element of RAT;
  commutativity;
::  for a1, a2 being Element of RAT holds
::  a1 * a2 = a2 * a1;
end;

:: BINOP_2:funcnot 18 => BINOP_2:func 18
definition
  let a1, a2 be Element of RAT;
  redefine func a1 / a2 -> Element of RAT;
end;

:: BINOP_2:funcnot 19 => BINOP_2:func 19
definition
  let a1 be Element of INT;
  redefine func - a1 -> Element of INT;
  involutiveness;
::  for a1 being Element of INT holds
::     - - a1 = a1;
end;

:: BINOP_2:funcnot 20 => BINOP_2:func 20
definition
  let a1, a2 be Element of INT;
  redefine func a1 + a2 -> Element of INT;
  commutativity;
::  for a1, a2 being Element of INT holds
::  a1 + a2 = a2 + a1;
end;

:: BINOP_2:funcnot 21 => BINOP_2:func 21
definition
  let a1, a2 be Element of INT;
  redefine func a1 - a2 -> Element of INT;
end;

:: BINOP_2:funcnot 22 => BINOP_2:func 22
definition
  let a1, a2 be Element of INT;
  redefine func a1 * a2 -> Element of INT;
  commutativity;
::  for a1, a2 being Element of INT holds
::  a1 * a2 = a2 * a1;
end;

:: BINOP_2:funcnot 23 => BINOP_2:func 23
definition
  let a1, a2 be Element of NAT;
  redefine func a1 + a2 -> Element of NAT;
  commutativity;
::  for a1, a2 being Element of NAT holds
::  a1 + a2 = a2 + a1;
end;

:: BINOP_2:funcnot 24 => BINOP_2:func 24
definition
  let a1, a2 be Element of NAT;
  redefine func a1 * a2 -> Element of NAT;
  commutativity;
::  for a1, a2 being Element of NAT holds
::  a1 * a2 = a2 * a1;
end;

:: BINOP_2:funcnot 25 => BINOP_2:func 25
definition
  func compcomplex -> Function-like quasi_total Relation of COMPLEX,COMPLEX means
    for b1 being Element of COMPLEX holds
       it . b1 = - b1;
end;

:: BINOP_2:def 1
theorem
for b1 being Function-like quasi_total Relation of COMPLEX,COMPLEX holds
      b1 = compcomplex
   iff
      for b2 being Element of COMPLEX holds
         b1 . b2 = - b2;

:: BINOP_2:funcnot 26 => BINOP_2:func 26
definition
  func invcomplex -> Function-like quasi_total Relation of COMPLEX,COMPLEX means
    for b1 being Element of COMPLEX holds
       it . b1 = b1 ";
end;

:: BINOP_2:def 2
theorem
for b1 being Function-like quasi_total Relation of COMPLEX,COMPLEX holds
      b1 = invcomplex
   iff
      for b2 being Element of COMPLEX holds
         b1 . b2 = b2 ";

:: BINOP_2:funcnot 27 => BINOP_2:func 27
definition
  func addcomplex -> Function-like quasi_total Relation of [:COMPLEX,COMPLEX:],COMPLEX means
    for b1, b2 being Element of COMPLEX holds
    it .(b1,b2) = b1 + b2;
end;

:: BINOP_2:def 3
theorem
for b1 being Function-like quasi_total Relation of [:COMPLEX,COMPLEX:],COMPLEX holds
      b1 = addcomplex
   iff
      for b2, b3 being Element of COMPLEX holds
      b1 .(b2,b3) = b2 + b3;

:: BINOP_2:funcnot 28 => BINOP_2:func 28
definition
  func diffcomplex -> Function-like quasi_total Relation of [:COMPLEX,COMPLEX:],COMPLEX means
    for b1, b2 being Element of COMPLEX holds
    it .(b1,b2) = b1 - b2;
end;

:: BINOP_2:def 4
theorem
for b1 being Function-like quasi_total Relation of [:COMPLEX,COMPLEX:],COMPLEX holds
      b1 = diffcomplex
   iff
      for b2, b3 being Element of COMPLEX holds
      b1 .(b2,b3) = b2 - b3;

:: BINOP_2:funcnot 29 => BINOP_2:func 29
definition
  func multcomplex -> Function-like quasi_total Relation of [:COMPLEX,COMPLEX:],COMPLEX means
    for b1, b2 being Element of COMPLEX holds
    it .(b1,b2) = b1 * b2;
end;

:: BINOP_2:def 5
theorem
for b1 being Function-like quasi_total Relation of [:COMPLEX,COMPLEX:],COMPLEX holds
      b1 = multcomplex
   iff
      for b2, b3 being Element of COMPLEX holds
      b1 .(b2,b3) = b2 * b3;

:: BINOP_2:funcnot 30 => BINOP_2:func 30
definition
  func divcomplex -> Function-like quasi_total Relation of [:COMPLEX,COMPLEX:],COMPLEX means
    for b1, b2 being Element of COMPLEX holds
    it .(b1,b2) = b1 / b2;
end;

:: BINOP_2:def 6
theorem
for b1 being Function-like quasi_total Relation of [:COMPLEX,COMPLEX:],COMPLEX holds
      b1 = divcomplex
   iff
      for b2, b3 being Element of COMPLEX holds
      b1 .(b2,b3) = b2 / b3;

:: BINOP_2:funcnot 31 => BINOP_2:func 31
definition
  func compreal -> Function-like quasi_total Relation of REAL,REAL means
    for b1 being Element of REAL holds
       it . b1 = - b1;
end;

:: BINOP_2:def 7
theorem
for b1 being Function-like quasi_total Relation of REAL,REAL holds
      b1 = compreal
   iff
      for b2 being Element of REAL holds
         b1 . b2 = - b2;

:: BINOP_2:funcnot 32 => BINOP_2:func 32
definition
  func invreal -> Function-like quasi_total Relation of REAL,REAL means
    for b1 being Element of REAL holds
       it . b1 = b1 ";
end;

:: BINOP_2:def 8
theorem
for b1 being Function-like quasi_total Relation of REAL,REAL holds
      b1 = invreal
   iff
      for b2 being Element of REAL holds
         b1 . b2 = b2 ";

:: BINOP_2:funcnot 33 => BINOP_2:func 33
definition
  func addreal -> Function-like quasi_total Relation of [:REAL,REAL:],REAL means
    for b1, b2 being Element of REAL holds
    it .(b1,b2) = b1 + b2;
end;

:: BINOP_2:def 9
theorem
for b1 being Function-like quasi_total Relation of [:REAL,REAL:],REAL holds
      b1 = addreal
   iff
      for b2, b3 being Element of REAL holds
      b1 .(b2,b3) = b2 + b3;

:: BINOP_2:funcnot 34 => BINOP_2:func 34
definition
  func diffreal -> Function-like quasi_total Relation of [:REAL,REAL:],REAL means
    for b1, b2 being Element of REAL holds
    it .(b1,b2) = b1 - b2;
end;

:: BINOP_2:def 10
theorem
for b1 being Function-like quasi_total Relation of [:REAL,REAL:],REAL holds
      b1 = diffreal
   iff
      for b2, b3 being Element of REAL holds
      b1 .(b2,b3) = b2 - b3;

:: BINOP_2:funcnot 35 => BINOP_2:func 35
definition
  func multreal -> Function-like quasi_total Relation of [:REAL,REAL:],REAL means
    for b1, b2 being Element of REAL holds
    it .(b1,b2) = b1 * b2;
end;

:: BINOP_2:def 11
theorem
for b1 being Function-like quasi_total Relation of [:REAL,REAL:],REAL holds
      b1 = multreal
   iff
      for b2, b3 being Element of REAL holds
      b1 .(b2,b3) = b2 * b3;

:: BINOP_2:funcnot 36 => BINOP_2:func 36
definition
  func divreal -> Function-like quasi_total Relation of [:REAL,REAL:],REAL means
    for b1, b2 being Element of REAL holds
    it .(b1,b2) = b1 / b2;
end;

:: BINOP_2:def 12
theorem
for b1 being Function-like quasi_total Relation of [:REAL,REAL:],REAL holds
      b1 = divreal
   iff
      for b2, b3 being Element of REAL holds
      b1 .(b2,b3) = b2 / b3;

:: BINOP_2:funcnot 37 => BINOP_2:func 37
definition
  func comprat -> Function-like quasi_total Relation of RAT,RAT means
    for b1 being Element of RAT holds
       it . b1 = - b1;
end;

:: BINOP_2:def 13
theorem
for b1 being Function-like quasi_total Relation of RAT,RAT holds
      b1 = comprat
   iff
      for b2 being Element of RAT holds
         b1 . b2 = - b2;

:: BINOP_2:funcnot 38 => BINOP_2:func 38
definition
  func invrat -> Function-like quasi_total Relation of RAT,RAT means
    for b1 being Element of RAT holds
       it . b1 = b1 ";
end;

:: BINOP_2:def 14
theorem
for b1 being Function-like quasi_total Relation of RAT,RAT holds
      b1 = invrat
   iff
      for b2 being Element of RAT holds
         b1 . b2 = b2 ";

:: BINOP_2:funcnot 39 => BINOP_2:func 39
definition
  func addrat -> Function-like quasi_total Relation of [:RAT,RAT:],RAT means
    for b1, b2 being Element of RAT holds
    it .(b1,b2) = b1 + b2;
end;

:: BINOP_2:def 15
theorem
for b1 being Function-like quasi_total Relation of [:RAT,RAT:],RAT holds
      b1 = addrat
   iff
      for b2, b3 being Element of RAT holds
      b1 .(b2,b3) = b2 + b3;

:: BINOP_2:funcnot 40 => BINOP_2:func 40
definition
  func diffrat -> Function-like quasi_total Relation of [:RAT,RAT:],RAT means
    for b1, b2 being Element of RAT holds
    it .(b1,b2) = b1 - b2;
end;

:: BINOP_2:def 16
theorem
for b1 being Function-like quasi_total Relation of [:RAT,RAT:],RAT holds
      b1 = diffrat
   iff
      for b2, b3 being Element of RAT holds
      b1 .(b2,b3) = b2 - b3;

:: BINOP_2:funcnot 41 => BINOP_2:func 41
definition
  func multrat -> Function-like quasi_total Relation of [:RAT,RAT:],RAT means
    for b1, b2 being Element of RAT holds
    it .(b1,b2) = b1 * b2;
end;

:: BINOP_2:def 17
theorem
for b1 being Function-like quasi_total Relation of [:RAT,RAT:],RAT holds
      b1 = multrat
   iff
      for b2, b3 being Element of RAT holds
      b1 .(b2,b3) = b2 * b3;

:: BINOP_2:funcnot 42 => BINOP_2:func 42
definition
  func divrat -> Function-like quasi_total Relation of [:RAT,RAT:],RAT means
    for b1, b2 being Element of RAT holds
    it .(b1,b2) = b1 / b2;
end;

:: BINOP_2:def 18
theorem
for b1 being Function-like quasi_total Relation of [:RAT,RAT:],RAT holds
      b1 = divrat
   iff
      for b2, b3 being Element of RAT holds
      b1 .(b2,b3) = b2 / b3;

:: BINOP_2:funcnot 43 => BINOP_2:func 43
definition
  func compint -> Function-like quasi_total Relation of INT,INT means
    for b1 being Element of INT holds
       it . b1 = - b1;
end;

:: BINOP_2:def 19
theorem
for b1 being Function-like quasi_total Relation of INT,INT holds
      b1 = compint
   iff
      for b2 being Element of INT holds
         b1 . b2 = - b2;

:: BINOP_2:funcnot 44 => BINOP_2:func 44
definition
  func addint -> Function-like quasi_total Relation of [:INT,INT:],INT means
    for b1, b2 being Element of INT holds
    it .(b1,b2) = b1 + b2;
end;

:: BINOP_2:def 20
theorem
for b1 being Function-like quasi_total Relation of [:INT,INT:],INT holds
      b1 = addint
   iff
      for b2, b3 being Element of INT holds
      b1 .(b2,b3) = b2 + b3;

:: BINOP_2:funcnot 45 => BINOP_2:func 45
definition
  func diffint -> Function-like quasi_total Relation of [:INT,INT:],INT means
    for b1, b2 being Element of INT holds
    it .(b1,b2) = b1 - b2;
end;

:: BINOP_2:def 21
theorem
for b1 being Function-like quasi_total Relation of [:INT,INT:],INT holds
      b1 = diffint
   iff
      for b2, b3 being Element of INT holds
      b1 .(b2,b3) = b2 - b3;

:: BINOP_2:funcnot 46 => BINOP_2:func 46
definition
  func multint -> Function-like quasi_total Relation of [:INT,INT:],INT means
    for b1, b2 being Element of INT holds
    it .(b1,b2) = b1 * b2;
end;

:: BINOP_2:def 22
theorem
for b1 being Function-like quasi_total Relation of [:INT,INT:],INT holds
      b1 = multint
   iff
      for b2, b3 being Element of INT holds
      b1 .(b2,b3) = b2 * b3;

:: BINOP_2:funcnot 47 => BINOP_2:func 47
definition
  func addnat -> Function-like quasi_total Relation of [:NAT,NAT:],NAT means
    for b1, b2 being Element of NAT holds
    it .(b1,b2) = b1 + b2;
end;

:: BINOP_2:def 23
theorem
for b1 being Function-like quasi_total Relation of [:NAT,NAT:],NAT holds
      b1 = addnat
   iff
      for b2, b3 being Element of NAT holds
      b1 .(b2,b3) = b2 + b3;

:: BINOP_2:funcnot 48 => BINOP_2:func 48
definition
  func multnat -> Function-like quasi_total Relation of [:NAT,NAT:],NAT means
    for b1, b2 being Element of NAT holds
    it .(b1,b2) = b1 * b2;
end;

:: BINOP_2:def 24
theorem
for b1 being Function-like quasi_total Relation of [:NAT,NAT:],NAT holds
      b1 = multnat
   iff
      for b2, b3 being Element of NAT holds
      b1 .(b2,b3) = b2 * b3;

:: BINOP_2:funcreg 1
registration
  cluster addcomplex -> Function-like quasi_total commutative associative;
end;

:: BINOP_2:funcreg 2
registration
  cluster multcomplex -> Function-like quasi_total commutative associative;
end;

:: BINOP_2:funcreg 3
registration
  cluster addreal -> Function-like quasi_total commutative associative;
end;

:: BINOP_2:funcreg 4
registration
  cluster multreal -> Function-like quasi_total commutative associative;
end;

:: BINOP_2:funcreg 5
registration
  cluster addrat -> Function-like quasi_total commutative associative;
end;

:: BINOP_2:funcreg 6
registration
  cluster multrat -> Function-like quasi_total commutative associative;
end;

:: BINOP_2:funcreg 7
registration
  cluster addint -> Function-like quasi_total commutative associative;
end;

:: BINOP_2:funcreg 8
registration
  cluster multint -> Function-like quasi_total commutative associative;
end;

:: BINOP_2:funcreg 9
registration
  cluster addnat -> Function-like quasi_total commutative associative;
end;

:: BINOP_2:funcreg 10
registration
  cluster multnat -> Function-like quasi_total commutative associative;
end;

:: BINOP_2:funcreg 11
registration
  cluster addcomplex -> Function-like quasi_total having_a_unity;
end;

:: BINOP_2:funcreg 12
registration
  cluster addreal -> Function-like quasi_total having_a_unity;
end;

:: BINOP_2:funcreg 13
registration
  cluster addrat -> Function-like quasi_total having_a_unity;
end;

:: BINOP_2:funcreg 14
registration
  cluster addint -> Function-like quasi_total having_a_unity;
end;

:: BINOP_2:funcreg 15
registration
  cluster addnat -> Function-like quasi_total having_a_unity;
end;

:: BINOP_2:funcreg 16
registration
  cluster multcomplex -> Function-like quasi_total having_a_unity;
end;

:: BINOP_2:funcreg 17
registration
  cluster multreal -> Function-like quasi_total having_a_unity;
end;

:: BINOP_2:funcreg 18
registration
  cluster multrat -> Function-like quasi_total having_a_unity;
end;

:: BINOP_2:funcreg 19
registration
  cluster multint -> Function-like quasi_total having_a_unity;
end;

:: BINOP_2:funcreg 20
registration
  cluster multnat -> Function-like quasi_total having_a_unity;
end;

:: BINOP_2:th 1
theorem
the_unity_wrt addcomplex = 0;

:: BINOP_2:th 2
theorem
the_unity_wrt addreal = 0;

:: BINOP_2:th 3
theorem
the_unity_wrt addrat = 0;

:: BINOP_2:th 4
theorem
the_unity_wrt addint = 0;

:: BINOP_2:th 5
theorem
the_unity_wrt addnat = 0;

:: BINOP_2:th 6
theorem
the_unity_wrt multcomplex = 1;

:: BINOP_2:th 7
theorem
the_unity_wrt multreal = 1;

:: BINOP_2:th 8
theorem
the_unity_wrt multrat = 1;

:: BINOP_2:th 9
theorem
the_unity_wrt multint = 1;

:: BINOP_2:th 10
theorem
the_unity_wrt multnat = 1;