Mathematica: упрощение индекса при некоммутативном умножении

Question

Используя Subscript [variable, integer] в Mathematica 7.0+, у меня есть выражения следующей формы:

a_-4 ** b_1 ** a_-4 ** b_-4 ** a_1 ** c_-4 ** c_1 ** c_5

Я хотел бы упростить это выражение.

Правила:
* Переменные с одним и тем же индексом не коммутируют,
* переменные с разными индексами коммутируют.

Мне нужен способ упростить выражение и объединить подобные термины (если это возможно);вывод должен выглядеть примерно так:

(a_-4)^2 ** b_-4 ** c_-4 ** b_1 ** a_1 ** c_1 ** c_5

Самое важное, что мне нужно, это упорядочить термины в выражении по индексам, сохраняя при этом правила о том, что коммутирует, а что нет.Второе (что я хотел бы) сделать, это объединить одинаковые термины, если порядок правильный.Мне нужно по крайней мере упорядочить выражения, подобные приведенным выше, следующим образом:

a_-4 ** a_-4 ** b_-4 ** c_-4 ** b_1 ** a_1 ** c_1 ** c_5,

, то есть коммутировать переменные с разными индексами, сохраняя при этом некоммуникативный характер переменных с одинаковыми индексами.

Все идеи приветствуются, спасибо.

Answer 1

Я на днях процитировал записную книжку библиотеки для связанного вопроса.

http://library.wolfram.com/infocenter/Conferences/325/

Как расширить арифметику дифференциальных операторов в математике

Я напишу какой-нибудь соответствующий код. Сначала я упомяну (снова), что я собираюсь определить и работать со своим собственным некоммутативным оператором, чтобы избежать головной боли при сопоставлении с образцом от встроенного NonCommulativeMultiply. Также я буду использовать [...] вместо Subscript [a, ...] для простоты записи ascii и вставки / вывода Mathematica.

Мы будем классифицировать некоторые «базовые» сущности как скаляры или переменные, последние являются вещами, которые имеют ограничения на коммутацию. Я не рассматриваю это настолько далеко, насколько это возможно, и я лишь определяю скаляры как довольно очевидные "не переменные".

variableQ[x_] := MemberQ[{a, b, c, d}, Head[x]]
scalarQ[x_?NumericQ] := True
scalarQ[x_[a_]^n_. /; !variableQ[x[a]]] := True
scalarQ[_] := False

ncTimes[] := 1
ncTimes[a_] := a
ncTimes[a___, ncTimes[b___, c___], d___] := ncTimes[a, b, c, d]
ncTimes[a___, x_ + y_, b___] := ncTimes[a, x, b] + ncTimes[a, y, b]
ncTimes[a___, n_?scalarQ*c_, b___] := n*ncTimes[a, c, b]
ncTimes[a___, n_?scalarQ, b___] := n*ncTimes[a, b]
ncTimes[a___, x_[i_Integer]^m_., x_[i_]^n_., b___] /; 
  variableQ[x[i]] := ncTimes[a, x[i]^(m + n), b]
ncTimes[a___, x_[i_Integer]^m_., y_[j_Integer]^n_., b___] /; 
  variableQ[x[i]] && ! OrderedQ[{x, y}] := (* !!! *)
    ncTimes[a, y[j]^n, x[i]^m, b]

Я буду использовать вашу форму ввода только с небольшими изменениями, поэтому мы преобразуем ** выражения для использования ncTimes.

Unprotect[NonCommutativeMultiply];
NonCommutativeMultiply[a___] := ncTimes[a]

Вот ваш пример.

In[124]:= 
    a[-4] ** b[1] ** a[-4] ** b[-4] ** a[1] ** c[-4] ** c[1] ** c[5]

Out[124]= ncTimes[a[-4]^2, a[1], b[1], b[-4], c[-4], c[1], c[5]]

Преимущество этого, казалось бы, трудоемкого метода состоит в том, что вы можете легко определить коммутаторы. Например, мы уже (неявно) применили это правило при формулировании приведенных выше правил.

commutator[x_[a_], y_[b_]] /; x =!= y || !VariableQ[x[a] := 0

Как правило, если у вас есть правила коммутатора, такие как

ncTimes[a[j],a[i]] == ncTimes[a[i],a[i]]+(j-i)*a[i]

всякий раз, когда j> i, вы можете канонизировать, скажем, поставив [i] перед a [j] во всех выражениях. Для этого вам необходимо изменить правило, помеченное ( !!! ), чтобы учесть такие коммутаторы.

Я должен добавить, что я ни в каком смысле не полностью протестировал приведенный выше код.

Даниэль Лихтблау Wolfram Research

Answer 2

Это то, что вы ищете

Эти типы правил можно обобщить (например, добавить правила коммутации для некоммутирующих объектов, заставить их обрабатывать нечисловые индексы и т. Д.) И объединить их в подпрограмму NCMSort. Вы также можете оптимизировать его, выполнив сортировку за один проход, определив уникальную функцию NCMOrder, например,

NCMSort[expr_] := expr /. a_NonCommutativeMultiply :> a[[NCMOrder[a]]]

---

В сторону: Я использовал такой процесс при генерации результатов arXiv: 1009.3298 - ноутбук будет распространяться с (скоро будет выпущено) более длинной бумагой.

Answer 3

Вы можете делать что хотите, используя NCAlgebra .В случае вашего примера:

<< NC`
<< NCAlgebra`
expr = Subscript[a, -4] ** Subscript[b, 1] ** Subscript[a, -4] ** Subscript[b, -4] ** Subscript[a, 1] ** Subscript[c, -4] ** Subscript[c, 1] ** Subscript[c, 5]
rule = {(Subscript[x_, i_] ** Subscript[y_, j_] /; i > j) -> Subscript[y, j] ** Subscript[x, i]}NCReplaceRepeated[expr, rule]
NCReplaceRepeated[expr, rule]

производит

Subscript[a, -4] ** Subscript[a, -4] ** Subscript[b, -4] ** Subscript[c, -4] ** Subscript[b, 1] ** Subscript[a, 1] ** Subscript[c, 1] ** Subscript[c, 5]

Это выглядит не очень хорошо, но Subscripts будет хорошо отображаться на ноутбуке.