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

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.

• Have you tried asking Brittenham and Hermiller? Email them and see what they say. Feb 28 at 16:52
• @N.Owad Yes I have. I will post an update if they answer me. Feb 28 at 17:08
• I have the code you need, and it works both for knots and links. Contact me in private if you still want it. I haven't checked the code you mention above. My function is written from the start (works with Sage and Python) and doesn't use the SnapPy functions, because when I try to use them (a few years ago) I spotted some errors in the package. Mar 9 at 20:25
• @knotMJ That would be great! But how can I contact you privately? Mar 10 at 12:35
• I guess in this service we can't send a private message, so I passed the code below in response. Mar 10 at 14:11

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
exe3=[list(map(lambda x:x+100*liczbaskrz, value1)) for index1, value1 in enumerate(exe1)]
dluG=0
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]
element2=skrzyz1[(it2+2) % 4]
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]
wykorzystaneIndeksy.append(element2)
else:
break