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])