Algebraic operation add( + ), sub( - ), mul( * ), div( / ) for BaseNode class (#439)

* BaseNode / Edge class text input protection added (#423)

BaseNode class - Add protection to name, axis_names
*Protected in 3 place
*Initialize stage - __init__
*Function use setting - set_name / add_axis_names
*Property - Add @Property to name to protect direct adding node.name = 123

Edge class - Add protection to name
*Protected in 3 place
*Initialize stage - __init__
*Function use setting - set_name
*Property

* BaseNode / Edge class text input protection code revise (#423)

*if type(name) != str
*if not isinstance(name, str)
*change using type to isinstance to follow pylint

* Algebraic operation add( + ), sub( - ), mul( * ), div( / ) for BaseNode class (#292)

        *[BaseNode class] - add / sub / mul / truediv NotImplemented function Added
        *[Node class] - add / sub / mul / truediv function added
        *[CopyNode class] - overload the BaseNode mul / truediv as NotImplemented

        *[basebackend] - add / sub / mul / div NotImplemented function added
        *[numpy / tensorflow / pytorch] - add / sub / mul / div function added
        *[shell] - add / sub / div NotImplemented function added

        *Testing files
        [network_components_free_test]
        * Exception - Tensorflow is not tested when the operand is scalar
        * 1. Check add / sub / mul / div with int / float / Node
        * 2. Check implicit conversion
        * 2. Check the Type Error when type is not int / float / Node
        * 3. Check is the operand backend same
        * 4. Check is BaseNode has attribute _tensor

        [backend_test - numpy / tensorflow / pytorch]
        *check add / sub / mul / divide work for int / float / Node

* Add test cases for Tensorflow Algebraic operation and fix add, sub name (#292)

[Change name]
*add -> addition
*subtract -> substraction

[Add test case for Tensorflow]
* Specify the datatype to resolve the conflict between different dtype operation

[Test case for pytorch / jax]
* pytorch - [int / int -> int] give different answer for torch when it is dividing two integer
* jax - Different from other backend jax backend return 64bits dtype even operate between 32bits
        so put exceptional dtype test case for jax backend

* Add test cases for Tensorflow Algebraic operation and fix add, sub name (#292)

[Change name]
*add -> addition
*subtract -> substraction

[Add test case for Tensorflow]
* Specify the datatype to resolve the conflict between different dtype operation

[Test case for pytorch / jax]
* pytorch - [int / int -> int] give different answer for torch when it is dividing two integer
* jax - Different from other backend jax backend return 64bits dtype even operate between 32bits
        so put exceptional dtype test case for jax backend

* Add __add__, __sub__, __mul__, __truediv__ to TestNode Class

Co-authored-by: Chase Roberts <chaseriley@google.com>

Author: IllgamhoDuck

tensornetwork/backends/base_backend.py

@@ -391,6 +391,32 @@ def eigsh_lanczos(self,
     raise NotImplementedError(
         "Backend '{}' has not implemented eighs_lanczos.".format(self.name))
 
+  def addition(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    """
+      Return the default multiplication of `tensor`.
+      A backend can override such implementation.
+      Args:
+        tensor1: A tensor.
+        tensor2: A tensor.
+      Returns:
+        Tensor
+    """
+    raise NotImplementedError(
+        "Backend '{}' has not implemented addition.".format(self.name))
+
+  def subtraction(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    """
+      Return the default multiplication of `tensor`.
+      A backend can override such implementation.
+      Args:
+        tensor1: A tensor.
+        tensor2: A tensor.
+      Returns:
+        Tensor
+    """
+    raise NotImplementedError(
+        "Backend '{}' has not implemented subtraction.".format(self.name))
+
   def multiply(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
     """
       Return the default multiplication of `tensor`.
@@ -404,6 +430,19 @@ def multiply(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
     raise NotImplementedError(
         "Backend '{}' has not implemented multiply.".format(self.name))
 
+  def divide(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    """
+      Return the default divide of `tensor`.
+      A backend can override such implementation.
+      Args:
+        tensor1: A tensor.
+        tensor2: A tensor.
+      Returns:
+        Tensor
+    """
+    raise NotImplementedError(
+        "Backend '{}' has not implemented divide.".format(self.name))
+
   def index_update(self, tensor: Tensor, mask: Tensor,
                    assignee: Tensor) -> Tensor:
     """

tensornetwork/backends/numpy/numpy_backend.py

@@ -371,9 +371,18 @@ def eigsh_lanczos(self,
       eigenvectors.append(state / self.np.linalg.norm(state))
     return eigvals[0:numeig], eigenvectors
 
+  def addition(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    return tensor1 + tensor2
+
+  def subtraction(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    return tensor1 - tensor2
+
   def multiply(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
     return tensor1 * tensor2
 
+  def divide(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    return tensor1 / tensor2
+
   def index_update(self, tensor: Tensor, mask: Tensor,
                    assignee: Tensor) -> Tensor:
     t = self.np.copy(tensor)

tensornetwork/backends/numpy/numpy_backend_test.py

@@ -321,15 +321,67 @@ def test_eigsh_lanczos_raises():
 
 
 @pytest.mark.parametrize("a, b, expected", [
+    pytest.param(1, 1, 2),
+    pytest.param(1., np.ones((1, 2, 3)), 2*np.ones((1, 2, 3))),
+    pytest.param(2.*np.ones(()), 1., 3.*np.ones((1, 2, 3))),
+    pytest.param(2.*np.ones(()), 1.*np.ones((1, 2, 3)), 3.*np.ones((1, 2, 3))),
+])
+def test_addition(a, b, expected):
+  backend = numpy_backend.NumPyBackend()
+  tensor1 = backend.convert_to_tensor(a)
+  tensor2 = backend.convert_to_tensor(b)
+  result = backend.addition(tensor1, tensor2)
+
+  np.testing.assert_allclose(result, expected)
+  assert tensor1.dtype == tensor2.dtype == result.dtype
+
+
+@pytest.mark.parametrize("a, b, expected", [
+    pytest.param(1, 1, 0),
+    pytest.param(2., 1.*np.ones((1, 2, 3)), 1.*np.ones((1, 2, 3))),
+    pytest.param(np.ones((1, 2, 3)), 1., np.zeros((1, 2, 3))),
+    pytest.param(np.ones((1, 2, 3)), np.ones((1, 2, 3)), np.zeros((1, 2, 3))),
+])
+def test_subtraction(a, b, expected):
+  backend = numpy_backend.NumPyBackend()
+  tensor1 = backend.convert_to_tensor(a)
+  tensor2 = backend.convert_to_tensor(b)
+  result = backend.subtraction(tensor1, tensor2)
+
+  np.testing.assert_allclose(result, expected)
+  assert tensor1.dtype == tensor2.dtype == result.dtype
+
+
+@pytest.mark.parametrize("a, b, expected", [
+    pytest.param(1, 1, 1),
+    pytest.param(2., 1.*np.ones((1, 2, 3)), 2.*np.ones((1, 2, 3))),
+    pytest.param(np.ones((1, 2, 3)), 1., np.ones((1, 2, 3))),
     pytest.param(np.ones((1, 2, 3)), np.ones((1, 2, 3)), np.ones((1, 2, 3))),
-    pytest.param(2. * np.ones(()), np.ones((1, 2, 3)), 2. * np.ones((1, 2, 3))),
 ])
 def test_multiply(a, b, expected):
   backend = numpy_backend.NumPyBackend()
   tensor1 = backend.convert_to_tensor(a)
   tensor2 = backend.convert_to_tensor(b)
+  result = backend.multiply(tensor1, tensor2)
+
+  np.testing.assert_allclose(result, expected)
+  assert tensor1.dtype == tensor2.dtype == result.dtype
+
+
+@pytest.mark.parametrize("a, b, expected", [
+    pytest.param(2., 2., 1.),
+    pytest.param(2., 0.5*np.ones((1, 2, 3)), 4.*np.ones((1, 2, 3))),
+    pytest.param(np.ones(()), 2., 0.5*np.ones((1, 2, 3))),
+    pytest.param(np.ones(()), 2.*np.ones((1, 2, 3)), 0.5*np.ones((1, 2, 3))),
+])
+def test_divide(a, b, expected):
+  backend = numpy_backend.NumPyBackend()
+  tensor1 = backend.convert_to_tensor(a)
+  tensor2 = backend.convert_to_tensor(b)
+  result = backend.divide(tensor1, tensor2)
 
-  np.testing.assert_allclose(backend.multiply(tensor1, tensor2), expected)
+  np.testing.assert_allclose(result, expected)
+  assert tensor1.dtype == tensor2.dtype == result.dtype
 
 
 def find(which, vector):

tensornetwork/backends/pytorch/pytorch_backend.py

@@ -275,9 +275,18 @@ def eigsh_lanczos(self,
       eigenvectors.append(state / self.torch.norm(state))
     return eigvals[0:numeig], eigenvectors
 
+  def addition(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    return tensor1 + tensor2
+
+  def subtraction(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    return tensor1 - tensor2
+
   def multiply(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
     return tensor1 * tensor2
 
+  def divide(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    return tensor1 / tensor2
+
   def index_update(self, tensor: Tensor, mask: Tensor,
                    assignee: Tensor) -> Tensor:
     #make a copy

tensornetwork/backends/pytorch/pytorch_backend_test.py

@@ -293,15 +293,59 @@ def test_eigsh_lanczos_raises():
 
 
 @pytest.mark.parametrize("a, b, expected", [
+    pytest.param(1, 1, 2),
+    pytest.param(np.ones((1, 2, 3)), np.ones((1, 2, 3)), 2.*np.ones((1, 2, 3))),
+])
+def test_addition(a, b, expected):
+  backend = pytorch_backend.PyTorchBackend()
+  tensor1 = backend.convert_to_tensor(a)
+  tensor2 = backend.convert_to_tensor(b)
+  result = backend.addition(tensor1, tensor2)
+
+  np.testing.assert_allclose(result, expected)
+  assert tensor1.dtype == tensor2.dtype == result.dtype
+
+
+@pytest.mark.parametrize("a, b, expected", [
+    pytest.param(1, 1, 0),
+    pytest.param(np.ones((1, 2, 3)), np.ones((1, 2, 3)), np.zeros((1, 2, 3))),
+])
+def test_subtraction(a, b, expected):
+  backend = pytorch_backend.PyTorchBackend()
+  tensor1 = backend.convert_to_tensor(a)
+  tensor2 = backend.convert_to_tensor(b)
+  result = backend.subtraction(tensor1, tensor2)
+
+  np.testing.assert_allclose(result, expected)
+  assert tensor1.dtype == tensor2.dtype == result.dtype
+
+
+@pytest.mark.parametrize("a, b, expected", [
+    pytest.param(1, 1, 1),
     pytest.param(np.ones((1, 2, 3)), np.ones((1, 2, 3)), np.ones((1, 2, 3))),
-    pytest.param(2. * np.ones(()), np.ones((1, 2, 3)), 2. * np.ones((1, 2, 3))),
 ])
 def test_multiply(a, b, expected):
   backend = pytorch_backend.PyTorchBackend()
   tensor1 = backend.convert_to_tensor(a)
   tensor2 = backend.convert_to_tensor(b)
+  result = backend.multiply(tensor1, tensor2)
+
+  np.testing.assert_allclose(result, expected)
+  assert tensor1.dtype == tensor2.dtype == result.dtype
+
+
+@pytest.mark.parametrize("a, b, expected", [
+    pytest.param(2., 2., 1.),
+    pytest.param(np.ones(()), 2.*np.ones((1, 2, 3)), 0.5*np.ones((1, 2, 3))),
+])
+def test_divide(a, b, expected):
+  backend = pytorch_backend.PyTorchBackend()
+  tensor1 = backend.convert_to_tensor(a)
+  tensor2 = backend.convert_to_tensor(b)
+  result = backend.divide(tensor1, tensor2)
 
-  np.testing.assert_allclose(backend.multiply(tensor1, tensor2), expected)
+  np.testing.assert_allclose(result, expected)
+  assert tensor1.dtype == tensor2.dtype == result.dtype
 
 
 def test_eigh():

tensornetwork/backends/shell/shell_backend.py

@@ -290,11 +290,20 @@ def eigsh_lanczos(self,
     raise ValueError(
         '`A` has no attribut shape adn no `initial_state` is given.')
 
+  def addition(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    raise NotImplementedError("Shell tensor has not implemented addition( + )")
+
+  def subtraction(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    raise NotImplementedError("Shell tensor has not implemented subtraction( - )")
+
   def multiply(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
     a = np.ones(tensor1.shape)
     b = np.ones(tensor2.shape)
     return ShellTensor((a * b).shape)
 
+  def divide(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    raise NotImplementedError("Shell tensor has not implemented add( / )")
+
   def index_update(self, tensor: Tensor, mask: Tensor,
                    assignee: Tensor) -> Tensor:
     return ShellTensor(tensor.shape)

tensornetwork/backends/tensorflow/tensorflow_backend.py

@@ -182,9 +182,18 @@ def eigsh_lanczos(self,
     raise NotImplementedError(
         "Backend '{}' has not implemented eighs_lanczos.".format(self.name))
 
+  def addition(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    return tensor1 + tensor2
+
+  def subtraction(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    return tensor1 - tensor2
+
   def multiply(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
     return tensor1 * tensor2
 
+  def divide(self, tensor1: Tensor, tensor2: Tensor) -> Tensor:
+    return tensor1 / tensor2
+
   def index_update(self, tensor: Tensor, mask: Tensor,
                    assignee: Tensor) -> Tensor:
     #returns a copy (unfortunately)

tensornetwork/backends/tensorflow/tensorflow_backend_test.py

@@ -247,15 +247,59 @@ def test_conj():
 
 
 @pytest.mark.parametrize("a, b, expected", [
+    pytest.param(1, 1, 2),
+    pytest.param(2.*np.ones(()), 1.*np.ones((1, 2, 3)), 3.*np.ones((1, 2, 3))),
+])
+def test_addition(a, b, expected):
+  backend = tensorflow_backend.TensorFlowBackend()
+  tensor1 = backend.convert_to_tensor(a)
+  tensor2 = backend.convert_to_tensor(b)
+  result = backend.addition(tensor1, tensor2)
+
+  np.testing.assert_allclose(result, expected)
+  assert tensor1.dtype == tensor2.dtype == result.dtype
+
+
+@pytest.mark.parametrize("a, b, expected", [
+    pytest.param(1, 1, 0),
+    pytest.param(np.ones((1, 2, 3)), np.ones((1, 2, 3)), np.zeros((1, 2, 3))),
+])
+def test_subtraction(a, b, expected):
+  backend = tensorflow_backend.TensorFlowBackend()
+  tensor1 = backend.convert_to_tensor(a)
+  tensor2 = backend.convert_to_tensor(b)
+  result = backend.subtraction(tensor1, tensor2)
+
+  np.testing.assert_allclose(result, expected)
+  assert tensor1.dtype == tensor2.dtype == result.dtype
+
+
+@pytest.mark.parametrize("a, b, expected", [
+    pytest.param(1, 1, 1),
     pytest.param(np.ones((1, 2, 3)), np.ones((1, 2, 3)), np.ones((1, 2, 3))),
-    pytest.param(2. * np.ones(()), np.ones((1, 2, 3)), 2. * np.ones((1, 2, 3))),
 ])
 def test_multiply(a, b, expected):
   backend = tensorflow_backend.TensorFlowBackend()
   tensor1 = backend.convert_to_tensor(a)
   tensor2 = backend.convert_to_tensor(b)
+  result = backend.multiply(tensor1, tensor2)
+
+  np.testing.assert_allclose(result, expected)
+  assert tensor1.dtype == tensor2.dtype == result.dtype
+
+
+@pytest.mark.parametrize("a, b, expected", [
+    pytest.param(2., 2., 1.),
+    pytest.param(np.ones(()), 2.*np.ones((1, 2, 3)), 0.5*np.ones((1, 2, 3))),
+])
+def test_divide(a, b, expected):
+  backend = tensorflow_backend.TensorFlowBackend()
+  tensor1 = backend.convert_to_tensor(a)
+  tensor2 = backend.convert_to_tensor(b)
+  result = backend.divide(tensor1, tensor2)
 
-  np.testing.assert_allclose(backend.multiply(tensor1, tensor2), expected)
+  np.testing.assert_allclose(result, expected)
+  assert tensor1.dtype == tensor2.dtype == result.dtype
 
 
 @pytest.mark.parametrize("dtype", [tf.float64, tf.complex128])