如果您不熟悉辫子理论，建议您先阅读本节。这个问题假设您至少熟悉手头的概念，并假设您熟悉小组理论

让我们定义σ _Ñ为其中所述编织物Ñ从顶部越过所述第链（一个索引）的n + 1个链，和σ _Ñ ^-是的逆σ _Ñ（即在N + 1个链与第n个链交叉）。

编织物组乙_Ñ然后通过产生<σ ₁，σ ₂，σ ₃，。。。，σn _-1 >。因此，B _n上的每个编织都可以写成σ编织的乘积。^1个

确定一组上的两个辫子是否相等并不是一件容易的事。这可能是很明显，σ ₁ σ ₃ =σ ₃ σ ₁，但它是不那么明显的是，例如σ ₂ σ ₁ σ ₂ =σ ₁ σ ₂ σ ₁。²

因此，问题是“如何确定两个辫子是否相同？”。上面的两个示例分别代表了这一点。通常，以下关系称为阿丁关系：

• σ _我 σ _Ĵ =σ _Ĵ σ _我 ; i-j> 1

• σ _我 σ _{i + 1的} σ _我 =σ _{i + 1的} σ _我 σ _{i + 1的}

我们可以将这两个关系与组公理结合使用，以证明任何相等的辫子都是相等的。因此，如果重复应用这些关系，则两个辫子是相等的，群公理可以证明这一点。

任务

您将编写一个程序或函数来接受两个辫子，并确定它们是否相等。您也可以选择取一个正整数来表示组的顺序。

这是一个代码问题，因此答案将以字节计分，字节越少越好。

输入输出

您应该将辫子表示为生成器（或任何等效结构，例如矢量）的有序列表。您可以用任何合理的形式表示生成器（例如，整数，正整数的两个元组和布尔值）。

与标准决策问题规则相提并论，您应该输出两个不同的值之一，即接受拒绝。

测试用例

[],       []              -> 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：请注意，虽然B _n满足组的所有属性，但是对辫子组的运算不是可交换的，因此，该组不是abelian。}

^{2：如果你想验证自己这一点，我建议将σ ₁ -双方，如果你在纸上画的两头在外，或将它们与实际模型的字符串应该清楚为什么是这样的情况。}

190字节的Haskell

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

在线尝试！

怎么运行的

令F _n为n个生成器x ₁，...，x _n上的自由组。一在编织理论第一结果（周华健阿廷，的Theorie DERZöpfe，1925）是我们有一个射同态˚F：乙_Ñ → AUT（˚F _Ñ）其中动作˚F _{σ 我} σ的_我由下式定义

˚F _{σ 我}（X _我）= X _我 X _{我 + 1} X _我 ^-1，
˚F _{σ 我}（X _{我 + 1}）= X _我，
˚F _{σ 我}（X _Ĵ）= X _Ĵ为Ĵ ∉{ 我，我 + 1}。

逆˚F _{σ 我 ^-1}由下式给出

˚F _{σ 我 ^-1}（X _我）= X _{我 + 1}，
˚F _{σ 我 ^-1}（X _{我 + 1}）= X _{我 + 1} ^-1 X _我 X _{我 + 1}，
˚F _{σ 我 ^-1}（X _Ĵ）= X _Ĵ为Ĵ ∉{ 我，我 + 1}

当然组合物由下式给出˚F _AB = ˚F _一个 ∘ ˚F _b。

到测试是否一个 = b ∈ 乙_Ñ，就足够了测试˚F _一个（X _我）= ˚F _b（X _我）的所有我 = 1，...，Ñ。在F _n中，这是一个简单得多的问题，我们只需要知道如何用x _i ^-1抵消x _i。

在代码中：

• i!j单位计算˚F _{σ 我}（X _Ĵ）（其中任一i或j可以是负的，表示的倒数），
• foldr(%)[] 减少自由组，
• i&a计算f _a（x _i），
• a?n计算[ f _a（x ₁），…，f _a（x _n）]，
• 并且(a#b)n对于相等测试一个 = b在乙_Ñ。

Python 2中，270个 263 260 250 249 241字节

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

在线尝试！

解决辫子同位素问题的“子词可逆”方法的实现：a = b iff ab ^ -1 =身份。

算法取自：编织同位素问题的有效解决方案，Patrick Dehornoy；他描述了可能感兴趣的其他几种算法...

该算法的工作原理是在列表中从左向右前进，先搜索负数，再搜索正数。即，一个子词形式为x _i ^-1 x _j，i，j> 0。

它使用以下等效项：

x _i ^-1 x _j = x _j x _i x _j ^-1 x _i ^-1如果i = j + 1或j = i + 1

x _i ^-1 x _j =身份（空列表），如果i == j

x _i ^-1 x _j = x _j x _i ^-1否则。

通过重复应用，我们最终得到一个形式的列表w1 + w2，其中的每个元素w1都是正数，而的每个元素w2都是负数。（这是该功能的作用g）。

然后我们g第二次申请清单w2 + w1; 如果原始列表与标识相同，则结果列表应为空。