#Notation :
#a, b : Partitions
#m, n : dimensions of the rectangle
#t    : list of partitions
import sage.libs.lrcalc.lrcalc as lrcalc
import numpy
def co(a,m,n):    #GIVES COMPLEMENT OF PARTITION 'a'
    c=a.length()
    d=[]
    e=a.to_list()
    for i in range(m-c):
        e.append(0)
    for i in e:
        d.append(n-i)
    d.reverse()
    return Partition(d)  

def add(a,b):       #RETURNS ADDITION OF TWO PARTITIONS 'a' and 'b'
    a1=a.to_list()
    b1=b.to_list()
    al=a.length()
    bl=b.length()
    c=max(al,bl)
    if al!=bl:
        if c==al:
            for i in range(al-bl):
                b1.append(0)
        else:
            for i in range(bl-al):
                a1.append(0)
    return Partition([a1[i]+b1[i] for i in range(c)])

#def sort(a,b):      #SORTS A PARTITION
#	c=a.to_list()+b.to_list()
#	c.sort()
#	c.reverse()
#	return Partition(c)
s = SymmetricFunctions(QQ).s()
def supp(a,m,n):
    return sorted((s(Partition(a))*s(co(Partition(a),m,n))).support())

def mix(a,m,n):      #RETURNS SORTED UNION OF PARTIION 'a' AND IT'S COMPLEMENT
	return add(a.conjugate(),co(a,m,n).conjugate()).conjugate()

def li(m,n):       #RETURNS THE LIST OF ALL PARTITIONS IN RECTANGLE m*n
    d=[]
    for j in range(m*n/2-1):
        for i in Partitions(j+1,max_part=n,max_length=m):
            d.append(i)
    for i in Partitions(int(m*n/2),max_part=n,max_length=m):
        if co(i,m,n) not in d:
                d.append(i)
    return d

def sdif(a,b,m,n):      #RETURNS THE PARTITIONS THAT ARE IN SUPPORT OF 'a' BUT NOT IN SUPPORT OF 'b'
    d=[]
    a=Partition(a)
    b=Partition(b)
    for i in lrcalc.mult(a,co(a,m,n)):
        if lrcalc.lrcoef(i,b,co(b,m,n))==0:
            d.append(i)
    return sorted(d)

def rem(t,a,m,n):       #RETURNS THE PARTITIONS IN 't' THAT ARE NOT IN THE SUPPORT OF 'a'
    a=Partition(a)
    for i in t:
        if lrcalc.lrcoef(Partition(i),a,co(a,m,n))>0:
            t.remove(i)
    return sorted(t)

def giv(m,n,z):           #RETURNS ALL THE EQUIVALENCE CLASSES OF PARTITIONS IN RECTANGLE m*n
    d=[]
    a=li(m,n)
    for i in a:
        c=set()
        for j in a:
            if add(i,co(i,m,n))==add(j,co(j,m,n)) and mix(i,m,n)==mix(j,m,n):
                a.remove(j)
                c.add(j)
        if len(c)>z:        #IF YOU WANT TO SEE ONLY EQUIVALENCE CLASSES OF SIZE > k, THEN REPLACE 0 BY k IN THIS LINE
            d.append(c)
    return d

def new(m,n):
    for i in li(m,n):
        if len(i)==m and i[0]==n:
            print i
        elif len(i)<m and i[0]<m:
            print co(i,m,n)

from sage.libs.lrcalc.lrcalc import lrskew
def pp(a,b):
    for c in (s(a)*s(b)).support():
        for st in lrskew(c,a,weight=b):
            st.pp()

1+1

s([3,3,1])*s([4,2,2])

s([4,3])*s([5,2,1])

s([3,3])*s([5,2,2])

for i in lrskew([5,3,3,2,2],[3,3],weight=[5,2,2]):
    i.pp()

for i in lrskew([5,3,3,2,2],[3,2],weight=[5,3,2]):
    i.pp()
#lrcalc.lrcoef([5,4,3,2,2],[3,2],[5,3,2])

giv(5,6,1)

for i in lrskew([6,6,6,5,3,2,2],[6,4,3,1,1],weight=[5,5,3,2]):
    i.pp()

for i in lrskew([6,6,6,5,3,2,2],[5,4,3,1],weight=[6,5,3,2,1]):
    i.pp()

#set([[5, 4, 3, 1], [6, 4, 3, 1, 1]])
supp([6,4,3,1,1],5,6)

sdif([3, 2], [3, 3],3,5)

#for i in sdif([3, 2], [3, 3],3,5):
#    for st in lrskew(i,[3,2],weight=[5,3,2]):
#        st.pp()
for i in lrskew([5,3,3,3,1],[3,2],weight=[5,3,2]):
    i.pp()

s([3,3])*s([5,2,2])

for i in lrskew([6,5,3,1],[3,2],weight=[5,3,2]):
    i.pp()

for i in lrskew([6,5,3,1],[3,3],weight=[5,2,2]):
    i.pp()

sdif([3, 2, 1], [3, 3, 1],3,5)

supp([3,2,1],3,5)

sdif([4, 2], [4, 3],3,5)

supp([4,2],3,5)

giv(3,3,1)

sdif([2, 1], [2, 2],3,3)

giv(3,4,1)

giv(3,5,1)

sdif([3, 2], [3, 3],3,5)

sdif([4,2],[4,3],3,5)

sdif([3,2,1],[3,3,1],3,5)

t=sdif([4,2],[4,3],3,5)
for j in t:
    print j, lrcalc.lrcoef(j,[4,2],[5,3,1])

for i in giv(3,7,1):
    t=sorted(list(i))
    print t
    sdif(t[0],t[1],3,7)
    print "\n"

for i in giv(5,7,2):
    t=sorted(list(i))
    print t
    a=sdif(t[0],t[1],5,7)
    a=rem(a,t[2],5,7)
    a=rem(a,t[3],5,7)
    a
    print "\n"

sdif([6,3],[6,4],3,7)

li(2,2)

li(2,3)

sdif([2,1],[1],3,3)

for i in lrskew([6,4,4,1],[4,3],weight=[5,2,1]):
    i.pp()

for i in lrskew([6,4,4,1],[4,2],weight=[5,3,1]):
    i.pp()