Tensor

class discopy.tensor.Tensor(array, *args, **kwargs)

Bases: Matrix

A tensor is a Matrix with dimensions as domain and codomain and the Kronecker product as tensor.

Parameters:

• inside – The array inside the tensor.

• dom (T) – The domain dimension.

• cod (T) – The codomain dimension.

Summary

id([dom])
then([other])
tensor([other])
dagger()
cups(left, right)
caps(left, right)
swap(left, right)
spiders(n_legs_in, n_legs_out, typ[, phase])	The tensor of interleaving spiders.
transpose([left])	Returns the diagrammatic transpose.
conjugate([diagrammatic])	Returns the conjugate of a tensor.
round([decimals])	Rounds the entries of a matrix up to a number of decimals.
subs(*args)
grad(var, **params)	Gradient with respect to variables.
jacobian(*variables, **params)	Jacobian with respect to variables.

Examples

>>> m = Tensor([0, 1, 1, 0], Dim(2), Dim(2))
>>> v = Tensor([0, 1], Dim(1), Dim(2))
>>> v >> m >> v.dagger()
Tensor[int64]([0], dom=Dim(1), cod=Dim(1))

Notes

Tensors can have sympy symbols as free variables.

>>> from sympy import Expr
>>> from sympy.abc import phi, psi
>>> v = Tensor[Expr]([phi, psi], Dim(1), Dim(2))
>>> d = v >> v.dagger()
>>> assert v >> v.dagger() == Tensor[Expr](
...     [phi * phi.conjugate() + psi * psi.conjugate()], Dim(1), Dim(1))

These can be substituted and lambdifed.

>>> v.subs(phi, 0).lambdify(psi, dtype=int)(1)
Tensor[int]([0, 1], dom=Dim(1), cod=Dim(2))

We can also use jax.numpy using backend().

>>> with backend('jax'):
...     f = lambda *xs: d.lambdify(phi, psi, dtype=float)(*xs).array
...     import jax
...     assert jax.grad(f)(1., 2.) == 2.

classmethod spiders(n_legs_in, n_legs_out, typ, phase=None)

The tensor of interleaving spiders.

Parameters:

• n_legs_in (int) – The number of legs in for each spider.

• n_legs_out (int) – The number of legs out for each spider.

• typ (Dim) – The type of the spiders.

Return type:

Tensor

classmethod copy(x, n)

Constructs spiders of dimension x with one leg in and n legs out.

Parameters:

• x (Dim) – The type of the spiders.

• n (int) – The number of legs out for each spider.

Return type:

Tensor

Example

>>> from discopy import markov
>>> n = markov.Ty('n')
>>> F = Functor(ob={n: Dim(2)}, ar={}, dom=markov.Category())
>>> assert F(markov.Copy(n, 2)) == Tensor[int].copy(Dim(2), 2)\
...     == Tensor[int]([1, 0, 0, 0, 0, 0, 0, 1], Dim(2), Dim(2, 2))

transpose(left=False)

Returns the diagrammatic transpose.

Note

This is not the same as the algebraic transpose for non-atomic dims.

Return type:

Tensor

property l: Tensor

Returns the diagrammatic transpose.

Note

This is not the same as the algebraic transpose for non-atomic dims.

property r: Tensor

Returns the diagrammatic transpose.

Note

This is not the same as the algebraic transpose for non-atomic dims.

conjugate(diagrammatic=True)

Returns the conjugate of a tensor.

Parameters:

diagrammatic (bool, default: True) – Whether to use the diagrammatic or algebraic conjugate.

Return type:

Tensor

classmethod zero(dom, cod)

Returns the zero tensor of a given shape.

Examples

>>> assert Tensor.zero(Dim(2), Dim(2))\
...     == Tensor([0, 0, 0, 0], Dim(2), Dim(2))

Parameters:

• dom (Dim) –

• cod (Dim) –

Return type:

Tensor

jacobian(*variables, **params)

Jacobian with respect to variables.

Parameters:

variables (list[sympy.Symbol]) – The list of variables to differentiate.

Returns:

tensor – with tensor.dom == self.dom and tensor.cod == Dim(len(variables)) @ self.cod.

Return type:

Tensor

Examples

>>> from sympy import Expr
>>> from sympy.abc import x, y, z
>>> vector = Tensor[Expr]([x ** 2, y * z], Dim(1), Dim(2))
>>> vector.jacobian(x, y, z)
Tensor[Expr]([2*x, 0, 0, z, 0, y], dom=Dim(1), cod=Dim(3, 2))

factory

alias of Tensor