How to do an oriented resolution of a crossing in a PD-code of a knot

Question

Given a PD-code of a knot diagram (see here for what a PD-code is https://knotinfo.math.indiana.edu/descriptions/pd_notation.html), I want to obtain the PD-code of the link which is obtained by doing an oriented resolution (the resolution of a crossing which respects the orientation) on a given crossing.

Given a crossing $(a, b, c, d)$ my initial idea was to first detect if the crossing is positive or negative. If it is positive, I identify $d$ with $c$ and $b$ with $a$, since they will become the same strand. I do this by assigning $d$ to every $c$ value in the pd-code and assigning $b$ to every a value in the PD-code. If the crossing is negative, I do the same except that I identify $c$ with $b$ and $d$ with $a$.

Unfortunately this gave me contradictory results, implying that this was not doing an oriented resolution after all. The contradiction was that a knot which had smooth slice genus bigger than $5$, was transformed into a knot having slice genus 1 (maybe it gave the resulting components the wrong orientation before doing the second resolution?). This contradicts Lemma $5$ in (https://arxiv.org/abs/1508.01098), saying that every such pair of knots must have smooth slice genus differing by at most $1$.

Prof. Brittenham and Prof. Hermiller have implemented oriented resolutions in this paper: https://arxiv.org/abs/2112.14925

The code is available at https://www.math.unl.edu/~mbrittenham2/knot_data/4genus/ There, the oriented resolution for pd codes is implemented in the file 17cr_cross_switch_resol_codeW_via_PDcodes--final1.txt contained in later_runs_last3.zip

The code is very long, and I have ran what I think should do the oriented resolutions, but I keep getting errors, since I am most likely missing something. Somehow the function resolve_crossing(n,pd,find_pairs(pd)) creates wrong pd codes, even after I use the code above to validate it first.

If someone sees how this code can easily be used to to oriented resolutions on PD-codes, I would be happy as well.

So does anybody know how to implement oriented resolutions in the language of PD-codes? If one can implement oriented resolutions in the language of DT-codes (which I think is even harder) I would be equally happy. I know that in the language of braid words, oriented resolutions are just deletions in the braid word, but unfortunately one can only do them in diagrams of braid closures. Is there maybe another link diagram notation in which one can easily implement these oriented resolutions? Or another software which can do this ?(I am working with SnapPy inside Sage). I want this to be able to run for big families automatically, not by hand in a diagram.

Thank you for your time.

Answer 1

It is not optimized or anything but here is the code:

import numpy as np

def L0res(PD, crs):   #crossing crs counted from 0
    exe2 = [val10 for ind10, val10 in enumerate(PD) if ind10 != crs]
    cr = PD[crs]
    if cr[3]-cr[1] == 1 or cr[3]-cr[1]<-1:
        luzne1, luzne2 = [[cr[0],cr[3]],[cr[1],cr[2]]]
    else:
        luzne1, luzne2 = [[cr[0],cr[1]],[cr[3],cr[2]]]
    exe7 = [[min(luzne1) if val4 == max(luzne1) else val4 for it4, val4 in enumerate(it3)] for it3 in exe2]
    exe8 = [[min(luzne2) if val4 == max(luzne2) else val4 for it4, val4 in enumerate(it3)] for it3 in exe7]
    exe1 = exe8
    liczbaskrz=len(exe1)
    exe3=[list(map(lambda x:x+100*liczbaskrz, value1)) for index1, value1 in enumerate(exe1)]
    dluG=0
    liczbaskrz=len(exe1)
    skladowE=[]
    wykorzystaneIndeksy=[]
    while True:    
        alfabetEtykiet=list(set([value2 for index1,value1 in enumerate(exe1) for index2,
                                 value2 in enumerate(value1)]))
        pomoc7=list(set(alfabetEtykiet).difference(wykorzystaneIndeksy))
        if len(pomoc7)==0:
            break
        else:
            element1=min(pomoc7)
            pomoc8=[[index1,index2] for index1,value1 in enumerate(exe1) for index2,value2 in enumerate(value1) 
                                 if (value2==element1)]
            indeksSkrzyzowania=pomoc8[0][0]
            skrzyz1=exe1[indeksSkrzyzowania]
            it2=pomoc8[0][1]
            skladowA=[]
            skladowA.append(element1)
            element2=skrzyz1[(it2+2) % 4]
            skladowA.append(element2)
            wykorzystaneIndeksy.append(element1)
            wykorzystaneIndeksy.append(element2)
            while True:
                pomoc1=[index1 for index1,value1 in enumerate(exe1) for index2,value2 in enumerate(value1) 
                                     if (value2==element2)]
                pomoc2=set(pomoc1).difference(set([indeksSkrzyzowania]))
                pomoc3=(indeksSkrzyzowania if len(pomoc2)==0 else list(set(pomoc1).difference(set([indeksSkrzyzowania])))[0])
                indeksSkrzyzowania=pomoc3
                pomoc4=[[index1,index2] for index1,value1 in enumerate(exe1) for index2,value2 in enumerate(value1) 
                                     if (value2==element2) and (index1==indeksSkrzyzowania)]
                it2=[pomoc4[0][1] if len(pomoc4)==1 else [it4 for it3, it4 in pomoc4 if not (it4==(it2+2) % 4)][0]][0]
                skrzyz1=exe1[indeksSkrzyzowania]
                element2=skrzyz1[(it2+2) % 4]
                if element2 not in skladowA:
                    skladowA.append(element2)
                    wykorzystaneIndeksy.append(element2)
                else:
                    break
            skladowE.append(skladowA)
    skladowychLista = [(it14 if len(set(it14))>1 else [it14[0]]) for it14 in skladowE]
    for ind8, slA in enumerate(skladowychLista):
        if sum(np.sign(np.array(slA[1:]) - np.array(slA[:-1])))<0:
            slA = slA[::-1]
        for ind9, etyK in enumerate(slA):
            exe3 = [list(map(lambda x:ind9+1+dluG if x==etyK+100*len(exe3) else x, value1)) for index1, value1 in enumerate(exe3)]
        dluG=dluG+len(slA)
    return exe3

####### test:
PD1 = [[10, 2, 11, 1], [6, 4, 7, 3], [16, 6, 13, 5], [14, 10, 15, 9], [8, 16, 9, 15], [12, 14, 5, 13], [2, 12, 3, 11], [4, 8, 1, 7]]

L0res(PD1, 2)