def comb_BD(binary_triangle, down_triangle):
size = len(binary_triangle)
B = [[x for x in row] for row in binary_triangle]
D = [[x for x in row] for row in down_triangle]
print('comb_DB start')
print(B)
print(D)
print('omega')
print(comb.get_omega(B, D))
for k in reversed(range(size)):
print('\tcomb row', k)
#### we already have a starting value for D[k][k]
#D[k][k] = sum([B[k][j] for j in range(k+1)])
print('\t\t@ adjusting D[k][k] for k=', k)
print('\t\t\tk+1=', k + 1)
print('\t\t\tB[k][0..k]=', [B[k][j] for j in range(k + 1)])
print('\t\t\tD[k][0..k]=', [D[k][j] for j in range(k + 1)])
old_dkk = D[k][k]
print('\t\t\tD[k][k] old=', D[k][k])
#D[k][k] = k+1 - sum([B[k][j] + D[k][j] for j in range(k+1)])
#D[k][k] = k + 1 - sum([B[k][j] for j in range(k + 1)]) - sum([D[k][j] for j in range(k + 1)])
print('\t\t\tD[k][k] new=', D[k][k])
if not old_dkk == D[k][k]:
TypeError('FAILURE')
for i in range(k, size - 1):
print('\tuntangle', i, k)
B, D = untangle(B, D, i, k)
print('\t\t', B)
print('\t\t', D)
print('comb_DB returning')
print(B)
print(D)
print('omega')
print(comb.get_omega(B, D))
print('++++++++++++++++++++++++')
return B, D
def matrix_to_tex(matrix):
tex_list = ['matrix:', '$\\begin{bmatrix}']
for row in matrix:
tex_list.append(' & '.join([str(x) for x in row]) + ' \\\\')
tex_list.append('\\end{bmatrix}$ \\quad \n')
# create the ssyt
ssyt = matrix_to_ssyt(matrix)
ssyt_tex = 'SSYT: ' + util.to_tex_ytableau(ssyt) + ' \\quad \n tangle:'
### create the tangle
B,D = matrix_to_BD(matrix)
omega = binary_comb.get_omega(B,D)
omega_tex = binary_comb.to_tikz_after(omega, False)
return '\n'.join(tex_list) + ssyt_tex + omega_tex
def get_atoms(size):
if not size in atom_map:
bin_list = binary_comb.get_binary_triangle(size)
combed_list = [binary_comb.comb(t) for t in bin_list]
omega_list = [
binary_comb.get_omega(combed[0], combed[1])
for combed in combed_list
]
atoms = dict()
down_path = get_down_path(size - 1)
for bin_tri, omega in zip(bin_list, omega_list):
if size == 1 or omega[1] == down_path:
atoms[str(omega[0])] = bin_tri
atom_map[size] = atoms
return atom_map[size]
def test_comb():
size = 3
combed_list = binary_comb.get_combed_triangles(size)
bc_list = get_bigog_for_comb(size)
#bc_list = [ bc_list[18], bc_list[52], bc_list[21], bc_list[53], bc_list[41], bc_list[60] ]
#bc_list = [ bc_list[41], ]
print('starting')
fail_count = 0
#bc_list = [ [[0, 2, 3], [0, 2], [0]]]
bc_mapping = dict()
double_count = 0
bigog_omega_list = []
bigog_omega_after_list = []
for count, bc in enumerate(bc_list):
B, D = to_BD(bc)
#B, D = binary_comb.comb_BD(B,D)
print('>>>>>>>>>>>>>>><<<<<<<<<<<<<<<')
util.print_array(bc)
util.print_array(B)
util.print_array(D)
util.print_array(binary_comb.get_omega(B, D))
# print('>>>>>>>>>>>>>>><<<<<<<<<<<<<<<')
# print('>>>>>>>>>>>>>>><<<<<<<<<<<<<<<')
# print('>>>>>>>>>>>>>>><<<<<<<<<<<<<<<')
print('>>>>>>> combing', count, bc, B, D)
print('\t', binary_comb.get_omega(B, D))
bigog_omega_list.append(binary_comb.get_omega(B, D))
BB, DD = gen_comb.comb_BD(B, D)
combed = binary_comb.get_omega(BB, DD)
bigog_omega_after_list.append(combed)
print('\t\t\t', combed)
combed_str = str(combed)
before = binary_comb.get_omega(B, D)
#print(combed)
if not combed in combed_list:
util.print_array(bc)
util.print_array(B)
util.print_array(D)
print('before')
util.print_array(before)
print('fail')
util.print_array(combed)
fail_count += 1
elif not combed_str in bc_mapping:
bc_mapping[combed_str] = [
before,
]
else:
bc_mapping[combed_str].append(before)
print('error double map:', combed_str, 'is mapped to by',
bc_mapping[combed_str])
print('\tcount=', count)
double_count += 1
#
#print('-------')
# else:
# print('pass')
# util.print_array(combed)
# print('BINARY COMBED LIST')
# for x in combed_list:
# print(x)
before_file_name = '/Users/abeverid/PycharmProjects/asm/data/bigog/bigog' + str(
size) + '.tex'
after_file_name = '/Users/abeverid/PycharmProjects/asm/data/bigog/bigog' + str(
size) + '-after.tex'
util.omega_list_to_tex_file(bigog_omega_list, before_file_name)
util.omega_list_to_tex_file(bigog_omega_after_list, after_file_name)
print(len(combed_list))
print('fail count', fail_count)
print('doubles', double_count)
def bigog_to_omega(bigog):
B, D = to_BD(bigog)
return binary_comb.get_omega(B, D)
def write_bin_layers(bin_list, layer_list, suffix):
sst_list = bss.build_stacks(len(bin_list[0]))
lines = util.get_tex_header()
num = -1
for bin_tri, layer_tri in zip(bin_list, layer_list):
num += 1
if True:
# need to invert this mapping!
xinv = [[1 - a for a in row] for row in bin_tri]
omega_before = binary_comb.get_omega_for_cliff(xinv)
B, D = binary_comb.comb(xinv)
omega = binary_comb.get_omega(B, D)
print(layer_tri)
size = len(layer_tri)
binlayer_list = [ binary_for_layer(row, size) for row in layer_tri ]
#binlayer_list = [ [row for row in reversed(tri)] for tri in binlayer_list]
#### this implementation rotates the triangle!!!!
print('binary:', bin_tri)
for x in binlayer_list:
print('\t', x)
rot_bin_tri = util.rotate_triangle(bin_tri)
rot_bin_tri = [row for row in reversed(rot_bin_tri)]
# if rot_bin_tri in sst_list:
if True:
lines.append('\\subsubsection*{Triangle Number ' + str(num) + '}')
lines.append('')
lines.append('\\begin{tikzpicture}[scale=.5]')
lines.append('\\node at (0,' + str(3 * size + 1) + ') {')
lines.append(util.to_tex_ytableau([ row for row in reversed(rot_bin_tri)]))
lines.append('};')
lines.append('\\begin{scope}[shift={(0,' + str(3 * size/ 2) + ')}]')
lines.append(util.omega_to_tangle(invert_bin_to_omega(rot_bin_tri)))
lines.append('\\end{scope}')
lines.append('\\begin{scope}[shift={(0,0)}]')
lines.append(util.omega_to_tangle(invert_bin_to_combed_omega(rot_bin_tri)))
lines.append('\\end{scope}')
for count,bl in enumerate(binlayer_list):
lines.append('\\node at (' + str( (count +1) * 3/2 * size ) + ',' + str(3 * size +1) + ') {')
lines.append(util.to_tex_ytableau([row for row in reversed(bl)]))
lines.append('};')
lines.append('\\begin{scope}[shift={(' + str((count + 1) * 3/2 * size) + ',' + str(3 * size/ 2) + ')}]')
lines.append(util.omega_to_tangle(invert_bin_to_omega(bl)))
lines.append('\\end{scope}')
lines.append('\\begin{scope}[shift={(' + str((count + 1) * 3/2 * size) + ',0)}]')
lines.append(util.omega_to_tangle(invert_bin_to_combed_omega(bl)))
lines.append('\\end{scope}')
lines.append('\\end{tikzpicture}')
lines.append('')
lines.append('\medskip')
lines = lines + util.get_tex_footer()
file_name = '/Users/abeverid/PycharmProjects/asm/data/sst_layer_' + suffix + str(size) + '.tex'
print('writing to', file_name)
out_file = open(file_name, 'w')
out_file.writelines(["%s\n" % item for item in lines])
def invert_bin_to_combed_omega(bin_tri):
new_bin = [[1-x for x in row] for row in bin_tri]
B, D = binary_comb.comb(new_bin)
omega = binary_comb.get_omega(B, D)
return omega
for x, y in zip(bin_list, layer_list):
#print('hi', x, y)
# for xrow, yrow in zip(reversed(x),y):
#
# print("{:<15}".format(str(xrow)), "{:<15}".format(str(yrow)))
# print('')
#print(x)
xinv = [[1-a for a in row] for row in x]
omega_before = binary_comb.get_omega_for_cliff(xinv)
B,D = binary_comb.comb(xinv)
omega = binary_comb.get_omega(B,D)
#if not binary_comb.is_magog(omega_before):
xx = util.flip_triangle(x)
if xx in sst_list: #not binary_comb.is_vless_gog(omega):
count +=1
#print(x, omega, y)
#print(x)
for xrow, orow, yrow in zip(reversed(xx), omega, y):
print("{:<15}".format(str(xrow)), "{:<15}".format(str(orow)), "{:<15}".format(str(yrow)))
if (not t[i - j][j] == 0) and t[i - j][j] < cur:
print('failing: t[i-j][j] < cur', t[i - j][j], cur)
return False
else:
cur = max(cur, t[i - j][j])
return True
size = 4
bin_list = binary_comb.get_binary_triangle(size)
combed_list = [binary_comb.comb(t) for t in bin_list]
omega_list = [
binary_comb.get_omega(combed[0], combed[1]) for combed in combed_list
]
# for omega in omega_list:
# print('OMEGA DECOMP')
# util.print_array(omega)
# decomp = factor(omega)
# for d in decomp:
# #util.print_array(convert(d))
# print('\t column is', convert(d))
# #B, D = binary_comb.comb(d)
# #print('\t\t', binary_comb.get_omega(B, D))
#omega_list = [[ [4, -4, 2, 1], [3, 2, 1], [2, 1], [1]],]
count = 0
def test(size):
combed_map = dict()
count_error_map = dict()
comb_error_list = []
intersect_list = []
bt_list = build_bt(size)
uncombed_omega_list = comb.get_uncombed_triangles(size)
combed_omega_list = comb.get_combed_triangles(size)
combed_omega_list = [update_omega(omega) for omega in combed_omega_list]
#for z in combed_omega_list:
# if z[0] == [-4,-4,-4,-3]:
# util.print_array(z)
for t in bt_list:
logging.debug('==========================')
logging.debug('BALLOT TRIANGLE')
logging.debug(str(t))
outB, outD = to_BD(t)
#util.print_array(outB)
#util.print_array(outD)
omega = comb.get_omega(outB, outD)
logging.debug('check omega %s', omega)
#comb_B, comb_D = comb_BD(outB, outD)
#comb_omega = comb.get_omega(comb_B, comb_D)
comb_omega = comb_new(omega)
logging.debug('combed to %s', comb_omega)
before_col_sums = get_column_sums(omega)
after_col_sums = get_column_sums(comb_omega)
logging.debug('\tbefore sums %s', before_col_sums)
logging.debug('\tafter sums %s', after_col_sums)
if not before_col_sums == after_col_sums:
count_error_map[str(omega)] = str(comb_omega)
key = str(comb_omega)
if key in combed_map:
print('ERROR!', str(omega), combed_map[key], 'both map to', key)
else:
print('start', omega, 'end', comb_omega)
combed_map[key] = omega
if omega in uncombed_omega_list:
intersect_list.append(omega)
idx = uncombed_omega_list.index(omega)
if not comb_omega == combed_omega_list[idx]:
comb_error_list.append(
[str(omega),
str(combed_omega_list[idx]),
str(comb_omega)])
#util.print_array()
print('errors:', str(len(bt_list) - len(combed_map)))
print('>>>>>>> missing combed triangles:')
for combed in combed_omega_list:
if str(combed) not in combed_map:
print(combed)
print('>>>>>>> failed BT combing:')
combed_omega_str_list = [str(x) for x in combed_omega_list]
for bt_combed in combed_map:
if str(bt_combed) not in combed_omega_str_list:
print(bt_combed)
print('>>>>>> failed column sums')
for x in count_error_map:
print(x)
print(count_error_map[x])
print('-------')
print('num col sum errors', len(count_error_map))
print('>>>> combing errors compared to standard combing')
print('total intersection', len(intersect_list), 'error count',
len(comb_error_list))
for x in comb_error_list:
print(x)
def untangle(B, D, i, k):
#print('untangle', i, k, B, D)
cur = 0
d = 0
s = 0
print('\t\t\ti=', i, 'k=', k)
print('\t\t\tbefore')
print('\t\t\t\t', B)
print('\t\t\t\t', D)
print('\t\t\t\tomega')
print('\t\t\t\t', comb.get_omega(B, D))
# CUR should be the gap. STILL NEED TO FIX THIS ARGH!!!!
for j in range(k + 1):
# ORIGINAL
cur = cur + B[i + 1][j] - B[i][j]
if (j > 0):
cur = cur + D[i + 1][j] - D[i][j - 1]
# BALLOT?
#cur = cur + B[i + 1][j] - D[i+1][j] - B[i][j] + D[i+1][j]
print('row i', i, 'col j', j, 'cur', cur, 'd', d)
if cur > d:
print('\tYES swap')
d = cur
s = s + d - cur
#print('$$$$$$$$$$$ hit it')
# interchange direction of steps
B[i][j] = 1
B[i + 1][j] = 0
else:
print('\tno swap')
# distribute the push downwards if we can
h = D[i][j]
if h <= s:
D[i][j] = 0
s = s - h
else:
D[i][j] = h - s
s = 0
# transfer d vertical steps to P_{i+1}
print('\tmoving d', d, 'steps from i,k', i, k)
######## HERE IS WHERE THE CHANGE NEEDS TO BE!
D[i][k] = D[i][k] - d
# ORIGINAL
#D[i+1][k] = d
# BALLOT?
D[i + 1][k] = D[i + 1][k] + d
#print('untangle returning', i, k, B, D)
print('\t\t\tafter')
print('\t\t\t\t', B)
print('\t\t\t\t', D)
print('\t\t\t\tomega')
print('\t\t\t\t', comb.get_omega(B, D))
print(min(D[i]))
if min(D[i]) < 0:
raise ValueError(' '.join([
'Untangle removed too many blocks (B,D,i,k)',
str(B),
str(D),
str(i),
str(k)
]))
return B, D
def compare_to_binary(size):
file_name = '/Users/abeverid/PycharmProjects/asm/data/ssyt/bin-ssyt' + str(size) + '.tex'
out_file = open(file_name, 'w')
lines = ['\\documentclass[12pt]{article}', '\\usepackage{amsmath}', '\\usepackage{ytableau}',
'\\usepackage{tikz}', '\\begin{document}']
matrix_list = get_ssyt_matrix(size)
#triangle_list = binary_triangle.get_binary_triangle_with_subset_order(size-1)
triangle_list = bin_tri_reordered
# bin_tri_list
# matrix_list = [
# [[1, 1], [1, 0], [0, 0]],
# [[1, 0], [1, 1], [0, 0]],
# [[1, 0], [1, 0], [0, 1]],
# [[1, 1], [0, 0], [1, 0]],
# [[1, 0], [0, 1], [1, 0]],
# [[1, 0], [0, 0], [1, 1]],
# [[0, 0], [1, 1], [1, 0]],
# [[0, 0], [1, 0], [1, 1]]
# ]
#
# triangle_list = [
# [[0], [0, 0]],
# [[0], [0, 1]],
# [[0], [1, 0]],
# [[1], [0, 0]],
# [[0], [1, 1]],
# [[1], [0, 1]],
# [[1], [1, 0]],
# [[1], [1, 1]]
# ]
count = -1
for t,m in zip(triangle_list, matrix_list):
count = count+1
size = len(triangle_list[0])
t_B, t_D = binary_comb.comb(t)
t_cliff_omega = binary_comb.get_omega_for_cliff(t)
t_combed_omega = binary_comb.get_omega(t_B, t_D)
m_B, m_D = matrix_to_BD(m)
m_omega = binary_comb.get_omega(m_B,m_D)
t_invert = [ [ 1 -x for x in row ] for row in reversed(t)]
#print(t, t_invert)
lines.append('\\begin{tikzpicture}[scale=.5]')
lines.append('\\node at (0,' + str(size/2) + ') {')
lines.append(util.to_tex_ytableau(t_invert))
lines.append('};')
lines.append('\\begin{scope}[shift={(' + str(1 * size -1) + ',1)}]')
lines.append(binary_comb.to_tangle2(t_cliff_omega))
lines.append('\\end{scope}')
lines.append('\\begin{scope}[shift={(' + str(2.5*size -1) + ',1)}]')
lines.append(binary_comb.to_tangle2(t_combed_omega))
lines.append('\\end{scope}')
lines.append('\\node at (' + str(4 * size) + ',' + str(size/2) + ') {')
lines.append(util.to_tex_ytableau(util.flip_triangle2(matrix_to_ssyt(m))))
lines.append('};')
lines.append('\\node at (' + str(5.5 * size) + ',' + str(size/2) + ') {')
lines.append(util.to_tex_ytableau(m))
lines.append('};')
lines.append('\\begin{scope}[shift={( ' + str(6.5 * size) + ',0)}]')
lines.append(binary_comb.to_tangle(m_omega))
lines.append('\\end{scope}')
lines.append('\\node at (' + str(7.5 * size) + ',0) {' + str(count) + '};')
lines.append('\\end{tikzpicture}')
lines.append('')
lines.append('\\end{document}')
out_file.writelines(["%s\n" % item for item in lines])
