#import "@preview/touying:0.6.1": *
#import "./presentation/theme.typ": *
#import "@preview/cetz:0.3.2"
#import "@preview/fletcher:0.5.4" as fletcher: edge, node
#import "@preview/numbly:0.1.0": numbly

#import "@preview/pinit:0.2.2": *
#import "@preview/fletcher:0.5.1"

#import "skein.typ": *

#let cetz-canvas = touying-reducer.with(reduce: cetz.canvas, cover: cetz.draw.hide.with(bounds: true))

#let fletcher-diagram = touying-reducer.with(reduce: fletcher.diagram, cover: fletcher.hide)

#show: dm-unipi-theme.with(aspect-ratio: "4-3", config-info(
  title: [Il Polinomio di Kauffman: un invariante di isotopia regolare],
  subtitle: [Tesi di Laurea Triennale],
  author: [Antonio De Lucreziis],
  date: [18 Luglio 2025],
  institution: [Dipartimento di Matematica \ Università di Pisa],
  logo: image("assets/dm-unipi-logo-bianco.png"),
))

#set text(font: "Open Sans", weight: 400, size: 16pt)
#show math.equation: set text(size: 19pt)
#show strong: it => text(weight: 600, it.body)

#set par(spacing: 1.5em)
#set list(indent: 0.5em, body-indent: 0.75em, spacing: 1.5em)
#set enum(numbering: "i.a)", indent: 0.5em, body-indent: 0.75em, spacing: 1.5em)

#show figure.caption: caption => block(inset: (x: 2em), {
  set align(left)
  set text(size: 15pt)
  caption.body
})


#title-slide()

= Teoria dei Nodi

== Nodi e Diagrammi


*Nodo.* $K subset bb(R)^3$ è un *nodo (tame)* se $exists f : bb(S)^1 arrow.hook bb(R)^3$ _embedding loc. piatto_ con $K = f(bb(S)^1)$

*Link.* $bb(S)^1 arrow bb(R)^3 ~> bb(S)^1 union.sq dots.c union.sq bb(S)^1 arrow bb(R)^3$

#pause

\

*Def.* $K_0, K_1$ sono equivalenti se $exists H : bb(R)^3 times [0, 1] arrow bb(R)^3$ *isotopia ambiente*, ovvero tale che:

- $forall t in [0, 1], H(dot, t)$ è un omeomorfismo

e posta $H_t (x) colon.eq H(x, t)$ si ha:

- $H_0 = id_(bb(R)^3)$

- $H_1(K_0) = K_1$

#pause

\

*Def.* Dato un _link_ $L subset RR^3$ esiste un suo *diagramma* $D subset RR^2$ attraverso una proiezione regolare. I punti doppi del diagramma sono detti *incroci*.

// SPEAKER NOTE: In particolare in corrispondenza dei punti doppi, che chiameremo incroci, aggiungiamo l'informazione sopra-sotto.

== Teorema di Reidemeister

Le mosse *I, II, III* in figura, sono dette *mosse di Reidemeister*.

*Teorema (di Reidemeister).* Due diagrammi di link _equivalenti_ sono collegati da una _successione finita di mosse di Reidemeister_ e isotopie planari.

#v(1em)

#figure(image("assets/reidemeister-moves.jpg", height: 9cm))

== Isotopia Regolare

#slide[
  #set align(center)

  #block([
    #set align(left)

    L'*isotopia regolare* è la relazione di equivalenza su diagrammi di link \ generata solo dalle mosse II e III.
  ])

  #figure(image("assets/ambient-regular-isotopy-difference.jpg", height: 7cm))
]

== Writhe

Il *segno* di un incrocio di un diagramma orientato è: $epsilon(#skein-generic(size-factor: 1.5, direction: (+1, +1))) = +1, epsilon(#skein-generic(size-factor: 1.5, direction: (+1, -1))) = -1$

$D$ diagramma di un link orientato, il *writhe* $display(w(D) colon.eq sum_(c "incrocio") epsilon(c))$.

#figure(image("assets/writhe-examples.png", width: 15cm))

#pause

*Prop.* Se $D$ è il diagramma di un nodo, il _writhe_ *non dipende dall'orientazione*.

#pause

*Prop.* Il writhe è un *invariante di isotopia regolare*, ovvero $D_1 tilde D_2 => w(D_1) = w(D_2)$.

= Polinomio di Kauffman

== Assiomi

Dimostreremo che per ogni _diagramma di link non orientato_ $D$, esiste un polinomio $L_D$ con $L_D in bb(Z)[a, a^(-1), z, z^(-1)]$ invariante di _isotopia regolare_ e che verifica i seguenti assiomi:

#set enum(numbering: "i.a)")

1. $D tilde D' => L_D = L_D'$.

2. Valgono le seguenti relazioni:

  1. $L[#skein.over-large] + L[#skein.under-large] = z (L[#skein.h-large] + L[#skein.v-large])$

  2. $L[#skein.unit-large] = 1$

  3. $L[#skein.over-twist-large] = a L[#skein.strand-large]$

  4. $L[#skein.under-twist-large] = a^(-1) L[#skein.strand-large]$

== Normalizzazione a invariante di isotopia ambiente

*Definizione.* $F_D (a, z) colon.eq a^(-w(D)) dot L_D (a, z)$

#pause

#v(1em)

*Prop.* $F_D$ invariante di isotopia ambiente.

_Dimostrazione._

- $w(D)$ invariante di _isotopia regolare_ $=> a^(-w(D))$ invariante di _isotopia regolare_.

#pause

- #grid(
    columns: (1fr, auto),
    align: (left, left, right),
    row-gutter: 1.75em,
    // stroke: 1pt,

    [
      $F[ #skein.over-twist-large ] = a^(-w(#skein.over-twist)) dot L[ #skein.over-twist-large ]$
    ],
    {
      show math.equation: set text(size: 16pt)
      $pause lr((L[#skein.over-twist] = a L[#skein.strand], quad w(#skein.over-twist) = w(#skein.strand) + 1), size: #1.5em)$
    },

    $pause #h(3.9em) = a^(-w(#skein.strand) - 1) dot a L[ #skein.strand-large ]$, [],

    $pause #h(3.9em) = a^(-w(#skein.strand)) cancel(stroke: #1pt, a^(-1)) dot cancel(stroke: #1pt, a) L[ #skein.strand-large ]$,
    [],

    $pause #h(3.9em) = a^(-w(#skein.strand)) dot L[ #skein.strand-large ]$, [],

    $pause #h(3.9em) = F[ #skein.strand-large ]$, [],
  )

// SPEAKER NOTE: Per lo stesso diagramma senza quel ricciolo

== Calcoli impliciti

#let knot-picture(src, ..rest) = $thin #image("assets/derived/atlas-" + src, ..rest) thin$

// #show image: it => rect(stroke: 1pt + red, inset: 0pt, it)

#slide(repeat: 8, self => [
  #let (alternatives,) = utils.methods(self)
  #set align(center + top)

  #v(7em)

  #alternatives(position: center + top)[
    #grid(
      columns: 1,
      row-gutter: 1.5em,
      column-gutter: 3em,
      align: center,
      [*Calcolo di $L[#skein.unit-large #skein.unit-large]$*],
    )
  ][
    #grid(
      columns: 1,
      row-gutter: 1.5em,
      column-gutter: 3em,
      align: center,
      [*Calcolo di $L[#skein.unit-large #skein.unit-large]$*],
      $
        (
        space & #knot-picture("infinity-0.png", width: 1.075em) space,
                space && #knot-picture("infinity-1.png", width: 1.075em) space,
                         space && #knot-picture("infinity-2.png", width: 1.075em) space,
                                  space && #knot-picture("infinity-3.png", width: 1.075em) space
                                           ) \
        text(
          fill: #white,
          L[ & thin #rect(width: 1.075em, height: 2.25em, stroke: none) thin ]
               +
               L[ && thin #rect(width: 1.075em, height: 2.25em, stroke: none) thin ] =
                     z (
                     L[ && thin #rect(width: 1.075em, height: 2.25em, stroke: none) thin ]
                           +
                           L[ && thin #rect(width: 1.075em, height: 2.25em, stroke: none) thin ]
                                 )
        )
      $,
    )
  ][
    #grid(
      columns: 1,
      row-gutter: 1.5em,
      column-gutter: 3em,
      align: center,
      [*Calcolo di $L[#skein.unit-large #skein.unit-large]$*],
      $
        & L[ #knot-picture("infinity-0.png", height: 2.25em) ]
          +
          L[ #knot-picture("infinity-1.png", height: 2.25em) ] =
          z (
            L[ #knot-picture("infinity-2.png", height: 2.25em) ]
            +
            L[ #knot-picture("infinity-3.png", height: 2.25em) ]
          )
      $,
    )
  ][
    #grid(
      columns: 1,
      row-gutter: 1.5em,
      column-gutter: 3em,
      align: center,
      [*Calcolo di $L[#skein.unit-large #skein.unit-large]$*],
      $
        & L[ #knot-picture("infinity-0.png", height: 2.25em) ]
          +
          L[ #knot-picture("infinity-1.png", height: 2.25em) ] =
          z (
            L[ #knot-picture("infinity-2.png", height: 2.25em) ]
            +
            L[ #knot-picture("infinity-3.png", height: 2.25em) ]
          ) \
        & =>
          a L[ #skein.unit-large ]
          +
          a^(-1) L[ #skein.unit-large ] =
          z (
            delta
            +
            L [ #skein.unit-large ]
          )
      $,
    )
  ][
    #grid(
      columns: 1,
      row-gutter: 1.5em,
      column-gutter: 3em,
      align: center,
      [*Calcolo di $L[#skein.unit-large #skein.unit-large]$*],
      $
        & L[ #knot-picture("infinity-0.png", height: 2.25em) ]
          +
          L[ #knot-picture("infinity-1.png", height: 2.25em) ] =
          z (
            L[ #knot-picture("infinity-2.png", height: 2.25em) ]
            +
            L[ #knot-picture("infinity-3.png", height: 2.25em) ]
          )                               \
        & =>
          a L[ #skein.unit-large ]
          +
          a^(-1) L[ #skein.unit-large ] =
          z (
            delta
            +
            L [ #skein.unit-large ]
          )                               \
        & => a + a^(-1) = z ( delta + 1 )
      $,
    )
  ][
    #grid(
      columns: 1,
      row-gutter: 1.5em,
      column-gutter: 3em,
      align: center,
      [*Calcolo di $L[#skein.unit-large #skein.unit-large]$*],
      $
        & L[ #knot-picture("infinity-0.png", height: 2.25em) ]
          +
          L[ #knot-picture("infinity-1.png", height: 2.25em) ] =
          z (
            L[ #knot-picture("infinity-2.png", height: 2.25em) ]
            +
            L[ #knot-picture("infinity-3.png", height: 2.25em) ]
          )                                  \
        & =>
          a L[ #skein.unit-large ]
          +
          a^(-1) L[ #skein.unit-large ] =
          z (
            delta
            +
            L [ #skein.unit-large ]
          )                                  \
        & => a + a^(-1) = z ( delta + 1 )    \
        & => delta = (a + 1 slash a) / z - 1
      $,
    )
  ][
    #grid(
      columns: 1,
      row-gutter: 1.5em,
      column-gutter: 3em,
      align: center,
      [*Calcolo di $L[#skein.unit-large #skein.unit-large]$*],
      {
        $
          & L[ #knot-picture("infinity-0.png", height: 2.25em) ]
            +
            L[ #knot-picture("infinity-1.png", height: 2.25em) ] =
            z (
              L[ #knot-picture("infinity-2.png", height: 2.25em) ]
              +
              L[ #knot-picture("infinity-3.png", height: 2.25em) ]
            )                                  \
          & =>
            a L[ #skein.unit-large ]
            +
            a^(-1) L[ #skein.unit-large ] =
            z (
              delta
              +
              L [ #skein.unit-large ]
            )                                  \
          & => a + a^(-1) = z ( delta + 1 )    \
          & => delta = (a + 1 slash a) / z - 1
        $

        $
          ~> L[D_1 union.sq D_2] = delta L[D_1] L[D_2]
        $
      },
    )
  ][
    #grid(
      columns: 2,
      gutter: 2em,

      align: center + top,

      {
        grid(
          columns: 1,
          row-gutter: 1.5em,
          column-gutter: 3em,
          align: center,
          [*Calcolo di $L[#skein.unit-large #skein.unit-large]$*],
          {
            $
              & L[ #knot-picture("infinity-0.png", height: 2.25em) ]
                +
                L[ #knot-picture("infinity-1.png", height: 2.25em) ] =
                z (
                  L[ #knot-picture("infinity-2.png", height: 2.25em) ]
                  +
                  L[ #knot-picture("infinity-3.png", height: 2.25em) ]
                )                                  \
              & =>
                a L[ #skein.unit-large ]
                +
                a^(-1) L[ #skein.unit-large ] =
                z (
                  delta
                  +
                  L [ #skein.unit-large ]
                )                                  \
              & => a + a^(-1) = z ( delta + 1 )    \
              & => delta = (a + 1 slash a) / z - 1
            $

            $
              ~> L[D_1 union.sq D_2] = delta L[D_1] L[D_2]
            $
          },
        )
      },
      {
        set text(size: 11pt)
        show math.equation: set text(size: 13pt)

        grid(
          columns: 1,
          row-gutter: 1.5em,
          align: center + horizon,

          [ *Link di Hopf*],

          $
            & L[ #knot-picture("hopf-0.png", height: 1.75em) ]
              +
              L[ #knot-picture("hopf-1.png", height: 1.75em) ] =
              z (
                L[ #knot-picture("hopf-2.png", height: 1.75em) ]
                +
                L[ #knot-picture("hopf-3.png", height: 1.75em) ]
              )                                          \
            & =>
              L[ #knot-picture("hopf-0.png", height: 1.75em) ]
              +
              delta =
              z (
                a
                +
                a^(-1)
              )                                          \
            & =>
              L[ #knot-picture("hopf-0.png", height: 1.75em) ] =
              - (a + a^(-1)) z^(-1) + 1 + (a + a^(-1)) z
          $,

          [ *Nodo trifoglio*],
          $
            & L[ #knot-picture("trefoil-0.png", height: 2em) ]
              +
              L[ #knot-picture("trefoil-1.png", height: 2em) ] =
              z (
                L[ #knot-picture("trefoil-2.png", height: 2em) ]
                +
                L[ #knot-picture("trefoil-3.png", height: 2em) ]
              )                                                  \
            & =>
              L[ #knot-picture("trefoil-0.png", height: 2em) ]
              +
              a =
              z (
                L[ #knot-picture("hopf-0.png", height: 1.75em) ]
                +
                a^(-2)
              )                                                  \
            & =>
              L[ #knot-picture("trefoil-0.png", height: 2em) ] =
              -(2a + a^(-1)) + (1 + a^(-2)) z + (a + a^(-1)) z^2
          $,
        )
      },
    )
  ]
])

== Considerazioni preliminari

#slide({
  set align(center)

  [Sia $D$ un diagramma di un link, $i$ etichetta di uno degli incroci:]

  v(1.5em)

  grid(
    columns: 4,
    column-gutter: 2em,
    row-gutter: 1em,
    align: center,
    {
      skein.over-large
      place(center + top, dy: -0.75em, {
        show math.equation: set text(size: 15pt)
        $i$
      })
    },
    {
      skein.under-large
      place(center + top, dy: -0.75em, {
        show math.equation: set text(size: 15pt)
        $i$
      })
    },
    {
      skein.h-large
      place(center + top, dy: -0.75em, {
        show math.equation: set text(size: 15pt)
        $i$
      })
    },
    {
      skein.v-large
      place(center + top, dy: -0.75em, {
        show math.equation: set text(size: 15pt)
        $i$
      })
    },

    $D$, $S_i D$, $E_i D$, $e_i D$,
  )
})

== Considerazioni preliminari

#align(center)[
  Il *nodo banale standard* (o in _forma discendente_) associato a $D$ è $hat(D)(cal(U), p)$:

  #alternatives[
    #move(dx: -1pt, image("assets/derived/std-unknot-1-cropped.jpg", height: 8cm))

    #grid(
      columns: (1fr, 1fr, 1fr, 1fr, 1fr),
      align: center,
      [], $D$, [], $hat(D)(cal(U), p)$, [],
    )

    $space$
  ][
    #image("assets/derived/std-unknot-2-cropped.jpg", height: 8cm)

    #grid(
      columns: (1fr, 1fr, 1fr, 1fr, 1fr),
      align: center,
      [],
      $D$,
      {
        show math.equation: set text(size: 16pt)
        $~> lambda=(6,4,2,1) ~>$
      },
      $hat(D)(cal(U), p)$,
      [],
    )

    $space$
  ][
    #image("assets/derived/std-unknot-2-cropped.jpg", height: 8cm)

    #grid(
      columns: (1fr, 1fr, 1fr, 1fr, 1fr),
      align: center,
      [],
      $D$,
      {
        show math.equation: set text(size: 16pt)
        $~> lambda=(6,4,2,1) ~>$
      },
      $hat(D)(cal(U), p)$,
      [],
    )

    $hat(D)(p) = S_6 S_4 S_2 S_1 D$
  ]
]

== Considerazioni preliminari

#let dotss = $space dots.c space$

#slide(
  repeat: 5,
  self => {
    let (only, uncover) = utils.methods(self)

    {
      set align(center)
      [Sia $p$ punto base direzionato, $lambda = (n, dots, 0)$ una sequenza di scambi che porta $D$ a $hat(D)(p)$:]
    }

    show math.equation: set text(size: 18pt)

    only(
      "1-4",
      $
        & L[D] + L[S_0 D] = z( L[E_0 D] + L[e_0 D] )                                                                 \
        & pause L[S_0 D] + L[S_1 S_0 D] = z( L[E_1 S_0 D] + L[e_1 S_0 D] )                                           \
        & pause L[S_1 S_0 D] + L[S_2 S_1 S_0 D] = z( L[E_1 S_1 S_0 D] + L[e_1 S_1 S_0 D] )                           \
        & space dots.v                                                                                               \
        & pause L[S_(n-1) dotss S_0 D] + L [hat(D)(p)] = z (L[E_n S_(n-1) dotss S_0 D] + L[e_n S_(n-1) dotss S_0 D])
      $,
    )

    only(
      5,
      $
                 & L[D] + L[S_0 D] = z( L[E_0 D] + L[e_0 D] )                                                                   \
              -( & L[S_0 D] + L[S_1 S_0 D]) = -z( L[E_1 S_0 D] + L[e_1 S_0 D] )                                                 \
                 & L[S_1 S_0 D] + L[S_2 S_1 S_0 D] = z( L[E_1 S_1 S_0 D] + L[e_1 S_1 S_0 D] )                                   \
                 & space dots.v                                                                                                 \
        (-1)^n ( & L[S_(n-1) dotss S_0 D] + L [hat(D)(p)]) = (-1)^n z (L[E_n S_(n-1) dotss S_0 D] + L[e_n S_(n-1) dotss S_0 D])
      $,
    )

    only(
      6,
      $
        & L[D] + cancel(L[S_0 D]) = z( L[E_0 D] + L[e_0 D] ) \
        -(& cancel(L[S_0 D]) + cancel(L[S_1 S_0 D])) = -z( L[E_1 S_0 D] + L[e_1 S_0 D] ) \
        & cancel(L[S_1 S_0 D]) + cancel(L[S_2 S_1 S_0 D]) = z( L[E_1 S_1 S_0 D] + L[e_1 S_1 S_0 D]) \
        & space dots.v \
        (-1)^n (& cancel(L[S_(n-1) dotss S_0 D]) + L [hat(D)(p)]) = (-1)^n z (L[E_n S_(n-1) dotss S_0 D] + L[e_n S_(n-1) dotss S_0 D])
      $,
    )

    {
      set text(fill: white)

      v(1.5em)

      h(4.4em)
      $display(
        => L[D] + (-1)^n L[hat(D)(p)] =
        z sum_(i=0)^n (-1)^i (
          L[E_i S_(i-1) dotss S_0 D] + L[e_i S_(i-1) dotss S_0 D]
        )
      )$
    }
  },
)

#slide({
  {
    set align(center)
    [Sia $p$ punto base direzionato, $lambda = (n, dots, 0)$ una sequenza di scambi che porta $D$ a $hat(D)(p)$:]
  }

  show math.equation: set text(size: 18pt)

  $
    & L[D] + cancel(L[S_0 D]) = z( L[E_0 D] + L[e_0 D] ) \
    -(& cancel(L[S_0 D]) + cancel(L[S_1 S_0 D])) = -z( L[E_1 S_0 D] + L[e_1 S_0 D] ) \
    & cancel(L[S_1 S_0 D]) + cancel(L[S_2 S_1 S_0 D]) = z( L[E_1 S_1 S_0 D] + L[e_1 S_1 S_0 D]) \
    & space dots.v \
    (-1)^n (& cancel(L[S_(n-1) dotss S_0 D]) + L [hat(D)(p)]) = (-1)^n z (L[E_n S_(n-1) dotss S_0 D] + L[e_n S_(n-1) dotss S_0 D])
  $

  v(1.5em)

  h(4.4em)
  $display(
    => L[D] + (-1)^n L[hat(D)(p)] =
    z sum_(i=0)^n (-1)^i lr(
      (
        L[E_i S_(i-1) dotss S_0 D] + L[e_i S_(i-1) dotss S_0 D]
      ), size: #1em
    )
  )$
})


#slide(
  repeat: 5,
  self => {
    let (alternatives,) = utils.methods(self)

    {
      set align(center)
      [Sia $p$ punto base direzionato, $lambda = (n, dots, 0)$ una sequenza di scambi che porta $D$ a $hat(D)(p)$:]
    }

    show math.equation: set text(size: 18pt)

    $
      & L[D] + cancel(L[S_0 D]) = z( L[E_0 D] + L[e_0 D] ) \
      -(& cancel(L[S_0 D]) + cancel(L[S_1 S_0 D])) = -z( L[E_1 S_0 D] + L[e_1 S_0 D] ) \
      & cancel(L[S_1 S_0 D]) + cancel(L[S_2 S_1 S_0 D]) = z( L[E_1 S_1 S_0 D] + L[e_1 S_1 S_0 D]) \
      & space dots.v \
      (-1)^n (& cancel(L[S_(n-1) dotss S_0 D]) + L [hat(D)(p)]) = (-1)^n z (L[E_n S_(n-1) dotss S_0 D] + L[e_n S_(n-1) dotss S_0 D])
    $

    v(1.5em)

    h(4.4em)

    alternatives(
      {
        show math.equation: set text(size: 18pt)

        $display(
          => L[D] + (-1)^n L[hat(D)(p)] =
          z #h(-0.125pt) #pin(1) sum_(i=0)^n (-1)^i lr(
            (
              L[E_i S_(i-1) dotss S_0 D] + L[e_i S_(i-1) dotss S_0 D]
            ), size: #1em
          ) #pin(2)
        )$

        pinit-place(
          (1,),
          dy: 1.25em,
          $
            underbrace(
              #h(21.5em), #{
                show math.equation: set text(size: 16pt)

                move(dy: 0.75em, $display("Notazione: " sum_D (lambda(p)))$)
              }
            )
          $,
        )
      },
      {
        show math.equation: set text(size: 18pt)

        $display(
          => L[D] + (-1)^n L[hat(D)(p)] =
          z sum_D^text(fill: #white, n) (lambda(p))
        )$
      },
      {
        show math.equation: set text(size: 18pt)

        $display(
          => L[D] =
          (-1)^(n+1) L[hat(D)(p)]
          + z sum_D^text(fill: #white, n) (lambda(p))
        )$
      },
      {
        show math.equation: set text(size: 18pt)

        $display(
          => L[D] =
          (-1)^(abs(lambda(p))+1) L[hat(D)(p)]
          + z sum_D^text(fill: #white, n) (lambda(p))
        )$
      },
      {
        show math.equation: set text(size: 18pt)

        $display(
          => L[D] =
          #h(-1pt)
          #pin(1)
          (-1)^(abs(lambda(p))+1) L[hat(D)(p)]
          + z sum_D^text(fill: #white, n) (lambda(p))
          #pin(2)
        )$

        pinit-highlight(1, 2, dy: -1.75em, dx: 3pt, extended-height: 3em, fill: rgb("#0002"))
      },
    )
  },
)

// #slide({
//   {
//     set align(center)
//     [Sia $p$ punto base direzionato, $lambda = (n, dots, 0)$ una sequenza di scambi che porta $D$ a $hat(D)(p)$:]
//   }

//   show math.equation: set text(size: 18pt)

//   $
//     & L[D] + cancel(L[S_0 D]) = z( L[E_0 D] + L[e_0 D] ) \
//     -(& cancel(L[S_0 D]) + cancel(L[S_1 S_0 D])) = -z( L[E_1 S_0 D] + L[e_1 S_0 D] ) \
//     & cancel(L[S_1 S_0 D]) + cancel(L[S_2 S_1 S_0 D]) = z( L[E_1 S_1 S_0 D] + L[e_1 S_1 S_0 D]) \
//     & space dots.v \
//     (-1)^n (& cancel(L[S_(n-1) dotss S_0 D]) + L [hat(D)(p)]) = (-1)^n z (L[E_n S_(n-1) dotss S_0 D] + L[e_n S_(n-1) dotss S_0 D])
//   $

//   v(1.5em)

//   h(4.4em)

// })

// #slide({
//   {
//     set align(center)
//     [Sia $p$ punto base direzionato, $lambda = (n, dots, 0)$ una sequenza di scambi che porta $D$ a $hat(D)(p)$:]
//   }

//   show math.equation: set text(size: 18pt)

//   $
//     & L[D] + cancel(L[S_0 D]) = z( L[E_0 D] + L[e_0 D] ) \
//     -(& cancel(L[S_0 D]) + cancel(L[S_1 S_0 D])) = -z( L[E_1 S_0 D] + L[e_1 S_0 D] ) \
//     & cancel(L[S_1 S_0 D]) + cancel(L[S_2 S_1 S_0 D]) = z( L[E_1 S_1 S_0 D] + L[e_1 S_1 S_0 D]) \
//     & space dots.v \
//     (-1)^n (& cancel(L[S_(n-1) dotss S_0 D]) + L [hat(D)(p)]) = (-1)^n z (L[E_n S_(n-1) dotss S_0 D] + L[e_n S_(n-1) dotss S_0 D])
//   $

//   v(1.5em)

//   h(4.4em)
//   $display(
//     => L[D] =
//     (-1)^(n+1) L[hat(D)(p)]
//     + z sum_D^text(fill: #white, n) (lambda(p))
//   )$
// })

// #slide({
//   {
//     set align(center)
//     [Sia $p$ punto base direzionato, $lambda = (n, dots, 0)$ una sequenza di scambi che porta $D$ a $hat(D)(p)$:]
//   }

//   show math.equation: set text(size: 18pt)

//   $
//     & L[D] + cancel(L[S_0 D]) = z( L[E_0 D] + L[e_0 D] ) \
//     -(& cancel(L[S_0 D]) + cancel(L[S_1 S_0 D])) = -z( L[E_1 S_0 D] + L[e_1 S_0 D] ) \
//     & cancel(L[S_1 S_0 D]) + cancel(L[S_2 S_1 S_0 D]) = z( L[E_1 S_1 S_0 D] + L[e_1 S_1 S_0 D]) \
//     & space dots.v \
//     (-1)^n (& cancel(L[S_(n-1) dotss S_0 D]) + L [hat(D)(p)]) = (-1)^n z (L[E_n S_(n-1) dotss S_0 D] + L[e_n S_(n-1) dotss S_0 D])
//   $

//   v(1.5em)

//   h(4.4em)
//   $display(
//     => L[D] =
//     (-1)^(abs(lambda(p))+1) L[hat(D)(p)]
//     + z sum_D^text(fill: #white, n) (lambda(p))
//   )$
// })

// #slide({
//   {
//     set align(center)
//     [Sia $p$ punto base direzionato, $lambda = (n, dots, 0)$ una sequenza di scambi che porta $D$ a $hat(D)(p)$:]
//   }

//   show math.equation: set text(size: 18pt)

//   $
//     & L[D] + cancel(L[S_0 D]) = z( L[E_0 D] + L[e_0 D] ) \
//     -(& cancel(L[S_0 D]) + cancel(L[S_1 S_0 D])) = -z( L[E_1 S_0 D] + L[e_1 S_0 D] ) \
//     & cancel(L[S_1 S_0 D]) + cancel(L[S_2 S_1 S_0 D]) = z( L[E_1 S_1 S_0 D] + L[e_1 S_1 S_0 D]) \
//     & space dots.v \
//     (-1)^n (& cancel(L[S_(n-1) dotss S_0 D]) + L [hat(D)(p)]) = (-1)^n z (L[E_n S_(n-1) dotss S_0 D] + L[e_n S_(n-1) dotss S_0 D])
//   $

//   v(1.5em)

//   h(4.4em)
//   $display(
//     => L[D] =
//     #h(-1pt)
//     #pin(1)
//     (-1)^(abs(lambda(p))+1) L[hat(D)(p)]
//     + z sum_D^text(fill: #white, n) (lambda(p))
//     #pin(2)
//   )$

//   pinit-highlight(1, 2, dy: -1.75em, dx: 3pt, extended-height: 3em, fill: rgb("#0002"))
// })

// SPEAKER NOTE: Scambiamo i segni in modo alternato delle equazioni ottenute.

== Definizione induttiva

#slide(
  repeat: 3,
  self => [
    #let (alternatives,) = utils.methods(self)

    #set align(top)

    #v(7em)

    #alternatives[

      Definiamo ora il polinomio $L_(D)(a,z)$ induttivamente come segue:

      1. Se $D$ è in _forma discendente_: $L_D (a, z) colon.eq a^w(D)$

      2. Se $D = D_1 union D_2$: $L(D_1 union D_2) colon.eq delta L(D_1) L(D_2)$ #h(1fr) $("con " delta colon.eq (a + 1 slash a) / z - 1)$

      3. Altrimenti $D = D_1 union dotss union D_n$:

        #v(0.75em)

        a) #h(0.35em) Se $n > 1$: $display(
          L_D (a, z) colon.eq
          1 / n
          sum_(i=1)^n
          ((-1)^(abs(lambda(p_i))+1) delta L_(D_i) L_(D - D_i) + z sum_D (lambda(p_i)))
        ) #rect(stroke: none, height: 3.5em, width: 1pt)$

        #v(1.5em)

        b) #h(0.35em) Se $n=1$: $display(
          L_D (a, z) colon.eq
          #h(-1pt) #pin(1) (-1)^(abs(lambda(p))+1) L[hat(D)(p)] + z sum_D (lambda(p)) #pin(2)
           // display((-1)^(abs(lambda(p))+1) L[hat(D)(p)] + z sum_D (lambda(p)))
        ) #rect(stroke: none, height: 3.5em, width: 1pt)$

        #pinit-highlight(1, 2, dy: -2em, dx: 3pt, extended-height: 3.5em, fill: rgb("#0002"))
    ][

      Definiamo ora il polinomio $L_(D)(a,z)$ induttivamente come segue:

      1. Se $D$ è in _forma discendente_: $L_D (a, z) colon.eq a^w(D)$

      2. Se $D = D_1 union D_2$: $L(D_1 union D_2) colon.eq delta L(D_1) L(D_2)$ #h(1fr) $("con " delta colon.eq (a + 1 slash a) / z - 1)$

      3. Altrimenti $D = D_1 union dotss union D_n$:

        #v(0.75em)

        a) #h(0.35em) Se $n > 1$: $display(
          L_D (a, z) colon.eq
          1 / n
          sum_(i=1)^n
          ((-1)^(abs(lambda(p_i))+1) delta L_(D_i) L_(D - D_i) + z sum_D (lambda(p_i)))
        ) #rect(stroke: none, height: 3.5em, width: 1pt)$

        #v(1.5em)

        b) #h(0.35em) Se $n=1$: $display(
          L_D (a, z) colon.eq
          (-1)^(abs(lambda(p))+1) L[hat(D)(p)] + z sum_D (lambda(p))
        ) #rect(stroke: none, height: 3.5em, width: 1pt)$
    ][

      Definiamo ora il polinomio $L_(D)(a,z)$ induttivamente come segue:

      1. Se $D$ è in _forma discendente_: $L_D (a, z) colon.eq a^w(D)$

      2. Se $D = D_1 union D_2$: $L(D_1 union D_2) colon.eq delta L(D_1) L(D_2)$ #h(1fr) $("con " delta colon.eq (a + 1 slash a) / z - 1)$

      3. Altrimenti $D = D_1 union dotss union D_n$:

        #v(0.75em)

        a) #h(0.35em) Se $n > 1$: $display(
          L_D (a, z) colon.eq
          1 / (2n)
          sum_(i=1)^n sum_(q=p_i, overline(p)_i)
          ((-1)^(abs(lambda(q))+1) delta L_(D_i) L_(D - D_i) + z sum_D (lambda(q)))
        ) #rect(stroke: none, height: 3.5em, width: 1pt)$

        #v(1.5em)

        b) #h(0.35em) Se $n=1$: $display(
          L_D (a, z) colon.eq
          1 / 2
          sum_(q = p, overline(p))
          ((-1)^(abs(lambda(q))+1) L_(hat(D)(q)) + z sum_D (lambda(q)))
        ) #rect(stroke: none, height: 3.5em, width: 1pt)$

    ]
  ],
)

== Dimostrazione buona definizione


== Ipotesi induttiva

#slide[
  #set enum(numbering: "a)")

  *Ipotesi induttiva.* Dimostreremo induttivamente le seguenti proprietà: per ogni diagramma di link $D$ con $< N$ incroci e per diagrammi contenenti $#skein.over-twist-large$ con $< N$ incroci:

  1. $L_D$ è ben definito (non dipende dalla scelta di punto base)

  2. $L_D$ verifica gli assiomi:

    - $L[D] + L[S_i D] = z ( L[e_i D] + L[E_i D] )$

    - $L[#skein.over-twist-large] = a L [#skein.strand-large]$, $L[#skein.under-twist-large] = a^(-1) L [#skein.strand-large]$

  3. $L_D$ è invariante per mosse di tipo II e III che non aumentano il numero di incroci

  4. Per certi diagrammi vale $L_D = a^w(D)$
]

== Dimostrazione buona definizione

#slide[
  #set enum(numbering: "a)")

  _Dimostrazione._

  1. $L_D$ è ben definito (non dipende dalla scelta di punto base)

    - Invarianza $sum_D (lambda(p))$ per rotazioni

    - Caso più componenti

    - Caso una sola componente

      - Splice di un nodo in forma discendente

      - Assiomi di $L_D$ per nodi in forma discendente

  2. $L_D$ verifica gli assiomi

  3. $L_D$ è invariante per mosse di tipo II e III che non aumentano il numero di incroci

  4. Per certi diagrammi vale $L_D = a^w(D)$
]

= Laboratorio Computazionale

== Implementazione in Python

Implementazioni esistenti:

- *KnotScape* -- scritto in C, degli anni \~1990

- *KnotTheory* -- ultimo aggiornamento \~2010, per Wolfram Mathematica

#pause

Per il progetto di Laboratorio Computazionale abbiamo scritto una *nuova implementazione* in *Python* open source:

- Strutture dati per la rappresentazione di nodi con *codici P.D.* e *S.G.*

- Algoritmo per il calcolo di $L_D$ e $F_D$

#pause

- Verifica di tutti i polinomi contenuti nel *database di KnotInfo* (\~7K tra nodi e link, \~20min)

#pause

- _Trovato un errore nel nodo_ $10_125$: è presente $F[m(10_125)]$ invece di $F[10_125]$ ovvero $F[10_125](1 slash a, z)$ #h(1fr)

== Implementazione in Python

#{
  set align(center)
  set text(15pt)
  show math.equation: set text(size: 12pt)

  v(2em)

  grid(
    columns: 2,
    align: top,
    gutter: 2em,

    [*Polinomio corretto*],

    [*Polinomio in KnotInfo*],

    $
      F[10_125] = & z^8 (1 / a^2 + 1) + z^7 (a + 2 / a + 1 / a^3) + z^6 (-6 - 6 / a^2) \
                  & + space z^5 (-5 a - 11 / a - 6 / a^3)
                    + z^4 (2 a^2 + 13 + 11 / a^2)                                      \
                  & + space z^3 (a^3 + 8 a + 17 / a + 10 / a^3)
                    + z^2 (a^4 - 6 a^2 - 15 - 8 / a^2)                                 \
                  & + space z (a^5 - a^3 - 6 a - 8 / a - 4 / a^3)
                    + 3 a^2 + 7 + 3 / a^2
    $,

    $
      F[m(10_125)] = & z^8 (a^2 + 1) + z^7 (a^3 + 2 a + 1 / a) + z^6 (-6 a^2 - 6) \
                     & + space z^5 (-6 a^3 - 11 a - 5 / a)
                       + z^4 (11 a^2 + 13 + 2 / a^2)                              \
                     & + space z^3 (10 a^3 + 17 a + 8 / a + 1 / a^3)
                       + z^2 (-8 a^2 - 15 - 6 / a^2 + 1 / a^4)                    \
                     & + space z (-4 a^3 - 8 a - 6 / a - 1 / a^3 + 1 / a^5)
                       + 3 a^2 + 7 + 3 / a^2
    $,

    pad(top: -2em, image("assets/untangle-10_125.png", height: 9cm)),

    pad(top: -2em, image("assets/untangle-10_125-mirror.png", height: 9cm)),
  )
}

== Fine

#slide[
  #set align(center)
  #set text(size: 42pt)

  *Grazie per l'attenzione*
]

