Ticket #14234: 17710.patch

sage/combinat/all.py

@@ -51 +51 @@
 #Partition algebra
 from partition_algebra import SetPartitionsAk, SetPartitionsPk, SetPartitionsTk, SetPartitionsIk, SetPartitionsBk, SetPartitionsSk, SetPartitionsRk, SetPartitionsRk, SetPartitionsPRk
 
+#Diagram algebra
+from diagram_algebras import PartitionAlgebra, BrauerAlgebra, PlanarAlgebra, TemperleyLiebAlgebra, IdealAlgebra
+
 #Cores
 from core import Core, Cores
 

new file sage/combinat/diagram_algebras.py

@@ +1 @@
+r"""
+Diagram/Partition Algebras
+"""
+#*****************************************************************************
+#  Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>, 
+#                2012 Stephen Doty <doty@math.luc.edu>,
+#                     Aaron Lauve <lauve@math.luc.edu>,
+#                     George H. Seelinger <ghseeli@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+from sage.categories.all import FiniteDimensionalAlgebrasWithBasis
+from sage.combinat.family import Family
+from sage.combinat.free_module import (CombinatorialFreeModule, 
+    CombinatorialFreeModuleElement)
+from sage.combinat.set_partition import SetPartitions
+from sage.sets.set import Set
+from sage.graphs.graph import Graph
+from sage.misc.cachefunc import cached_method
+import collections
+import functools, math
+##these four imports are for drawing diagrams; these may be removed in the final version.
+#import networkx 
+#import pylab
+#import matplotlib.pyplot as plt
+#import itertools
+##
+
+def partition_diagrams(k):
+    r"""
+    partition_diagrams(k) returns a list of all partition diagrams of order `k`,
+    where we define a partition diagram of order `k` to be any set partition
+    of the set `\{1, \dots, k, -1, \dots, -k\}`.
+
+    INPUT:
+
+    - ``k`` - integer or integer + 1/2. This is the order of the partition diagrams.
+
+    OUTPUT:
+
+    set partitions -- if k is an integer, set partitions of the set
+    `\{1, \dots, k, -1, \dots, -k\}`. If k is an integer + 1/2, set
+    partitions `\{1, \dots, k-0.5, -1, \dots, -(k-0.5)\}` with
+    `\{k+0.5, -(k+0.5)\}` appended to each set partition.
+
+    EXAMPLES::
+
+        sage: partition_diagrams(2)
+        Set partitions of [1, 2, -1, -2]
+        sage: partition_diagrams(1.5) #random order
+        [{{2, -2}, {1, -1}}, {{-1}, {2, -2}, {1}}]
+
+    """
+    if int(k) == k:
+        return SetPartitions( range(1,k+1) + [-j for j in range(1,k+1)] )
+    if k - math.floor(k) == 0.5:
+        L = []
+        counter = 0
+        for i in SetPartitions( range(1,int(k+0.5)) + [-j for j in range(1,int(k+0.5))] ).list():
+            L.append(i.list())
+            (L[counter]).append(Set([int(k)+1, -(int(k)+1)]))
+            L[counter] = Set(L[counter])
+            counter = counter+1
+        return L
+
+def brauer_diagrams(k):
+    r"""
+    brauer_diagrams(k) returns a list of all Brauer diagrams of order `k`,
+    where we define a Brauer diagram of order `k` to  be any set partition
+    of the set`\{1, \dots, k, -1, \dots, -k\}` with block size 2.
+
+    INPUT:
+
+     - ``k`` - integer. This is the order of the Brauer diagrams.
+
+    OUTPUT:
+
+    set partitions -- set partitions of the set
+    `\{1, \dots, k, -1, \dots, -k\}` with block size 2. If k is an
+    integer + 1/2, set partitions
+    `\{1, \dots, k-0.5, -1, \dots, -(k-0.5)\}` of block size 2 with
+    `\{k+0.5, -(k+0.5)\}` appended to each set partition.
+
+    EXAMPLES::
+
+        sage: brauer_diagrams(2)
+        Set partitions of [1, 2, -1, -2] with sizes in [[2, 2]]
+        sage: brauer_diagrams(2.5) #random order
+        [{{1, 2}, {3, -3}, {-1, -2}}, {{2, -2}, {3, -3}, {1, -1}}, {{2, -1}, {3, -3}, {1, -2}}]
+        
+    """
+    if int(k) == k:
+        return SetPartitions( range(1,k+1) + [-j for j in range(1,k+1)], [2 for j in range(1,k+1)] )
+    if k - math.floor(k) == 0.5:
+        L = []
+        counter = 0
+        for i in SetPartitions( range(1,int(k+0.5)) + [-j for j in range(1,int(k+0.5))], [2 for j in range(1,k+0.5)] ).list():
+            L.append(i.list())
+            (L[counter]).append(Set([int(k)+1, -(int(k)+1)]))
+            L[counter] = Set(L[counter])
+            counter = counter+1
+        return L
+
+def temperley_lieb_diagrams(k):
+    r"""
+    temperley_lieb_diagrams(k) returns a list of all Temperley-Lieb
+    diagrams of order `k`, where we define a Temperley-Lieb diagram of
+    order `k` to be any set partition of the set
+    `\{1, \dots, k, -1, \dots, -k\}` with block size  2 and that is
+    planar.
+
+    INPUT:
+
+    - ``k`` - integer or integer + 1/2. This is the order of the
+    Temperley-Lieb diagrams.
+
+    OUTPUT:
+
+    set partitions -- set partitions of the set
+    `\{1, \dots, k, -1, \dots, -k\}` with block size 2 that are planar.
+    If k is an integer + 1/2, set partitions
+    `\{1, \dots, k-0.5, -1, \dots, -(k-0.5)\}` of block size 2 that are
+    planar with `\{k+0.5, -(k+0.5)\}` appended to each set partition.
+
+    EXAMPLES::
+
+        sage: temperley_lieb_diagrams(2) #random order
+        [{{1, 2}, {-1, -2}}, {{2, -2}, {1, -1}}]
+        sage: temperley_lieb_diagrams(2.5) #random order
+        [{{1, 2}, {3, -3}, {-1, -2}}, {{2, -2}, {3, -3}, {1, -1}}]
+    """
+    B = brauer_diagrams(k)
+    T = []
+    for i in B:
+        if is_planar(i) == True:
+            T.append(i)
+    return T
+
+def planar_diagrams(k):
+    A = partition_diagrams(k)
+    P = []
+    for i in A:
+        if is_planar(i) == True:
+            P.append(i)
+    return P
+
+def ideal_diagrams(k):
+    A = partition_diagrams(k)
+    I = []
+    for i in A:
+        if propagating_number(i) < k:
+            I.append(i)
+    return I
+
+def is_partition_diagram(s,k):
+    r"""
+    is_partition_diagram(s,k) returns True if `s` is a partition diagram of order
+    exactly `k` (i.e., a set partition on `\{1, \dots, k, -1, \dots ,-k\}`) and returns False
+    otherwise.
+    INPUT:
+
+     - ``s`` - set partition. This is the set partition being tested.
+     - ``k`` - integer. This is the test order.
+
+    OUTPUT:
+
+    boolean -- this is true if `s` has order `k` and false otherwise.
+
+    EXAMPLES::
+
+        sage: s = partition_diagrams(2)
+        sage: is_partition_diagram(s.list()[2], 2)
+        True
+        sage: is_partition_diagram(s.list()[2], 3)
+        False
+
+    TODO: SHOULD BE MADE A METHOD OF THE SetPartitions CLASS ?
+    """
+    return s in partition_diagrams(k)
+        
+class PartitionAlgebra(CombinatorialFreeModule):
+    r"""
+    INPUT:
+
+     -``k``-- rank of the algebra (equals half the number of nodes in the diagrams)
+     -``q``-- a parameter.
+
+    OPTIONAL ARGUMENTS:
+
+     -``base_ring``-- a ring containing q (default q.parent())
+     -``prefix``-- a label for the basis elements (default "P")
+
+    The partition algebra of rank k is an algebra with basis indexed by the
+    collection of set partitions of `\{1, \dots, k, -1, \dots, -k\}`. Each such set
+    partition is regarded as a graph on nodes `\{1, \dots, k, -1, \dots, -k\}`
+    arranged in two rows, with nodes `1, \dots, k` in the top row from left to
+    right and with nodes `-1, \dots, -k` in the bottom row from left to right,
+    and an edge connecting two nodes if and only if the nodes lie in the same
+    subset of the set partition.
+
+    The partition algebra is regarded as an example of a "diagram algebra" due
+    to the fact that its natural basis is given by certain graphs often called
+    diagrams.
+
+    The product of two basis elements is given by the rule  a.b = q^N (a o b),
+    where a o b is the composite set partition obtained by placing diagram
+    a above diagram b, identifying the bottom row nodes of a with the top row
+    nodes of b, and omitting any closed "loops" in the middle. The number N
+    is the number of connected components of the omitted loops.
+
+    The parameter q is a deformation parameter. Taking `q=1` produces the
+    semigroup algebra (over the base ring) of the partition monoid, in which
+    the product of two set partitions is simply given by their composition.
+
+    The Iwahori-Hecke algebra of type A (with a single parameter) is naturally
+    a subalgebra of the partition algebra. 
+
+    An excellent reference for partition algebras and its various subalgebras
+    (Brauer algebra, Temperley-Lieb algebra, etc) is the paper [HR]_.
+
+    REFERENCES:
+
+    .. [HR] Tom Halverson and Arun Ram, Partition algebras. European Journal of
+            Combinatorics 26 (2005), 869--921.
+
+    EXAMPLES:
+
+    The following shorthand simultaneously define the univariate polynomial
+    ring over the rationals as well as the variable `x`::
+    
+        sage: R.<x> = PolynomialRing(QQ)
+        sage: R
+        Univariate Polynomial Ring in x over Rational Field
+        sage: x
+        x
+        sage: x.parent() is R
+        True
+
+    We now define the partition algebra of rank `2` with parameter `x` over the Integer ring::
+
+        sage: P = PartitionAlgebra(2,x,ZZ['x'])
+        sage: P
+        Partition Algebra of rank 2 with parameter x over Univariate Polynomial Ring in x over Integer Ring, with prefix P
+        sage: P.basis()
+        Lazy family (Term map from Set partitions of [1, 2, -1, -2] to Partition Algebra of rank 2 with parameter x over Univariate Polynomial Ring in x over Integer Ring, with prefix P(i))_{i in Set partitions of [1, 2, -1, -2]}
+        sage: b = P.basis().list()
+        sage: b #random order
+        [P[{{1, 2, -1, -2}}], P[{{2, -1, -2}, {1}}], P[{{2}, {1, -1, -2}}], P[{{-1}, {1, 2, -2}}], P[{{-2}, {1, 2, -1}}], P[{{2, -1}, {1, -2}}], P[{{2, -2}, {1, -1}}], P[{{1, 2}, {-2, -1}}], P[{{2}, {-1, -2}, {1}}], P[{{-1}, {2, -2}, {1}}], P[{{-2}, {2, -1}, {1}}], P[{{-1}, {2}, {1, -2}}], P[{{-2}, {2}, {1, -1}}], P[{{-1}, {-2}, {1, 2}}], P[{{-1}, {-2}, {2}, {1}}]]
+        sage: E = P([[1,2],[-2,-1]]); E
+        P[{{1, 2}, {-2, -1}}]
+        sage: E in b
+        True
+        sage: E^2
+        x*P[{{1, 2}, {-2, -1}}]
+        sage: E^5
+        x^4*P[{{1, 2}, {-2, -1}}]
+        sage: (P([[2,-2],[-1,1]]) - 2*P([[1,2],[-1,-2]]))^2
+        (4*x-4)*P[{{1, 2}, {-2, -1}}] + P[{{2, -2}, {1, -1}}]
+
+    One can work with partition algebras using a symbol for the parameter,
+    leaving the base ring unspecified. This implies that the underlying
+    base ring is Sage's Symbolic Ring.
+
+    ::
+
+        sage: q = var('q')
+        sage: PA = PartitionAlgebra(2,q); PA
+        Partition Algebra of rank 2 with parameter q over Symbolic Ring, with prefix P
+        sage: P = PA.basis().list()
+        sage: P[7], P[7]*P[7]
+        (P[{{1, 2}, {-2, -1}}], q*P[{{1, 2}, {-2, -1}}])
+        sage: (P[6] - 2*P[7])^2
+        (4*q-4)*P[{{1, 2}, {-2, -1}}] + P[{{2, -2}, {1, -1}}]
+
+    The identity element of the partition algebra is the diagram whose set
+    partition is `\{\{1,-1\}, \{2,-2\}, ..., \{k,-k\}\}`.
+
+    ::
+
+        sage: PA.one() #random order from SetPartitions
+        P[{{2, -2}, {1, -1}}]  
+        sage: PA.one()*P[7]
+        P[{{1, 2}, {-2, -1}}]
+        sage: P[7]*PA.one()
+        P[{{1, 2}, {-2, -1}}]
+
+        We now give some further examples of the use of the other arguments.
+        One may wish to "specialize" the parameter to a chosen element of
+        the base ring.
+
+    ::
+
+        sage: PA = PartitionAlgebra(2, q, RR['q'], prefix='B')
+        sage: PA
+        Partition Algebra of rank 2 with parameter q over Univariate Polynomial Ring in q over Real Field with 53 bits of precision, with prefix B
+        sage: PA.basis().list()[7]
+        1.00000000000000*B[{{1, 2}, {-2, -1}}]
+        sage: PA = PartitionAlgebra(2, 5, base_ring=ZZ, prefix='B')
+        sage: PA
+        Partition Algebra of rank 2 with parameter 5 over Integer Ring, with prefix B
+        sage: P = PA.basis().list()
+        sage: (P[6] - 2*P[7])^2
+        16*B[{{1, 2}, {-2, -1}}] + B[{{2, -2}, {1, -1}}]
+    """
+
+    @staticmethod
+    def __classcall_private__(cls, k, q, base_ring=None, prefix="P"):
+        r"""
+        This method gets the base_ring from the parent of the parameter q
+        if no base_ring is given.
+        """
+        if base_ring is None:
+            base_ring = q.parent()
+        return super(PartitionAlgebra, cls).__classcall__(
+            cls, k, q=q, base_ring = base_ring, prefix=prefix)
+
+
+    # The following is the basic constructor method for the class.
+    # The purpose of the "prefix" is to label the basis elements
+    def __init__(self, k, q, base_ring, prefix):
+        r"""
+        See :class:`PartitionAlgebra` for full documentation.
+
+        TESTS::
+
+            sage: q = var('q')
+            sage: PA = PartitionAlgebra(2, q, RR['q'])
+            sage: TestSuite(PA).run()
+        """
+
+        self._k = k
+        self._prefix = prefix
+        self._q = base_ring(q)
+        category = FiniteDimensionalAlgebrasWithBasis(base_ring)
+        CombinatorialFreeModule.__init__(self, base_ring, partition_diagrams(k),
+                    category = category, prefix=prefix)
+
+    # The following constructs a basis element from a given set partition.
+    # It should never be called directly.
+    def _element_constructor_(self, set_partition):
+        r"""
+        If PA is a particular partition algebra (previously defined) then 
+        PA( sp ) returns the element of the algebra PA corresponding to a
+        given set partition sp.
+
+        EXAMPLES::
+
+            sage: q = var('q')
+            sage: PA = PartitionAlgebra(2,q,QQ['q'])
+            sage: PA
+            Partition Algebra of rank 2 with parameter q over Univariate Polynomial Ring in q over Rational Field, with prefix P
+            sage: sp = to_set_partition( [[1,2], [-1,-2]] )  # create a set partition
+            sage: sp
+            {{1, 2}, {-1, -2}}
+            sage: PA(sp)  # construct a basis element from it
+            P[{{1, 2}, {-1, -2}}]
+            sage: PA(sp) in PA
+            True
+            sage: PA([[1,2],[-1,-2]])
+            P[{{1, 2}, {-1, -2}}]
+            sage: PA([{1,2},{-1,-2}])
+            P[{{1, 2}, {-1, -2}}]
+        """
+        if (set_partition in self.basis().keys()) and isinstance(set_partition, collections.Hashable):
+            return self.monomial(set_partition)
+        elif isinstance(set_partition, list):
+            sp = to_set_partition(set_partition) # attempt coercion
+            assert sp in self.basis().keys() # did it work?
+            return self.monomial(sp)
+        else:
+            raise AssertionError, "%s invalid form" % set_partition
+
+    @cached_method
+    def one_basis(self):
+        r"""
+        The following constructs the identity element of the partition algebra.
+        It is not called directly; instead one should use PA.one() if PA is a
+        previously defined partition algebra instance.
+
+        EXAMPLES::
+
+            sage: PA = PartitionAlgebra(2, x);
+            sage: PA.one_basis()
+            {{2, -2}, {1, -1}}
+
+        """
+        return identity_set_partition(self._k)
+
+    def _repr_(self):
+        msg = "Partition Algebra of rank %s with parameter %s over %s, with prefix %s"
+        return msg % (self._k, self._q, self.base_ring(), self._prefix)
+
+    def order(self):
+        r"""
+        The method PA.order() returns the 'order' of the given partition algebra PA.
+        This is defined as half of the number of nodes in the diagrams.
+
+        EXAMPLES::
+
+            sage: q = var('q')
+            sage: PA = PartitionAlgebra(2,q)
+            sage: PA.order()
+            2
+        """
+        return self._k
+
+    def set_partitions(self):
+        r"""
+        The method PA.set_partitions() returns the collection of underlying
+        set partitions indexing the basis elements of the given partition
+        algebra PA.
+
+        EXAMPLES::
+
+            sage: PA = PartitionAlgebra(2, x)
+            sage: PA.set_partitions()
+            Set partitions of [1, 2, -1, -2]
+            sage: PA.set_partitions().list() #random order
+            [{{1, 2, -1, -2}}, {{2, -1, -2}, {1}}, {{2}, {1, -1, -2}}, {{-1}, {1, 2, -2}}, {{-2}, {1, 2, -1}}, {{2, -1}, {1, -2}}, {{2, -2}, {1, -1}}, {{1, 2}, {-2, -1}}, {{2}, {-1, -2}, {1}}, {{-1}, {2, -2}, {1}}, {{-2}, {2, -1}, {1}}, {{-1}, {2}, {1, -2}}, {{-2}, {2}, {1, -1}}, {{-1}, {-2}, {1, 2}}, {{-1}, {-2}, {2}, {1}}]
+        """
+        return self.basis().keys()
+    
+    def product_on_basis(self, d1, d2):
+        r"""
+        This method defines the product of two basis diagrams. Usually
+        it is not called directly, but indirectly through usualy arithmetic
+        operators.
+
+        TESTS::
+            sage: P = PartitionAlgebra(2, x);
+            sage: P.product_on_basis(P([[1,2],[-1,-2]]), P([[1,2],[-1,-2]]))
+            x*P[{{1, {{1, 2}, {-1, -2}}}}]
+        """
+        (composite_diagram, loops_removed) = set_partition_composition(d1, d2)
+        return self.term(composite_diagram, self._q**loops_removed)
+
+
+    # The following subclass provides a few additional methods for
+    # partition algebra elements.  NOTE: Most element methods we need are
+    # ALREADY implemented! Use the __dir__() builtin python function
+    # to figure out what methods are defined.
+
+    class Element(CombinatorialFreeModuleElement):
+        r"""
+        This subclass provides a few additional methods for
+        partition algebra elements. Most element methods are
+        already implemented elsewhere.
+        """
+        
+        def diagram(self):
+            r"""
+            This method returns the underlying diagram of a given
+            basis element (or an error if not a basis element.)
+            """
+            if len(self) != 1:
+                raise NotImplementedError("this works only for basis elements")
+            PA = self.parent()
+            ans = self.support_of_term()
+            if is_partition_diagram(ans,PA.order()):
+                return ans
+            raise NotImplementedError("element should be keyed by a diagram")
+
+        def diagrams(self):
+            r"""
+            this method returns the diagrams in the support of any
+            given element. It is just a rename of "support" which already exists.
+            """
+            return self.support()
+#        def show(self):
+#            diagram = self.diagram()
+#            sp = to_set_partition(diagram)
+#            sageGraph = to_graph(sp)
+#            G = sageGraph.networkx_graph()
+#            flatlist = itertools.chain(*diagram)
+#            k = max(flatlist)
+#            pos=dict(zip(range(1,k+1),zip(range(1,k+1),[1]*k)))
+#            pos.update(dict(zip(reversed(range(-k,0)),zip(range(1,k+1),[0.5]*k))))
+#            plt.clf()
+#            networkx.draw(G,pos)
+#            pylab.xlim(-1,9)
+#            pylab.ylim(-1,2)
+#            plt.savefig("tmp.png", bbox_inches='tight', pad_inches=-1)
+#            plt.show()
+
+class BrauerAlgebra(CombinatorialFreeModule):
+    r"""
+    INPUT:
+
+     -``k``-- rank of the algebra (equals half the number of nodes in the diagrams)
+     -``q``-- a parameter.
+
+    OPTIONAL ARGUMENTS:
+
+     -``base_ring``-- a ring containing q (default q.parent())
+     -``prefix``-- a label for the basis elements (default "B")
+
+    The Brauer algebra of rank k is an algebra with basis indexed by the
+    collection of set partitions of `\{1, \dots, k, -1, \dots, -k\}`
+    with block size 2. This algebra is thus a subalgebra of the
+    partition algebra. For more information, see
+    :class:`PartitionAlgebra`
+
+    EXAMPLES:
+
+    The following shorthand simultaneously define the univariate polynomial
+    ring over the rationals as well as the variable `x`::
+    
+        sage: R.<x> = PolynomialRing(QQ)
+        sage: R
+        Univariate Polynomial Ring in x over Rational Field
+        sage: x
+        x
+        sage: x.parent() is R
+        True
+
+    We now define the Brauer algebra of rank `2` with parameter `x` over the Integer ring::
+
+        sage: B = BrauerAlgebra(2,x,ZZ['x'])
+        sage: B
+        Brauer Algebra of rank 2 with parameter x over Univariate Polynomial Ring in x over Integer Ring, with prefix B
+        sage: B.basis()
+        Lazy family (Term map from Set partitions of [1, 2, -1, -2] with sizes in [[2, 2]] to Brauer Algebra of rank 2 with parameter x over Univariate Polynomial Ring in x over Integer Ring, with prefix B(i))_{i in Set partitions of [1, 2, -1, -2] with sizes in [[2, 2]]}
+        sage: b = B.basis().list()
+        sage: b
+        [B[{{2, -1}, {1, -2}}], B[{{2, -2}, {1, -1}}], B[{{1, 2}, {-2, -1}}]]
+        sage: b[2]
+        B[{{1, 2}, {-2, -1}}]
+        sage: b[2]^2
+        x*B[{{1, 2}, {-2, -1}}]
+        sage: b[2]^5
+        x^4*B[{{1, 2}, {-2, -1}}]
+    """
+    @staticmethod
+    def __classcall_private__(cls, k, q, base_ring=None, prefix="B"):
+        r"""
+        This method gets the base_ring from the parent of the parameter q
+        if no base_ring is given.
+        """
+        if base_ring is None:
+            base_ring = q.parent()
+        return super(BrauerAlgebra, cls).__classcall__(
+                                                       cls, k, q=q, base_ring = base_ring, prefix=prefix)
+    def __init__(self, k, q, base_ring, prefix = "B"):
+        r"""
+        See :class:`BrauerAlgebra` for full documentation.
+
+        TESTS::
+
+            sage: q = var('q')
+            sage: BA = BrauerAlgebra(2, q, RR['q'])
+            sage: TestSuite(BA).run()
+        """
+        self._k = k
+        self._prefix = prefix
+        self._q = base_ring(q)
+        category = FiniteDimensionalAlgebrasWithBasis(base_ring)
+        CombinatorialFreeModule.__init__(self, base_ring, brauer_diagrams(k), category = category, prefix=prefix)
+    
+    @cached_method
+    def one_basis(self):
+        r"""
+        The following constructs the identity element of the Brauer algebra.
+        It is not called directly; instead one should use BA.one() if BA is a
+        previously defined Brauer algebra instance.
+
+        EXAMPLES::
+
+            sage: BA = BrauerAlgebra(2, x);
+            sage: BA.one_basis()
+            {{2, -2}, {1, -1}}
+            sage: BA.one()
+            B[{{2, -2}, {1, -1}}]
+
+        """
+        return identity_set_partition(self._k)
+    
+    def _repr_(self):
+        msg = "Brauer Algebra of rank %s with parameter %s over %s, with prefix %s"
+        return msg % (self._k, self._q, self.base_ring(), self._prefix)
+
+    def _element_constructor_(self, set_partition):
+        r"""
+        If BA is a particular Brauer algebra (previously defined) then 
+        BA( sp ) returns the element of the algebra BA corresponding to a
+        given set partition sp.
+
+        EXAMPLES::
+
+            sage: q = var('q')
+            sage: BA = BrauerAlgebra(2,q,QQ['q'])
+            sage: BA
+            Brauer Algebra of rank 2 with parameter q over Univariate Polynomial Ring in q over Rational Field, with prefix B
+            sage: sp = to_set_partition( [[1,2], [-1,-2]] )  # create a set partition
+            sage: sp
+            {{1, 2}, {-1, -2}}
+            sage: BA(sp)  # construct a basis element from it
+            B[{{1, 2}, {-1, -2}}]
+            sage: BA(sp) in BA
+            True
+            sage: BA([[1,2],[-1,-2]])
+            B[{{1, 2}, {-1, -2}}]
+            sage: BA([{1,2},{-1,-2}])
+            B[{{1, 2}, {-1, -2}}]
+        """
+        if (set_partition in self.basis().keys()) and isinstance(set_partition, collections.Hashable):
+            return self.monomial(set_partition)
+        elif isinstance(set_partition, list):
+            sp = to_set_partition(set_partition) # attempt coercion
+            assert sp in self.basis().keys() # did it work?
+            return self.monomial(sp)
+        else:
+            raise AssertionError, "%s invalid form" % set_partition
+    
+    #These methods allow for BrauerAlgebra to be correctly identified as a sub-algebra of PartitionAlgebra
+    def ambient(self):
+        r"""
+        ambient returns the partition algebra the Brauer algebra is a sub-algebra of.
+        Generally, this method is not called directly.
+
+        EXAMPLES::
+            sage: BA = BrauerAlgebra(2, x);
+            sage: P = BA.ambient()
+            sage: P
+            Partition Algebra of rank 2 with parameter x over Symbolic Ring, with prefix B
+        """
+        return PartitionAlgebra(self._k, self._q, self.base_ring(), prefix=self._prefix)
+    def lift(self, x):
+        r"""
+        lift maps a Brauer algebra element to the corresponding element
+        in the ambient space. This method is not intended
+        to be called directly.
+
+        EXAMPLES::
+            sage: BA = BrauerAlgebra(2, x);
+            sage: E = BA([[1,2],[-1,-2]]); E
+            B[{{1, 2}, {-1, -2}}]
+            sage: BA.lift(E) in BA.ambient()
+            True
+            sage: BA.lift(E) in BA
+            False
+        """
+        assert x in self
+        monomial_indices = x.support()
+        monomial_coefficients = x.coefficients()
+        result = 0
+        for i in xrange(len(monomial_coefficients)):
+            result += monomial_coefficients[i]*self.ambient().monomial(monomial_indices[i])
+        return result
+    def retract(self, x):
+        r"""
+        retract maps an appropriate partition algebra element to the
+        corresponding element in the Brauer algebra. This method
+        is not intended to be called directly.
+
+        EXAMPLES::
+            sage: BA = BrauerAlgebra(2, x)
+            sage: PA = BA.ambient()
+            sage: E = PA([[1,2],[-1,-2]])
+            sage: BA.retract(E) in PA
+            False
+            sage: BA.retract(E) in BA
+            True
+        """
+        assert x in self.ambient() and set(x.support()).issubset(set(self.basis().keys()))
+        monomial_indices = x.support()
+        monomial_coefficients = x.coefficients()
+        result = self.zero()
+        for i in xrange(len(monomial_coefficients)):
+            result += monomial_coefficients[i]*self.monomial(monomial_indices[i])
+        return result
+    
+    #These methods depend on the above three methods
+    
+    def product_on_basis(self, left, right):
+        r"""
+        This method is not made to be called directly but by using
+        arithematic operators on elements.
+        EXAMPLES::
+            sage: BA = BrauerAlgebra(2, x)
+            sage: E = BA([[1,2],[-1,-2]])
+            sage: E*E
+            x*B[{{1, 2}, {-2, -1}}]
+            sage: E^4
+            x^3*B[{{1, 2}, {-2, -1}}]
+        """
+        return self.ambient().product_on_basis(left,right)
+    def order(self):
+        r"""
+        Returns the order of the Brauer Algebra
+        EXAMPLES::
+            sage: BA = BrauerAlgebra(2, x)
+            sage: BA.order()
+            2
+        """
+        return self.ambient().order()
+    
+class TemperleyLiebAlgebra(CombinatorialFreeModule):
+    r"""
+    INPUT:
+
+     -``k``-- rank of the algebra (equals half the number of nodes in the diagrams)
+     -``q``-- a parameter.
+
+    OPTIONAL ARGUMENTS:
+
+     -``base_ring``-- a ring containing q (default q.parent())
+     -``prefix``-- a label for the basis elements (default "T")
+
+    The Temperley-Lieb algebra of rank k is an algebra with basis indexed by the
+    collection of set partitions of `\{1, \dots, k, -1, \dots, -k\}`
+    with block size 2 and each set partition is planar.
+    This algebra is thus a subalgebra of the partition algebra. For more
+    information, see :class:`PartitionAlgebra`
+
+    EXAMPLES:
+
+    The following shorthand simultaneously define the univariate polynomial
+    ring over the rationals as well as the variable `x`::
+    
+        sage: R.<x> = PolynomialRing(QQ); R
+        Univariate Polynomial Ring in x over Rational Field
+        sage: x
+        x
+        sage: x.parent() is R
+        True
+
+    We now define the Temperley-Lieb algebra of rank `2` with parameter
+    `x` over the Integer ring::
+
+        sage: T = TemperleyLiebAlgebra(2, x); T
+        Temperley-Lieb Algebra of rank 2 with parameter x over Univariate Polynomial Ring in x over Rational Field, with prefix T
+        sage: T.basis()
+        Finite family {{{2, -2}, {1, -1}}: T[{{2, -2}, {1, -1}}], {{1, 2}, {-2, -1}}: T[{{1, 2}, {-2, -1}}]}
+        sage: b = T.basis().list()
+        sage: b
+        [T[{{2, -2}, {1, -1}}], T[{{1, 2}, {-2, -1}}]]
+        sage: b[1]
+        T[{{1, 2}, {-2, -1}}]
+        sage: b[1]^2
+        x*T[{{1, 2}, {-2, -1}}]
+        sage: b[1]^5
+        x^4*T[{{1, 2}, {-2, -1}}]
+
+    """
+    @staticmethod
+    def __classcall_private__(cls, k, q, base_ring=None, prefix="T"):
+        r"""
+        This method gets the base_ring from the parent of the parameter q
+        if no base_ring is given.
+        """
+        if base_ring is None:
+            base_ring = q.parent()
+        return super(TemperleyLiebAlgebra, cls).__classcall__(cls, k, q=q, base_ring = base_ring, prefix=prefix)
+
+    def __init__(self, k, q, base_ring, prefix = "T"):
+        r"""
+        See :class:`TemperleyLiebAlgebra` for full documentation.
+
+        TESTS::
+
+            sage: q = var('q')
+            sage: TL = TemperleyLiebAlgebra(2, q, RR['q'])
+            sage: TestSuite(TL).run()
+        """
+        self._k = k
+        self._prefix = prefix
+        self._q = base_ring(q)
+        category = FiniteDimensionalAlgebrasWithBasis(base_ring)
+        CombinatorialFreeModule.__init__(self, base_ring, temperley_lieb_diagrams(k), category = category, prefix=prefix)
+
+    @cached_method
+    def one_basis(self):
+        r"""
+        The following constructs the identity element of the
+        Temperley-Lieb algebra. It is not called directly;
+        instead one should use TL.one() if TL is a
+        previously defined Temperley-Lieb algebra instance.
+
+        EXAMPLES::
+
+            sage: TL = TemperleyLiebAlgebra(2, x);
+            sage: TL.one_basis()
+            {{2, -2}, {1, -1}}
+            sage: TL.one()
+            T[{{2, -2}, {1, -1}}]
+
+        """
+        return identity_set_partition(self._k)
+
+    def _repr_(self):
+        msg = "Temperley-Lieb Algebra of rank %s with parameter %s over %s, with prefix %s"
+        return msg % (self._k, self._q, self.base_ring(), self._prefix)
+
+    def _element_constructor_(self, set_partition):
+        r"""
+        If TL is a particular Temperley-Lieb algebra (previously defined)
+        then TL( sp ) returns the element of the algebra TL corresponding
+        to a given set partition sp.
+
+        EXAMPLES::
+
+            sage: q = var('q')
+            sage: TL = TemperleyLiebAlgebra(2,q,QQ['q'])
+            sage: TL
+            Temperley-Lieb Algebra of rank 2 with parameter q over Univariate Polynomial Ring in q over Rational Field, with prefix T
+            sage: sp = to_set_partition( [[1,2], [-1,-2]] )  # create a set partition
+            sage: sp
+            {{1, 2}, {-1, -2}}
+            sage: TL(sp)  # construct a basis element from it
+            T[{{1, 2}, {-1, -2}}]
+            sage: TL(sp) in TL
+            True
+            sage: TL([[1,2],[-1,-2]])
+            T[{{1, 2}, {-1, -2}}]
+            sage: TL([{1,2},{-1,-2}])
+            T[{{1, 2}, {-1, -2}}]
+        """
+        if (set_partition in self.basis().keys()) and isinstance(set_partition, collections.Hashable):
+            return self.monomial(set_partition)
+        elif isinstance(set_partition, list):
+            sp = to_set_partition(set_partition) # attempt coercion
+            assert sp in self.basis().keys() # did it work?
+            return self.monomial(sp)
+        else:
+            raise AssertionError, "%s invalid form" % set_partition
+
+    def ambient(self):
+        r"""
+        ambient returns the partition algebra the Temperley-Lieb algebra
+        is a sub-algebra of. Generally, this method is not called
+        directly.
+
+        EXAMPLES::
+            sage: TL = TemperleyLiebAlgebra(2, x);
+            sage: P = TL.ambient()
+            sage: P
+            Partition Algebra of rank 2 with parameter x over Symbolic Ring, with prefix T
+        """
+        return PartitionAlgebra(self._k, self._q, self.base_ring(), prefix=self._prefix)
+    def lift(self, x):
+        r"""
+        lift maps a Temperley-Lieb algebra element to the corresponding
+        element in the ambient space. This method is not intended
+        to be called directly.
+
+        EXAMPLES::
+            sage: TL = TemperleyLiebAlgebra(2, x);
+            sage: E = TL([[1,2],[-1,-2]]); E
+            T[{{1, 2}, {-1, -2}}]
+            sage: TL.lift(E) in TL.ambient()
+            True
+            sage: TL.lift(E) in TL
+            False
+        """
+        assert x in self
+        monomial_indices = x.support()
+        monomial_coefficients = x.coefficients()
+        result = 0
+        for i in xrange(len(monomial_coefficients)):
+            result += monomial_coefficients[i]*self.ambient().monomial(monomial_indices[i])
+        return result
+
+    def retract(self, x):
+        r"""
+        retract maps an appropriate partition algebra element to the
+        corresponding element in the Temperley-Lieb algebra. This method
+        is not intended to be called directly.
+
+        EXAMPLES::
+            sage: TL = TemperleyLiebAlgebra(2, x)
+            sage: PA = TL.ambient()
+            sage: E = PA([[1,2],[-1,-2]])
+            sage: TL.retract(E) in PA
+            False
+            sage: TL.retract(E) in TL
+            True
+        """
+        assert x in self.ambient() and set(x.support()).issubset(set(self.basis().keys()))
+        monomial_indices = x.support()
+        monomial_coefficients = x.coefficients()
+        result = self.zero()
+        for i in xrange(len(monomial_coefficients)):
+            result += monomial_coefficients[i]*self.monomial(monomial_indices[i])
+        return result
+
+    def product_on_basis(self, left, right):
+        r"""
+        This method is not made to be called directly but by using
+        arithematic operators on elements.
+        EXAMPLES::
+            sage: TL = TemperleyLiebAlgebra(2, x)
+            sage: E = TL([[1,2],[-1,-2]])
+            sage: E*E
+            x*T[{{1, 2}, {-2, -1}}]
+            sage: E^4
+            x^3*T[{{1, 2}, {-2, -1}}]
+        """
+        return self.ambient().product_on_basis(left,right)
+
+    def order(self):
+        r"""
+        Returns the order of the Temperley-Lieb Algebra
+        EXAMPLES::
+            sage: TL = TemperleyLiebAlgebra(2, x)
+            sage: TL.order()
+            2
+        """
+        return self.ambient().order()
+
+class PlanarAlgebra(CombinatorialFreeModule):
+    r"""
+    INPUT:
+
+     -``k``-- rank of the algebra (equals half the number of nodes in the diagrams)
+     -``q``-- a parameter.
+
+    OPTIONAL ARGUMENTS:
+
+     -``base_ring``-- a ring containing q (default q.parent())
+     -``prefix``-- a label for the basis elements (default "Pl")
+
+    The Planar algebra of rank k is an algebra with basis indexed by the
+    collection of set partitions of `\{1, \dots, k, -1, \dots, -k\}`
+    where each set partition is planar.
+    This algebra is thus a subalgebra of the partition algebra. For more
+    information, see :class:`PartitionAlgebra`
+
+    EXAMPLES:
+
+    The following shorthand simultaneously define the univariate polynomial
+    ring over the rationals as well as the variable `x`::
+    
+        sage: R.<x> = PolynomialRing(QQ); R
+        Univariate Polynomial Ring in x over Rational Field
+        sage: x
+        x
+        sage: x.parent() is R
+        True
+
+    We now define the Temperley-Lieb algebra of rank `2` with parameter
+    `x` over the Integer ring::
+
+        sage: Pl = PlanarAlgebra(2, x); Pl
+        Planar Algebra of rank 2 with parameter x over Univariate Polynomial Ring in x over Rational Field, with prefix Pl
+        sage: Pl.basis() #random order
+        Finite family {{{1, 2, -1, -2}}: Pl[{{1, 2, -1, -2}}], {{-1}, {2, -2}, {1}}: Pl[{{-1}, {2, -2}, {1}}], {{2, -1, -2}, {1}}: Pl[{{2, -1, -2}, {1}}], {{2}, {1, -1, -2}}: Pl[{{2}, {1, -1, -2}}], {{-2}, {1, 2, -1}}: Pl[{{-2}, {1, 2, -1}}], {{-1}, {2}, {1, -2}}: Pl[{{-1}, {2}, {1, -2}}], {{-2}, {2}, {1, -1}}: Pl[{{-2}, {2}, {1, -1}}], {{1, 2}, {-1, -2}}: Pl[{{1, 2}, {-1, -2}}], {{-1}, {-2}, {2}, {1}}: Pl[{{-1}, {-2}, {2}, {1}}], {{2}, {-1, -2}, {1}}: Pl[{{2}, {-1, -2}, {1}}], {{-1}, {1, 2, -2}}: Pl[{{-1}, {1, 2, -2}}], {{2, -2}, {1, -1}}: Pl[{{2, -2}, {1, -1}}], {{-1}, {-2}, {1, 2}}: Pl[{{-1}, {-2}, {1, 2}}], {{-2}, {2, -1}, {1}}: Pl[{{-2}, {2, -1}, {1}}]}
+        sage: b = Pl.basis().list()
+        sage: b #random order
+        [Pl[{{1, 2, -1, -2}}], Pl[{{2, -1, -2}, {1}}], Pl[{{2}, {1, -1, -2}}], Pl[{{-1}, {1, 2, -2}}], Pl[{{-2}, {1, 2, -1}}], Pl[{{1, 2}, {-1, -2}}], Pl[{{2, -2}, {1, -1}}], Pl[{{2}, {-1, -2}, {1}}], Pl[{{-1}, {2, -2}, {1}}], Pl[{{-2}, {2, -1}, {1}}], Pl[{{-1}, {2}, {1, -2}}], Pl[{{-2}, {2}, {1, -1}}], Pl[{{-1}, {-2}, {1, 2}}], Pl[{{-1}, {-2}, {2}, {1}}]]
+        sage: b[6]
+        Pl[{{1, 2}, {-2, -1}}]
+        sage: b[6]^2
+        x*Pl[{{1, 2}, {-2, -1}}]
+        sage: b[6]^5
+        x^4*Pl[{{1, 2}, {-2, -1}}]
+
+    """
+    @staticmethod
+    def __classcall_private__(cls, k, q, base_ring=None, prefix="Pl"):
+        r"""
+        This method gets the base_ring from the parent of the parameter q
+        if no base_ring is given.
+        """
+        if base_ring is None:
+            base_ring = q.parent()
+        return super(PlanarAlgebra, cls).__classcall__(cls, k, q=q, base_ring = base_ring, prefix=prefix)
+
+    def __init__(self, k, q, base_ring, prefix = "Pl"):
+        r"""
+        See :class:`PlanarAlgebra` for full documentation.
+
+        TESTS::
+
+            sage: q = var('q')
+            sage: PlA = PlanarAlgebra(2, q, RR['q'])
+            sage: TestSuite(PlA).run()
+        """
+        self._k = k
+        self._prefix = prefix
+        self._q = base_ring(q)
+        category = FiniteDimensionalAlgebrasWithBasis(base_ring)
+        CombinatorialFreeModule.__init__(self, base_ring, planar_diagrams(k), category = category, prefix=prefix)
+
+    @cached_method
+    def one_basis(self):
+        r"""
+        The following constructs the identity element of the
+        Temperley-Lieb algebra. It is not called directly;
+        instead one should use TL.one() if TL is a
+        previously defined Temperley-Lieb algebra instance.
+
+        EXAMPLES::
+
+            sage: PlA = PlanarAlgebra(2, x);
+            sage: PlA.one_basis()
+            {{2, -2}, {1, -1}}
+            sage: PlA.one()
+            Pl[{{2, -2}, {1, -1}}]
+
+        """
+        return identity_set_partition(self._k)
+
+    def _repr_(self):
+        msg = "Planar Algebra of rank %s with parameter %s over %s, with prefix %s"
+        return msg % (self._k, self._q, self.base_ring(), self._prefix)
+
+    def _element_constructor_(self, set_partition):
+        r"""
+        If PlA is a particular Planar algebra (previously defined)
+        then PlA( sp ) returns the element of the algebra PlA corresponding
+        to a given set partition sp.
+
+        EXAMPLES::
+
+            sage: q = var('q')
+            sage: PlA = PlanarAlgebra(2,q,QQ['q'])
+            sage: PlA
+            Planar Algebra of rank 2 with parameter q over Univariate Polynomial Ring in q over Rational Field, with prefix Pl
+            sage: sp = to_set_partition( [[1,2], [-1,-2]] )  # create a set partition
+            sage: sp
+            {{1, 2}, {-1, -2}}
+            sage: PlA(sp)  # construct a basis element from it
+            Pl[{{1, 2}, {-1, -2}}]
+            sage: PlA(sp) in PlA
+            True
+            sage: PlA([[1,2],[-1,-2]])
+            Pl[{{1, 2}, {-1, -2}}]
+            sage: PlA([{1,2},{-1,-2}])
+            Pl[{{1, 2}, {-1, -2}}]
+        """
+        if (set_partition in self.basis().keys()) and isinstance(set_partition, collections.Hashable):
+            return self.monomial(set_partition)
+        elif isinstance(set_partition, list):
+            sp = to_set_partition(set_partition) # attempt coercion
+            assert sp in self.basis().keys() # did it work?
+            return self.monomial(sp)
+        else:
+            raise AssertionError, "%s invalid form" % set_partition
+
+    def ambient(self):
+        r"""
+        ambient returns the partition algebra the Planar algebra
+        is a sub-algebra of. Generally, this method is not called
+        directly.
+
+        EXAMPLES::
+            sage: PlA = PlanarAlgebra(2, x);
+            sage: P = PlA.ambient()
+            sage: P
+            Partition Algebra of rank 2 with parameter x over Symbolic Ring, with prefix Pl
+        """
+        return PartitionAlgebra(self._k, self._q, self.base_ring(), prefix=self._prefix)
+    def lift(self, x):
+        r"""
+        lift maps a Planar algebra element to the corresponding
+        element in the ambient space. This method is not intended
+        to be called directly.
+
+        EXAMPLES::
+            sage: PlA = PlanarAlgebra(2, x);
+            sage: E = PlA([[1,2],[-1,-2]]); E
+            Pl[{{1, 2}, {-1, -2}}]
+            sage: PlA.lift(E) in PlA.ambient()
+            True
+            sage: PlA.lift(E) in PlA
+            False
+        """
+        assert x in self
+        monomial_indices = x.support()
+        monomial_coefficients = x.coefficients()
+        result = 0
+        for i in xrange(len(monomial_coefficients)):
+            result += monomial_coefficients[i]*self.ambient().monomial(monomial_indices[i])
+        return result
+
+    def retract(self, x):
+        r"""
+        retract maps an appropriate partition algebra element to the
+        corresponding element in the planar algebra. This method
+        is not intended to be called directly.
+
+        EXAMPLES::
+            sage: PlA = PlanarAlgebra(2, x)
+            sage: PA = PlA.ambient()
+            sage: E = PA([[1,2],[-1,-2]])
+            sage: PlA.retract(E) in PA
+            False
+            sage: PlA.retract(E) in PlA
+            True
+        """
+        assert x in self.ambient() and set(x.support()).issubset(set(self.basis().keys()))
+        monomial_indices = x.support()
+        monomial_coefficients = x.coefficients()
+        result = self.zero()
+        for i in xrange(len(monomial_coefficients)):
+            result += monomial_coefficients[i]*self.monomial(monomial_indices[i])
+        return result
+
+    def product_on_basis(self, left, right):
+        r"""
+        This method is not made to be called directly but by using
+        arithematic operators on elements.
+        EXAMPLES::
+            sage: PlA = PlanarAlgebra(2, x)
+            sage: E = PlA([[1,2],[-1,-2]])
+            sage: E*E
+            x*Pl[{{1, 2}, {-2, -1}}]
+            sage: E^4
+            x^3*Pl[{{1, 2}, {-2, -1}}]
+        """
+        return self.ambient().product_on_basis(left,right)
+
+    def order(self):
+        r"""
+        Returns the order of the Planar Algebra
+        EXAMPLES::
+            sage: PlA = PlanarAlgebra(2, x)
+            sage: PlA.order()
+            2
+        """
+        return self.ambient().order()
+
+class IdealAlgebra(CombinatorialFreeModule):
+    r"""
+    INPUT:
+
+     -``k``-- rank of the algebra (equals half the number of nodes in the diagrams)
+     -``q``-- a parameter.
+
+    OPTIONAL ARGUMENTS:
+
+     -``base_ring``-- a ring containing q (default q.parent())
+     -``prefix``-- a label for the basis elements (default "I")
+
+    The ideal algebra of rank k is an algebra with basis indexed by the
+    collection of set partitions of `\{1, \dots, k, -1, \dots, -k\}`
+    where each set partition has propogating number less than `k`.
+    This algebra is thus a subalgebra of the partition algebra. For more
+    information, see :class:`PartitionAlgebra`
+
+    EXAMPLES:
+
+    The following shorthand simultaneously define the univariate polynomial
+    ring over the rationals as well as the variable `x`::
+    
+        sage: R.<x> = PolynomialRing(QQ); R
+        Univariate Polynomial Ring in x over Rational Field
+        sage: x
+        x
+        sage: x.parent() is R
+        True
+
+    We now define the Temperley-Lieb algebra of rank `2` with parameter
+    `x` over the Integer ring::
+
+        sage: I = IdealAlgebra(2, x); I
+        Ideal Algebra of rank 2 with parameter x over Univariate Polynomial Ring in x over Rational Field, with prefix I
+        sage: I.basis() #random order
+        Finite family {{{1, 2, -1, -2}}: I[{{1, 2, -1, -2}}], {{-1}, {2, -2}, {1}}: I[{{-1}, {2, -2}, {1}}], {{2, -1, -2}, {1}}: I[{{2, -1, -2}, {1}}], {{2}, {1, -1, -2}}: I[{{2}, {1, -1, -2}}], {{-2}, {1, 2, -1}}: I[{{-2}, {1, 2, -1}}], {{-1}, {2}, {1, -2}}: I[{{-1}, {2}, {1, -2}}], {{-2}, {2}, {1, -1}}: I[{{-2}, {2}, {1, -1}}], {{1, 2}, {-1, -2}}: I[{{1, 2}, {-1, -2}}], {{-1}, {-2}, {2}, {1}}: I[{{-1}, {-2}, {2}, {1}}], {{2}, {-1, -2}, {1}}: I[{{2}, {-1, -2}, {1}}], {{-1}, {1, 2, -2}}: I[{{-1}, {1, 2, -2}}], {{-1}, {-2}, {1, 2}}: I[{{-1}, {-2}, {1, 2}}], {{-2}, {2, -1}, {1}}: I[{{-2}, {2, -1}, {1}}]}
+        sage: b = I.basis().list()
+        sage: b #random order
+        [I[{{1, 2, -1, -2}}], I[{{2, -1, -2}, {1}}], I[{{2}, {1, -1, -2}}], I[{{-1}, {1, 2, -2}}], I[{{-2}, {1, 2, -1}}], I[{{1, 2}, {-1, -2}}], I[{{2}, {-1, -2}, {1}}], I[{{-1}, {2, -2}, {1}}], I[{{-2}, {2, -1}, {1}}], I[{{-1}, {2}, {1, -2}}], I[{{-2}, {2}, {1, -1}}], I[{{-1}, {-2}, {1, 2}}], I[{{-1}, {-2}, {2}, {1}}]]
+        sage: E = I([[1,2],[-1,-2]]); E
+        I[{{1, 2}, {-1, -2}}]
+        sage: E^2
+        x*I[{{1, 2}, {-2, -1}}]
+        sage: E^5
+        x^4*I[{{1, 2}, {-2, -1}}]
+
+    """
+    @staticmethod
+    def __classcall_private__(cls, k, q, base_ring=None, prefix="I"):
+        r"""
+        This method gets the base_ring from the parent of the parameter q
+        if no base_ring is given.
+        """
+        if base_ring is None:
+            base_ring = q.parent()
+        return super(IdealAlgebra, cls).__classcall__(cls, k, q=q, base_ring = base_ring, prefix=prefix)
+
+    def __init__(self, k, q, base_ring, prefix = "I"):
+        r"""
+        See :class:`IdealAlgebra` for full documentation.
+
+        TESTS::
+
+            sage: q = var('q')
+            sage: I = IdealAlgebra(2, q, RR['q'])
+            sage: TestSuite(I).run()
+        """
+        self._k = k
+        self._prefix = prefix
+        self._q = base_ring(q)
+        category = FiniteDimensionalAlgebrasWithBasis(base_ring)
+        CombinatorialFreeModule.__init__(self, base_ring, ideal_diagrams(k), category = category, prefix=prefix)
+
+    @cached_method
+    def one_basis(self):
+        r"""
+        The following constructs the identity element of the
+        Ideal algebra. It is not called directly;
+        instead one should use I.one() if I is a
+        previously defined Ideal algebra instance.
+
+        TODO:
+        Make this method correct.
+
+        EXAMPLES::
+
+            sage: I = IdealAlgebra(2, x);
+            sage: I.one_basis()
+            {{2, -2}, {1, -1}}
+            sage: I.one()
+            I[{{2, -2}, {1, -1}}]
+
+        """
+        return identity_set_partition(self._k)
+
+    def _repr_(self):
+        msg = "Ideal Algebra of rank %s with parameter %s over %s, with prefix %s"
+        return msg % (self._k, self._q, self.base_ring(), self._prefix)
+
+    def _element_constructor_(self, set_partition):
+        r"""
+        If I is a particular Ideal algebra (previously defined)
+        then I( sp ) returns the element of the algebra I corresponding
+        to a given set partition sp.
+
+        EXAMPLES::
+
+            sage: q = var('q')
+            sage: I = IdealAlgebra(2,q,QQ['q'])
+            sage: I
+            Ideal Algebra of rank 2 with parameter q over Univariate Polynomial Ring in q over Rational Field, with prefix I
+            sage: sp = to_set_partition( [[1,2], [-1,-2]] )  # create a set partition
+            sage: sp
+            {{1, 2}, {-1, -2}}
+            sage: I(sp)  # construct a basis element from it
+            I[{{1, 2}, {-1, -2}}]
+            sage: I(sp) in I
+            True
+            sage: I([[1,2],[-1,-2]])
+            I[{{1, 2}, {-1, -2}}]
+            sage: I([{1,2},{-1,-2}])
+            I[{{1, 2}, {-1, -2}}]
+        """
+        if (set_partition in self.basis().keys()) and isinstance(set_partition, collections.Hashable):
+            return self.monomial(set_partition)
+        elif isinstance(set_partition, list):
+            sp = to_set_partition(set_partition) # attempt coercion
+            assert sp in self.basis().keys() # did it work?
+            return self.monomial(sp)
+        else:
+            raise AssertionError, "%s invalid form" % set_partition
+
+    def ambient(self):
+        r"""
+        ambient returns the partition algebra the Ideal algebra
+        is a sub-algebra of. Generally, this method is not called
+        directly.
+
+        EXAMPLES::
+            sage: I = IdealAlgebra(2, x);
+            sage: P = I.ambient()
+            sage: P
+            Partition Algebra of rank 2 with parameter x over Symbolic Ring, with prefix I
+        """
+        return PartitionAlgebra(self._k, self._q, self.base_ring(), prefix=self._prefix)
+    def lift(self, x):
+        r"""
+        lift maps a Ideal algebra element to the corresponding
+        element in the ambient space. This method is not intended
+        to be called directly.
+
+        EXAMPLES::
+            sage: I = IdealAlgebra(2, x);
+            sage: E = I([[1,2],[-1,-2]]); E
+            I[{{1, 2}, {-1, -2}}]
+            sage: I.lift(E) in I.ambient()
+            True
+            sage: I.lift(E) in I
+            False
+        """
+        assert x in self
+        monomial_indices = x.support()
+        monomial_coefficients = x.coefficients()
+        result = 0
+        for i in xrange(len(monomial_coefficients)):
+            result += monomial_coefficients[i]*self.ambient().monomial(monomial_indices[i])
+        return result
+
+    def retract(self, x):
+        r"""
+        retract maps an appropriate partition algebra element to the
+        corresponding element in the Ideal algebra. This method
+        is not intended to be called directly.
+
+        EXAMPLES::
+            sage: I = IdealAlgebra(2, x)
+            sage: PA = I.ambient()
+            sage: E = PA([[1,2],[-1,-2]])
+            sage: I.retract(E) in PA
+            False
+            sage: I.retract(E) in I
+            True
+        """
+        assert x in self.ambient() and set(x.support()).issubset(set(self.basis().keys()))
+        monomial_indices = x.support()
+        monomial_coefficients = x.coefficients()
+        result = self.zero()
+        for i in xrange(len(monomial_coefficients)):
+            result += monomial_coefficients[i]*self.monomial(monomial_indices[i])
+        return result
+
+    def product_on_basis(self, left, right):
+        r"""
+        This method is not made to be called directly but by using
+        arithematic operators on elements.
+        EXAMPLES::
+            sage: I = IdealAlgebra(2, x)
+            sage: E = I([[1,2],[-1,-2]])
+            sage: E*E
+            x*I[{{1, 2}, {-2, -1}}]
+            sage: E^4
+            x^3*I[{{1, 2}, {-2, -1}}]
+        """
+        return self.ambient().product_on_basis(left,right)
+
+    def order(self):
+        r"""
+        Returns the order of the Temperley-Lieb Algebra
+        EXAMPLES::
+            sage: I = IdealAlgebra(2, x)
+            sage: I.order()
+            2
+        """
+        return self.ambient().order()
+
+#########################################################################
+# START BORROWED CODE
+#########################################################################
+# Borrowed from Mike Hansen's original code -- global methods for dealing
+# with partition diagrams, compositions of partition diagrams, and so on.
+# --> CHANGED 'identity' to 'identity_set_partition' for enhanced clarity.
+#########################################################################
+                
+def is_planar(sp):
+    r"""
+    Returns True if the diagram corresponding to the set partition is
+    planar; otherwise, it returns False.
+    
+    EXAMPLES::
+    
+        sage: import sage.combinat.partition_algebra as pa
+        sage: pa.is_planar( pa.to_set_partition([[1,-2],[2,-1]]))
+        False
+        sage: pa.is_planar( pa.to_set_partition([[1,-1],[2,-2]]))
+        True
+    """
+    to_consider = map(list, sp)
+
+    #Singletons don't affect planarity
+    to_consider = filter(lambda x: len(x) > 1, to_consider)
+    n = len(to_consider)
+    
+    for i in range(n):
+        #Get the positive and negative entries of this
+        #part
+        ap = filter(lambda x: x>0, to_consider[i])
+        an = filter(lambda x: x<0, to_consider[i])
+        an = map(abs, an)
+        #print a, ap, an
+
+
+        #Check if a includes numbers in both the top and bottom rows
+        if len(ap) > 0 and len(an) > 0:
+
+            for j in range(n):
+                if i == j:
+                    continue
+                #Get the positive and negative entries of this part
+                bp = filter(lambda x: x>0, to_consider[j])
+                bn = filter(lambda x: x<0, to_consider[j])
+                bn = map(abs, bn)
+
+                #Skip the ones that don't involve numbers in both
+                #the bottom and top rows
+                if len(bn) == 0 or len(bp) == 0:
+                    continue
+
+                #Make sure that if min(bp) > max(ap)
+                #then min(bn) >  max(an)
+                if max(bp) > max(ap):
+                    if min(bn) < min(an):
+                        return False
+
+
+        #Go through the bottom and top rows
+        for row in [ap, an]:
+            if len(row) > 1:
+                row.sort()
+                for s in range(len(row)-1):
+                    if row[s] + 1 == row[s+1]:
+                        #No gap, continue on
+                        continue
+                    else:
+                        rng = range(row[s] + 1, row[s+1])
+                        
+                        #Go through and make sure any parts that
+                        #contain numbers in this range are completely
+                        #contained in this range
+                        for j in range(n):
+                            if i == j:
+                                continue
+
+                            #Make sure we make the numbers negative again
+                            #if we are in the bottom row
+                            if row is ap:
+                                sr = Set(rng)
+                            else:
+                                sr = Set(map(lambda x: -1*x, rng))
+
+                            
+                            sj = Set(to_consider[j])
+                            intersection = sr.intersection(sj)
+                            if intersection:
+                                if sj != intersection:
+                                    return False
+
+    return True
+
+   
+def to_graph(sp):
+    r"""
+    Returns a graph representing the set partition sp.
+    
+    EXAMPLES::
+    
+        sage: import sage.combinat.partition_algebra as pa
+        sage: g = pa.to_graph( pa.to_set_partition([[1,-2],[2,-1]])); g
+        Graph on 4 vertices
+    
+    ::
+    
+        sage: g.vertices() #random
+        [1, 2, -2, -1]
+        sage: g.edges() #random
+        [(1, -2, None), (2, -1, None)]
+    """
+    g = Graph()
+    for part in sp:
+        part_list = list(part)
+        if len(part_list) > 0:
+            g.add_vertex(part_list[0])
+        for i in range(1, len(part_list)):
+            g.add_vertex(part_list[i])
+            g.add_edge(part_list[i-1], part_list[i])
+    return g
+
+def pair_to_graph(sp1, sp2):
+    r"""
+    Returns a graph consisting of the graphs of set partitions sp1 and
+    sp2 along with edges joining the bottom row (negative numbers) of
+    sp1 to the top row (positive numbers) of sp2.
+    
+    EXAMPLES::
+    
+        sage: import sage.combinat.partition_algebra as pa
+        sage: sp1 = pa.to_set_partition([[1,-2],[2,-1]])
+        sage: sp2 = pa.to_set_partition([[1,-2],[2,-1]])        
+        sage: g = pa.pair_to_graph( sp1, sp2 ); g
+        Graph on 8 vertices
+    
+    ::
+    
+        sage: g.vertices() #random
+        [(1, 2), (-1, 1), (-2, 2), (-1, 2), (-2, 1), (2, 1), (2, 2), (1, 1)]
+        sage: g.edges() #random
+        [((1, 2), (-1, 1), None),
+         ((1, 2), (-2, 2), None),
+         ((-1, 1), (2, 1), None),
+         ((-1, 2), (2, 2), None),
+         ((-2, 1), (1, 1), None),
+         ((-2, 1), (2, 2), None)]
+    """
+    g = Graph()
+
+    #Add the first set partition to the graph
+    for part in sp1:
+        part_list = list(part)
+        if len(part_list) > 0:
+            g.add_vertex( (part_list[0],1) )
+
+            #Add the edge to the second part of the graph
+            if part_list[0] < 0 and len(part_list) > 1:
+                g.add_edge( (part_list[0], 1), (abs(part_list[0]),2)  )
+            
+        for i in range(1, len(part_list)):
+            g.add_vertex( (part_list[i],1) )
+            
+            #Add the edge to the second part of the graph
+            if part_list[i] < 0:
+                g.add_edge( (part_list[i], 1), (abs(part_list[i]),2) )
+
+            #Add the edge between parts
+            g.add_edge( (part_list[i-1],1), (part_list[i],1) )
+
+    #Add the second set partition to the graph
+    for part in sp2:
+        part_list = list(part)
+        if len(part_list) > 0:
+            g.add_vertex( (part_list[0],2) )
+        for i in range(1, len(part_list)):
+            g.add_vertex( (part_list[i],2) )
+            g.add_edge( (part_list[i-1],2), (part_list[i],2) )
+            
+    return g
+
+def propagating_number(sp):
+    r"""
+    Returns the propagating number of the set partition sp. The
+    propagating number is the number of blocks with both a positive and
+    negative number.
+    
+    EXAMPLES::
+    
+        sage: import sage.combinat.partition_algebra as pa
+        sage: sp1 = pa.to_set_partition([[1,-2],[2,-1]])
+        sage: sp2 = pa.to_set_partition([[1,2],[-2,-1]])        
+        sage: pa.propagating_number(sp1)
+        2
+        sage: pa.propagating_number(sp2)
+        0
+    """
+    pn = 0
+    for part in sp:
+        if min(part) < 0  and max(part) > 0:
+            pn += 1
+    return pn
+
+def to_set_partition(l,k=None):
+    r"""
+    Converts a list of a list of numbers to a set partitions. Each list
+    of numbers in the outer list specifies the numbers contained in one
+    of the blocks in the set partition.
+    
+    If k is specified, then the set partition will be a set partition
+    of 1, ..., k, -1, ..., -k. Otherwise, k will default to the minimum
+    number needed to contain all of the specified numbers.
+    
+    EXAMPLES::
+    
+        sage: import sage.combinat.partition_algebra as pa
+        sage: pa.to_set_partition([[1,-1],[2,-2]]) == pa.identity(2)
+        True
+    """
+    if k == None:
+        if l == []:
+            return Set([])
+        else:
+            k = max( map( lambda x: max( map(abs, x) ), l) )
+
+    to_be_added = Set( range(1, k+1) + map(lambda x: -1*x, range(1, k+1) ) )
+    
+    sp = []
+    for part in l:
+        spart = Set(part)
+        to_be_added -= spart
+        sp.append(spart)
+
+    for singleton in to_be_added:
+        sp.append(Set([singleton]))
+
+    return Set(sp)
+
+def identity_set_partition(k):
+    """
+    Returns the identity set partition 1, -1, ..., k, -k
+    
+    EXAMPLES::
+    
+        sage: identity_set_partition(2) #random order
+        {{2, -2}, {1, -1}}
+    """
+    if k == int(k):
+        return Set( [Set([i,-i]) for i in range(1, k + 1)] )
+    if k - math.floor(k) == 0.5:
+        return Set( [Set([i, -i]) for i in range(1, k + 1.5)] )
+
+def set_partition_composition(sp1, sp2):
+    r"""
+    Returns a tuple consisting of the composition of the set partitions
+    sp1 and sp2 and the number of components removed from the middle
+    rows of the graph.
+    
+    EXAMPLES::
+    
+        sage: import sage.combinat.partition_algebra as pa
+        sage: sp1 = pa.to_set_partition([[1,-2],[2,-1]])
+        sage: sp2 = pa.to_set_partition([[1,-2],[2,-1]])
+        sage: pa.set_partition_composition(sp1, sp2) == (pa.identity(2), 0)
+        True
+    """
+    g = pair_to_graph(sp1, sp2)
+    connected_components = g.connected_components()
+
+    res = []
+    total_removed = 0
+    for cc in connected_components:
+        #Remove the vertices that live in the middle two rows
+        new_cc = filter(lambda x: not ( (x[0]<0 and x[1] == 1) or (x[0]>0 and x[1]==2)), cc)
+
+        if new_cc == []:
+            if len(cc) > 1:
+                total_removed += 1
+        else:
+            res.append( Set(map(lambda x: x[0], new_cc)) )
+
+
+    return ( Set(res), total_removed )
+
+##########################################################################
+# END BORROWED CODE
+##########################################################################    
+