def rowvacuation_ideal(P,I):
    r = P.rank()
    f = P.rank_function()
    my_order_ideal = I
    for i in range(r+1):
        for j in range(r+1-i):
            s = r+1-j-1
            for x in P:
                if f(x)==s:
                    my_order_ideal = P.order_ideal_toggle(my_order_ideal,x)
    return my_order_ideal

def antichain_from_ideal(P,I):
    return P.subposet(set(P).difference(set(I))).minimal_elements()

def antichain_size(P,I):
    return len(antichain_from_ideal(P,I))

def antichain_toggle(P,A,x):
    if x in A:
        return list(set(A).difference(set([x])))
    else:
        flag=true
        for y in A:
            if (P.le(x,y) or P.le(y,x)):
                flag=false
        if flag:
            return list(set(A).union(set([x])))
        else:
            return A

def rowvacuation_antichain(P,A):
    r = P.rank()
    f = P.rank_function()
    my_antichain = A
    for i in range(r+1):
        for j in range(i,r+1):
            for x in P:
                if f(x)==j:
                    my_antichain = antichain_toggle(P,my_antichain,x)
    return my_antichain

def root_poset_rvac_anti_size_test(R):
    n=R.root_lattice().rank()
    print("Root system: " + str(R))
    P = R.root_poset()
    error=[]
    max_error = 0
    num_errors = 0
    totcount=0
    for A in P.antichains_iterator():
        totcount=totcount+1
        B = rowvacuation_antichain(P,A)
        m = len(A)+len(B)
        if not(m==n):
            if abs(m-n) >= max_error:
                error += [(m,A,B)]
                max_error=abs(m-n)
            num_errors = num_errors + 1
    print("Number of antichains of root poset: " + str(totcount))
    print("Number of antichains for which #A + #Rvac(A) != rank: " + str(num_errors))
    if (num_errors > 0):
          print("An example of a failure: " + str(error[0]))

def root_poset_rvac_anti_size_test_oi(R):
    n=R.root_lattice().rank()
    print("Root system: " + str(R))
    P = R.root_poset()
    Q = P.order_ideals_lattice(facade=true)
    error=[]
    num_errors = 0
    totcount=0
    for I in Q:
        totcount=totcount+1
        J = rowvacuation_ideal(P,I)
        m = antichain_size(P,I)+antichain_size(P,J)
        if not(m==n):
            if (num_errors == 0):
                error += [(m,I,J)]
            num_errors = num_errors + 1
    print("Number of antichains of root poset: " + str(totcount))
    print("Number of antichains for which #A + #Rvac(A) != rank: " + str(num_errors))
    if (num_errors > 0):
          print("An example of a failure: " + str(error[0]))

def root_poset_rvac_fix_test(R):
    print("Root system: " + str(R))
    P = R.root_poset()
    count1=0
    count2=0
    totcount=0
    for A in P.antichains_iterator():
        totcount=totcount+1
        B = rowvacuation_antichain(P,A)
        C = rowvacuation_antichain(P,P.order_ideal_complement_generators(A))
        if set(A) == set(B):
            count1 = count1+1
        if set(A) == set(C):
            count2 = count2+1
    print("Number of antichains of root poset: " + str(totcount))
    print("Number fixed by Rvac: " + str(count1))
    print("Number fixed by Row^{-1}*Rvac: " + str(count2))

def root_poset_rvac_fix_test_oi(R):
    print("Root system: " + str(R))
    P = R.root_poset()
    Q = P.order_ideals_lattice(facade=true)
    count1=0
    count2=0
    totcount=0
    for I in Q:
        totcount=totcount+1
        J = rowvacuation_ideal(P,I)
        K = rowvacuation_ideal(P,P.rowmotion(I))
        if I == J:
            count1 = count1+1
        if I == K:
            count2 = count2+1
    print("Number of antichains of root poset: " + str(totcount))
    print("Number fixed by Rvac: " + str(count1))
    print("Number fixed by Row^{-1}*Rvac: " + str(count2))

def noncrossing_refl_fix_test(R):
    W=R.root_lattice().weyl_group()
    print("Weyl group: " + str(W))
    Cmin = W.prod([W.simple_reflection(i) for i in W.coxeter_diagram().bipartite_sets()[0]])
    Cplu = W.prod([W.simple_reflection(i) for i in W.coxeter_diagram().bipartite_sets()[1]])
    C = Cmin*Cplu
    P = list(W.absolute_order_ideal(gens=C))
    print("Number of noncrossing partitions: " + str(len(P)))
    count1 = 0
    count2 = 0
    for x in P:
        y = Cmin*x.inverse()*Cmin.inverse()
        z = C*y.inverse()
        if x==y:
            count1=count1+1
        if x==z:
            count2=count2+1
    print("Number fixed by Refl: " + str(count1))
    print("Number fixed by Krew*Refl: " + str(count2))

for n in range(2,9):
    R = RootSystem(['A',n])
    root_poset_rvac_anti_size_test(R)
    print()
    root_poset_rvac_fix_test(R)
    #noncrossing_refl_fix_test(R)
    print()

for n in range(2,9):
    R = RootSystem(['B',n])
    root_poset_rvac_anti_size_test(R)
    print()
    root_poset_rvac_fix_test(R)
    #noncrossing_refl_fix_test(R)
    print()

for n in range(3,9):
    R = RootSystem(['D',n])
    root_poset_rvac_anti_size_test(R)
    print()
    root_poset_rvac_fix_test(R)
    #noncrossing_refl_fix_test(R)
    print()

R = RootSystem(['G',2])
root_poset_rvac_anti_size_test(R)
print()
root_poset_rvac_fix_test(R)
#noncrossing_refl_fix_test(R)
print()

R = RootSystem(['F',4])
root_poset_rvac_anti_size_test(R)
print()
root_poset_rvac_fix_test(R)
#noncrossing_refl_fix_test(R)
print()

R = RootSystem(['E',6])
root_poset_rvac_anti_size_test(R)
print()
root_poset_rvac_fix_test(R)
#noncrossing_refl_fix_test(R)
print()

R = RootSystem(['E',7])
root_poset_rvac_anti_size_test(R)
print()
root_poset_rvac_fix_test(R)
#noncrossing_refl_fix_test(R)
print()

R = RootSystem(['E',8])
root_poset_rvac_anti_size_test(R)
print()
root_poset_rvac_fix_test(R)
##noncrossing_refl_fix_test(R)
print()

def h3_poset():
    return Poset({1:[4],2:[4,5],3:[5],4:[6,7],5:[7],6:[8,9],7:[9],8:[10],9:[10,11],10:[12],11:[12],12:[13],13:[14],14:[15]})

P = h3_poset()
n = 3
error=[]
num_errors = 0
totcount=0
for A in P.antichains_iterator():
    totcount=totcount+1
    B = rowvacuation_antichain(P,A)
    m = len(A)+len(B)
    if not(m==n):
        if (num_errors == 0):
            error += [(m,A,B)]
        num_errors = num_errors + 1
print("Number of antichains of root poset: " + str(totcount))
print("Number of antichains for which #A + #Rvac(A) != rank: " + str(num_errors))
if (num_errors > 0):
    print("An example of a failure: " + str(error[0]))

count1=0
count2=0
totcount=0
for A in P.antichains_iterator():
    totcount=totcount+1
    B = rowvacuation_antichain(P,A)
    C = rowvacuation_antichain(P,P.order_ideal_complement_generators(A))
    if set(A) == set(B):
        count1 = count1+1
    if set(A) == set(C):
        count2 = count2+1
print("Number of antichains of root poset: " + str(totcount))
print("Number fixed by Rvac: " + str(count1))
print("Number fixed by Row^{-1}*Rvac: " + str(count2))

W=CoxeterGroup(['H',3])
print("Weyl group: " + str(W))
Cmin = W.prod([W.simple_reflection(i) for i in W.coxeter_diagram().bipartite_sets()[0]])
Cplu = W.prod([W.simple_reflection(i) for i in W.coxeter_diagram().bipartite_sets()[1]])
C = Cmin*Cplu
P = list(W.absolute_order_ideal(gens=C))
print("Number of noncrossing partitions: " + str(len(P)))
count1 = 0
count2 = 0
for x in P:
    y = Cmin*x.inverse()*Cmin.inverse()
    z = C*y.inverse()
    if x==y:
        count1=count1+1
    if x==z:
        count2=count2+1
print("Number fixed by Refl: " + str(count1))
print("Number fixed by Krew*Refl: " + str(count2))