Functor

class discopy.hopf.Functor(ob_map=None, ar_map=None, dom=None, cod=None, colour_map=None)

Bases: discopy.ribbon.Functor

A ribbon functor from ribbon diagrams to Intertwiner, i.e. it sends a knot to the tensor network of \(\mathrm{Rep}(H)\) that computes its invariant. Contract it yourself with tensor.Diagram.eval().

Parameters:

• ob_map – A mapping from atomic ribbon.Ty to Representation.

• ar_map – A mapping from generating ribbon.Box to arrays.

• cod – The category Intertwiner[H] of the target algebra.

The inherited ribbon dispatch does the work: an atom goes to its Representation (its dual l or r when the winding is odd), a product of atoms to the product of modules, and a cup/cap/twist to Intertwiner.cups/caps/twist(). The one override routes both crossings of a braid to Intertwiner.braid(), the under-crossing being the antipode inverse rather than the tensor adjoint.

Example

The twist followed by the trace of the inverse braid is the identity in any ribbon category. The functor maps this ribbon diagram to a tensor network that contracts to the identity, drawn as the tensor.CMap:

>>> import numpy as np
>>> D = Double(Algebra.cyclic(2))
>>> e = Representation[D].anyon(0, -1)
>>> m = Representation[D].anyon(1, 1)
>>> V = Representation[D].direct_sum([e, m])
>>> x = ribbon.Ty('x')
>>> F = Functor(ob_map={x: V}, ar_map={}, cod=Intertwiner[D])
>>> d = ribbon.Twist(x) >> ribbon.Braid(x, x)[::-1].trace()
>>> network = F(d)
>>> assert network.eval(dtype=complex).is_close(
...     F(ribbon.Id(x)).eval(dtype=complex))
>>> network.to_map().draw(  
...     doctest='docs/_static/hopf/ribbon-functor.dot')

A single braid contracts to the braiding matrix of the toric code:

>>> matrix = F(ribbon.Braid(x, x)).eval(dtype=complex).array
>>> assert np.allclose(matrix.reshape(4, 4), [[1, 0, 0, 0], [0, 0, -1, 0],
...                                           [0, 1, 0, 0], [0, 0, 0, 1]])

dom

alias of Diagram

cod

alias of Intertwiner