Si no está familiarizado con Braid-Theory, le recomiendo que lea esto primero. Esta pregunta supone que al menos está familiarizado con los conceptos en cuestión y supone que está bien familiarizado con la teoría de grupos.

Definamos σ _n ser la trenza en la que el n º hebra (Una indexado) a partir de los mejores cruza sobre el n + 1 º hebra, y σ _n ^- ser la inversa de σ _n (que es el n + 1 º cadena cruza el n º hebra).

El grupo trenza B _n es entonces generada por <σ ₁ , σ ₂ , σ ₃ ,. . . , σ _n-1 > . Por lo tanto, cada trenza en B _n se puede escribir como el producto de las trenzas σ. ¹

Determinar si dos trenzas en un grupo son iguales no es una tarea simple. Puede ser bastante obvio que σ ₁ σ ₃ = σ ₃ σ ₁ , pero es un poco menos obvio que, por ejemplo, σ ₂ σ ₁ σ ₂ = σ ₁ σ ₂ σ ₁ . ²

Entonces la pregunta es "¿Cómo podemos determinar si dos trenzas son iguales?". Bueno, los dos ejemplos anteriores representan un poco de esto. En general, las siguientes relaciones, llamadas relaciones de Artin, son ciertas:

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

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

Podemos usar estas dos relaciones junto con los axiomas de grupo para demostrar que cualquier trenza igual es igual. Por lo tanto, dos trenzas son iguales si la aplicación repetida de estas relaciones y los axiomas grupales pueden demostrarlo.

Tarea

Escribirás un programa o función para tomar dos trenzas y determinar si son iguales o no. Opcionalmente, también puede tomar un número entero positivo que represente el orden del grupo.

Esta es una pregunta de código de golf , por lo que las respuestas se puntuarán en bytes, con menos bytes mejor.

Entrada y salida

Debe representar una trenza como una lista ordenada de generadores (o cualquier estructura equivalente, por ejemplo, vector). Puede representar los generadores en cualquier forma razonable (por ejemplo, un número entero, dos tuplas de un número entero positivo y un booleano).

A la par con las reglas estándar de problemas de decisión, debe generar uno de dos valores distintos, aceptar y rechazar.

Casos de prueba

[],       []              -> 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: Tenga en cuenta que mientras B _n satisface todas las propiedades de un grupo, la operación en nuestro grupo de trenzas no es conmutativa y, por lo tanto, nuestro grupo no es abeliano.}

^{2: Si desea verificar esto por sí mismo Sugiero aplicar σ ₁ - a ambos lados, si dibuja los dos fuera en el papel, o ellos modelar con cadenas reales que debería ser evidente por qué este es el caso.}

Haskell , 190 bytes

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

Pruébalo en línea!

Cómo funciona

Sea F _n el grupo libre en n generadores x ₁ , ..., x _n . Uno de los primeros resultados en la teoría de la trenza (Emil Artin, Theorie der Zöpfe , 1925) es que tenemos un homomorfismo inyectivo f : B _n → Aut ( F _n ) donde la acción f _{σ i} de σ _i está definida por

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

El inverso f _{σ i ⁻¹} viene dado por

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 para j ∉ { i , i + 1}

y, por supuesto, la composición viene dada por f _ab = f _a ∘ f _b .

Para probar si a = b ∈ B _n , es suficiente probar que f _a ( x _i ) = f _b ( x _i ) para todo i = 1, ..., n . Este es un problema mucho más simple en F _n , donde solo necesitamos saber cómo cancelar x _i con x _i ⁻¹ .

En el codigo:

• i!jcalcula f _{σ i} ( x _j ) (donde cualquiera io jpuede ser negativo, representando un inverso),
• foldr(%)[] realiza reducción en el grupo libre,
• i&acalcula f _a ( x _i ),
• a?ncalcula [ f _a ( x ₁ ),…, f _a ( x _n )],
• y (a#b)nes la prueba de igualdad para a = b en B _n .

Python 2 , 270 263 260 250 249 241 bytes

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

Pruébalo en línea!

Implementación del método de 'inversión de subpalabras' para resolver el problema de isotopía de trenza: a = b iff ab ^ -1 = la identidad.

Algoritmo tomado de: Soluciones eficientes para el problema de la isotopía de la trenza, Patrick Dehornoy ; describe varios otros algoritmos que pueden ser de interés ...

Este algoritmo funciona marchando de izquierda a derecha en la lista, buscando un número negativo seguido de un número positivo; es decir, una sub-palabra de la forma x _i ^-1 x _j con i, j> 0.

Utiliza las siguientes equivalencias:

x _i ^-1 x _j = x _j x _i x _j ^-1 x _i ^-1 si i = j + 1 o j = i + 1

x _i ^-1 x _j = identidad (lista vacía) si i == j

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

Mediante la aplicación repetida, terminamos con una lista de la forma w1 + w2, donde cada elemento de w1es positivo y cada elemento de w2es negativo. (Esta es la acción de la función g).

Luego aplicamos guna segunda vez a la lista w2 + w1; la lista resultante debería estar vacía si la lista original fuera equivalente a la identidad.