Se non hai familiarità con la teoria delle trecce, ti consiglio di leggere prima questo . Questa domanda presuppone che tu abbia almeno familiarità con i concetti a portata di mano e presuppone che tu abbia familiarità con la teoria dei gruppi

Definiamo σ _n per essere la treccia in cui il n ° filamento (One indicizzato) dalla parte superiore attraversa il n + 1 esimo filo, e σ _n ^- di essere l'inverso di σ _n (Questa è la n + 1 ° filo attraversa il n ° filamento).

Il gruppo treccia B _n viene quindi generato da <σ ₁ , σ ₂ , σ ₃ ,. . . , σ _n-1 > . Pertanto ogni treccia su B _n può essere scritta come il prodotto delle trecce σ. ¹

Determinare se due trecce su un gruppo sono uguali non è un compito semplice. Può essere abbastanza ovvio che σ ₁ σ ₃ = σ ₃ σ ₁ , ma è un po 'meno ovvio che ad esempio σ ₂ σ ₁ σ ₂ = σ ₁ σ ₂ σ ₁ . ²

Quindi la domanda è "Come possiamo determinare se due trecce sono uguali?". Bene, i due esempi sopra ciascuno rappresentano un po 'di questo. In generale, sono vere le seguenti relazioni, chiamate relazioni di Artin:

• σ _i σ _j = σ _j σ _i ; i - j> 1

• σ _i σ _{i + 1} σ _i = σ _{i + 1} σ _i σ _{i + 1}

Possiamo usare queste due relazioni in congiunzione con gli assiomi di gruppo per dimostrare che tutte le trecce uguali sono uguali. Quindi due trecce sono uguali se la ripetuta applicazione di queste relazioni e gli assiomi di gruppo possono dimostrarlo.

Compito

Scriverai un programma o una funzione per prendere due trecce e determinare se sono uguali o meno. Puoi anche prendere un numero intero positivo che rappresenta l'ordine del gruppo.

Questa è una domanda di code-golf, quindi le risposte verranno classificate in byte, con meno byte migliori.

Ingresso e uscita

Dovresti rappresentare una treccia come un elenco ordinato di generatori (o qualsiasi struttura equivalente, ad es. Vettore). Puoi rappresentare i generatori in qualsiasi forma ragionevole (ad esempio un numero intero, una due tupla di un numero intero positivo e un valore booleano).

Alla pari con le regole standard del problema di decisione dovresti generare uno di due valori distinti, e accetta un rifiuto.

Casi test

[],       []              -> True
[1,-1],   []              -> True
[1,2,1],  [2,1,2]         -> True
[1,3],    [3,1]           -> True
[1,3,2,1],[3,2,1,2]       -> True
[1,4,-4,3,2,1], [3,2,1,2] -> True
[2,2,1],  [2,1,2]         -> False
[1,2,-1], [-1,2,1]        -> False
[1,1,1,2],[1,1,2]         -> False

^{1: Nota che mentre B _n soddisfa tutte le proprietà di un gruppo l'operazione sul nostro gruppo a treccia non è commutativa, e quindi il nostro gruppo non è abeliano.}

^{2: Se desideri verificarlo da solo, ti suggerisco di applicare σ ₁ - su entrambi i lati, se disegni i due su carta o li modelli con stringhe effettive, dovrebbe essere chiaro perché questo è il caso.}

Haskell , 190 byte

i!j|j<0=reverse$map(0-)$i!(-j)|i==j=[i,i+1,-i]|i+1==j=[i]|i+j==0=[j+1]|i+j==1=[-j,-i,j]
_!j=[j]
j%(k:a)|j+k==0=a
j%a=j:a
i&a=foldr(%)[]$foldr((=<<).(!))[i]a
a?n=map(&a)[1..n]
(a#b)n=a?n==b?n

Provalo online!

Come funziona

Lasciate F _n essere il gruppo libero su n generatori x ₁ , ..., x _n . Uno dei primi risultati nella teoria delle trecce (Emil Artin, Theorie der Zöpfe , 1925) è che abbiamo un omomorfismo iniettivo f : B _n → Aut ( F _n ) dove l' azione f _{σ i} di σ _i è definita da

f _{σ i} ( x _i ) = x _i x _{i + 1} x _i ⁻¹ ,
f _{σ i} ( x _{i + 1} ) = x _i ,
f _{σ i} ( x _j ) = x _j per j ∉ { i , i + 1}.

L'inverso f _{σ i ⁻¹} è dato da

f _{σ i ⁻¹} ( x _i ) = x _{i + 1} ,
f _{σ i ⁻¹} ( x _{i + 1} ) = x _{i + 1} ⁻¹ x _i x _{i + 1} ,
f _{σ i ⁻¹} ( x _j ) = x _j per j ∉ { i , i + 1}

e ovviamente la composizione è data da f _ab = f _a ∘ f _b .

Per verificare se a = b ∈ B _n , è sufficiente verificare che f _a ( x _i ) = f _b ( x _i ) per tutti i = 1,…, n . Questo è un problema molto più semplice in F _n , dove dobbiamo solo sapere come cancellare x _i con x _i ⁻¹ .

Nel codice:

• i!jcalcola f _{σ i} ( x _j ) (dove uno io jpuò essere negativo, che rappresenta un inverso),
• foldr(%)[] esegue la riduzione nel gruppo libero,
• i&acalcola f _a ( x _i ),
• a?ncalcola [ f _a ( x ₁ ),…, f _a ( x _n )],
• ed (a#b)nè il test di uguaglianza per a = b in B _n .

Python 2 , 270 263 260 250 249 241 byte

def g(b,i=0):
 while i<len(b)-1:
  R,s=b[i:i+2]
  if R<0<s:b[i:i+2]=[[],[s,-R,-s,R],[s,R]][min(abs(R+s),2)];i=-1
  i+=1
 return b
def f(a,b):
 b=g(a+[-v for v in b][::-1]);i=0
 while i<len(b)and b[0]>0:b=b[1:]+[b[0]];i+=1   
 return g(b)==[]

Provalo online!

Implementazione del metodo di "subword reversing" per risolvere il problema dell'isotopia treccia: a = b iff ab ^ -1 = identità.

Algoritmo tratto da: Soluzioni efficienti al problema dell'isotopia treccia, Patrick Dehornoy ; descrive diversi altri algoritmi che potrebbero essere di interesse ...

Questo algoritmo funziona marciando da sinistra a destra nell'elenco, cercando un numero negativo seguito da un numero positivo; vale a dire, una parola secondaria della forma x _i ^-1 x _j con i, j> 0.

Utilizza le seguenti equivalenze:

x _i ^-1 x _j = x _j x _i x _j ^-1 x _i ^-1 se i = j + 1 oppure j = i + 1

x _i ^-1 x _j = identità (elenco vuoto) se i == j

x _i ^-1 x _j = x _j x _i ^-1 altrimenti.

Con un'applicazione ripetuta, finiamo con un elenco del modulo w1 + w2, in cui ogni elemento di w1è positivo e ogni elemento di w2è negativo. (Questa è l'azione della funzione g).

Quindi applichiamo guna seconda volta all'elenco w2 + w1; l'elenco risultante dovrebbe essere vuoto se l'elenco originale era equivalente all'identità.