Intertwiner

class discopy.hopf.Intertwiner(inside, dom, cod, _scan=True)

Bases: discopy.abc.Result, discopy.tensor.Diagram, discopy.abc.RibbonCategory

The ribbon category \(\mathrm{Rep}(H)\) of representations of the class parameter algebra: given a Algebra H, the class Intertwiner[H] is a category of tensor.Diagrams whose objects are Representation[H], and algebra is accessible on both the class and its instances. Its ribbon structure is given by its classmethods — the braiding is braid() (the R-matrix acting on the two strands, then a swap), the twist() is the trace of the self-braiding, and the (co)evaluations cups/caps pair a module with its dual Representation.r, which carries the antipode-twisted action.

An intertwiner can also be built from concrete data: Intertwiner[H](array, dom, cod) wraps the array in a single box, as for a tensor.Tensor — this is how a ribbon Functor maps its generating boxes.

Example

An intertwiner f between modules is a map that commutes with the action, \(f \circ \rho_V = \rho_W \circ (1_H \otimes f)\). We check this axiom for the braid on \(V \otimes V\), whose product action \(\rho_{V \otimes V}\) goes through the comultiplication (see Representation.tensor()), and draw the left-hand side as the tensor.CMap it contracts to:

>>> 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])
>>> action = (V @ V).action
>>> braid = Intertwiner[D].braid(V, V)
>>> lhs, rhs = action >> braid, Id(D.ty) @ braid >> action
>>> assert lhs.eval(dtype=complex).is_close(rhs.eval(dtype=complex))
>>> lhs.to_map().draw(  
...   doctest='docs/_static/hopf/intertwiner.dot')

The braid contracts to the braiding matrix of the toric code:

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

Parameters:

• dom (C0) –

• cod (C0) –

ob

alias of Dim

classmethod braid(left, right, is_dagger=False)

The braiding \(V \otimes W \to W \otimes V\) (its inverse \(R^{-1} = (S \otimes 1) R\) when is_dagger): the R-matrix acting on the two strands, i.e. \((\rho_V \otimes \rho_W)(R)\), then a swap. Raises a ValueError if the algebra has no R-matrix.

classmethod twist(dom)

The twist of dom: the action of the ribbon element Algebra.twist, computed once as the ribbon trace of the self-braiding of the regular representation.