Справка Maple по некоторым командам пакета Physics
и примеры их применения.

Coordinates	dAlembertian
Diff	Commutator и Anticommutator
Intc	Annihilation и Creation

Установки названий пространственно-временных координат, используемых в командах пакета Physics:

Команда
Coordinates( )
Coordinates(X, quiet, clear)

Параметры

X	–	неприсваиваемая заглавная буква, представляющая последовательность n координат в n-мерном пространстве-времени,
quiet	–	опция – работа без выдачи сообщений на экран,
clear	–	опция – удалить ранее введенные в Coordinates обозначения.

При вызове без аргументов возвращает имеющиеся заглавные буквы, обозначающие координатные системы.

Описание
♦ Команда Coordinates применяется для установки обозначений заглавных букв, например X, представляющих n пространственно-временных координат (n – размерность пространства-времени). Такая упрощенная запись позволяет избежать необходимости задания всех параметров пространства-времени в правильном порядке при вводе функций пространства-времени или использовании команд дифференцирования пакета Physics:d_[mu] или dAlembertian (задание обозначений не освобождает от необходимости это делать).

♦ В пакете Physics есть предустановки размера, метрики пространственно-временных координат и переменных дифференцирования (см. Setup), которые вызываются командой Setup(advanced). Эти установки можно адаптировать с помощью Setup().

♦ Если вы вызвали эти предустановки, то размерность = 4 с псевдоевклидовой метрикой (4 = 3 + 1 – пространство-время; метрика (– – – +), см. список литературы в параграфе Необходимое пояснение к главе) и последовательность координат для задаваемой в Coordinates буквы X (командой alias). Это означает, что при вычислениях X записывается как последовательность x1, x2, x3, x4.

Правило: наименования пространственно-временных параметров ассоциируются с большой буквой алфавита, а сами координаты обозначаются соответствующими маленькими буквами с цифрами от 1 до n, где n – размерность. Разрешены заглавные буквы от A до Z, исключая D, E, G, I, O, W.

♦ Установки размерности переменных дифференцирования и Coordinates взаимосвязаны:

• Пространственно-временные координаты Coordinates упорядочены по n и обозначаются символами, например: x1, x2 , x3, x4.
• Переменные дифференцирования по умолчанию можно задать в любой последовательности с помощью Coordinates.

♦ Если в середине сеанса Maple изменяется Dimension, то все предыдущие установки переменных дифференцирования и обозначения координат автоматически стираются.

Примеры
Загрузите Coordinates и связанные с ним параметры:

• with(Physics):

Установите обозначение X, чтобы координаты записывались как x1, x2, x3, x4, а координаты дифференцирования по умолчанию для d_ и dAlembertian обозначались X. Это можно сделать одной командой в Setup:

• Setup(differentiationvariables = X);

• nops([X]);

4

• X[1], X[4];

x1, x4

После установки X как координат дифференцирования по умолчанию можно их не обозначать при использовании d_ и dAlembertian (второй аргумент):

• f(X);

f(X)

• d_[mu]( % );

pμ(f(X))

• dAlembertian( %% );

□(f(X))

Для задания большей последовательности пространственно-временных координат примените:

• Coordinates(Y, Z);

Это полезно, если надо представлять объекты, вычисленные в разных точках пространства-времени. Если используется d_ или dAlembertian с Y или Z, которые (в этом примере) не являются переменными дифференцирования по умолчанию, необходимо обозначить их в качестве второго аргумента, и они будут показаны на экране:

• d_[mu](f(Y), [Y]);

pμ(f(Y),[Y])

• dAlembertian(f(Y), [Y]);

□(f(Y),[Y])

Пример, когда есть внутренняя потребность в более чем одной системе координат – functional differentiation:

• f(X);

f(X)

• 'Fundiff'(%, f(Y)); # '' отложенные вычисления

• %;# полный расчет

В результате функционального дифференцирования показана четырехмерная дельта-функция Дирака. Можно сделать иначе: вместо применения одинарных кавычек, откладывающих вычисления, можете использовать инертную форму %Fundiff и value

• %Fundiff(f(Y), f(Z));

• value(%);

Команда предназначена для дифференцирования, в том числе – одновременно для объектов разного типа вроде: commutative, anticommutative и noncommutative. Для конвертации между форматами представления производных в D и diff применяются команды:
convert(expr, diff)
convert(expr, D)

Параметры

expr

–

любой объект типа object.

Описание
Эквивалентность для антикоммутативных производных высокого порядка, записанных в формате D и в формате diff пакета Physics, – такая, как в записи вида:

• Physics:-diff(f(theta1,theta2),theta1,theta2) =
  D[1,2](f)(theta1,theta2);

Для более высоких производных порядок действий таков: первое дифференцирование по θ1 и затем по θ2; если наоборот, то умножение на –1. Тогда правую часть следует интерпретировать обычно, как коммутирующую производную высокого порядка.

Примеры
Загрузите пакет и поставьте префикс, чтобы обозначить антикоммутирующие переменные anticommutative variables (см. Setup)

• with(Physics):
  Setup(anticommutativepre = theta);

Рассмотрим коммутирующую функцию, которая зависит от коммутирующей и антикоммутирующей переменных и одной более высокой их производной:

• f(x, y, z, theta1, theta2, theta3);

• diff(%, x, theta3, y, theta1, z, theta2);

Учтите, что в этой записи первыми применяются коммутирующие переменные дифференцирования, а затем применяются антикоммутирующие.

• lprint(%);

diff(diff(diff(diff(diff(diff(f(x,y,z,theta1,theta2,theta3),
x),y),z),theta1),theta2),theta3)

Перепишите это выражение в обозначениях D, а затем иначе – в обозначениях diff:

• convert(%, D);

• convert(%, diff);

Быстрый ввод кратных интегралов от –∞ до +∞.

Команда
Intc(f, x1, x2, ..., xn)

Параметры

f	–	подынтегральное выражение, т. е. любое алгебраическое выражение,
x1, x2, ..., xn	–	имена переменных интегрирования.

Описание
Команда Intc облегчает ввод часто применяемых в пакете Physics кратных интегралов от –∞ до +∞. Первый аргумент – это подынтегральное выражение, а остальные интегралы, построенные на Intc, используют инертное Int вместо int.

Примеры

• with(Physics):

Для ввода двумерного интеграла от –∞ до +∞ надо написать:

• Intc(F(x1, x2), x1, x2);

Типичная ситуация: нужно проинтегрировать в d-мерном объеме, где d – размерность пространства-времени. Координаты надо вводить как аргументы в команду Intc или упростить ввод, назначив с помощью команды Coordinates обозначение (псевдоним) координат: X = x1, x2, x3, x4 (пакет Physics загружен с установками пространства-времени Минковского с размерностью 4 = 3 + 1, которые можно изменить в Setup):

• Coordinates(X);

• Intc(F(X),X);

Даламберовское дифференцирование по пространственно-временным координатам.

Команда
dAlembertian(A)

dAlembertian(A, [X])

Параметры

A	–	любое математическое выражение или соотношение между ними,
[X]	–	опция – список переменных дифференцирования, относительно которых рассчитывается даламбертиан. Если опция не задана, используются переменные по умолчанию,
x1, x2, ..., xn	–	имена переменных интегрирования.

Описание
♦ Команда dAlembertian – это компьютерное представление дифференциального оператора Даламбера и здесь изображается как квадрат. Используемые в данном
случае определения и условия таковы, что если их применить, скажем, к A, то dAlembertian(A) = d_[mu](d_[mu](A)) (см. также d_) в n-мерном пространстве-времени.

♦ dAlembertian(A) = d_[0](d_[0](A)) + s * (d_[1](d_[1](A)) + ... +
d_[n-1](d_[n-1](A))),

где s – характеристика пространства-времени.

♦ %dAlembertian – это инертная форма dAlembertian, т. е. она представляет те же самые математические операции, но не выполняет их. Для активации операции примените value. Для получения dAlembertian (или инертной его формы) как суммы конструкций diff примените convert/diff.

♦ Как и для d_[mu] (отображается как р[μ]), в случае, когда в dAlembertian задается только один аргумент, переменные дифференцирования – это тот же самый набор X, что задан в команде Setup (обычно x1, x2, x3, x4, причем x0 автоматически переобозначается на x4, см. Coordinates). Для изменения установок по умолчанию – см. Setup.

♦ Независимо от наличия установок по умолчанию для переменных дифференцирования можно вызвать команду dAlembertian с двумя аргументами, где второй из них – нужный список переменных дифференцирования (не тот, что по умолчанию). В этом случае список должен иметь столько же переменных, сколько установлено для переменных пространства-времени (по умолчанию = 4, но может быть задано любым, см. Setup).

♦ При каждом вызове dAlembertian(A) автоматически делаются упрощения:

• если A не зависит от переменных дифференцирования, возвращается 0;
• если A – неизвестная функция (неизвестно правило для ее производных), дельта-функция Дирака или производная, то возвращается dAlembertian(A) без вычисления;
• если A в виде р[μ](B), то возвращается р[μ](dAlembertian(B));
• в любом ином случае dAlembertian(A) вычисляется вызовом d_ как р[μ](р[μ](A)).

♦ Дополняя дифференцирование, dAlembertian вызывает d_ , использующее diff пакета Physics, которое использует стандартную Maple-овскую команду :-diff с соответствующими аргументами. Таким образом, пользовательское определение правил дифференцирования в созданной вами библиотеке, например для функции foo, имеет вид `diff/foo`. Это dAlembertian учитывает автоматически.

Примеры

• with(Physics):

Задает переменные дифференцирования по умолчанию для dAlembertian и d_, определяет тензорную функцию пространства-времени A и использует улучшенную схему пакетов дифференцирования.

• Setup(differentiationvariables = X);

• Define(A);

• PDEtools[declare]((f, A, Phi)(X));

Оператор Даламбера dAlembertian – это двойное применение d_[mu] с фиксированным индексом:

• d_[mu](d_[mu](f(X)));

По умолчанию размерность пространства Минковского 4 = 3 + 1, причем форма dAlembertian представляется как сумма конструкций diff:

• convert(%, diff);

dAlembertian обычно работает с производными, записанными с помощью любого оператора дифференцирования Maple, включая D, diff и d_. Он также распространяется на суммы и произведения.

• d_[mu](f(X) + A[mu](X));

• dAlembertian(%);

• d_[mu](f[mu](X))*A[nu](X);

• dAlembertian(%);

Поскольку dAlembertian – это дифференциальный оператор второго порядка dAlembertian(f) = р[μ](р[μ](f)), то применение правил дифференцирования к произведению требует разложения операций dAlembertian на последовательность операций р[μ]. Учтите также, что вводится немой индекс α, который может быть любым пространственно-временным индексом. Эти индексы выбираются после проверки на то, что они не назначались ранее и не присутствуют сейчас, при вводе данного выражения.

Независимо от наличия X (набора переменных дифференцирования по умолчанию), можно вызвать dAlembertian или d_ с другим набором координат в качестве переменных дифференцирования, например ввести еще одну систему координат.

• Coordinates(Y);

• dAlembertian(f(X));

• dAlembertian(f(Y), [Y]);

Приведенная выше выдача показывает переменные дифференцирования, потому что они задаются как [Y], хотя не являются переменными дифференцирования по умолчанию.

• Setup(differentiationvariables = Y);

• dAlembertian(f(X)); # теперь переменными дифференцирования являются [Y]

• dAlembertian(f(X), [X]); # показываются[X]

• dAlembertian(f(Y), [Y]); # теперь опущены[Y]

dAlembertian вводит классические уравнения поля в разных моделях. Вот тензор электромагнитного поля:

• Setup(differentiationvariables = X);

• F[mu, nu] := d_[mu](A[nu](X)) – d_[nu](A[mu](X));

В результате взятия функциональной производной получатся уравнения Максвелла:

• 'Fundiff'( Intc(F[mu,nu]^2, X), A[rho](Y)); # <- расчет отложен: выполнение в следующей строке

• subs(Y = X, %);

Для упрощения фиксированных пространственно-временных индексов используем Simplify:

• Simplify(%);

Соответствующая функция Лагранжа модели λΦ^4 и уравнения поля:

• L := 1/2 * d_[mu](Phi(X)) * d_[mu](Phi(X)) – m^2/2 * Phi(X)^2 + lambda/4*Phi(X)^4;

• 'Fundiff'(Intc(L,X), Phi(Y)); # <- задержка вычислений; выполнение в следующей строке

• subs(Y = X, %);

Это коммутатор AB – BA и антикоммутатор AB + BA.

Команды
Commutator(A, B)
AntiCommutator(A, B)

Параметры

A, B

–

два любых алгебраических выражения.

Описание
Команды Commutator и AntiCommutator представляют соответственно AB – BA и AB + BA, где A и B могут не коммутировать. Выдача (результат выполнения команд) AntiCommutator(A, B) и Commutator(A, B) выглядит так:

• 2AB для Anticommutator и 0 для Commutator, если A и B коммутируют;
• результат можно показать, задав правила алгебры для Commutator или AntiCommutator;
• сама введенная функция без вычисления ее.

Инертная форма команд выглядит так: %Commutator и %AntiCommutator, т. е. они представляют те же математические операции, но без их выполнения. Для активации операций примените value или expand.

Commutator и AntiCommutator можно разложить с помощью команд expand или Expand. Если ответ представлен в виде разложения, то он нормирован и любые повторяющиеся индексы в произведениях тензоров (которые определены с помощью Define) автоматически упрощаются с помощью Simplify.

Активация инертной операции с помощью value – это то же самое, что разложение с помощью expand, но только в случае, если результат для Commutator есть 0 или для AntiCommutator 2AB. Иначе активация просто заменит в выводе инертные операторы % на активные.

Если пакет Physics загружен, то две процедуры – Commutator и AntiCommutator – загружаются вместе, чтобы улучшить отображения невычисляемых и инертных величин. При этом Commutator показывается как список из двух операндов с индексами `–`, а AntiCommutator – как такой же список с индексами`+`. В литературе AntiCommutator изображается как два операнда в фигурных скобках{ }, но в Maple это обозначение не применяется, чтобы избежать потенциального конфликта с наборами Maple (sets), которые тоже отображаются фигурными скобками при нефиксированном порядке операторов.

Примеры
Для использования инертной формы надо добавлять префикс %.

• with(Physics):
  e1 := %Commutator(Z[1], Z[2]);

Следует учитывать, что в этом случае для отображения применяется иная процедура (lprintcommand), а не обычно применяемая `print/Commutator` (см. справку по print)

• lprint(%);

%Commutator(Z[1],Z[2])

• e2 := %AntiCommutator(theta[1], theta[2]);

• lprint(%);

%AntiCommutator(theta[1],theta[2])

В этом месте Z и θ – просто два коммутирующих символа в команде, поэтому при разложении или активации Commutator и AntiCommutator получится:

• expand(e1)= value(e1);

• expand(e2)= value(e2);

Сравним исполнение активной формы Commutator и AntiCommutator с автоматическими упрощениями:
Commutator(A, B) → 0,
AntiCommutator(A, B) → 2AB,
когда A или B коммутируют.

• Commutator(Z[1], Z[2]);

• AntiCommutator(theta[1], theta[2]);

Вычислим заново разложения вида e1 и e2, при условии, что Z и θ соответственно будут префиксами некоммутирующей и антикоммутирующей переменных:

• Setup(anticommutativeprefix = theta, noncommutativeprefix = Z);

• e1;

• expand(%) = value(%); # Здесь активация операции отличается от разложения.

• e2;

• expand(%) = value(%); # разложение = активации, только если результат 0 или 2AB.

Перед возвратом выполняется нормировка некоммутативных произведений:

• e3 := theta[1] + theta[2];

• e4 := theta[1] – theta[2];

• e5 := %Commutator( theta[1]*e3, theta[2]*e4 );

• expand(e5);

Активация с помощью value позволяет увидеть, что эта форма снова выдает 0:

• value(e5);

Введем определение двух квантовых операторов и правил коммутации для них:

• Setup(quantumop = {R, P}, algebrarule = {%Commutator(R[j],
  P[k]) = I*KroneckerDelta[j, k]});

• Commutator(R[1], P[2]);

• Commutator(R[2], P[2]);

• Commutator(R[n], P[m]);

С некоторыми ограничениями можно ввести алгебру Commutator для степеней квантовых операторов.

Рассмотрим, например, два сопряженных оператора:

• Setup(quantumop = {Q, P}, algebrarule = {%Commutator(Q, P) = I});

• Commutator(Q, P);

После установки правил алгебры записанными выше командами имеем:

• Commutator(Q, P^2);

• Commutator(Q^2, P^3);

• Simplify(%);

• Commutator(Q, P^m);

Правил Commutator достаточно для расчета, если степень оператора – четная, и недостаточно, если это символ вида P^m. В этих случаях можно самому, напрямую установить правило для степени, которое также будет работать при экспоненте = 1.

• Setup(redo, algebra = {%Commutator(Q, P^m) = I*m*P^(m-1)});

• Commutator(Q, P);

• Commutator(Q^2, P^3);

• Commutator(Q^2, P^s);

Annihilation – создает операторы уничтожения, действующие на заданное пространство квантовых состояний.

Creation – создает операторы рождения, действующие на заданное пространство квантовых состояний.

Команды
Annihilation(A, n1, n2, ... notation = ..., phaseconvention = ...)
Creation(A, n1, n2, ... notation = ..., phaseconvention = ...)

Параметры

A	–	имя (символ), обозначающее пространство квантовых состояний, на которое действует возвращаемый оператор,
n1, n2, ...	–	положительные целые числа, обозначающие положение квантовых чисел, на которые действует возвращаемый оператор,
notation = ...	–	опция – правая или левая часть, либо действительная, либо комплексная (по умолчанию), такая, что возвращаемый оператор показывает явно пространство и квантовые числа, на которые он действует,
phaseconvention = ...	–	опция – правая часть – процедура с одним аргументом, говорящим, как оператор будет строить фазовый множитель. По умолчанию для оператора уничтожения: sqrt; по умолчанию для оператора рождения: n ->sqrt(n + 1).

Описание
♦ Команды Annihilation и Creation возвращают, соответственно, операторы уничтожения и рождения, которые действуют на квантовые числа состояний векторов Ket или Bra в пространстве квантовых состояний. Первый аргумент обозначает базис квантовых состояний, на которые действует возвращаемый оператор. Второй и последующий аргументы – положительные целые числа, указывающие на положение квантовых чисел, на которые действует возвращаемый оператор. Если они не заданы, то полагается, что есть только одно квантовое число.

♦ %Annihilation и %Creation – инертные формы Annihilation и Creation, т. е. они представляют те же математические операции, но без их выполнения. Для активации операторов применяют value.

♦ По умолчанию операторы a- и a+ (в данном случае `a-`и `a+`), показываемые на экране возвращаемыми командами Annihilation и Creation, являются локальными переменными. Возвращаемый по умолчанию оператор ничего не говорит ни о базисе состояний, ни о положении квантовых чисел, на которые он действует. Это можно изменить с помощью опции notation = explicit. Она, например, позволяет различать `a-` и `a+` в пределах одного рабочего листа, делает возвращаемые величины, например `a-` и `a+`, экспортируемыми в Physics, а не локальными. Другой способ сделать то же – применить команду alias.

♦ Операторы рождения и уничтожения удовлетворяют соотношениям коммутации [a-, a+][–] = 1, где [a-, a+][–] – это коммутатор, кроме случая, когда метка базиса состояний, на которые действуют операторы, – это антикоммутативная переменная. В этом случае операторы удовлетворяют соотношению антикоммутации [a-, a+][+] = 1, где [a-, a+][+] – антикоммутатор. При конструировании этих операторов через вызов Annihilation и Creation (анти)коммутационные соотношения автоматически учитываются командами Commutator и AntiCommutator.

♦ Учтите: операторы уничтожения и рождения можно создать для работы только с Bra и Ket дискретного спектра.

Соглашение о фазе
Пусть базис состояний обозначен A и есть единственное квантовое число n. Тогда оператор уничтожения удовлетворяет уравнению a- |A, 0> = 0. Вектор состяния |A, 0> опеределен с точностью до постоянного множителя. Если |A, 0> нормирован на 1, этот множитель имеет вид exp(iθ), где θ – действительное число. Потребуем в дополнение |A, 1> = c1a+ |A, 0>, при c1 действительном и положительном. Учтем, что соотношение (анти)коммутации удовлетворяется для a- и a+. Тогда множитель c1 = 1.

Для бозонов с теми же предположениями учтем, что |A, n> = cna+ |A, n – 1>, из чего следует соглашение о фазах:
|A, n> = sqrt (n) |A, n – 1>
a+ |A, n> = sqrt (n + 1) |A, n+1>.

С помощью опции phaseconvention = pc, где pc – процедура с одним аргументом, это соглашение о фазах можно переопределить собственным.

Для фермионов, в соответствии с принципом Паули каждое квантовое число принимает значение либо 0, либо 1:
|A, 1> = |A, 0>
a+ |A, 1> = 0.

Теперь рассмотрим случай множества квантовых чисел, например a- и a+ действуют на N-е квантовое число (qm). Пусть M – полное число частиц, занимающих состояния, представленные предыдущим qm (от 1 до N – 1), тогда M = добавке к qm (от 1 до N–1), и соглашение о фазе имеет вид:
|A, n[1].... 1, ... > = (–1)^M |A, n[1].... 0, ... >
a+ |A, n[1].... 0, ... > = (–1)^M |A, n[1].... 1, ... >.

Примеры

• with(Physics):

Для (дискретного) базиса векторов Φ создадим операторы уничтожения и рождения состояний, рассматривая 1-е и 2-е квантовые числа векторов состояний Ket этого базиса.

• am := Annihilation(phi, 1);

• ap := Creation(phi, 1);

`a-`и `a+` рассматриваются как локальные переменные, а сами операторы применяются к Bra и Ket данного пространства состояний с помощью оператора скалярного произведения из пакета Physics:-`.`:

• am . Ket(phi, n);

• Bra(phi, n) . am;

• ap . Ket(phi, n);

• Bra(phi, n) . ap;

• Commutator(am, ap);

Можно использовать инертную форму Commutator и/или активировать вычисления, применив value, когда в этом возникнет необходимость.

• %Commutator(am, ap);

• value(%);

Построим еще пару операторов уничтожения и рождения для другого базиса – Ψ, а чтобы отличить новую пару от той, что действует в базисе Φ, применим опцию notation = explicit.

• am2 := Annihilation(psi, 1, notation = explicit);

• ap2 := Creation(psi, 2, notation = explicit);

Видно, что индексы при a- и a+ показывают в явном виде базисные состояния и положение квантовых чисел, на которые они действуют. Кроме того, ` a-` и ` a+` являются для Physics экспортируемыми, а не локальными переменными.

Первый и второй операторы действуют только на векторы состояний того базиса, что указан при конструировании операторов, и коммутируют с векторами состояний другого базиса.

• am2 . Ket(psi, n, m);

• am . Ket(psi, n, m);

• ap2 . Ket(psi, n, m);

• ap . Ket(psi, n, m);

• ap2 . Ket(phi, n, m);

Чтобы различать операторы уничтожения, действующие на разные базисы или на разные квантовые числа, кроме применения опции notation = explicit, можно использовать alias.

• alias(Am1 = Annihilation(psi, 1)):
  alias(Am2 = Annihilation(psi, 2)):
  A1;

• Am1 . Ket(psi, n, m);

• Am2;

• Am2 . Ket(psi, n, m);

Если метка, обозначающая базис состояний, антикоммутативна, то операторы уничтожения и рождения антикоммутируют. Для иллюстрации соглашения о фазе для фермионов рассмотрим случай, когда a- и a+ действуют на третье квантовое число:

• Physics:-Setup(anticommutativeprefix = theta);

• am := Annihilation(theta, 3, notation=explicit);

• ap := Creation(theta, 3, notation=explicit);

• %AntiCommutator(am, ap); # инертная форма AntiCommutator(am, ap); требуется value

• value(%);

В примере ниже имеется одна частица с первым квантовым числом и ноль со вторым квантовым числом. a- действует на третье квантовое число, следовательно, в результат первого примера надо ввести множитель (–1)^(1+0) = –1.

• `%.`(am, Ket(theta, 1,0, 1));

• value(%);

• `%.`(am, Ket(theta, 1,1, 1));

• value(%);

• ap . Ket(theta, 1,0, 1);

• ap . Ket(theta, 1,0, 0);