Maxima Manual: Функции и переменные пакета ctensor

Previous: Введение в пакет ctensor, Up: Пакет ctensor [Contents][Index]

### 26.2 Функции и переменные пакета ctensor

#### 26.2.1 Начальные установки

Функция: csetup ()

  Эта функция производит начальные установки пакета `ctensor` и позволяет пользователю ввести метрику интерактивно. См. `ctensor` для более подробного описания.

Функция: cmetric (dis)
Функция: cmetric ()

  Функция пакета `ctensor`, которая вычисляет обратную метрику и готовит пакет к проведению дальнейших вычислений.

  Если переключатель `cframe_flag` равен `false`, то функция вычисляет обратную метрику `ug` исходя из заданной пользователем матрицы `lg`. Определитель метрики тоже вычисляется и сохраняется в переменной `gdet`. Боле того, программа определяет является ли метрика диагональной и соответственным образом устанавливает значение ключа `diagmetric`. Если задан необязательный ключ dis и его значение не равно `false`, то в ходе сессии пользователь запрашивается требуется ли распечатать компоненты обратной метрики на экран.

  Если ключ `cframe_flag` равен `true`, тогда ожидается, что заданы значения `fri` (матрица обратного базиса) и массив `lfg` (метрика относительно данного базиса). Исходя из этих данных вычисляются матрица `fr` и обратная метрика `ufg` относительно заданного базиса.

Функция: ct_coordsys (coordinate_system, extra_arg)
Функция: ct_coordsys (coordinate_system)

  Задает одну из предопределенных координатных систем и метрик. Аргумент coordinate_system может принимать одно из следующих значений:

       Символ               Dim Координаты        Описание/комментарии
       ------------------------------------------------------------------
       cartesian2d           2  [x,y]             Декартовы 2D координаты
       polar                 2  [r,phi]           Полярные координаты
       elliptic              2  [u,v]             Эллиптические
                                                  координаты
       confocalelliptic      2  [u,v]             Конфокальные
                                                  эллиптические
       bipolar               2  [u,v]             Биполярные координаты
       parabolic             2  [u,v]             Параболические
                                                  координаты
       cartesian3d           3  [x,y,z]           Декартова 3D система
                                                  координат
       polarcylindrical      3  [r,theta,z]       Цилиндрические
                                                  координаты
       ellipticcylindrical   3  [u,v,z]           Эллиптические 2D
                                                  с цилинром z
       confocalellipsoidal   3  [u,v,w]           Конфокальные
                                                  эллипсоидальные
       bipolarcylindrical    3  [u,v,z]           Биполярные 2D
                                                  с цилиндром z
       paraboliccylindrical  3  [u,v,z]           Параболические 2D
                                                  с цилиндром z
       paraboloidal          3  [u,v,phi]         Параболоидные
                                                  координаты
       conical               3  [u,v,w]           Конические координаты
       toroidal              3  [u,v,phi]         Тороидальные координаты
       spherical             3  [r,theta,phi]     Сферические координаты
       oblatespheroidal      3  [u,v,phi]         Сжатые сфероидальные
       oblatespheroidalsqrt  3  [u,v,phi]
       prolatespheroidal     3  [u,v,phi]         Вытянутые сфероидальные
       prolatespheroidalsqrt 3  [u,v,phi]
       ellipsoidal           3  [r,theta,phi]     Эллипсоидальные
                                                  координаты
       cartesian4d           4  [x,y,z,t]         Декартовы 4D координаты
       spherical4d           4  [r,theta,eta,phi] Сферические 4D
                                                  координаты
       exteriorschwarzschild 4  [t,r,theta,phi]   Метрика Шварцшильда
       interiorschwarzschild 4  [t,z,u,v]         Внутреняя метрика
                                                  Шрарцшильда
       kerr_newman           4  [t,r,theta,phi]   Метрика Керра-Ньюмана

  `coordinate_system` может быть списком функций преобразования, за которым следует список координат. Например, можно задать метрику следующим образом:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) ct_coordsys([r*cos(theta)*cos(phi),r*cos(theta)*sin(phi),
            r*sin(theta),[r,theta,phi]]);
      (%o2)                                done
      (%i3) lg:trigsimp(lg);
                                 [ 1  0         0        ]
                                 [                       ]
                                 [     2                 ]
      (%o3)                      [ 0  r         0        ]
                                 [                       ]
                                 [         2    2        ]
                                 [ 0  0   r  cos (theta) ]
      (%i4) ct_coords;
      (%o4)                           [r, theta, phi]
      (%i5) dim;
      (%o5)                                  3

  Функции преобразования могут также использоваться и в случае, когда `cframe_flag` равно `true`:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) cframe_flag:true;
      (%o2)                                true
      (%i3) ct_coordsys([r*cos(theta)*cos(phi),r*cos(theta)*sin(phi),
            r*sin(theta),[r,theta,phi]]);
      (%o3)                                done
      (%i4) fri;
      (%o4)
       [cos(phi)cos(theta) -cos(phi) r sin(theta) -sin(phi) r cos(theta)]
       [                                                                ]
       [sin(phi)cos(theta) -sin(phi) r sin(theta)  cos(phi) r cos(theta)]
       [                                                                ]
       [    sin(theta)           r cos(theta)                0          ]

      (%i5) cmetric();
      (%o5)                                false
      (%i6) lg:trigsimp(lg);
                                 [ 1  0         0        ]
                                 [                       ]
                                 [     2                 ]
      (%o6)                      [ 0  r         0        ]
                                 [                       ]
                                 [         2    2        ]
                                 [ 0  0   r  cos (theta) ]

  Необязательный аргумент extra_arg может принимать одно из следующих значений:

  `cylindrical` указывает `ct_coordsys` добавить одну дополнительную цилиндрическую координату.

  `minkowski` указывает `ct_coordsys` добавить дополнительную декартову координату с отрицательной сигнатурой.

  `all` указывает `ct_coordsys`, что после определения метрики необходимо вызвать `cmetric` и `christof(false)`.

  Если глобальная переменная `verbose` равна `true`, то `ct_coordsys` выводит значения `dim`, `ct_coords`, и или `lg` или `lfg` и `fri`, в зависимости от значения `cframe_flag`.

Функция: init_ctensor ()

  Инициализирует пакет `ctensor`.

  Функция `init_ctensor` ре-инициализирует пакет `ctensor`, при этом из памяти удаляются все использованные ранее пакетом `ctensor` массивы и матрицы и восстанавливаются стандартные значения всех ключей, в том числе: размерность многообразия, `dim`, устанавливается равной 4, а метрика устанавливается равной метрике Лоренца.

#### 26.2.2 Тензоры искривленного пространства

Основное назначение пакета `ctensor` – вычисление различных тензоров для искривленного пространства-времени, в основном тензоров, использующихся в общей теории относительности.

При использовании голономного (координатного) базиса `ctensor` может вычислить следующие объекты:

     lg  -- ug
       \      \
        lcs -- mcs -- ric -- uric
                  \      \       \
                   \      tracer - ein -- lein
                    \
                     riem -- lriem -- weyl
                         \
                          uriem

`ctensor` может также работать при неголономном базисе (тетрадный формализм). Когда `cframe_flag` равно `true`, следующие объекты могут быть вычислены:

     lfg -- ufg
         \
     fri -- fr -- lcs -- mcs -- lriem -- ric -- uric
          \                       |  \      \       \
           lg -- ug               |   weyl   tracer - ein -- lein
                                  |\
                                  | riem
                                  |
                                  \uriem

Функция: christof (dis)

  Функция пакета `ctensor`, вычисляющая символы Кристоффеля первого и второго родов. Аргумент dis определяет какой результат должен быть отображен. Символы Кристоффеля первого и второго рода хранятся в массивах `lcs[i,j,k]` и `mcs[i,j,k]` соответственно и считается симметричным по первой паре индексов. Если аргумент `christof` есть `lcs` или `mcs` то будут выведены все уникальные (симметрия) ненулевые значения `lcs[i,j,k]` или `mcs[i,j,k]`, соответственно. Если аргумент равен `all`, тогда печатаются уникальные ненулевые значения как `lcs[i,j,k]` и `mcs[i,j,k]`. Если аргумент равен `false`, то ни какие значения не отображаются. Массив `mcs[i,j,k]` определен таким образом, что последний индекс является контравариантным.

Функция: ricci (dis)

  Функция пакета `ctensor`, вычисляющая ковариантные (симметричные) компоненты тензора Риччи `ric[i,j]`. Если аргумент dis равен `true`, то на экран выводится печать результатов вычисления ненулевых компонент тензора.

Функция: uricci (dis)

  Эта функция сначала вычисляет ковариантные компоненты тензора Риччи `ric[i,j]`. Затем с помощью контравариантной метрики вычисляется тензор Риччи со смешанными компонентами. Если аргумент dis равен `true`, тогда смешанные компоненты `uric[i,j]` (индекс `i` ковариантный, а индекс `j` контравариантный), будут распечатаны. При `ricci(false)` просто вычисляется массив `uric[i,j]` без печати на экран.

Функция: scurvature ()

  Возвращает значение скалярной кривизны, получаемое сверткой тензора кривизны Риччи.

Функция: einstein (dis)

  Функция `einstein` вычисляет смешанный тензор Эйнштейна после того как вычислены символы Кристоффеля и тензор Риччи пи помощи функций `christof` и `ricci`. Если аргумент dis равен `true`, тогда ненулевые компоненты тензора Эйнштейна `ein[i,j]` будут напечатаны, где индекс `j` является ковариантным. Переключатель `rateinstein` вызывает рациональное упрощение результирующих компонент. Если `ratfac` равен `true` тогда компоненты будут автоматически факторизованы.

Функция: leinstein (dis)

  Вычисляет ковариантный тензор Эйнштейна. `leinstein` записывает компоненты ковариантного тензора Эйнштейна в массив `lein`. Контравариантные компоненты тензора Эйнштейна вычисляются исходя из смешанного тензора Эйнштейна `ein`. Если аргумент dis равен `true`, тогда ненулевые компоненты ковариантного тензора Эйнштейна распечатываются на экране.

Функция: riemann (dis)

  Функция `riemann` вычисляет тензор кривизны Римана используя метрику и символы Кристоффеля. При этом используются следующие соглашения:

                      l      _l       _l       _l   _m    _l   _m
       R[i,j,k,l] =  R    = |      - |      + |    |   - |    |
                      ijk     ij,k     ik,j     mk   ij    mj   ik

  Эти обозначения совместимы с используемыми в пакете `itensor` и его функцией `icurvature`. Если необязательный аргумент dis равен `true`, тогда ненулевые компоненты тензора `riem[i,j,k,l]` печатаются на экране. Как и для тензора Эйнштейна, управление процессом упрощения компонент тензора Римана осуществляется при помощи различные переключателей(флагов). Если `ratriemann` равен `true`, тогда будет применено рациональное упрощение. Если `ratfac` равен `true`, тогда каждая компонента факторизуется.

  Если `cframe_flag` равен `false`, тогда тензор Римана вычисляется непосредственно исходя из символов Кристоффеля. Если `cframe_flag` равен `true`, тогда сначала вычисляется ковариантный тензор Римана исходя из компонент неголономного базиса.

Функция: lriemann (dis)

  Ковариантный тензор Римана (`lriem[]`). Функция вычисляет ковариантный тензор Римана и заносит результаты в массив `lriem`. Если флаг dis равен `true`, то результаты вычислений уникальных ненулевых компонент тензора выводятся на экран.

  Если флаг `cframe_flag` равен `true`, то ковариантный тензор Римана вычисляется напрямую по компонентам тетрады, если иначе, то вначале вычисляется тензор Римана ранга (3,1).

  Информация о порядке следования индексов подробнее освящена в пункте `riemann`.

Функция: uriemann (dis)

  Вычисляет контравариантные компоненты тензора Римана и заносит их в матрицу `uriem[i,j,k,l]`. Результаты вычислений печатаются на экране если флаг dis равен `true`.

Функция: rinvariant ()

  Вычисляет инвариант Кречмана (Kretchmann) (`kinvariant`), используя свертку тензоров. Например,

      lriem[i,j,k,l]*uriem[i,j,k,l].

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

Функция: weyl (dis)

  Вычисляет конформный тензор Вейля. Если флаг dis равен `true` - на экране печатаются не нулевые компоненты `weyl[i,j,k,l]`, если иначе, то результаты вычислений просто заносятся в матрицу. Если ключ `ratweyl` равен `true`, тогда производится автоматическое упрощение результата с использованием алгебры рациональных чисел; при `ratfac` равном `true` результат вычислений автоматически факторизуется.

#### 26.2.3 Разложение в ряды Тейлора

В пакете `ctensor` реализованы возможности упрощения результатов вычислений если метрика апроксимирована рядом Тейлора. Для учета метрики такого типа необходимо установить ключ `ctayswitch` равным `true`. Данный ключ заставляет использовать при пакетных вычислениях функцию `ctaylor` для упрощения результатов.

Функция `ctaylor` вызывается в следующих пакетных функциях `ctensor`:

        Функция      Комментарий
        ---------------------------------
        christof()   Только для mcs
        ricci()
        uricci()
        einstein()
        riemann()
        weyl()
        checkdiv()

Функция: ctaylor ()

  Функция `ctaylor` преобразует выражения заданных аргументов конвертируя их в Тейлоровские ряды, используя функцию `taylor`, и затем вызывая `ratdisrep`. Это приводит к отбрасыванию слагаемых высокого порядка по переменной разложения `ctayvar`. Порядок отбрасываемых членов определен переменной `ctaypov`; центральная точка окрестности разложения определяется переменной `ctaypt`.

  В качестве примера рассмотрим простую метрику , полученную в результате возмущений метрики Минковского. Если не наложить ограничений, то даже диагональная метрика в этом случае приводит к достаточно громоздким выражениям тензора Эйнштейна:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) ratfac:true;
      (%o2)                                true
      (%i3) derivabbrev:true;
      (%o3)                                true
      (%i4) ct_coords:[t,r,theta,phi];
      (%o4)                         [t, r, theta, phi]
      (%i5) lg:matrix([-1,0,0,0],[0,1,0,0],[0,0,r^2,0],
                      [0,0,0,r^2*sin(theta)^2]);
                              [ - 1  0  0         0        ]
                              [                            ]
                              [  0   1  0         0        ]
                              [                            ]
      (%o5)                   [          2                 ]
                              [  0   0  r         0        ]
                              [                            ]
                              [              2    2        ]
                              [  0   0  0   r  sin (theta) ]
      (%i6) h:matrix([h11,0,0,0],[0,h22,0,0],[0,0,h33,0],[0,0,0,h44]);
                                  [ h11   0    0    0  ]
                                  [                    ]
                                  [  0   h22   0    0  ]
      (%o6)                       [                    ]
                                  [  0    0   h33   0  ]
                                  [                    ]
                                  [  0    0    0   h44 ]
      (%i7) depends(l,r);
      (%o7)                               [l(r)]
      (%i8) lg:lg+l*h;
            [ h11 l - 1      0          0                 0            ]
            [                                                          ]
            [     0      h22 l + 1      0                 0            ]
            [                                                          ]
      (%o8) [                        2                                 ]
            [     0          0      r  + h33 l            0            ]
            [                                                          ]
            [                                    2    2                ]
            [     0          0          0       r  sin (theta) + h44 l ]
      (%i9) cmetric(false);
      (%o9)                                done
      (%i10) einstein(false);
      (%o10)                               done
      (%i11) ntermst(ein);
      [[1, 1], 62]
      [[1, 2], 0]
      [[1, 3], 0]
      [[1, 4], 0]
      [[2, 1], 0]
      [[2, 2], 24]
      [[2, 3], 0]
      [[2, 4], 0]
      [[3, 1], 0]
      [[3, 2], 0]
      [[3, 3], 46]
      [[3, 4], 0]
      [[4, 1], 0]
      [[4, 2], 0]
      [[4, 3], 0]
      [[4, 4], 46]
      (%o12)                               done

  Однако если считать что `l` мало и оставить только линейные члены по `l`, тогда получим намного более простое выражение для тензора Эйнштейна:

      (%i14) ctayswitch:true;
      (%o14)                               true
      (%i15) ctayvar:l;
      (%o15)                                 l
      (%i16) ctaypov:1;
      (%o16)                                 1
      (%i17) ctaypt:0;
      (%o17)                                 0
      (%i18) christof(false);
      (%o18)                               done
      (%i19) ricci(false);
      (%o19)                               done
      (%i20) einstein(false);
      (%o20)                               done
      (%i21) ntermst(ein);
      [[1, 1], 6]
      [[1, 2], 0]
      [[1, 3], 0]
      [[1, 4], 0]
      [[2, 1], 0]
      [[2, 2], 13]
      [[2, 3], 2]
      [[2, 4], 0]
      [[3, 1], 0]
      [[3, 2], 2]
      [[3, 3], 9]
      [[3, 4], 0]
      [[4, 1], 0]
      [[4, 2], 0]
      [[4, 3], 0]
      [[4, 4], 9]
      (%o21)                               done
      (%i22) ratsimp(ein[1,1]);
                               2      2  4               2     2
      (%o22) - (((h11 h22 - h11 ) (l )  r  - 2 h33 l    r ) sin (theta)
                                    r               r r

                                  2               2      4    2
                    - 2 h44 l    r  - h33 h44 (l ) )/(4 r  sin (theta))
                             r r                r

  Данное приближение полезно в пределе слабого поля, вдали от гравитационных источников.

#### 26.2.4 Неголономный базис

Если ключ `cframe_flag` равен `true`, то пакетные вычисления выполняются с использованием тетрадного (неголономного в общем случае) базиса.

Функция: frame_bracket (fr, fri, diagframe)

  Скобка тетрады (`fb[]`).

  Вычисляет скобку тетрады, следуя определению:

         c          c         c        d     e
      ifb   = ( ifri    - ifri    ) ifr   ifr
         ab         d,e       e,d      a     b

#### 26.2.5 Алгебраическая классификация

Новой особенностью пакета `ctensor` (начиная с ноября 2004) является возможность вычисления классификации Петрова 4-мерного пространственно-временного многообразия. Демонстрационные вычисления по данной теме представлены в файле `share/tensor/petrov.dem`.

Функция: nptetrad ()

  Вычисляет световую тетраду (`np`) Ньюмана-Пенроуза и связанную с ней дуальную часть (`npi`), см. `petrov` для примера.

  Световая тетрада конструируется с использованием 4-х мерного ортонормального базиса метрики, обладающей сигнатурой (-,+,+,+). Компоненты световой тетрады связаны с обратной матрицей метрики следующими соотношениями:

      np  = (fri  + fri ) / sqrt(2)
        1       1      2

      np  = (fri  - fri ) / sqrt(2)
        2       1      2

      np  = (fri  + %i fri ) / sqrt(2)
        3       3         4

      np  = (fri  - %i fri ) / sqrt(2)
        4       3         4

Функция: psi (dis)

  Вычисляет пять коэффициентов Ньюмана-Пенроуза `psi[0]`...`psi[4]`. Если `psi` равен `true`, эти коэффициенты печатаются на экране, см пример в пункте `petrov`.

  Коэффициенты вычисляются в координатном базисе из тензора Вейля. Если при использовании тетрадного базиса, компоненты тензора Вейля предварительно конвертируются в координатный базис. Эта процедура не оптимальна с вычислительной точки зрения и поэтому перед вычислением тензора Вейля предварительно рекомендуется задать координатный базис. Заметим однако, что вычисления световой тетрады (`np`) Ньюмана-Пенроуза требует задания тетрадного базиса. Таким образом, имеющая смысл схема вычислений в этом случае может состоять из следующих этапов: вначале задается базис тетрады, который затем используется для вычисления метрики `lg` (вычисляется автоматически при вызове `cmetric`) и обратной метрики `ug`; на этом этапе можно переключится обратно к координатному базису установив ключ `cframe_flag` равным `false` перед началом вычислений символов Кристоффеля. Переход обратно к тетрадному базису на более поздних стадиях вычислений может привести к несогласованным результатам, поскольку в выражении перемешиваются результаты вычислений компонент тензоров выполненных в различных базисах.

Функция: petrov ()

  Вычисляет классификацию Петрова для данной метрики, определяя `psi[0]`...`psi[4]`.

  Например, нижеследующее показывает, как получить классификацию Петрова для метрики Керра:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) (cframe_flag:true,gcd:spmod,ctrgsimp:true,ratfac:true);
      (%o2)                                true
      (%i3) ct_coordsys(exteriorschwarzschild,all);
      (%o3)                                done
      (%i4) ug:invert(lg)$
      (%i5) weyl(false);
      (%o5)                                done
      (%i6) nptetrad(true);
      (%t6) np =

      [ sqrt(r - 2 m)           sqrt(r)                                 ]
      [---------------   ---------------------    0            0        ]
      [sqrt(2) sqrt(r)   sqrt(2) sqrt(r - 2 m)                          ]
      [                                                                 ]
      [ sqrt(r - 2 m)            sqrt(r)                                ]
      [---------------  - ---------------------   0            0        ]
      [sqrt(2) sqrt(r)    sqrt(2) sqrt(r - 2 m)                         ]
      [                                                                 ]
      [                                          r      %i r sin(theta) ]
      [       0                    0          -------   --------------- ]
      [                                       sqrt(2)       sqrt(2)     ]
      [                                                                 ]
      [                                          r       %i r sin(theta)]
      [       0                    0          -------  - ---------------]
      [                                       sqrt(2)        sqrt(2)    ]

                                   sqrt(r)         sqrt(r - 2 m)
      (%t7) npi = matrix([- ---------------------,---------------, 0, 0],
                            sqrt(2) sqrt(r - 2 m) sqrt(2) sqrt(r)

                sqrt(r)            sqrt(r - 2 m)
      [- ---------------------, - ---------------, 0, 0],
         sqrt(2) sqrt(r - 2 m)    sqrt(2) sqrt(r)

                 1               %i
      [0, 0, ---------, --------------------],
             sqrt(2) r  sqrt(2) r sin(theta)

                 1                 %i
      [0, 0, ---------, - --------------------])
             sqrt(2) r    sqrt(2) r sin(theta)

      (%o7)                                done
      (%i7) psi(true);
      (%t8)                              psi  = 0
                                            0

      (%t9)                              psi  = 0
                                            1

                                                m
      (%t10)                             psi  = --
                                            2    3
                                                r

      (%t11)                             psi  = 0
                                            3

      (%t12)                             psi  = 0
                                            4
      (%o12)                               done
      (%i12) petrov();
      (%o12)                                 D

  Вычисление классификации Петрова основано на алгоритме опубликованном в монографии "Classifying geometries in general relativity: III Classification in practice" by Pollney, Skea, and d’Inverno, Class. Quant. Grav. 17 2885-2902 (2000). В текущем виде (по состоянию на 19 декабря 2004) код программы протестирован только для некоторых простых случаев и может содержать ошибки.

#### 26.2.6 Кручение и неметричность

В пакете `ctensor` реализованы учета неметричности и кручения в коэффициентах связности.

Коэффициенты кручения вычисляются при помощи определенного пользователем тензора кручения ранга (2,1) `tr`. Используя его, коэффициенты кручения, `kt`, вычисляются по формулам:

                  m          m      m
           - g  tr   - g   tr   - tr   g
              im  kj    jm   ki     ij  km
    kt   = -------------------------------
      ijk                 2

      k     km
    kt   = g   kt
      ij         ijm

Заметим, что массив `kt` содержит только смешанные компоненты.

Коэффициенты неметричности вычисляются из предварительно определенного пользователем вектора неметричности `nm` по следующим формулам:

                 k    k        km
           -nm  D  - D  nm  + g   nm  g
       k      i  j    i   j         m  ij
    nmc  = ------------------------------
       ij                2

где D обозначает дельта-символ Кронекера.

Если ключ `ctorsion_flag` равен `true`, то коэффициенты `kt` выделяются из смешанных компонент связности вычисляемых функцией `christof` и запоминаются в массиве `mcs`. Аналогичным образом Maxima поступает, если флаг `cnonmet_flag` равен `true`, в этом случае из смешанных компонент связности выделяется массив `nmc`.

Если необходимо, функция `christof` вызывает функции `contortion` `nonmetricity` для вычисления массивов `kt` `nm`.

Функция: contortion (tr)

  Вычисляет коэффициенты кручения ранга (2,1) из тензора кручения tr.

Функция: nonmetricity (nmс)

  Вычисляет коэффициенты неметричности ранга (2,1) из вектора неметричности nm.

#### 26.2.7 Вспомогательные средства

Функция: ctransform (M)

  Функция, выполняющая координатное преобразование произвольной симметричной матрицы M. Пользователь интерактивно запрашивается системой о функциях осуществляющих преобразование (прошлое название `transform`).

Функция: findde (A, n)

  возвращает список дифференциальных уравнений, соответствующих элементам n -ой квадратной матрицы A. В текущем виде n может быть 2 или 3. `deindex` - список (определенный глобально) содержащий индексы матрицы A соответствующие этим дифференциальным уравнениям. Для тензора Эйнштейна (`ein`), представленного в форме двухмерного массива вычисленного по метрике данной ниже, функция `findde` дает следующую систему уравнений:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) derivabbrev:true;
      (%o2)                                true
      (%i3) dim:4;
      (%o3)                                  4
      (%i4) lg:matrix([a, 0, 0, 0], [ 0, x^2, 0, 0],
                                    [0, 0, x^2*sin(y)^2, 0], [0,0,0,-d]);
                                [ a  0       0        0  ]
                                [                        ]
                                [     2                  ]
                                [ 0  x       0        0  ]
      (%o4)                     [                        ]
                                [         2    2         ]
                                [ 0  0   x  sin (y)   0  ]
                                [                        ]
                                [ 0  0       0       - d ]
      (%i5) depends([a,d],x);
      (%o5)                            [a(x), d(x)]
      (%i6) ct_coords:[x,y,z,t];
      (%o6)                            [x, y, z, t]
      (%i7) cmetric();
      (%o7)                                done
      (%i8) einstein(false);
      (%o8)                                done
      (%i9) findde(ein,2);
                                                  2
      (%o9) [d  x - a d + d, 2 a d d    x - a (d )  x - a  d d  x
              x                     x x         x        x    x

                                                    2          2
                                + 2 a d d   - 2 a  d , a  x + a  - a]
                                         x       x      x
      (%i10) deindex;
      (%o10)                     [[1, 1], [2, 2], [4, 4]]

Функция: cograd ()

  Вычисляет ковариантный градиент скалярной функции. Пользователь может задать имя полученному вектору, согласно процедуре проиллюстрированной ниже в пункте `contragrad`.

Функция: contragrad ()

  Вычисляет контравариантный градиент скалярной функции. Пользователь может задать имя полученному вектору, следуя примеру (вычисления используют метрику Шварцшильда):

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) derivabbrev:true;
      (%o2)                                true
      (%i3) ct_coordsys(exteriorschwarzschild,all);
      (%o3)                                done
      (%i4) depends(f,r);
      (%o4)                               [f(r)]
      (%i5) cograd(f,g1);
      (%o5)                                done
      (%i6) listarray(g1);
      (%o6)                            [0, f , 0, 0]
                                            r
      (%i7) contragrad(f,g2);
      (%o7)                                done
      (%i8) listarray(g2);
                                     f  r - 2 f  m
                                      r        r
      (%o8)                      [0, -------------, 0, 0]
                                           r

Функция: dscalar ()

  вычисляет даламбертиан скалярной функции, (зависимость от переменных должна быть определена заранее), например:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) derivabbrev:true;
      (%o2)                                true
      (%i3) ct_coordsys(exteriorschwarzschild,all);
      (%o3)                                done
      (%i4) depends(p,r);
      (%o4)                               [p(r)]
      (%i5) factor(dscalar(p));
                                2
                          p    r  - 2 m p    r + 2 p  r - 2 m p
                           r r           r r        r          r
      (%o5)               --------------------------------------
                                             2
                                            r

Функция: checkdiv ()

  вычисляет ковариантную дивергенцию смешанного тензора второго ранга (первый индекс должен быть ковариантным). На печать выводится n-соответствующих компонент полученного векторного поля, где n = `dim`. Если аргументом функции является `g` (метрический тензор), тогда для упрощения результата используется равенство нулю ковариантной дивергенции тензора Эйнштейна. Результат вычислений (вектор) запоминается в массиве с именем `div`.

Функция: cgeodesic (dis)

  Функция пакета `ctensor` вычисляющая уравнения геодезических для заданной метрики. Результат запоминается в массиве `geod[i]`. Если аргумент dis равен `true`, тогда на экране печатается результат вычислений.

Функция: bdvac (f)

  генерирует ковариантные компоненты вакуумных уравнений поля теории Бранса-Дикке. Скалярное поле определено аргументом f, который задается в виде взятого в кавычки имени функции вместе со своими функциональными аргументами, например, `bdvac('p(x))`. Результат вычислений (компоненты поля ковариантного тензора 2-го ранга) запоминается в `bd`.

Функция: invariant1 ()

  генерирует полевые уравнения Эйлера-Лагранжа для инвариантной плотности R^2. Результат запоминается в массиве `inv1`.

Функция: invariant2 ()

  *** ПОКА НЕ РЕАЛИЗОВАНО *** генерирует смешанные полевые уравнения Эйлера-Лагранжа для инвариантной плотности `ric[i,j]*uriem[i,j]`. Результат запоминается в массиве `inv2`.

Функция: bimetric ()

  *** ПОКА НЕ РЕАЛИЗОВАНО *** генерирует полевые уравнения биметрической теории Розена. Результат запоминается в массиве `rosen`.

#### 26.2.8 Утилиты

Функция: diagmatrixp (M)

  Возвращает `true` если M - диагональная матрица (2-х мерный массив).

Функция: symmetricp (M)

  Возвращает `true` если M - симметричная матрица (2-х мерный массив).

Функция: ntermst (f)

  Дает пользователю возможность оценить размеры массива компонент тензора f. В результате печатается список двух элементов, где первый элемент является списком индексов компоненты тензора, а второй элемент соответствует количеству слагаемых этой компоненты. Таким способом можно быстро выявить ненулевые компоненты и оценить стратегию упрощения тензора.

Функция: cdisplay (ten)

  показывает все элементы тензора ten, в виде многомерного массива. Тензора ранга 0 и 1, также как и другие типы переменных показываются стандартной функцией Maxima - `ldisplay`. Тензоры ранга 2 печатаются в виде двухмерной матрицы, тензоры более высокого порядка выводятся на экран как список 2-мерных матриц. Например в следующем примере на экран выводится результаты вычисления тензора Римана для метрики Шварцшильда:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) ratfac:true;
      (%o2)                                true
      (%i3) ct_coordsys(exteriorschwarzschild,all);
      (%o3)                                done
      (%i4) riemann(false);
      (%o4)                                done
      (%i5) cdisplay(riem);
                [ 0               0                   0           0     ]
                [                                                       ]
                [                              2                        ]
                [      3 m (r - 2 m)   m    2 m                         ]
                [ 0  - ------------- + -- - ----      0           0     ]
                [            4          3     4                         ]
                [           r          r     r                          ]
                [                                                       ]
      riem    = [                                m (r - 2 m)            ]
          1, 1  [ 0               0              -----------      0     ]
                [                                     4                 ]
                [                                    r                  ]
                [                                                       ]
                [                                           m (r - 2 m) ]
                [ 0               0                   0     ----------- ]
                [                                                4      ]
                [                                               r       ]

                                      [    2 m (r - 2 m)       ]
                                      [ 0  -------------  0  0 ]
                                      [          4             ]
                                      [         r              ]
                           riem     = [                        ]
                               1, 2   [ 0        0        0  0 ]
                                      [                        ]
                                      [ 0        0        0  0 ]
                                      [                        ]
                                      [ 0        0        0  0 ]

                                      [         m (r - 2 m)    ]
                                      [ 0  0  - -----------  0 ]
                                      [              4         ]
                                      [             r          ]
                           riem     = [                        ]
                               1, 3   [ 0  0        0        0 ]
                                      [                        ]
                                      [ 0  0        0        0 ]
                                      [                        ]
                                      [ 0  0        0        0 ]

                                      [            m (r - 2 m) ]
                                      [ 0  0  0  - ----------- ]
                                      [                 4      ]
                                      [                r       ]
                           riem     = [                        ]
                               1, 4   [ 0  0  0        0       ]
                                      [                        ]
                                      [ 0  0  0        0       ]
                                      [                        ]
                                      [ 0  0  0        0       ]

                                     [       0         0  0  0 ]
                                     [                         ]
                                     [       2 m               ]
                                     [ - ------------  0  0  0 ]
                          riem     = [    2                    ]
                              2, 1   [   r  (r - 2 m)          ]
                                     [                         ]
                                     [       0         0  0  0 ]
                                     [                         ]
                                     [       0         0  0  0 ]

                   [     2 m                                         ]
                   [ ------------  0        0               0        ]
                   [  2                                              ]
                   [ r  (r - 2 m)                                    ]
                   [                                                 ]
                   [      0        0        0               0        ]
                   [                                                 ]
        riem     = [                         m                       ]
            2, 2   [      0        0  - ------------        0        ]
                   [                     2                           ]
                   [                    r  (r - 2 m)                 ]
                   [                                                 ]
                   [                                         m       ]
                   [      0        0        0         - ------------ ]
                   [                                     2           ]
                   [                                    r  (r - 2 m) ]

                                      [ 0  0       0        0 ]
                                      [                       ]
                                      [            m          ]
                                      [ 0  0  ------------  0 ]
                           riem     = [        2              ]
                               2, 3   [       r  (r - 2 m)    ]
                                      [                       ]
                                      [ 0  0       0        0 ]
                                      [                       ]
                                      [ 0  0       0        0 ]

                                      [ 0  0  0       0       ]
                                      [                       ]
                                      [               m       ]
                                      [ 0  0  0  ------------ ]
                           riem     = [           2           ]
                               2, 4   [          r  (r - 2 m) ]
                                      [                       ]
                                      [ 0  0  0       0       ]
                                      [                       ]
                                      [ 0  0  0       0       ]

                                            [ 0  0  0  0 ]
                                            [            ]
                                            [ 0  0  0  0 ]
                                            [            ]
                                 riem     = [ m          ]
                                     3, 1   [ -  0  0  0 ]
                                            [ r          ]
                                            [            ]
                                            [ 0  0  0  0 ]

                                            [ 0  0  0  0 ]
                                            [            ]
                                            [ 0  0  0  0 ]
                                            [            ]
                                 riem     = [    m       ]
                                     3, 2   [ 0  -  0  0 ]
                                            [    r       ]
                                            [            ]
                                            [ 0  0  0  0 ]

                                     [   m                      ]
                                     [ - -   0   0       0      ]
                                     [   r                      ]
                                     [                          ]
                                     [        m                 ]
                                     [  0   - -  0       0      ]
                          riem     = [        r                 ]
                              3, 3   [                          ]
                                     [  0    0   0       0      ]
                                     [                          ]
                                     [              2 m - r     ]
                                     [  0    0   0  ------- + 1 ]
                                     [                 r        ]

                                          [ 0  0  0    0   ]
                                          [                ]
                                          [ 0  0  0    0   ]
                                          [                ]
                               riem     = [            2 m ]
                                   3, 4   [ 0  0  0  - --- ]
                                          [             r  ]
                                          [                ]
                                          [ 0  0  0    0   ]

                                      [       0        0  0  0 ]
                                      [                        ]
                                      [       0        0  0  0 ]
                                      [                        ]
                           riem     = [       0        0  0  0 ]
                               4, 1   [                        ]
                                      [      2                 ]
                                      [ m sin (theta)          ]
                                      [ -------------  0  0  0 ]
                                      [       r                ]

                                      [ 0        0        0  0 ]
                                      [                        ]
                                      [ 0        0        0  0 ]
                                      [                        ]
                           riem     = [ 0        0        0  0 ]
                               4, 2   [                        ]
                                      [         2              ]
                                      [    m sin (theta)       ]
                                      [ 0  -------------  0  0 ]
                                      [          r             ]

                                    [ 0  0          0          0 ]
                                    [                            ]
                                    [ 0  0          0          0 ]
                                    [                            ]
                         riem     = [ 0  0          0          0 ]
                             4, 3   [                            ]
                                    [                2           ]
                                    [         2 m sin (theta)    ]
                                    [ 0  0  - ---------------  0 ]
                                    [                r           ]

                 [        2                                             ]
                 [   m sin (theta)                                      ]
                 [ - -------------         0                0         0 ]
                 [         r                                            ]
                 [                                                      ]
                 [                         2                            ]
                 [                    m sin (theta)                     ]
      riem     = [        0         - -------------         0         0 ]
          4, 4   [                          r                           ]
                 [                                                      ]
                 [                                          2           ]
                 [                                   2 m sin (theta)    ]
                 [        0                0         ---------------  0 ]
                 [                                          r           ]
                 [                                                      ]
                 [        0                0                0         0 ]

      (%o5)                                done

Функция: deleten (L, n)

  Возвращает новый список состоящий из элементов списка L с удаленным n-ым элементом.

#### 26.2.9 Переменные пакета ctensor

Управляющая переменная: dim

  Значение по умолчанию: 4

  Опция пакета `ctensor` (компонентные вычисления). Размерность многообразия, по умолчанию: 4 Команда `dim: n` переопределяет размерность величине равной `n`.

Управляющая переменная: diagmetric

  Значение по умолчанию: `false`

  Опция пакета `ctensor` (компонентные вычисления). Если `diagmetric` равен `true`, тогда вычисления всех геометрических объектов проводятся по упрощенной схеме: с учетом диагональности метрики. Это позволяет уменьшить время счета. Данная опция устанавливается автоматически если при вызове `csetup` была задана диагональная метрика.

Управляющая переменная: ctrgsimp

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

Управляющая переменная: cframe_flag

  Если ключ `cframe_flag` равен `true`, тогда вычисления проводятся в тетрадном базисе (в общем случае с не голономной метрикой). Базис определяется массивом дуального фрейма `fri` и метрикой базиса `lfg`. При вычислениях в декартовой тетраде массив, `lfg` должен быть единичной матрицей соответствующего размера; при вычислениях с Лоренцевой тетрадой, массив `lfg` должен иметь соответствующую сигнатуру.

Управляющая переменная: ctorsion_flag

  Если `ctorsion_flag` равен `true`, тогда при вычислении связности учитываются коэффициенты кручения `contortion`. В свою очередь, коэффициенты кручения, `contortion`, вычисляются из заданного пользователем тензора кручения `tr`.

Управляющая переменная: cnonmet_flag

  Если `cnonmet_flag` равен `true`, тогда при вычислении связности учитывается неметричность `nonmetricity`, которая, сама по себе, вычисляется из заданного пользователем вектора неметричности `nm`.

Управляющая переменная: ctayswitch

  Если ключ равен `true`, то при вычислениях используются ряды Тейлора. В текущем состоянии пакета, эти ряды влияют на вычисление следующих тензоров: `christof`, `ricci`, `uricci`, `einstein`, и `weyl`.

Управляющая переменная: ctayvar

  Переменная ряда Тейлора. Она активируется при `ctayswitch` равном `true`.

Управляющая переменная: ctaypov

  Максимальная ряда Тэйлора. Ее определение влияет на вычисления только если `ctayswitch` равен `true`.

Управляющая переменная: ctaypt

  Центральная точка ряда Тэйлора. Ее определение влияет на вычисления только если `ctayswitch` равен `true`.

Системная переменная: gdet

  Детерминант метрического тензора `lg`. Вычисляется функцией `cmetric`, когда флаг `cframe_flag` равен `false`.

Управляющая переменная: ratchristof

  Включает рациональное упрощение коэффициентов связности `christof`.

Управляющая переменная: rateinstein

  Значение по умолчанию: `true`

  Если равен `true` тогда проводится рациональное упрощение компонент тензора Эйнштейна; если `ratfac` равен `true`, тогда компоненты тензора автоматически факторизуются.

Управляющая переменная: ratriemann

  Значение по умолчанию: `true`

  Один из ключей, контролирующих упрощение тензора Римана; Если равен `true` тогда применяется рациональное упрощение; если `ratfac` равен `true`, тогда компоненты тензора автоматически факторизуются.

Управляющая переменная: ratweyl

  Значение по умолчанию: `true`

  Если равен `true` тогда применяется рациональное упрощение тензора Вейля; если `ratfac` равен `true`, тогда компоненты тензора автоматически факторизуются.

Переменная: lfg

  Имя ковариантной метрики тетрады. По умолчанию совпадает с Лоренцевой метрикой, имеет сигнатуру (+,+,+,-). Используется когда `cframe_flag` равен `true`.

Переменная: ufg

  Имя контравариантной метрики тетрады. Вычисляется из `lfg`, если вызывается функция `cmetric` и флаг `cframe_flag` равен `true`.

Переменная: riem

  Тензор Римана ранга (3,1). Вычисляется вызовом функции `riemann`. Для информации о порядке следования индексов см. описание `riemann`.

  Если `cframe_flag` равен `true`, `riem` вычисляется по ковариантным компонентам тензора Римана `lriem`.

Переменная: lriem

  Ковариантная версия тензора Римана. Вычисляется вызовом функции `lriemann`.

Переменная: uriem

  Контравариантная версия тензора Римана. Вычисляется вызовом функции `uriemann`.

Переменная: ric

  Смешанный тензор Риччи. Вычисляется функцией `ricci`.

Переменная: uric

  Контравариантный тензор Риччи. Вычисляется функцией `uricci`.

Переменная: lg

  Метрический тензор. Данный тензор должен (наравне с переменной `dim`) определен до начала других вычислений.

Переменная: ug

  Обратный метрический тензор. Вычисляется функцией `cmetric`.

Переменная: weyl

  Тензор Вейля. Вычисляется функцией `weyl`.

Переменная: fb

  Коммутатор (скобка) тетрады, вычисляется функцией `frame_bracket`.

Переменная: kinvariant

  Инвариант Кретчмана. Вычисляется функцией `rinvariant`.

Переменная: np

  Нуль-тетрада Ньюмана-Пенроуза. Вычисляется функцией `nptetrad`.

Переменная: npi

  Нуль-тетрада Ньюмана-Пенроуза с поднятыми индексами; вычисляется процедурой `nptetrad`. Определена посредством `ug.np`. Произведение `np.transpose(npi)` является константой:

      (%i39) trigsimp(np.transpose(npi));
                                    [  0   - 1  0  0 ]
                                    [                ]
                                    [ - 1   0   0  0 ]
      (%o39)                        [                ]
                                    [  0    0   0  1 ]
                                    [                ]
                                    [  0    0   1  0 ]

Переменная: tr

  Определенный пользователем тензор 3-го ранга, задающий кручение. Используется процедурой `contortion`.

Переменная: kt

  Вклад кручения в коэффициенты связности, вычисляется из тензора кручения `tr` функцией `contortion`.

Переменная: nm

  Определенный пользователем вектор неметричности. Используется функцией `nonmetricity`.

Переменная: nmc

  Вклад неметричности в связность; вычисляется из `nm` функцией `nonmetricity`.

Системная переменная: tensorkill

  Переменная показывающая, что пакет `ctensor` инициализирован. Эти установки используются процедурой `csetup`, и переопределяются процедурой `init_ctensor`.

Управляющая переменная: ct_coords

  Значение по умолчанию: `[]`

  Опция пакета `ctensor` (компонентные вычисления тензоров). `ct_coords` содержит список имен координат. Обычно он определяется при вызове процедуры `csetup`. Список может быть переопределен назначением нового списка `ct_coords: [j1, j2, ..., jn]`, j’s имена новых координат. Смотри также `csetup`.

#### 26.2.10 Зарезервированные имена

Следующие имена используются функциями и процедурами пакета `ctensor` (не следует их переопределять):

      Наименование Описание
      ----------------------------------------------------------------
      _lg()        Присваивается массиву lfg если используется
                   тетрадная метрика; по умолчанию присваивается
                   массиву lg
      _ug()        Присваивается массиву ufg если используется
                   тетрадная метрика; по умолчанию присваивается
                   массиву ug
      cleanup()    Удаляет элементы drom списка deindex
      contract4()  используется функцией psi()
      filemet()    используется функцией csetup() при чтении метрики
                   из файла
      findde1()    используется функцией findde()
      findde2()    используется функцией findde()
      findde3()    используется функцией findde()
      kdelt()      дельта-символ Кронекера (необобщенный)
      newmet()     используется функцией csetup() для интерактивного
                   определения метрики
      setflags()   используется функцией init_ctensor()
      readvalue()
      resimp()
      sermet()     используется функцией csetup() для ввода метрики
                   в виде разложения в ряд Тэйлора
      txyzsum()
      tmetric()    Метрика тетрады, используется функцией cmetric(),
                   если cframe_flag:true
      triemann()   Тензор Римана в тетрадном представлении,
                   используется если cframe_flag:true
      tricci()     Тензор Риччи в тетрадном представлении,
                   используется если cframe_flag:true
      trrc()       Коэффициенты вращения Риччи, используется
                   функцией christof()
      yesp()

#### 26.2.11 Изменения

В ноябре 2004 пакет `ctensor` был существенно переписан. Многие функции и переменные были переименованы для того чтобы сделать данный пакет совместимым с коммерческой версией Macsyma.

      Новое имя    Статое имя      Описание
      -----------------------------------------------------------------
      ctaylor()    DLGTAYLOR()     Разложение выражения в ряд
                                   Тэйлора
      lgeod[]      EM              Уравнения геодезических
      ein[]        G[]             Смешанный тензор Эйнштейна
      ric[]        LR[]            Смешанный тензор Риччи
      ricci()      LRICCICOM()     Вычисляет смешанный тензор Риччи
      ctaypov      MINP            Максимальная степень ряда Тэйлора
      cgeodesic()  MOTION          Вычисляет уравнения геодезических
      ct_coords    OMEGA           метрические координаты
      ctayvar      PARAM           Переменная ряда Тэйлора
      lriem[]      R[]
      uriemann()   RAISERIEMANN()  Вычисляет контравариантный тензор
                                   Римана
      ratriemann   RATRIEMAN       Рациональное упрощение тензора
                                   Римана
      uric[]       RICCI[]         Контравариантный тензор Риччи
      uricci()     RICCICOM()      Вычисляет контравариантный тензор
                                   Риччи
      cmetric()    SETMETRIC()     Определяет метрику
      ctaypt       TAYPT           Центральная точка окрестности ряда
                                   Тэйлора
      ctayswitch   TAYSWITCH       Ключ, устанавливающий использовать
                                   ли ряды Тэйлора в метрике
      csetup()     TSETUP()        Вызывает начало интерактивного
                                   режима задания метрики и пр.
      ctransform() TTRANSFORM()    Интерактивное преобразование
                                   координат
      uriem[]      UR[]            Контравариантный тензор Римана
      weyl[]       W[]             Тензор Вейля ранга (3,1)

Previous: Введение в пакет ctensor, Up: Пакет ctensor [Contents][Index]