doc/info/ru/Itensor.texi

   1 @c Language=Russian
   2 @c Encoding=UTF-8
   3 @c File=Itensor.texi
   4 @c OriginalRevision=1.44
   5 @c TranslatedBy: (c) 2005-12 Valery Pipin <pip@iszf.irk.ru>
   6
   7 @menu
   8 * Введение в пакет itensor::
   9 * Функции и переменные пакета itensor::
  10 @end menu
  11
  12 @node Введение в пакет itensor, Функции и переменные пакета itensor, Пакет itensor, Пакет itensor
  13 @section Введение в пакет itensor
  14
  15 В Maxima реализованы два различных типа операций над тензорами:
  16 операции над компонентами -- пакет @code{ctensor} и операции с индексами -- пакет
  17 @code{itensor}.
  18
  19 ВАЖНОЕ ЗАМЕЧАНИЕ: Пожалуйста, ниже, обратите внимание на нововведения в системе индексных
  20 обозначений для тензоров.
  21
  22 При операциях с компонентами тензорный объект рассматривается, как многомерный массив
  23 или матрица.  Операции свертки и ковариантного дифференцирования над такими объектами
  24 фактически сводятся к дифференцированию элементов матрицы и суммированию по повторяющимся индексам
  25 при помощи команды @code{do}.  Полученный результат операций над компонентами тензора
  26 хранится в форме массива или матрицы.
  27
  28 При операциях с индексами, тензор рассматривается как функция своих индексов (ковариантных,
  29 контравариантных и индексов производной).  В этом случае результат тензорных операций,
  30 например, таких как свертка или ковариантное дифференцирование, достигается только
  31 с помощью соответствующих манипуляций с индексами, а не с
  32 компонентами, которым они соответствуют.
  33
  34 Оба подхода к рассмотрению дифференциальных, алгебраических и аналитических проблем в
  35 контексте Римановой геометрии имеют и преимущества,  и недостатки,
  36 которые выявляются при рассмотрении конкретных задач.  Необходимо иметь ввиду
  37 следующие специфические свойства каждого из методов:
  38
  39 i) Представление тензоров в явном виде через их компоненты делает
  40 @code{ctensor} алгоритмически простым в использовании. Вычисления метрики,
  41 производных тензоров и инвариантов реализуются непосредственно по определению.
  42 Однако, несмотря на вычислительную мощь Maxima, в случае достаточно
  43 сложной метрики, внутренние функциональные связи и координатные зависимости
  44 компонент метрики легко могут привести к чрезвычайно громоздким выражениям,
  45 со скрытой структурой.
  46
  47 ii) В силу специфики способа, при котором тензора и операции над ними
  48 рассматриваются в терминах символьных операций над их индексами, выражения,
  49 вычисления которых в компонентном представлении выглядели бы громоздко, могут быть
  50 иногда сильно упрощены при помощи использования симметрий тензоров и
  51 специальных функций пакета @code{itensor}, использующих симметрии.  В тоже
  52 время, индексное представление тензоров в этом пакете создает
  53 определенные трудности при определении метрики, функций
  54 и вычислении дифференцируемых объектов.
  55
  56 @opencatbox{Категории:}
  57 @category{Тензоры}
  58 @category{Пакеты библиотеки share}
  59 @category{Пакет itensor}
  60 @closecatbox
  61
  62 @subsection Новые соглашения для обозначения тензорных индексов
  63
  64 До настоящего времени, в пакете  @code{itensor} были приняты обозначения,
  65 которые не сохраняли порядок индексов при операциях свертки, например:
  66
  67 @example
  68 (%i2) imetric(g);
  69 (%o2)                                done
  70 (%i3) ishow(g([],[j,k])*g([],[i,l])*a([i,j],[]))$
  71                                  i l  j k
  72 (%t3)                           g    g    a
  73                                            i j
  74 (%i4) ishow(contract(%))$
  75                                       k l
  76 (%t4)                                a
  77 @end example
  78
  79 Этот результат не верен за исключением случая когда тензор @code{a}
  80 симметричен.  Порядок следования индекса теряется при свертке, несмотря на
  81 то, что @code{itensor} сохраняет порядок индексов внутри
  82 каждого набора ковариантных и контравариантных индексов (в соответствии
  83 со свойствами симметрии).
  84
  85 Для того, чтобы избежать данной проблемы была предложена новая система
  86 обозначений, которая совместима с существующей. В данном случае
  87 контравариантные индексы могут быть вставлены в нужную позицию в наборе
  88 ковариантных, но со знаком минус. Функции типа  @code{contract()} и
  89 @code{ishow()} были модифицированы таким образом, чтобы понимать
  90 новые обозначения.
  91
  92 В данных обозначениях вычисление предыдущего примера дает:
  93
  94 @example
  95 (%i5) ishow(g([-j,-k],[])*g([-i,-l],[])*a([i,j],[]))$
  96                                  i l       j k
  97 (%t5)                           g    a    g
  98                                       i j
  99 (%i6) ishow(contract(%))$
 100                                       l k
 101 (%t6)                                a
 102 @end example
 103
 104 В настоящий момент, единственной функцией, где  новые обозначения
 105 играют существенную роль является @code{lc2kdt}. Благодаря этому
 106 удается получить корректный результат для тензорного произведения
 107 символов Леви-Чивита, применяя метрический тензор не прибегая
 108 к пересортировке численных индексов обобщенных символов Кронекера.
 109
 110 Поскольку данные нововведения сделаны относительно недавно, можно
 111 ожидать присутствие ошибок.  Код был достаточно тщательно
 112 протестирован, чтобы убедиться, что ничего не нарушается
 113 при использовании старых обозначений. В тоже время при работе
 114 в новых обозначения шанс получения ошибки довольно значителен.
 115 Для исправления замеченных ошибок обращайтесь к разработчикам.
 116
 117
 118 @subsection Манипулирование тензорными индексами
 119
 120 Пакет манипулирования тензорными индексами загружается в Maxima командой
 121 @code{load("itensor")}. Доступен ряд демонстрационных программ,
 122 которые загружаются командой @code{demo(tensor)}.
 123
 124 В этом пакете тензор рассматривается, как функция индексов и их списков.
 125 Список ковариантных индексов -- это первый аргумент индексного
 126 объекта. Далее идет список контравариантных индексов и индексы
 127 производной. Списки могут быть пустыми -- @code{[]}. Это говорит об отсутствии
 128 ковариантный или контравариантных индексов тензора. Таким образом, @code{g([a,b],[c])}
 129 представляет тензор @code{g}, который имеет 2 ковариантных индекса
 130 @code{(a,b)}, один контравариантный -- (@code{c}) и не имеет индексов производной.
 131
 132 Если есть индексы производной, то они добавляются в качестве
 133 дополнительных аргументов после списка контравариантных индексов.
 134 Они могут быть либо определены пользователем в явном виде,  либо
 135 получены в процессе дифференцирования тензора.
 136 Поскольку обычная производная -- это коммутативная операция, то индексы
 137 производной по умолчанию сортируются в алфавитном порядке если флаг
 138 @code{iframe_flag} не равен @code{true}, указывая на то, что
 139 используется тетрадная метрика. Такой принцип сортировки делает возможным
 140 для  Maxima распознать что, например, @code{t([a],[b],i,j)} есть тоже
 141 самое что и @code{t([a],[b],j,i)}.  Дифференцирование индексных
 142 объектов в отношении координат, индексы которых не являются аргументом
 143 этого объекта, в обычной ситуации давало бы ноль, потому, что
 144 по-умолчанию Maxima не знает, что тензор, представляемый в виде функции
 145 по индексам, может неявно зависеть от соответствующей
 146 координаты.  Модификация существующей функции @code{diff} в
 147 пакете @code{itensor} приводит к тому, что любой индексный объект зависит от
 148 любой переменной дифференцирования пока не объявлено обратное. Это
 149 делает возможным распространить известное правило суммирования по немым
 150 индексам на индексы производных. Необходимо отметить, что @code{itensor} не
 151 заложена возможность для подъема индексов производных и поэтому они
 152 всегда рассматриваются как ковариантные.
 153
 154 В настоящий момент, все функции направленные на упрощение тензорных
 155 выражений предполагают, что по умолчанию тензор не обладает
 156 какими-либо свойствами симметрии. Это условие может быть переопределено путем
 157 замены значения флага @code{allsym:false} на @code{true}. В этом
 158 случае функции манипулирования индексами будут рассматривать все
 159 индексные объекты, как полностью симметричные по спискам ковариантных
 160 и контравариантных индексов.
 161
 162 Пакет @code{itensor} рассматривает тензора, как функциональные объекты. При
 163 манипулировании тензорными уравнениями используются алгебраические правила,
 164 свойства симметрии и свертки. Кроме того, в @code{itensor} определены операции
 165 ковариантного дифференцирования, а также кривизна и
 166 кручение. Вычисления могут проводится также и с учетом метрики
 167 подвижных базисов (тетрады) если значение переменной
 168 @code{iframe_flag} равно @code{true}.
 169
 170 В примере ниже показано как загрузить пакет @code{itensor}, задать имя
 171 метрики и выполнить простые вычисления.
 172
 173 @example
 174 (%i1) load("itensor");
 175 (%o1)      /share/tensor/itensor.lisp
 176 (%i2) imetric(g);
 177 (%o2)                                done
 178 (%i3) components(g([i,j],[]),p([i,j],[])*e([],[]))$
 179 (%i4) ishow(g([k,l],[]))$
 180 (%t4)                               e p
 181                                        k l
 182 (%i5) ishow(diff(v([i],[]),t))$
 183 (%t5)                                  0
 184 (%i6) depends(v,t);
 185 (%o6)                               [v(t)]
 186 (%i7) ishow(diff(v([i],[]),t))$
 187                                     d
 188 (%t7)                               -- (v )
 189                                     dt   i
 190 (%i8) ishow(idiff(v([i],[]),j))$
 191 (%t8)                                v
 192                                       i,j
 193 (%i9) ishow(extdiff(v([i],[]),j))$
 194 (%t9)                             v    - v
 195                                    j,i    i,j
 196                                   -----------
 197                                        2
 198 (%i10) ishow(liediff(v,w([i],[])))$
 199                                %3          %3
 200 (%t10)                        v   w     + v   w
 201                                    i,%3    ,i  %3
 202 (%i11) ishow(covdiff(v([i],[]),j))$
 203                                               %4
 204 (%t11)                        v    - v   ichr2
 205                                i,j    %4      i j
 206 (%i12) ishow(ev(%,ichr2))$
 207                %4 %5
 208 (%t12) v    - g      v   (e p       + e   p     - e p       - e    p
 209         i,j           %4     j %5,i    ,i  j %5      i j,%5    ,%5  i j
 210
 211                                          + e p       + e   p    )/2
 212                                               i %5,j    ,j  i %5
 213 (%i13) iframe_flag:true;
 214 (%o13)                               true
 215 (%i14) ishow(covdiff(v([i],[]),j))$
 216                                              %6
 217 (%t14)                        v    - v   icc2
 218                                i,j    %6     i j
 219 (%i15) ishow(ev(%,icc2))$
 220                                              %6
 221 (%t15)                        v    - v   ifc2
 222                                i,j    %6     i j
 223 (%i16) ishow(radcan(ev(%,ifc2,ifc1)))$
 224              %6 %8                    %6 %8
 225 (%t16) - (ifg      v   ifb       + ifg      v   ifb       - 2 v
 226                     %6    j %8 i             %6    i j %8      i,j
 227
 228                                              %6 %8
 229                                         - ifg      v   ifb      )/2
 230                                                     %6    %8 i j
 231 (%i17) ishow(canform(s([i,j],[])-s([j,i])))$
 232 (%t17)                            s    - s
 233                                    i j    j i
 234 (%i18) decsym(s,2,0,[sym(all)],[]);
 235 (%o18)                               done
 236 (%i19) ishow(canform(s([i,j],[])-s([j,i])))$
 237 (%t19)                                 0
 238 (%i20) ishow(canform(a([i,j],[])+a([j,i])))$
 239 (%t20)                            a    + a
 240                                    j i    i j
 241 (%i21) decsym(a,2,0,[anti(all)],[]);
 242 (%o21)                               done
 243 (%i22) ishow(canform(a([i,j],[])+a([j,i])))$
 244 (%t22)                                 0
 245 @end example
 246
 247
 248 @node Функции и переменные пакета itensor,  , Введение в пакет itensor, Пакет itensor
 249
 250 @section Функции и переменные пакета @code{itensor}
 251 @subsection Манипулирование индексными объектами
 252
 253 @deffn {Функция} entertensor (@var{name})
 254
 255 это интерактивная функция, которая позволяет создать индексный объект с
 256 именем @var{name}, содержащий заданные пользователем списки
 257 ковариантных и контравариантных индексов и индексы производных.
 258 Отдельный индекс или список индексов (возможно пустой) считаются
 259 допустимым вводом (см. пример в секции @code{covdiff}).
 260
 261 @opencatbox{Категории:}
 262 @category{Пакет itensor}
 263 @closecatbox
 264 @end deffn
 265
 266 @deffn {Функция} changename (@var{old}, @var{new}, @var{expr})
 267
 268 заменяет имя тензора со старого @var{old} на новое @var{new}
 269 в выражении @var{expr}. @var{old} может быть как простым символом,
 270 так и списком в форме @code{[@var{name}, @var{m}, @var{n}]}.
 271 В последнем случае переименовываются только индексные объекты
 272 с именем @var{name} с @var{m} ковариантным и @var{n}
 273 контравариантным индексами.
 274
 275 @opencatbox{Категории:}
 276 @category{Пакет itensor}
 277 @closecatbox
 278 @end deffn
 279
 280 @deffn {Функция} listoftens (@var{expr})
 281
 282 в качестве результата возвращает список всех тензоров выражения
 283 @var{expr}. Например,
 284
 285 @example
 286
 287 (%i6) ishow(a([i,j],[k])*b([u],[],v)+c([x,y],[])*d([],[])*e)$
 288                                          k
 289 (%t6)                        d e c    + a    b
 290                                   x y    i j  u,v
 291 (%i7) ishow(listoftens(%))$
 292                                k
 293 (%t7)                        [a   , b   , c   , d]
 294                                i j   u,v   x y
 295
 296 @end example
 297
 298 @opencatbox{Категории:}
 299 @category{Пакет itensor}
 300 @closecatbox
 301 @end deffn
 302
 303 @deffn {Функция} ishow (@var{expr})
 304
 305 печатает выражение @var{expr}, содержащее индексные объекты,
 306 в виде, где ковариантные индексы изображены в нижней позиции,
 307 а контравариантные в верхней.  Индексы производной изображаются после
 308 ковариантных индексов и отделены запятой (примеры вывода данной
 309 функции можно найти практически в любой части этого документа).
 310
 311 @opencatbox{Категории:}
 312 @category{Пакет itensor}
 313 @closecatbox
 314 @end deffn
 315
 316
 317 @deffn {Функция} indices (@var{expr})
 318
 319 Возвращает список из двух элементов.  Первый -- список свободных
 320 индексов, не участвующих в свертке, в  @var{expr}. Второй --
 321 список немых индексов, участвующих в свертках.  Например,
 322
 323 @example
 324
 325 (%i1) load("itensor");
 326 (%o1)      /share/tensor/itensor.lisp
 327 (%i2) ishow(a([i,j],[k,l],m,n)*b([k,o],[j,m,p],q,r))$
 328                                 k l      j m p
 329 (%t2)                          a        b
 330                                 i j,m n  k o,q r
 331 (%i3) indices(%);
 332 (%o3)                 [[l, p, i, n, o, q, r], [k, j, m]]
 333
 334 @end example
 335
 336 Тензорное произведение в котором один и тот же немой индекс
 337 встречается более чем два раза является синтаксически
 338 неправильным. При работе с ним Maxima выдаст ошибку.
 339
 340 @opencatbox{Категории:}
 341 @category{Пакет itensor}
 342 @closecatbox
 343 @end deffn
 344
 345 @deffn {Функция} rename (@var{expr})
 346 @deffnx {Функция} rename (@var{expr}, @var{count})
 347
 348 Возвращает выражение эквивалентное исходному @var{expr}, но в
 349 котором все немые индексы переименованы и пронумерованы. Имена берутся из списка
 350 @code{[%1, %2, ...]}. В качестве опции можно задать номер @var{count}
 351 с которого начинается список пронумерованных индексов. По умолчанию
 352 немые индексы нумеруются от текущей величины @var{count}. Все немые
 353 индексы в произведении встречаются ровно 2 раза. В случае ошибки
 354 пользователя, когда в исходном выражении одно и тоже имя немого индекса
 355 встречается более двух раз, Maxima выдаст ошибку и остановит вычисления.
 356 Для суммы тензорных произведений, @code{rename} применяется к каждому
 357 члену суммы при этом счетчик @var{count} каждый раз обнуляется при переходе к следующему
 358 слагаемому.  В этом случае функция @code{rename} может служить
 359 для упрощения тензорных выражений.  Кроме того, если @code{allsym} равно
 360 @code{true}, то индексы сортируются в алфавитном порядке.
 361 Если значение @code{flipflag} равно @code{false}, то переименование
 362 и сортировка осуществляется относительно порядка контравариантных индексов.
 363 В случае если значение @code{flipflag} равно  @code{true} переименование и сортировка
 364 производится относительно порядка ковариантных индексов. Часто
 365 бывает, что комбинированный эффект двух применений  @code{rename} с
 366 переменой значения флага  @code{flipflag} позволяет существенно
 367 упростить исходное выражение. Например,
 368
 369 @example
 370
 371 (%i1) load("itensor");
 372 (%o1)      /share/tensor/itensor.lisp
 373 (%i2) allsym:true;
 374 (%o2)                                true
 375 (%i3) g([],[%4,%5])*g([],[%6,%7])*ichr2([%1,%4],[%3])*
 376 ichr2([%2,%3],[u])*ichr2([%5,%6],[%1])*ichr2([%7,r],[%2])-
 377 g([],[%4,%5])*g([],[%6,%7])*ichr2([%1,%2],[u])*
 378 ichr2([%3,%5],[%1])*ichr2([%4,%6],[%3])*ichr2([%7,r],[%2]),noeval$
 379 (%i4) expr:ishow(%)$
 380
 381        %4 %5  %6 %7      %3         u          %1         %2
 382 (%t4) g      g      ichr2      ichr2      ichr2      ichr2
 383                          %1 %4      %2 %3      %5 %6      %7 r
 384
 385         %4 %5  %6 %7      u          %1         %3         %2
 386      - g      g      ichr2      ichr2      ichr2      ichr2
 387                           %1 %2      %3 %5      %4 %6      %7 r
 388 (%i5) flipflag:true;
 389 (%o5)                                true
 390 (%i6) ishow(rename(expr))$
 391        %2 %5  %6 %7      %4         u          %1         %3
 392 (%t6) g      g      ichr2      ichr2      ichr2      ichr2
 393                          %1 %2      %3 %4      %5 %6      %7 r
 394
 395         %4 %5  %6 %7      u          %1         %3         %2
 396      - g      g      ichr2      ichr2      ichr2      ichr2
 397                           %1 %2      %3 %4      %5 %6      %7 r
 398 (%i7) flipflag:false;
 399 (%o7)                                false
 400 (%i8) rename(%th(2));
 401 (%o8)                                  0
 402 (%i9) ishow(rename(expr))$
 403        %1 %2  %3 %4      %5         %6         %7        u
 404 (%t9) g      g      ichr2      ichr2      ichr2     ichr2
 405                          %1 %6      %2 %3      %4 r      %5 %7
 406
 407         %1 %2  %3 %4      %6         %5         %7        u
 408      - g      g      ichr2      ichr2      ichr2     ichr2
 409                           %1 %3      %2 %6      %4 r      %5 %7
 410 @end example
 411
 412 @opencatbox{Категории:}
 413 @category{Пакет itensor}
 414 @closecatbox
 415 @end deffn
 416
 417 @defvr {Управляющая переменная} flipflag
 418 Значение по умолчанию: @code{false}
 419
 420 Если значение @code{flipflag} равно @code{false}, то сортировка и переименование индексов
 421 осуществляется  относительно порядка контравариантных индексов, в
 422 противном случае  -- относительно порядка ковариантных индексов.
 423 Значение флага  @code{flipflag} влияет на результат применения функции
 424 @code{rename()} следующим образом: если  @code{flipflag} равно
 425 @code{false} то @code{rename} формирует список немых индексов по списку контравариантных
 426 индексов, по мере поступления, слева направо (если значение флага равно
 427 @code{true}, тогда используется список ковариантных индексов). Первый
 428 немой индекс в списке переименовывается в  @code{%1}, следующий в
 429 @code{%2} и т.д.). Затем индексы сортируются (см. пример в  @code{rename()}).
 430
 431 @opencatbox{Категории:}
 432 @category{Пакет itensor}
 433 @closecatbox
 434 @end defvr
 435
 436
 437 @deffn {Функция} defcon (@var{tensor_1})
 438 @deffnx {Функция} defcon (@var{tensor_1}, @var{tensor_2}, @var{tensor_3})
 439 задает свойства тензорной свертки тензора @var{tensor_1} с @var{tensor_3} так, что в
 440 результате получается @var{tensor_3} с соответствующими индексами.
 441 Если задан единственный аргумент, @var{tensor_1}, тогда свертка любого
 442 другого тензора (скажем @code{my_tensor}) с  @var{tensor_1} дает тот
 443 же тензор (@code{my_tensor}), но с новым набором индексов в
 444 соответствии с операцией свертки.  В этом случае, @var{tensor_1}
 445 может быть использован для подъема или опускания индексов.
 446
 447 Например, пусть @code{imetric:g}, тогда путем @code{defcon(g)} можно
 448 реализовать подъем и опускание индексов тензора, сворачивая его с метрическим тензором.
 449
 450 Для одного и того же индексного объекта может быть задано более одного
 451 правила свертки.  В этом случае, для одинаковых объектов
 452 используется правило свертки заданное последним.
 453 @code{contractions}  содержит список индексных объектов с заданными,
 454 посредством @code{defcon}, правилами  свертки.
 455
 456 @opencatbox{Категории:}
 457 @category{Пакет itensor}
 458 @closecatbox
 459 @end deffn
 460
 461
 462 @deffn {Функция} remcon (@var{tensor_1} , ..., @var{tensor_n})
 463 удаляет все правила свертки для объектов @var{tensor_i}.
 464 @code{remcon(all)} удаляет все правила свертки для всех
 465 индексных объектов.
 466
 467 @opencatbox{Категории:}
 468 @category{Пакет itensor}
 469 @closecatbox
 470 @end deffn
 471
 472
 473 @deffn {Функция} contract (@var{expr})
 474
 475 Выполняет свертку тензорного выражения @var{expr}, которое само по себе может быть
 476 произвольной комбинацией сумм и произведений тензоров. Правила свертки должны
 477 быть предварительно заданы с помощью @code{defcon}.
 478 Для наилучших результатов, в выражении @var{expr}, необходимо раскрыть
 479 все скобки. Если коэффициенты при тензорах в @var{expr}
 480 не содержат дробей, то  наиболее эффективный и быстрый способ
 481 раскрытия скобок в @var{expr} состоит в применении функции
 482 @code{ratexpand}. При этом, флаг @code{gcd} можно положить равным
 483 @code{false}, чтобы программа не пыталась искать сокращение
 484 множителей, используя GCD алгоритмы.
 485
 486 @opencatbox{Категории:}
 487 @category{Пакет itensor}
 488 @closecatbox
 489 @end deffn
 490
 491
 492 @deffn {Функция} indexed_tensor (@var{tensor})
 493
 494 Данная операция необходима всяких раз, когда пользователь собирается
 495 присвоить новые индексные выражения компонентам тензора
 496 @var{tensor}, для которого в системе уже предусмотрено свое
 497 индексное представление.  Примером могут служить символы Кристоффеля 1-го и 2-го рода
 498 @code{ichr1}, @code{ichr2}, выраженные через компоненты метрики, или
 499 тензор кривизны Римана @code{icurvature}. См. пример в
 500 пункте @code{icurvature}.
 501
 502 @opencatbox{Категории:}
 503 @category{Пакет itensor}
 504 @closecatbox
 505 @end deffn
 506
 507
 508 @deffn {Функция} components (@var{tensor}, @var{expr})
 509
 510 Данная функция присваивает тензору @var{tensor} индексное выражение
 511 @var{expr}. Это приводит к тому, что при последующих вычислениях
 512 индексные выражения @var{tensor} автоматически заменяются на
 513 соответствующие @var{expr}. @var{tensor} должен иметь вид @code{t([...],[...])},
 514 где каждый из списков может быть пустым. @var{expr} может быть любым
 515 индексным выражением имеющим тот же набор свободных индексов (не
 516 участвующих в свертке), что и @var{tensor}. Если @var{expr} содержит
 517 свертки, то необходимо быть внимательным в выборе значений немых
 518 индексов, чтобы избежать повторных немых индексов. В
 519 этом случае можно рекомендовать другой способ присваивания
 520 компонент, заключающийся в использовании конструкций @code{defrule}
 521 (см. пример ниже).  Функция @code{remcomps} очищает использованное
 522 ранее определение компонент тензора.
 523
 524 Важно понимать, что для @code{components} важна только валентность
 525 тензора а не порядок индексов.  Присваивание значения
 526 @code{x([i,-j],[])}, @code{x([-j,i],[])} или @code{x([i],[j])}
 527 приводит к одному результату -- значение присваивается
 528 тензору с именем @code{x} и валентностью @code{(1,1)}.
 529
 530
 531 Любому индексному выражению можно присвоить любое другое индексное
 532 представление и компоненты 4-мя различными способами, 2 способа
 533 включают использование, рассмотренной выше функции  @code{components}:
 534
 535 1) Присваивание одного индексного выражения другому:
 536
 537 @example
 538
 539 (%i2) components(g([],[i,j]),e([],[i])*p([],[j]))$
 540 (%i3) ishow(g([],[i,j]))$
 541                                       i  j
 542 (%t3)                                e  p
 543
 544 @end example
 545
 546 2) В виде матрицы компонент:
 547
 548 @example
 549
 550 (%i6) components(g([i,j],[]),lg);
 551 (%o6)                                done
 552 (%i7) ishow(g([i,j],[]))$
 553 (%t7)                                g
 554                                       i j
 555 (%i8) g([3,3],[]);
 556 (%o8)                                  1
 557 (%i9) g([4,4],[]);
 558 (%o9)                                 - 1
 559
 560 @end example
 561
 562 3) Путем определения функции. В примере ниже, тензор
 563 @code{h} равен  @code{kdelta} если  @code{h} имеет одинаковое
 564 количество ковариантных и контравариантных индексов, а индексы
 565 производной отсутствуют. В любом другом случае, тензор @code{h}
 566 равен тензору @code{g}:
 567
 568 @example
 569
 570 (%i4) h(l1,l2,[l3]):=if length(l1)=length(l2) and length(l3)=0
 571   then kdelta(l1,l2) else apply(g,append([l1,l2], l3))$
 572 (%i5) ishow(h([i],[j]))$
 573                                           j
 574 (%t5)                               kdelta
 575                                           i
 576 (%i6) ishow(h([i,j],[k],l))$
 577                                      k
 578 (%t6)                               g
 579                                      i j,l
 580
 581 @end example
 582
 583 4) Последний пример связан с использованием конструкций
 584 типа @code{defrule}.
 585
 586 @example
 587
 588 (%i1) load("itensor");
 589 (%o1)      /share/tensor/itensor.lisp
 590 (%i2) matchdeclare(l1,listp);
 591 (%o2)                                done
 592 (%i3) defrule(r1,m(l1,[]),(i1:idummy(),
 593       g([l1[1],l1[2]],[])*q([i1],[])*e([],[i1])))$
 594
 595 (%i4) defrule(r2,m([],l1),(i1:idummy(),
 596       w([],[l1[1],l1[2]])*e([i1],[])*q([],[i1])))$
 597
 598 (%i5) ishow(m([i,n],[])*m([],[i,m]))$
 599                                     i m
 600 (%t5)                              m    m
 601                                          i n
 602 (%i6) ishow(rename(applyb1(%,r1,r2)))$
 603                            %1  %2  %3 m
 604 (%t6)                     e   q   w     q   e   g
 605                                          %1  %2  %3 n
 606
 607
 608 @end example
 609
 610 @opencatbox{Категории:}
 611 @category{Пакет itensor}
 612 @closecatbox
 613 @end deffn
 614
 615
 616 @deffn {Функция} remcomps (@var{tensor})
 617
 618 Удаляет из системы значения компонент тензора
 619 @code{tensor}, присвоенных при помощи функции @code{components}.
 620
 621 @opencatbox{Категории:}
 622 @category{Пакет itensor}
 623 @closecatbox
 624 @end deffn
 625
 626 @c NEED LIST OF ARGUMENTS HERE
 627 @deffn {Функция} showcomps (@var{tensor})
 628
 629 Печатает значение компонент тензора, которые были присвоены с
 630 помощью @code{components}.
 631 Данная функция особенно полезна в случае, когда компоненты
 632 тензора были заданы с помощью матрицы, как в данном примере:
 633
 634 @example
 635
 636 (%i1) load("ctensor");
 637 (%o1)       /share/tensor/ctensor.mac
 638 (%i2) load("itensor");
 639 (%o2)      /share/tensor/itensor.lisp
 640 (%i3) lg:matrix([sqrt(r/(r-2*m)),0,0,0],[0,r,0,0],
 641                 [0,0,sin(theta)*r,0],[0,0,0,sqrt((r-2*m)/r)]);
 642                [         r                                     ]
 643                [ sqrt(-------)  0       0              0       ]
 644                [      r - 2 m                                  ]
 645                [                                               ]
 646                [       0        r       0              0       ]
 647 (%o3)          [                                               ]
 648                [       0        0  r sin(theta)        0       ]
 649                [                                               ]
 650                [                                      r - 2 m  ]
 651                [       0        0       0        sqrt(-------) ]
 652                [                                         r     ]
 653 (%i4) components(g([i,j],[]),lg);
 654 (%o4)                                done
 655 (%i5) showcomps(g([i,j],[]));
 656                   [         r                                     ]
 657                   [ sqrt(-------)  0       0              0       ]
 658                   [      r - 2 m                                  ]
 659                   [                                               ]
 660                   [       0        r       0              0       ]
 661 (%t5)      g    = [                                               ]
 662             i j   [       0        0  r sin(theta)        0       ]
 663                   [                                               ]
 664                   [                                      r - 2 m  ]
 665                   [       0        0       0        sqrt(-------) ]
 666                   [                                         r     ]
 667 (%o5)                                false
 668
 669 @end example
 670
 671 Функция @code{showcomps} может также печатать компоненты тензоров
 672 ранга выше чем 2.
 673
 674 @opencatbox{Категории:}
 675 @category{Пакет itensor}
 676 @closecatbox
 677 @end deffn
 678
 679
 680 @deffn {Функция} idummy ()
 681
 682 Увеличивает значение счетчика @code{icounter} немых индексов на 1 и возвращает
 683 значение индекса в форме @code{%n}, где n это положительное целое число.
 684 Применение @code{idummy} гарантирует, что немые индексы, встречающиеся в
 685 текущем выражении? не будут конфликтовать с уже использованными
 686 (см. пример в секции @code{indices}).
 687
 688 @opencatbox{Категории:}
 689 @category{Пакет itensor}
 690 @closecatbox
 691 @end deffn
 692
 693
 694 @defvr {Управляющая переменная} idummyx
 695 Значение по умолчанию: @code{%}
 696
 697 Данная переменная задает приставку (префикс) для генерируемых немых индексов
 698 (см. пример в секции @code{indices}).
 699
 700 @opencatbox{Категории:}
 701 @category{Пакет itensor}
 702 @closecatbox
 703 @end defvr
 704
 705 @defvr {Управляющая переменная} icounter
 706 Значение по умолчанию: @code{1}
 707
 708 Определяет численный суффикс для генерируемого
 709 немого индекса. Приставка (префикс) определяется
 710 переменной @code{idummyx}
 711
 712 @opencatbox{Категории:}
 713 @category{Пакет itensor}
 714 @closecatbox
 715 @end defvr
 716
 717 @deffn {Функция} kdelta (@var{l1}, @var{l2})
 718 Обобщенный символ Кронекера, где  @var{l1} и @var{l2} -- списки ковариантных и
 719 контравариантных индексов соответственно. @code{kdelta([i],[j])} возвращает обычный
 720 дельта-символ Кронекера. Команда @code{ev(@var{expr},kdelta)} вычисляет @var{expr}, заменяя
 721 все конструкции вида @code{kdelta([],[])} (след @code{kdelta}) на размерность многообразия.
 722
 723 @code{itensor} также позволяет использование в @code{kdelta()} c  двумя ковариантными или
 724 двумя контравариантными индексами. Эта дает возможность задать единичную ко(нтра)-вариантную
 725 матрицу. Данная конструкция предусмотрена только для целей программирования. Следует помнить,
 726 что в @code{itensor}  @code{kdelta([i,j],[])} не является разрешенным тензорным объектом.
 727 Будьте готовы,что при операциях с @code{kdelta([i,j],[])} Maxima может
 728 пожаловаться на неправильный индексный объект и отказаться от дальнейших вычислений.
 729
 730 @opencatbox{Категории:}
 731 @category{Пакет itensor}
 732 @closecatbox
 733 @end deffn
 734
 735 @deffn {Функция} kdels (@var{l1}, @var{l2})
 736
 737 Симметризованная версия обобщенного дельта-символа Кронекера. Введена для удобства вычислений.
 738 Свертка выражения с этим тензором приводит к его симметризации. Примеры:
 739
 740 @example
 741
 742 (%i1) load("itensor");
 743 (%o1)      /share/tensor/itensor.lisp
 744 (%i2) kdelta([1,2],[2,1]);
 745 (%o2)                                 - 1
 746 (%i3) kdels([1,2],[2,1]);
 747 (%o3)                                  1
 748 (%i4) ishow(kdelta([a,b],[c,d]))$
 749                              c       d         d       c
 750 (%t4)                  kdelta  kdelta  - kdelta  kdelta
 751                              a       b         a       b
 752 (%i4) ishow(kdels([a,b],[c,d]))$
 753                              c       d         d       c
 754 (%t4)                  kdelta  kdelta  + kdelta  kdelta
 755                              a       b         a       b
 756
 757 @end example
 758
 759 @opencatbox{Категории:}
 760 @category{Пакет itensor}
 761 @closecatbox
 762 @end deffn
 763
 764 @deffn {Функция} levi_civita (@var{l})
 765 Перестановочный тензор Леви-Чивита, который дает 1 если список @var{l}
 766 является четной перестановкой целых чисел, -1 для нечетной
 767 перестановки, и 0 когда встречаются повторяющиеся индексы.
 768
 769 @opencatbox{Категории:}
 770 @category{Пакет itensor}
 771 @closecatbox
 772 @end deffn
 773
 774
 775 @deffn {Функция} lc2kdt (@var{expr})
 776 Приводит к упрощению выражений содержащих символы Леви-Чивита (произведения этих символов
 777 заменяются на соответствующие дельта-символы Кронекера). Основная разница между действием
 778 данной функции и непосредственным вычислением перестановочного тензора состоит в том,
 779 что прямое вычисление тензора Леви-Чивита часто приводит к выражениям
 780 содержащим дельта-символы с  целочисленными значения индексов, что затрудняет
 781 дальнейшие операции. Применение функции @code{lc2kdt} позволяет избежать этих проблем.
 782
 783 @example
 784
 785 (%i1) load("itensor");
 786 (%o1)      /share/tensor/itensor.lisp
 787 (%i2) expr:ishow('levi_civita([],[i,j])
 788                  *'levi_civita([k,l],[])*a([j],[k]))$
 789                                   i j  k
 790 (%t2)                  levi_civita    a  levi_civita
 791                                        j            k l
 792 (%i3) ishow(ev(expr,levi_civita))$
 793                                   i j  k       1 2
 794 (%t3)                       kdelta    a  kdelta
 795                                   1 2  j       k l
 796 (%i4) ishow(ev(%,kdelta))$
 797              i       j         j       i   k
 798 (%t4) (kdelta  kdelta  - kdelta  kdelta ) a
 799              1       2         1       2   j
 800
 801                                1       2         2       1
 802                         (kdelta  kdelta  - kdelta  kdelta )
 803                                k       l         k       l
 804 (%i5) ishow(lc2kdt(expr))$
 805                      k       i       j    k       j       i
 806 (%t5)               a  kdelta  kdelta  - a  kdelta  kdelta
 807                      j       k       l    j       k       l
 808 (%i6) ishow(contract(expand(%)))$
 809                                  i           i
 810 (%t6)                           a  - a kdelta
 811                                  l           l
 812
 813 @end example
 814
 815 Для использования @code{lc2kdt()} необходимо задать метрический тензор
 816 (для случая когда, встречаются произведения перестановочных тензоров одинакового
 817 ранга и типа).  Если метрика не была задана заранее (с помощью
 818 @code{imetric}), то можно столкнуться с ошибкой.
 819
 820 @example
 821
 822 (%i7) expr:ishow('levi_civita([],[i,j])
 823                  *'levi_civita([],[k,l])*a([j,k],[]))$
 824                                  i j            k l
 825 (%t7)                 levi_civita    levi_civita    a
 826                                                      j k
 827 (%i8) ishow(lc2kdt(expr))$
 828 Maxima encountered a Lisp error:
 829
 830  Error in $IMETRIC [or a callee]:
 831  $IMETRIC [or a callee] requires less than two arguments.
 832
 833 Automatically continuing.
 834 To reenable the Lisp debugger set *debugger-hook* to nil.
 835 (%i9) imetric(g);
 836 (%o9)                                done
 837 (%i10) ishow(lc2kdt(expr))$
 838          %3 i       k   %4 j       l     %3 i       l   %4 j
 839 (%t10) (g     kdelta   g     kdelta   - g     kdelta   g
 840                     %3             %4               %3
 841               k
 842         kdelta  ) a
 843               %4   j k
 844 (%i11) ishow(contract(expand(%)))$
 845                                   l i      l i
 846 (%t11)                           a    - a g
 847
 848 @end example
 849
 850 @opencatbox{Категории:}
 851 @category{Пакет itensor}
 852 @closecatbox
 853 @end deffn
 854
 855
 856 @deffn {Функция} lc_l
 857
 858 Правило упрощения выражений содержащих индексные символы Леви-Чивита
 859 (@code{levi_civita}). Данное правило преобразования использует свойства антисимметрии
 860 перестановочного тензора. Например:
 861
 862 @example
 863
 864 (%i1) load("itensor");
 865 (%o1)      /share/tensor/itensor.lisp
 866 (%i2)  el1:ishow('levi_civita([i,j,k],[])*a([],[i])*a([],[j]))$
 867                              i  j
 868 (%t2)                       a  a  levi_civita
 869                                              i j k
 870 (%i3) el2:ishow('levi_civita([],[i,j,k])*a([i])*a([j]))$
 871                                        i j k
 872 (%t3)                       levi_civita      a  a
 873                                               i  j
 874 (%i4) ishow(canform(contract(expand(applyb1(el1,lc_l,lc_u)))))$
 875 (%t4)                                  0
 876 (%i5) ishow(canform(contract(expand(applyb1(el2,lc_l,lc_u)))))$
 877 (%t5)                                  0
 878
 879 @end example
 880
 881 @opencatbox{Категории:}
 882 @category{Пакет itensor}
 883 @closecatbox
 884 @end deffn
 885
 886 @deffn {Функция} lc_u
 887
 888 Правило упрощения выражений содержащих индексные символы Леви-Чивита
 889 (@code{levi_civita}), аналогично @code{lc_l}, данное правило преобразования
 890 использует свойства антисимметрии перестановочного тензора
 891 (см. пример в секции  @code{lc_l}).
 892
 893 @opencatbox{Категории:}
 894 @category{Пакет itensor}
 895 @closecatbox
 896 @end deffn
 897
 898 @deffn {Функция} canten (@var{expr})
 899 Функция предназначена для упрощения тензорных выражений путем переименования
 900 и перестановки немых индексов. Область применения @code{canten} ограничена. Данная функция
 901 применима только для сумм тензорных произведений в которых отсутствуют индексы производной
 902 и не встречаются символы Леви-Чивита. Ввиду этих ограничений, следует избегать
 903 ее использования. Вместо нее рекомендуется применять  @code{canform}.
 904
 905 @opencatbox{Категории:}
 906 @category{Пакет itensor}
 907 @closecatbox
 908 @end deffn
 909
 910 @deffn {Функция} concan (@var{expr})
 911
 912 Аналогична @code{canten} но дополнительно производит
 913 свертку индексов.
 914
 915 @opencatbox{Категории:}
 916 @category{Пакет itensor}
 917 @closecatbox
 918 @end deffn
 919
 920
 921 @subsection Симметрии тензоров
 922
 923 @defvr {Управляющая переменная} allsym
 924 Значение по умолчанию: @code{false}
 925
 926 Если данной переменной присвоить  @code{true}, тогда все индексные
 927 объекты будут считаться симметричными
 928 по всем ковариантным и контравариантным индексам. Если @code{allsym} равно
 929 @code{false}, все тензора не имеют никаких свойств симметрии априори,
 930 пока симметрии не будут объявлены. Индексы производной предполагаются симметричными,
 931 до тех пор пока не объявлено, что @code{iframe_flag} равен @code{true}.
 932
 933 @opencatbox{Категории:}
 934 @category{Пакет itensor}
 935 @closecatbox
 936 @end defvr
 937
 938
 939 @deffn {Функция} decsym (@var{tensor}, @var{m}, @var{n}, [@var{cov_1}, @var{cov_2}, ...], [@var{contr_1}, @var{contr_2}, ...])
 940
 941 Объявляет свойства симметрии тензора @var{tensor} по @var{m} ковариантному и
 942 @var{n} контравариантным индексам, где @var{cov_i} и @var{contr_i} --
 943 псевдофункции, выражающие соотношения перестановочных симметрий по ковариантным и
 944 контравариантным индексам соответственно. Данные псевдофункции
 945 записываются в форме @code{symoper(@var{index_1}, @var{index_2}, ...)}, где
 946 переменная @code{symoper} принимает  одно из следующих: @code{sym},
 947 @code{anti} или @code{cyc}, которые означают соответственно, симметрию,
 948 антисимметрию или цикличность индексов. Переменная
 949 @var{index_i} принимает целочисленные значения и указывает на позицию
 950 индекса в  @var{tensor}, для которого объявляются свойства симметрии.
 951 Определения вида @code{symoper(all)} также дозволены, означая, что все
 952 индексы удовлетворяют выбранному свойству симметрии.
 953 Например, рассмотрим тензорный объект @code{b} с 5-ю ковариантными
 954 индексами. Команда
 955  @code{decsym(b,5,3,[sym(1,2),anti(3,4)],[cyc(all)])} объявляет @code{b}
 956 симметричным по первому и второму индексу, антисимметричным по 3 и 4
 957 ковариантным индексам и циклическим по всем контравариантным индексам.
 958 Список декларирующий симметрии может быть пустым. Функция @code{canform}
 959 использует декларированные свойства симметрии для упрощения тензорных
 960 выражений. Примеры даны ниже.
 961
 962 @example
 963
 964 (%i1) load("itensor");
 965 (%o1)      /share/tensor/itensor.lisp
 966 (%i2) expr:contract( expand( a([i1, j1, k1], [])
 967            *kdels([i, j, k], [i1, j1, k1])))$
 968 (%i3) ishow(expr)$
 969 (%t3)         a      + a      + a      + a      + a      + a
 970                k j i    k i j    j k i    j i k    i k j    i j k
 971 (%i4) decsym(a,3,0,[sym(all)],[]);
 972 (%o4)                                done
 973 (%i5) ishow(canform(expr))$
 974 (%t5)                              6 a
 975                                       i j k
 976 (%i6) remsym(a,3,0);
 977 (%o6)                                done
 978 (%i7) decsym(a,3,0,[anti(all)],[]);
 979 (%o7)                                done
 980 (%i8) ishow(canform(expr))$
 981 (%t8)                                  0
 982 (%i9) remsym(a,3,0);
 983 (%o9)                                done
 984 (%i10) decsym(a,3,0,[cyc(all)],[]);
 985 (%o10)                               done
 986 (%i11) ishow(canform(expr))$
 987 (%t11)                        3 a      + 3 a
 988                                  i k j      i j k
 989 (%i12) dispsym(a,3,0);
 990 (%o12)                     [[cyc, [[1, 2, 3]], []]]
 991
 992 @end example
 993
 994 @opencatbox{Категории:}
 995 @category{Пакет itensor}
 996 @closecatbox
 997 @end deffn
 998
 999
1000 @deffn {Функция} remsym (@var{tensor}, @var{m}, @var{n})
1001
1002 Удаляет все свойства симметрии тензора @var{tensor}, имеющего @var{m}
1003 ковариантных и @var{n} контравариантных индексов.
1004
1005 @opencatbox{Категории:}
1006 @category{Пакет itensor}
1007 @closecatbox
1008 @end deffn
1009
1010
1011 @deffn {Функция} canform (@var{expr})
1012 @deffnx {Функция} canform (@var{expr}, @var{rename})
1013 Упрощает выражение @var{expr}, используя
1014 переименование немых индексов и сортировку всех индексов с учетом
1015 объявленных свойств симметрии. Если @code{allsym} равен @code{true},
1016 тогда все индексные выражения подразумеваются симметричными по всем
1017 индексам. В противном случае используется свойства , объявленные при помощи @code{decsym}.
1018 Немые индексы переименовываются таким же образом, как и при
1019 использовании @code{rename}.
1020 Следует иметь ввиду, что упрощение громоздких выражений может потребовать
1021 значительного количества вычислительного времени и ресурсов
1022 памяти. Иногда затраты на вычисления можно уменьшить если сначала
1023 переименовать индексы при помощи @code{rename}.
1024 См. примеры в пункте @code{decsym}. Заметим, что @code{canform} не
1025 всегда приводит выражение к простейшей форме.
1026 В тоже время @code{canform} всегда возвращает математически
1027 корректный результат.
1028
1029 Если значение второго необязательного параметра @var{rename} равно @code{false},
1030 то переименование не производится.
1031
1032
1033 @opencatbox{Категории:}
1034 @category{Пакет itensor}
1035 @closecatbox
1036 @end deffn
1037
1038 @subsection Операции над индексами тензоров
1039
1040
1041 @deffn {Функция} diff (@var{expr}, @var{v_1}, [@var{n_1}, [@var{v_2}, @var{n_2}] ...])
1042 Стандартная функция дифференцирования Maxima, которая в пакете @code{itensor} имеет
1043 дополнительные свойства. Данная конструкция означает взятие
1044 производной выражения @var{expr} по переменной @var{v_1}, @var{n_1}
1045 раз, по @var{v_2}, @var{n_2}раз и т.д.
1046 В применении к тензорным объектам, функция дифференцирования
1047 модифицирована таким образом, что @code{v_i} может иметь целочисленные
1048 значения от 1 до @code{dim}. В этом случае дифференцирование выполняется
1049 по отношению к @code{v_i}-ому элементу списка @code{vect_coords}. Если
1050 @code{vect_coords} является атомом, тогда переменная
1051 индексированная именем @code{v_i} будет использована как переменная для
1052 дифференцирования. Это допускает использование массива имен координат или индексированных
1053 имен типа @code{x[1]}, @code{x[2]}, в качестве переменных
1054 дифференцирования.
1055
1056 @opencatbox{Категории:}
1057 @category{Пакет itensor}
1058 @closecatbox
1059 @end deffn
1060
1061
1062 @deffn {Функция} idiff (@var{expr}, @var{v_1}, [@var{n_1}, [@var{v_2}, @var{n_2}] ...])
1063 Индексное дифференцирование. В отличие от функции @code{diff}, которая
1064 дифференцирует в отношении некоторой независимой переменной, @code{idiff} может
1065 быть использован при дифференцировании по координате. Для индексного
1066 объекта, такое дифференцирование добавляет @code{v_i} к индексам
1067 производной (он добавляется последовательно к ковариантным индексам
1068 после запятой). В дальнейшем индексы производной могут сортироваться
1069 если переменная @code{iframe_flag} не равна @code{true}.
1070
1071 @code{idiff} можно использовать при дифференцировании детерминанта
1072 метрического тензора. Таким образом, если метрика @code{imetric}
1073 обозначена через @code{g}, тогда @code{idiff(determinant(g),k)} возвращает
1074 @code{2*determinant(g)*ichr2([%i,k],[%i])}, где немой индекс @code{%i}
1075 пробегает соответствующие значения.
1076
1077 @opencatbox{Категории:}
1078 @category{Пакет itensor}
1079 @closecatbox
1080 @end deffn
1081
1082
1083 @deffn {Функция} liediff (@var{v}, @var{tensor})
1084
1085 Вычисляет производную Ли от тензорного выражения @var{tensor} в отношении
1086 векторного поля @var{v}. @var{tensor} может быть произвольным тензорным
1087 объектом, а @var{v} -- имя векторного поля (без индексов). Например:
1088
1089 @example
1090
1091 (%i1) load("itensor");
1092 (%o1)      /share/tensor/itensor.lisp
1093 (%i2) ishow(liediff(v,a([i,j],[])*b([],[k],l)))$
1094        k    %2            %2          %2
1095 (%t2) b   (v   a       + v   a     + v   a    )
1096        ,l       i j,%2    ,j  i %2    ,i  %2 j
1097
1098                           %1  k        %1  k      %1  k
1099                       + (v   b      - b   v    + v   b   ) a
1100                               ,%1 l    ,l  ,%1    ,l  ,%1   i j
1101
1102 @end example
1103
1104
1105 @opencatbox{Категории:}
1106 @category{Пакет itensor}
1107 @closecatbox
1108 @end deffn
1109
1110
1111
1112 @deffn {Функция} rediff (@var{ten})
1113
1114 Вычисляет все команды @code{idiff} в выражении @var{ten}.
1115
1116 @opencatbox{Категории:}
1117 @category{Пакет itensor}
1118 @closecatbox
1119 @end deffn
1120
1121
1122 @deffn {Функция} undiff (@var{expr})
1123
1124 Возвращает выражение эквивалентное @var{expr}, но в котором все
1125 производные индексных объектов заменяются на  не вычисляемую форму
1126 функции @code{idiff} с такими аргументами, чтобы при дифференцировании
1127 получился бы соответствующий индексный объект. Это бывает полезно, когда
1128 желательно провести некоторые замены в продифференцированных индексных
1129 объектах. После этого дифференцирование выполняется при помощи
1130 @code{ev(@var{expr}, idiff)}.
1131
1132 @opencatbox{Категории:}
1133 @category{Пакет itensor}
1134 @closecatbox
1135 @end deffn
1136
1137
1138 @deffn {Функция} evundiff
1139
1140 Эквивалентно применению @code{undiff}, затем @code{ev} и
1141 @code{rediff}.
1142
1143 При помощи этой функции можно легко вычислять выражения,
1144 дифференциальную форму которых иначе
1145 невозможно вычислить. Например, следующее выражение приводит к ошибке:
1146
1147 @example
1148 (%i1) load("itensor");
1149 (%o1)      /share/tensor/itensor.lisp
1150 (%i2) icurvature([i,j,k],[l],m);
1151 Maxima encountered a Lisp error:
1152
1153  Error in $ICURVATURE [or a callee]:
1154  $ICURVATURE [or a callee] requires less than three arguments.
1155
1156 Automatically continuing.
1157 To reenable the Lisp debugger set *debugger-hook* to nil.
1158 @end example
1159
1160 Однако, если сначала ввести @code{icurvature} в не вычисляемой форме, а
1161 затем применить @code{evundiff}, то получим желаемый результат:
1162
1163 @example
1164 (%i3) ishow('icurvature([i,j,k],[l],m))$
1165                                          l
1166 (%t3)                          icurvature
1167                                          i j k,m
1168 (%i4) ishow(evundiff(%))$
1169              l              l         %1           l           %1
1170 (%t4) - ichr2        - ichr2     ichr2      - ichr2       ichr2
1171              i k,j m        %1 j      i k,m        %1 j,m      i k
1172
1173              l              l         %1           l           %1
1174       + ichr2        + ichr2     ichr2      + ichr2       ichr2
1175              i j,k m        %1 k      i j,m        %1 k,m      i j
1176 @end example
1177
1178 ЗАМЕЧАНИЕ: В ранних версиях Maxima, операции производных в определениях
1179 символов Кристоффеля всегда должны были вводится в не вычисляемой
1180 форме. Сейчас это исправлено и надобность в процедуре @code{evundiff}
1181 в этом случае отпала. Например:
1182
1183 @example
1184 (%i5) imetric(g);
1185 (%o5)                                done
1186 (%i6) ishow(ichr2([i,j],[k],l))$
1187        k %3
1188       g     (g         - g         + g        )
1189               j %3,i l    i j,%3 l    i %3,j l
1190 (%t6) -----------------------------------------
1191                           2
1192
1193                          k %3
1194                         g     (g       - g       + g      )
1195                          ,l     j %3,i    i j,%3    i %3,j
1196                       + -----------------------------------
1197                                          2
1198 @end example
1199
1200
1201 @opencatbox{Категории:}
1202 @category{Пакет itensor}
1203 @closecatbox
1204 @end deffn
1205
1206
1207 @deffn {Функция} flush (@var{expr}, @var{tensor_1}, @var{tensor_2}, ...)
1208 Обнуляет в @var{expr} все объекты  @var{tensor_i}, не имеющие индексов
1209 производной.
1210
1211 @opencatbox{Категории:}
1212 @category{Пакет itensor}
1213 @closecatbox
1214 @end deffn
1215
1216
1217 @deffn {Функция} flushd (@var{expr}, @var{tensor_1}, @var{tensor_2}, ...)
1218 Обнуляет в @var{expr} все объекты  @var{tensor_i}, имеющие индексы
1219 производной.
1220
1221 @opencatbox{Категории:}
1222 @category{Пакет itensor}
1223 @closecatbox
1224 @end deffn
1225
1226 @deffn {Функция} flushnd (@var{expr}, @var{tensor}, @var{n})
1227 Обнуляет в @var{expr} все объекты  @var{tensor}, имеющие @var{n} и больше индексов
1228 производной. Например,
1229
1230 @example
1231
1232 (%i1) load("itensor");
1233 (%o1)      /share/tensor/itensor.lisp
1234 (%i2) ishow(a([i],[J,r],k,r)+a([i],[j,r,s],k,r,s))$
1235                                 J r      j r s
1236 (%t2)                          a      + a
1237                                 i,k r    i,k r s
1238 (%i3) ishow(flushnd(%,a,3))$
1239                                      J r
1240 (%t3)                               a
1241                                      i,k r
1242 @end example
1243
1244 @opencatbox{Категории:}
1245 @category{Пакет itensor}
1246 @closecatbox
1247 @end deffn
1248
1249
1250 @deffn {Функция} coord (@var{tensor_1}, @var{tensor_2}, ...)
1251
1252 Дает тензорам @var{tensor_i} свойства координатного дифференцирования,
1253 такие что производная контравариантного вектора, имя которого  совпадает
1254 с одним из @var{tensor_i}, дает дельта-символ Кронекера. Например, если
1255 @code{coord(x)}, тогда  вычисление @code{idiff(x([],[i]),j)} дает @code{kdelta([i],[j])}.
1256 @code{coord} это список всех индексных объектов имеющих это свойство.
1257
1258 @opencatbox{Категории:}
1259 @category{Пакет itensor}
1260 @closecatbox
1261 @end deffn
1262
1263 @deffn {Функция} remcoord (@var{tensor_1}, @var{tensor_2}, ...)
1264
1265 Удаляет свойства координатного дифференцирования для объектов @var{tensor_i}.
1266 @code{remcoord(all)} удаляет свойства координатного дифференцирования
1267 для всех индексных объектов.
1268
1269 @opencatbox{Категории:}
1270 @category{Пакет itensor}
1271 @closecatbox
1272 @end deffn
1273
1274
1275 @deffn {Функция} makebox (@var{expr})
1276 Служит для цели аналогичной @code{ishow}. В дополнение,
1277 все  даламбертианы, встречающиеся в @var{expr} отображаются символом @code{[]}.
1278 Например, @code{[]p([m],[n])} представляет сокращение для
1279 @code{g([],[i,j])*p([m],[n],i,j)}.
1280
1281 @opencatbox{Категории:}
1282 @category{Пакет itensor}
1283 @closecatbox
1284 @end deffn
1285
1286 @deffn {Функция} conmetderiv (@var{expr}, @var{tensor})
1287 Используется для упрощения выражений, содержащих
1288 частные производные ковариантных и контравариантных форм метрического
1289 тензора.
1290 Например, при помощи @code{conmetderiv} можно связать частные
1291 производные  метрического тензора с символами Кристоффеля:
1292
1293 @example
1294
1295 (%i1) load("itensor");
1296 (%o1)      /share/tensor/itensor.lisp
1297 (%i2) ishow(g([],[a,b],c))$
1298                                       a b
1299 (%t2)                                g
1300                                       ,c
1301 (%i3) ishow(conmetderiv(%,g))$
1302                          %1 b      a       %1 a      b
1303 (%t3)                 - g     ichr2     - g     ichr2
1304                                    %1 c              %1 c
1305
1306 @end example
1307
1308 @opencatbox{Категории:}
1309 @category{Пакет itensor}
1310 @closecatbox
1311 @end deffn
1312
1313
1314 @deffn {Функция} simpmetderiv (@var{expr})
1315 @deffnx {Функция} simpmetderiv (@var{expr} [, @var{stop}])
1316
1317 Упрощает выражения, содержащие произведения производных метрического
1318 тензора.  В частности @code{simpmetderiv} использует два тождества:
1319
1320 @example
1321
1322    ab        ab           ab                 a
1323   g   g   + g   g     = (g   g  )   = (kdelta )   = 0
1324    ,d  bc        bc,d         bc ,d          c ,d
1325
1326 @end example
1327
1328 откуда
1329
1330 @example
1331
1332    ab          ab
1333   g   g   = - g   g
1334    ,d  bc          bc,d
1335 @end example
1336
1337 и
1338
1339 @example
1340
1341   ab          ab
1342  g   g     = g   g
1343   ,j  ab,i    ,i  ab,j
1344
1345 @end example
1346
1347 которое следует из симметрии символов Кристоффеля.
1348
1349 Функция @code{simpmetderiv} имеет один необязательный аргумент,
1350 который, если присутствует, вызывает прекращение работы функции
1351 сразу после первой успешной подстановки.
1352 Функция @code{simpmetderiv} использует глобальную опцию
1353 @var{flipflag}, которая определяет каким образом следует выбирать
1354 "канонический" порядок индексов произведения.
1355
1356 В целом, данные возможности позволяют осуществлять упрощения,
1357 которые невозможно реализовать другими способами,
1358 что демонстрируется в следующем примере:
1359
1360 @example
1361
1362 (%i1) load("itensor");
1363 (%o1)      /share/tensor/itensor.lisp
1364 (%i2) imetric(g);
1365 (%o2)                                done
1366 (%i3) ishow(g([],[a,b])*g([],[b,c])*g([a,b],[],d)*g([b,c],[],e))$
1367                              a b  b c
1368 (%t3)                       g    g    g      g
1369                                        a b,d  b c,e
1370 (%i4) ishow(canform(%))$
1371
1372 errexp1 has improper indices
1373  -- an error.  Quitting.  To debug this try debugmode(true);
1374 (%i5) ishow(simpmetderiv(%))$
1375                              a b  b c
1376 (%t5)                       g    g    g      g
1377                                        a b,d  b c,e
1378 (%i6) flipflag:not flipflag;
1379 (%o6)                                true
1380 (%i7) ishow(simpmetderiv(%th(2)))$
1381                                a b  b c
1382 (%t7)                         g    g    g    g
1383                                ,d   ,e   a b  b c
1384 (%i8) flipflag:not flipflag;
1385 (%o8)                                false
1386 (%i9) ishow(simpmetderiv(%th(2),stop))$
1387                                a b  b c
1388 (%t9)                       - g    g    g      g
1389                                     ,e   a b,d  b c
1390 (%i10) ishow(contract(%))$
1391                                     b c
1392 (%t10)                           - g    g
1393                                     ,e   c b,d
1394
1395 @end example
1396
1397 См. также @code{weyl.dem}, для примера совместного применения @code{simpmetderiv}
1398 и @code{conmetderiv} для упрощения тензора Вейля.
1399
1400 @opencatbox{Категории:}
1401 @category{Пакет itensor}
1402 @closecatbox
1403 @end deffn
1404
1405
1406 @deffn {Функция} flush1deriv (@var{expr}, @var{tensor})
1407
1408 Обнуляет все производные первого порядка от @var{tensor} в @var{expr}.
1409
1410 @opencatbox{Категории:}
1411 @category{Пакет itensor}
1412 @closecatbox
1413 @end deffn
1414
1415
1416 @subsection Тензоры в искривленном пространстве
1417
1418
1419 @deffn {Функция} imetric (@var{g})
1420 @deffnx {Системная переменная} imetric
1421
1422 Определяет имя метрического тензора, присваивая соответствующее значение
1423 переменной @code{imetric}, @code{imetric:@var{g}}. В дополнение к этому программа
1424 устанавливает соответствующие свойства свертки для данной метрики:
1425 @code{defcon(@var{g})}, @code{defcon(@var{g},@var{g},kdelta)}.
1426 По умолчанию переменная @code{imetric} не имеет значения.
1427
1428 @opencatbox{Категории:}
1429 @category{Пакет itensor}
1430 @closecatbox
1431 @end deffn
1432
1433
1434 @deffn {Функция} ichr1 ([@var{i}, @var{j}, @var{k}])
1435 Дает значение символа Кристоффеля первого рода, которое по определению равно:
1436
1437 @example
1438        (g      + g      - g     )/2 .
1439          ik,j     jk,i     ij,k
1440 @end example
1441 @noindent
1442 Перед тем как использовать явные выражения для символов Кристоффеля
1443 необходимо определить имя метрического тензора, присвоив соответствующее
1444 значение переменной @code{imetric}, см. пример ниже в разделе @code{covdiff}.
1445
1446 @opencatbox{Категории:}
1447 @category{Пакет itensor}
1448 @closecatbox
1449 @end deffn
1450
1451 @deffn {Функция} ichr2 ([@var{i}, @var{j}],[@var{k}])
1452 Дает значение символа Кристоффеля 2-го рода, которые по определению равны:
1453
1454 @example
1455                        ks
1456    ichr2([i,j],[k]) = g    (g      + g      - g     )/2
1457                              is,j     js,i     ij,s
1458 @end example
1459
1460 @opencatbox{Категории:}
1461 @category{Пакет itensor}
1462 @closecatbox
1463 @end deffn
1464
1465
1466 @deffn {Функция} icurvature ([@var{i}, @var{j}, @var{k}], [@var{h}])
1467 Дает выражение для тензора кривизны Римана через символы Кристоффеля
1468 2-го рода (@code{ichr2}).  Используется следующее определение:
1469 @example
1470             h             h            h         %1         h
1471   icurvature     = - ichr2      - ichr2     ichr2    + ichr2
1472             i j k         i k,j        %1 j      i k        i j,k
1473                             h          %1
1474                      + ichr2      ichr2
1475                             %1 k       i j
1476 @end example
1477
1478 @opencatbox{Категории:}
1479 @category{Пакет itensor}
1480 @closecatbox
1481 @end deffn
1482
1483
1484 @deffn {Функция} covdiff (@var{expr}, @var{v_1}, @var{v_2}, ...)
1485 Вычисляет ковариантную производную от @var{expr} по переменным
1486 @var{v_i} используя символы Кристоффеля
1487 2-го рода (@code{ichr2}).  Для получения явных выражений ковариантной
1488 производной через компоненты метрики необходимо использовать
1489 @code{ev(@var{expr},ichr2)}, определив предварительно метрический тензор.
1490
1491 @example
1492
1493 (%i1) load("itensor");
1494 (%o1)      /share/tensor/itensor.lisp
1495 (%i2) entertensor()$
1496 Enter tensor name: a;
1497 Enter a list of the covariant indices: [i,j];
1498 Enter a list of the contravariant indices: [k];
1499 Enter a list of the derivative indices: [];
1500                                       k
1501 (%t2)                                a
1502                                       i j
1503 (%i3) ishow(covdiff(%,s))$
1504              k         %1     k         %1     k
1505 (%t3)     - a     ichr2    - a     ichr2    + a
1506              i %1      j s    %1 j      i s    i j,s
1507
1508              k     %1
1509       + ichr2     a
1510              %1 s  i j
1511 (%i4) imetric:g;
1512
1513 (%o4)                                  g
1514 (%i5) ishow(ev(%t3,ichr2))$
1515
1516          %1 %4  k
1517         g      a     (g       - g       + g      )
1518                 i %1   s %4,j    j s,%4    j %4,s
1519 (%t5) - ------------------------------------------
1520                             2
1521     %1 %3  k
1522    g      a     (g       - g       + g      )
1523            %1 j   s %3,i    i s,%3    i %3,s
1524  - ------------------------------------------
1525                        2
1526     k %2  %1
1527    g     a    (g        - g        + g       )
1528           i j   s %2,%1    %1 s,%2    %1 %2,s     k
1529  + ------------------------------------------- + a
1530                         2                         i j,s
1531
1532 @end example
1533
1534 @opencatbox{Категории:}
1535 @category{Пакет itensor}
1536 @closecatbox
1537 @end deffn
1538
1539
1540 @deffn {Функция} lorentz_gauge (@var{expr})
1541 Налагает условие Лоренцевой калибровки на все индексные объекты в @var{expr},
1542 приравнивая к нулю те, в которых индекс производной совпадает с
1543 одним из контравариантных индексов.
1544
1545 @opencatbox{Категории:}
1546 @category{Пакет itensor}
1547 @closecatbox
1548 @end deffn
1549
1550
1551 @deffn {Функция} igeodesic_coords (@var{expr}, @var{name})
1552
1553 Позволяет пользователю обнулить не дифференцированные символы
1554 Кристоффеля и первые производные метрического тензора в @var{expr} (подразумевая
1555 "нормальные" координаты). Переменная @var{name} в
1556 функции @code{igeodesic_coords} может относится, или к имени метрики (если таковая
1557 присутствует в явном виде в @var{expr}), или к имени связности
1558 в качестве которых используются фиксированные имена @code{ichr1} и (или)
1559 @code{ichr2}. В следующем примере, при помощи
1560 @code{igeodesic_coords}), проверяется свойство цикличности
1561 тензора Римана.
1562
1563 @example
1564
1565 (%i1) load("itensor");
1566 (%o1)      /share/tensor/itensor.lisp
1567 (%i2) ishow(icurvature([r,s,t],[u]))$
1568              u            u         %1         u
1569 (%t2) - ichr2      - ichr2     ichr2    + ichr2
1570              r t,s        %1 s      r t        r s,t
1571
1572                                               u         %1
1573                                        + ichr2     ichr2
1574                                               %1 t      r s
1575 (%i3) ishow(igeodesic_coords(%,ichr2))$
1576                                  u            u
1577 (%t3)                       ichr2      - ichr2
1578                                  r s,t        r t,s
1579 (%i4) ishow(igeodesic_coords(icurvature([r,s,t],[u]),ichr2)+
1580             igeodesic_coords(icurvature([s,t,r],[u]),ichr2)+
1581             igeodesic_coords(icurvature([t,r,s],[u]),ichr2))$
1582              u            u            u            u
1583 (%t4) - ichr2      + ichr2      + ichr2      - ichr2
1584              t s,r        t r,s        s t,r        s r,t
1585
1586                                              u            u
1587                                       - ichr2      + ichr2
1588                                              r t,s        r s,t
1589 (%i5) canform(%);
1590 (%o5)                                  0
1591
1592 @end example
1593
1594 @opencatbox{Категории:}
1595 @category{Пакет itensor}
1596 @closecatbox
1597 @end deffn
1598
1599 @subsection Вычисления в подвижном базисе
1600
1601 В Maxima существует возможность проводить вычисления с использованием
1602 подвижных базисов в качестве которых можно выбирать, либо
1603 ортонормированный  базис типа тетрады либо произвольный базис.
1604
1605 Для использования подвижного базиса переменной @code{iframe_flag}
1606 необходимо присвоить значение @code{true}. В этом случае символы
1607 Кристоффеля  @code{ichr1} и @code{ichr2} заменяются более общими
1608 коэффициентами связности @code{icc1} и @code{icc2} соответственно.
1609 Выражения для  @code{covdiff} и @code{icurvature} также заменяются более
1610 общими.
1611
1612 Базис определяется двумя тензорами: полем дуального базиса (@code{ifri}),
1613 и метрическим тензором @code{ifg}. Для ортонормированного базиса
1614 метрический тензор совпадает с единичной матрицей или Лоренцевой
1615 метрикой для пространства-времени Минковского. Дуальный базис
1616 определяется базисом векторов (единичных). Явный вид дуального базиса и
1617 его метрики не обязателен. По умолчанию все
1618 вычисления проводятся в общем виде без использования явных выражений для
1619 @code{ifri} и @code{ifg}.
1620
1621 При @code{iframe_flag} равном @code{true}, во многих случаях для
1622 опускания и подъема индексов вместо стандартной метрики @code{imetric}
1623 используется метрика тетрады @code{ifg}.
1624
1625 ВАЖНО: Присвоение @code{iframe_flag} значения @code{true} не отменяет
1626 свойства свертки обычной метрики, определенные ранее командами
1627 @code{defcon} или @code{imetric}. Если используется тетрадный
1628 формализм, то определение стандартной метрики лучше всего ввести с
1629 помощью присвоения соответствующего имени переменной
1630 @code{imetric}. Команду @code{imetric} лучше НЕ использовать.
1631
1632 Maxima использует  поле дуального базиса (@code{ifri})
1633 и метрический тензор @code{ifg} для определения структурных коэффициентов базиса (@code{ifc1}
1634 и @code{ifc2}), которые в дальнейшем используются для вычисления
1635 коэффициентов связности (@code{icc1}
1636 и @code{icc2}), как показано в следующем примере:
1637
1638 @example
1639
1640 (%i1) load("itensor");
1641 (%o1)      /share/tensor/itensor.lisp
1642 (%i2) iframe_flag:true;
1643 (%o2)                                true
1644 (%i3) ishow(covdiff(v([],[i]),j))$
1645                                i        i     %1
1646 (%t3)                         v   + icc2     v
1647                                ,j       %1 j
1648 (%i4) ishow(ev(%,icc2))$
1649                         %1      i           i        i
1650 (%t4)                  v   (ifc2     + ichr2    ) + v
1651                                 %1 j        %1 j     ,j
1652 (%i5) ishow(ev(%,ifc2))$
1653             %1    i %2
1654            v   ifg     (ifb        - ifb        + ifb       )
1655                            j %2 %1      %2 %1 j      %1 j %2     i
1656 (%t5)      -------------------------------------------------- + v
1657                                    2                             ,j
1658 (%i6) ishow(ifb([a,b,c]))$
1659                        %5    %4
1660 (%t6)               ifr   ifr   (ifri        - ifri       )
1661                        a     b       c %4,%5       c %5,%4
1662
1663 @end example
1664
1665 Когда переменной @code{iframe_bracket_form} присвоено
1666 @code{false}, то  используется альтернативный метод для вычисления
1667 коммутатора тетрады (@code{ifb}).
1668
1669 @example
1670
1671 (%i8) block([iframe_bracket_form:false],ishow(ifb([a,b,c])))$
1672                        %7    %6        %6      %7
1673 (%t8)              (ifr   ifr     - ifr     ifr  ) ifri
1674                        a     b,%7      a,%7    b       c %6
1675
1676 @end example
1677
1678
1679 @deffn {Функция} iframes ()
1680
1681 Поскольку в данной версии Maxima свойства свертки для @code{ifr} и
1682 @code{ifri}, а также (@code{ifb}) определены всегда, то
1683 данная функция не выполняет никаких действий.
1684
1685 @opencatbox{Категории:}
1686 @category{Пакет itensor}
1687 @closecatbox
1688 @end deffn
1689
1690
1691 @defvr {Переменная} ifb
1692
1693 Скобка тетрады (коммутатор). Вклад метрического тензора тетрады в
1694 коэффициенты связности выражается через коммутатор тетрады.
1695
1696 @example
1697
1698           - ifb      + ifb      + ifb
1699                c a b      b c a      a b c
1700 ifc1    = --------------------------------
1701     abc                  2
1702
1703 @end example
1704
1705 Сам по себе коммутатор вычисляется через компоненты тетрады и
1706 метрический тензор тетрады. В зависимости от значения
1707 @code{frame_bracket_form} вычисление скобки тетрады дает разный
1708 результат. При @code{frame_bracket_form} равном @code{true}
1709 получим:
1710
1711 @example
1712
1713           d      e                                      f
1714 ifb =  ifr    ifr   (ifri      - ifri      - ifri    itr   )
1715    abc    b      c       a d,e       a e,d       a f    d e
1716
1717
1718 @end example
1719
1720 А при @code{itorsion_flag} равном @code{true}:
1721
1722 @example
1723              e      d        d      e
1724 ifb    = (ifr    ifr    - ifr    ifr   ) ifri
1725    abc       b      c,e      b,e    c        a d
1726
1727 @end example
1728
1729 @opencatbox{Категории:}
1730 @category{Пакет itensor}
1731 @closecatbox
1732 @end defvr
1733
1734
1735 @defvr {Переменная} icc1
1736
1737 Коэффициенты связности первого рода. В @code{itensor}, определяется как:
1738
1739 @example
1740
1741 icc1    = ichr1    - ikt1    - inmc1
1742     abc        abc       abc        abc
1743
1744 @end example
1745
1746 В этом выражении, если @code{iframe_flag} равно @code{true}, символы Кристоффеля
1747 @code{ichr1} заменяются коэффициентами связности тетрады @code{ifc1}.
1748 Если @code{itorsion_flag} равно @code{false}, то @code{ikt1}
1749 опускается. @code{ikt1} опускается и в случае если используется базис
1750 тетрады, так как кручение уже вычислено, как часть скобки тетрады.
1751 Наконец, если @code{inonmet_flag} равен @code{false}, то
1752 @code{inmc1}, также опускается при вычислениях.
1753
1754 @opencatbox{Категории:}
1755 @category{Пакет itensor}
1756 @closecatbox
1757 @end defvr
1758
1759
1760 @defvr {Переменная} icc2
1761
1762 Коэффициенты связности второго рода. В @code{itensor}, определяются как,
1763
1764 @example
1765
1766     c         c        c         c
1767 icc2   = ichr2   - ikt2   - inmc2
1768     ab        ab       ab        ab
1769
1770 @end example
1771
1772 В этом выражении, если @code{iframe_flag} равно @code{true}, символы Кристоффеля
1773 @code{ichr2} заменяются коэффициентами связности тетрады @code{ifc2}.
1774 Если @code{itorsion_flag} равно @code{false}, то @code{ikt2}
1775 опускается. @code{ikt2} опускается и в случае, если используется базис
1776 тетрады, так как кручение уже вычислено, как часть скобки тетрады.
1777 Наконец, если @code{inonmet_flag} равен @code{false}, то
1778 @code{inmc2}, также опускается при вычислениях.
1779
1780 @opencatbox{Категории:}
1781 @category{Пакет itensor}
1782 @closecatbox
1783 @end defvr
1784
1785
1786 @defvr {Переменная} ifc1
1787
1788 Структурные коэффициенты 1-го рода, известные, также, как коэффициенты
1789 вращения Риччи. Этот тензор выражает  вклад метрики тетрады в
1790 коэффициенты связности 1-го рода.  Определяется как:
1791
1792 @example
1793
1794           - ifb      + ifb      + ifb
1795                c a b      b c a      a b c
1796 ifc1    = --------------------------------
1797     abc                   2
1798
1799
1800 @end example
1801
1802 @opencatbox{Категории:}
1803 @category{Пакет itensor}
1804 @closecatbox
1805 @end defvr
1806
1807
1808 @defvr {Переменная} ifc2
1809
1810 Структурные коэффициенты 2-го рода. Получаются сверткой структурных
1811 коэффициентов 1-го рода и метрики тетрады:
1812
1813 @example
1814
1815     c       cd
1816 ifc2   = ifg   ifc1
1817     ab             abd
1818
1819 @end example
1820
1821 @opencatbox{Категории:}
1822 @category{Пакет itensor}
1823 @closecatbox
1824 @end defvr
1825
1826
1827 @defvr {Переменная} ifr
1828
1829 Базис тетрады. Произведение с дуальным базисом (@code{ifri}) дает
1830 метрику тетрады.
1831
1832 @opencatbox{Категории:}
1833 @category{Пакет itensor}
1834 @closecatbox
1835 @end defvr
1836
1837
1838 @defvr {Переменная} ifri
1839
1840 Дуальный базис тетрады. Определяется набором векторов.
1841 Вместе с тензором тетрадной метрики @code{ifg} образует основу тетрадного
1842 формализма реализованного в @code{itensor}.
1843
1844 @opencatbox{Категории:}
1845 @category{Пакет itensor}
1846 @closecatbox
1847 @end defvr
1848
1849
1850 @defvr {Переменная} ifg
1851
1852 Тензор тетрадной метрики. По умолчанию равен @code{kdelta}. Пользователь может
1853 определить свой, используя @code{components}.
1854
1855 @opencatbox{Категории:}
1856 @category{Пакет itensor}
1857 @closecatbox
1858 @end defvr
1859
1860
1861 @defvr {Переменная} ifgi
1862
1863 Обратная тетрадная метрика. Свертка с @code{ifg} дает  @code{kdelta}.
1864
1865 @opencatbox{Категории:}
1866 @category{Пакет itensor}
1867 @closecatbox
1868 @end defvr
1869
1870
1871 @defvr {Управляющая переменная} iframe_bracket_form
1872 Значение по умолчанию: @code{true}
1873
1874 Определяет метод вычисления скобки тетрады @code{ifb}.
1875
1876 @opencatbox{Категории:}
1877 @category{Пакет itensor}
1878 @closecatbox
1879 @end defvr
1880
1881 @subsection Кручение и неметричность
1882
1883 Maxima умеет учитывать кручение и неметричность. Вклад кручения в
1884 коэффициенты связности вычисляется, если @code{itorsion_flag} равен
1885 @code{true}. Аналогично, компоненты  неметричности будут учтены, если
1886 @code{inonmet_flag} равен @code{true}.
1887
1888
1889 @defvr {Переменная} inm
1890
1891 Вектор неметричности.  Конформная неметричность определяется через
1892 ковариантную производную метрического тензора, которая в обычном случае
1893 равна нулю. Если @code{inonmet_flag} равен @code{true}, то вычисление
1894 ковариантной производной метрики дает:
1895
1896 @example
1897
1898 g     =- g  inm
1899  ij;k     ij   k
1900
1901 @end example
1902
1903 @opencatbox{Категории:}
1904 @category{Пакет itensor}
1905 @closecatbox
1906 @end defvr
1907
1908
1909 @defvr {Переменная} inmc1
1910
1911 Ковариантная перестановка компонент вектора неметричности. Определяется путем:
1912
1913 @example
1914
1915            g   inm  - inm  g   - g   inm
1916             ab    c      a  bc    ac    b
1917 inmc1    = ------------------------------
1918      abc                 2
1919
1920 @end example
1921
1922 В тетрадном формализме вместо @code{g} используется @code{ifg}.
1923
1924 @opencatbox{Категории:}
1925 @category{Пакет itensor}
1926 @closecatbox
1927 @end defvr
1928
1929
1930 @defvr {Переменная} inmc2
1931
1932 Контравариантная перестановка компонент вектора
1933 неметричности. Применяется когда @code{inonmet_flag} равен @code{true}.
1934 Определяется путем:
1935
1936
1937 @example
1938
1939                       c         c         cd
1940           -inm  kdelta  - kdelta  inm  + g   inm  g
1941      c        a       b         a    b          d  ab
1942 inmc2   = -------------------------------------------
1943      ab                        2
1944
1945 @end example
1946
1947 В тетрадном формализме вместо @code{g} используется @code{ifg}.
1948
1949 @opencatbox{Категории:}
1950 @category{Пакет itensor}
1951 @closecatbox
1952 @end defvr
1953
1954
1955 @defvr {Переменная} ikt1
1956
1957 Ковариантная перестановка тензора кручения.
1958 Вычисляется посредством:
1959
1960 @example
1961
1962                   d           d       d
1963           -g   itr  - g    itr   - itr   g
1964             ad    cb    bd    ca      ab  cd
1965 ikt1    = ----------------------------------
1966     abc                   2
1967
1968 @end example
1969
1970 В тетрадном формализме вместо @code{g} используется @code{ifg}.
1971
1972 @opencatbox{Категории:}
1973 @category{Пакет itensor}
1974 @closecatbox
1975 @end defvr
1976
1977
1978 @defvr {Переменная} ikt2
1979
1980 Контравариантная перестановка тензора кручения.
1981 Вычисляется посредством:
1982
1983 @example
1984
1985     c     cd
1986 ikt2   = g   ikt1
1987     ab           abd
1988
1989 @end example
1990
1991 В тетрадном формализме вместо @code{g} используется @code{ifg}.
1992
1993 @opencatbox{Категории:}
1994 @category{Пакет itensor}
1995 @closecatbox
1996 @end defvr
1997
1998
1999 @defvr {Переменная} itr
2000
2001 Тензор кручения. Для метрики с кручением индексы ковариантной
2002 производной не коммутируют. Пример:
2003
2004 @example
2005
2006 (%i1) load("itensor");
2007 (%o1)      /share/tensor/itensor.lisp
2008 (%i2) imetric:g;
2009 (%o2)                                  g
2010 (%i3) covdiff( covdiff( f( [], []), i), j)
2011                       - covdiff( covdiff( f( [], []), j), i)$
2012 (%i4) ishow(%)$
2013                                    %4              %2
2014 (%t4)                    f    ichr2    - f    ichr2
2015                           ,%4      j i    ,%2      i j
2016 (%i5) canform(%);
2017 (%o5)                                  0
2018 (%i6) itorsion_flag:true;
2019 (%o6)                                true
2020 (%i7) covdiff( covdiff( f( [], []), i), j)
2021                       - covdiff( covdiff( f( [], []), j), i)$
2022 (%i8) ishow(%)$
2023                            %8             %6
2024 (%t8)             f    icc2    - f    icc2    - f     + f
2025                    ,%8     j i    ,%6     i j    ,j i    ,i j
2026 (%i9) ishow(canform(%))$
2027                                    %1             %1
2028 (%t9)                     f    icc2    - f    icc2
2029                            ,%1     j i    ,%1     i j
2030 (%i10) ishow(canform(ev(%,icc2)))$
2031                                    %1             %1
2032 (%t10)                    f    ikt2    - f    ikt2
2033                            ,%1     i j    ,%1     j i
2034 (%i11) ishow(canform(ev(%,ikt2)))$
2035                       %2 %1                    %2 %1
2036 (%t11)          f    g      ikt1       - f    g      ikt1
2037                  ,%2            i j %1    ,%2            j i %1
2038 (%i12) ishow(factor(canform(rename(expand(ev(%,ikt1))))))$
2039                            %3 %2            %1       %1
2040                      f    g      g      (itr    - itr   )
2041                       ,%3         %2 %1     j i      i j
2042 (%t12)               ------------------------------------
2043                                       2
2044 (%i13) decsym(itr,2,1,[anti(all)],[]);
2045 (%o13)                               done
2046 (%i14) defcon(g,g,kdelta);
2047 (%o14)                               done
2048 (%i15) subst(g,nounify(g),%th(3))$
2049 (%i16) ishow(canform(contract(%)))$
2050                                            %1
2051 (%t16)                           - f    itr
2052                                     ,%1    i j
2053
2054 @end example
2055
2056 @opencatbox{Категории:}
2057 @category{Пакет itensor}
2058 @closecatbox
2059 @end defvr
2060
2061 @subsection Внешняя алгебра
2062
2063 В @code{itensor} реализованы возможности для операций с полностью
2064 антисимметричными ковариантными тензорными объектами (внешние формы).
2065 Полностью антисимметричное тензорное поле ранга
2066 (0,L) соответствует внешней (дифференциальной) L-форме. Грассманова
2067 алгебра L-форм включает операции внешнего (косого) произведения.
2068
2069 Операция внешнего произведения не имеет общепринятого определения.
2070 Некоторые авторы определяют внешнее произведение способом, который
2071 соответствует операции антисимметризации. Например,
2072
2073 @example
2074             a a  - a a
2075              i j    j i
2076  a  /\ a  = -----------
2077   i     j        2
2078 @end example
2079
2080 В более общем случае, внешнее произведение p-формы и q-формы можно
2081 определить путем:
2082
2083 @example
2084                        1     k1..kp l1..lq
2085 A       /\ B       = ------ D              A       B
2086  i1..ip     j1..jq   (p+q)!  i1..ip j1..jq  k1..kp  l1..lq
2087 @end example
2088
2089 где @code{D} обозначает дельта-символ Кронекера.
2090
2091 Другие авторы предпочитают  "геометрическое" определение,
2092 соответствующее понятию элемента объема:
2093
2094 @example
2095 a  /\ a  = a a  - a a
2096  i     j    i j    j i
2097 @end example
2098
2099 В более общем случае имеем:
2100
2101 @example
2102                        1    k1..kp l1..lq
2103 A       /\ B       = ----- D              A       B
2104  i1..ip     j1..jq   p! q!  i1..ip j1..jq  k1..kp  l1..lq
2105 @end example
2106
2107 С алгебраической точки зрения первое определение выглядит
2108 более естественным для @code{itensor}. С другой стороны, во многих приложения
2109 более принято следовать "геометрическому" определению. У пользователя
2110 есть выбор -- какое из двух определений использовать.  При
2111 @code{igeowedge_flag} равном @code{false} (по умолчанию), используется
2112 антисимметризация.  В противном случае применяется "геометрическое" определение.
2113
2114
2115 @defvr {Оператор} ~
2116 @ifinfo
2117 @fnindex Внешнее произведение
2118 @end ifinfo
2119
2120 Обозначает операцию внешнего произведения. Это бинарная операция.
2121 В качестве аргументов можно использовать выражения, включающие
2122 скаляры, ковариантные тензоры 1-го ранга или антисимметричные
2123 ковариантные тензоры ранга  @code{l} (предварительно объявленные, как
2124 антисимметричные по всем ковариантным индексам).
2125
2126 Результат внешнего произведения контролируется флагом
2127 @code{igeowedge_flag}. Например:
2128
2129 @example
2130 (%i1) load("itensor");
2131 (%o1)      /share/tensor/itensor.lisp
2132 (%i2) ishow(a([i])~b([j]))$
2133                                  a  b  - b  a
2134                                   i  j    i  j
2135 (%t2)                            -------------
2136                                        2
2137 (%i3) decsym(a,2,0,[anti(all)],[]);
2138 (%o3)                                done
2139 (%i4) ishow(a([i,j])~b([k]))$
2140                           a    b  + b  a    - a    b
2141                            i j  k    i  j k    i k  j
2142 (%t4)                     ---------------------------
2143                                        3
2144 (%i5) igeowedge_flag:true;
2145 (%o5)                                true
2146 (%i6) ishow(a([i])~b([j]))$
2147 (%t6)                            a  b  - b  a
2148                                   i  j    i  j
2149 (%i7) ishow(a([i,j])~b([k]))$
2150 (%t7)                     a    b  + b  a    - a    b
2151                            i j  k    i  j k    i k  j
2152 @end example
2153
2154 @opencatbox{Категории:}
2155 @category{Пакет itensor}
2156 @category{Операторы}
2157 @closecatbox
2158 @end defvr
2159
2160
2161 @defvr {Оператор} |
2162 @ifinfo
2163 @fnindex Свертка с вектором
2164 @end ifinfo
2165
2166 Бинарная операция, обозначающая "внутреннее" произведение -- свертку с
2167 контравариантным вектором. При этой операции
2168 результат не зависит от векторных индексов, участвующих в
2169 свертке. Поэтому вектор можно задать только именем.
2170
2171 В пакете @code{itensor}, "внутренняя" свертка с вектором всегда выполняется по
2172 первому (в отношении алфавитного порядка) индексу. Это позволяет
2173 проводить  более эффективные упрощения выражений, включающих
2174 "внутренние" свертки. Например:
2175
2176 @example
2177 (%i1) load("itensor");
2178 (%o1)      /share/tensor/itensor.lisp
2179 (%i2) decsym(a,2,0,[anti(all)],[]);
2180 (%o2)                                done
2181 (%i3) ishow(a([i,j],[])|v)$
2182                                     %1
2183 (%t3)                              v   a
2184                                         %1 j
2185 (%i4) ishow(a([j,i],[])|v)$
2186                                      %1
2187 (%t4)                             - v   a
2188                                          %1 j
2189 @end example
2190
2191 Заметим, что "внутренняя" свертка определена только для  полностью
2192 антисимметричных объектов. В противном случае результат вычисления будет неправильным.
2193
2194 @opencatbox{Категории:}
2195 @category{Пакет itensor}
2196 @category{Операторы}
2197 @closecatbox
2198 @end defvr
2199
2200 @deffn {Функция} extdiff (@var{expr}, @var{ind})
2201
2202 Внешнее дифференцирование @var{expr} по индексу @var{ind}.
2203 В @code{itensor} оператор внешней производной определен как внешнее
2204 произведение оператора производной и формы. Таким образом, результат
2205 вычисления, также зависит от значения флага @code{igeowedge_flag}.
2206 Например:
2207
2208 @example
2209 (%i1) load("itensor");
2210 (%o1)      /share/tensor/itensor.lisp
2211 (%i2) ishow(extdiff(v([i]),j))$
2212                                   v    - v
2213                                    j,i    i,j
2214 (%t2)                             -----------
2215                                        2
2216 (%i3) decsym(a,2,0,[anti(all)],[]);
2217 (%o3)                                done
2218 (%i4) ishow(extdiff(a([i,j]),k))$
2219                            a      - a      + a
2220                             j k,i    i k,j    i j,k
2221 (%t4)                      ------------------------
2222                                       3
2223 (%i5) igeowedge_flag:true;
2224 (%o5)                                true
2225 (%i6) ishow(extdiff(v([i]),j))$
2226 (%t6)                             v    - v
2227                                    j,i    i,j
2228 (%i7) ishow(extdiff(a([i,j]),k))$
2229 (%t7)                      a      - a      + a
2230                             j k,i    i k,j    i j,k
2231 @end example
2232
2233 @opencatbox{Категории:}
2234 @category{Пакет itensor}
2235 @closecatbox
2236 @end deffn
2237
2238
2239 @deffn {Функция} hodge (@var{expr})
2240
2241 Вычисляет форму дуальную @var{expr}. Например:
2242
2243 @example
2244
2245 (%i1) load("itensor");
2246 (%o1)      /share/tensor/itensor.lisp
2247 (%i2) imetric(g);
2248 (%o2)                            done
2249 (%i3) idim(4);
2250 (%o3)                            done
2251 (%i4) icounter:100;
2252 (%o4)                             100
2253 (%i5) decsym(A,3,0,[anti(all)],[])$
2254
2255 (%i6) ishow(A([i,j,k],[]))$
2256 (%t6)                           A
2257                                  i j k
2258 (%i7) ishow(canform(hodge(%)))$
2259                           %1 %2 %3 %4
2260                levi_civita            g        A
2261                                        %1 %102  %2 %3 %4
2262 (%t7)          -----------------------------------------
2263                                    6
2264 (%i8) ishow(canform(hodge(%)))$
2265                  %1 %2 %3 %8            %4 %5 %6 %7
2266 (%t8) levi_civita            levi_civita            g
2267                                                      %1 %106
2268                              g        g        g      A         /6
2269                               %2 %107  %3 %108  %4 %8  %5 %6 %7
2270 (%i9) lc2kdt(%)$
2271
2272 (%i10) %,kdelta$
2273
2274 (%i11) ishow(canform(contract(expand(%))))$
2275 (%t11)                     - A
2276                               %106 %107 %108
2277
2278 @end example
2279
2280 @opencatbox{Категории:}
2281 @category{Пакет itensor}
2282 @closecatbox
2283 @end deffn
2284
2285
2286 @defvr {Переменная} igeowedge_flag
2287 Значение по умолчанию: @code{false}
2288
2289 Контролирует результат вычисления внешнего произведения или внешней
2290 производной. При @code{igeowedge_flag} равном @code{false} (по
2291 умолчанию), понятие  внешней (дифференциальной) формы соответствует
2292 полностью антисимметричному ковариантному тензорному полю.
2293 В противном случае внешняя форма будет согласована с понятием элемента объема.
2294
2295 @opencatbox{Категории:}
2296 @category{Пакет itensor}
2297 @closecatbox
2298 @end defvr
2299
2300
2301 @subsection Экспорт в TeX
2302
2303 В @code{itensor} имеется некоторая поддержка экспорта тензорных выражений в
2304 формат TeX. Поскольку на базовом уровне Maxima тензорные выражения
2305 представлены как вызов некоторых функций, то вызов команды,
2306 @code{tex()} не даст желаемого результата. Для экспорта тензорных
2307 выражений в TeX можно использовать команду @code{tentex}.
2308
2309 @deffn {Функция} tentex (@var{expr})
2310
2311 Команда экспорта тензорных
2312 выражений в TeX. Перед использованием необходимо загрузить необходимый
2313 подпакет, @code{load("tentex")}. Например:
2314
2315 @example
2316
2317 (%i1) load("itensor");
2318 (%o1)      /share/tensor/itensor.lisp
2319 (%i2) load("tentex");
2320 (%o2)       /share/tensor/tentex.lisp
2321 (%i3) idummyx:m;
2322 (%o3)                                  m
2323 (%i4) ishow(icurvature([j,k,l],[i]))$
2324             m1       i           m1       i           i
2325 (%t4)  ichr2    ichr2     - ichr2    ichr2     - ichr2
2326             j k      m1 l        j l      m1 k        j l,k
2327
2328                                                       i
2329                                                + ichr2
2330                                                       j k,l
2331 (%i5) tentex(%)$
2332 $$\Gamma_@{j\,k@}^@{m_1@}\,\Gamma_@{l\,m_1@}^@{i@}-\Gamma_@{j\,l@}^@{m_1@}\,
2333  \Gamma_@{k\,m_1@}^@{i@}-\Gamma_@{j\,l,k@}^@{i@}+\Gamma_@{j\,k,l@}^@{i@}$$
2334
2335 @end example
2336
2337 Заметим, что данном примере @code{idummyx} равен @code{m}, для того
2338 чтобы избежать символов % в TeX-овских выражениях.
2339
2340 ЗАМЕЧАНИЕ: Текущая версия @code{tentex} является экспериментальной.
2341
2342 @opencatbox{Категории:}
2343 @category{Пакет itensor}
2344 @category{Вывод в формате TeX}
2345 @closecatbox
2346 @end deffn
2347
2348 @subsection Взаимодействие с пакетом @code{ctensor}
2349
2350 В пакет @code{itensor} заложены возможности для генерации кода Maxima
2351  для компонент тензорных выражений для последующего использования в
2352  @code{ctensor}. Эта задача выполняется вызовом команды @code{ic_convert()}.
2353
2354
2355 @deffn {Функция} ic_convert (@var{eqn})
2356
2357 Конвертирует тензорное выражение @var{eqn} из формата @code{itensor} в
2358 компоненты для использования в @code{ctensor}. При этом суммирование по немым
2359 индексам выполняется в явном виде, используя соответствующие замены
2360 индексных объектов в массивы; индексы производной заменяются
2361 не вычисляемую форму @code{diff}; символы Кристоффеля @code{ichr1} и @code{ichr2}
2362 заменяются на @code{lcs} и @code{mcs}, соответственно и если флаг
2363 @code{metricconvert} равен @code{true}, тогда ковариантные
2364 (контравариантные) выражения для метрического тензора везде
2365 заменяется на  @code{lg} (или @code{ug}). Кроме того, для суммирования по
2366 всем немым индексам вводится @code{do}. Полученное выражение можно
2367 вычислить  (загрузив предварительно пакет @code{ctensor}), используя
2368 @code{ev}.  Пример:
2369
2370 @example
2371 (%i1) load("itensor");
2372 (%o1)      /share/tensor/itensor.lisp
2373 (%i2) eqn:ishow(t([i,j],[k])=f([],[])*g([l,m],[])*a([],[m],j)
2374       *b([i],[l,k]))$
2375                              k        m   l k
2376 (%t2)                       t    = f a   b    g
2377                              i j      ,j  i    l m
2378 (%i3) ic_convert(eqn);
2379 (%o3) for i thru dim do (for j thru dim do (
2380        for k thru dim do
2381         t        : f sum(sum(diff(a , ct_coords ) b
2382          i, j, k                   m           j   i, l, k
2383
2384  g    , l, 1, dim), m, 1, dim)))
2385   l, m
2386 (%i4) imetric(g);
2387 (%o4)                                done
2388 (%i5) metricconvert:true;
2389 (%o5)                                true
2390 (%i6) ic_convert(eqn);
2391 (%o6) for i thru dim do (for j thru dim do (
2392        for k thru dim do
2393         t        : f sum(sum(diff(a , ct_coords ) b
2394          i, j, k                   m           j   i, l, k
2395
2396  lg    , l, 1, dim), m, 1, dim)))
2397    l, m
2398 @end example
2399
2400 @opencatbox{Категории:}
2401 @category{Пакет itensor}
2402 @category{Пакет ctensor}
2403 @closecatbox
2404 @end deffn
2405
2406 @subsection Зарезервированные имена переменных
2407
2408 Следующие имена переменных зарезервированы для использования
2409 в пакете @code{itensor}. Следует избегать их переопределения.
2410
2411 @example
2412
2413   Имя        Комментарий
2414   ------------------------------------------
2415   indices2() Внутренняя версия indices()
2416   conti      Список контравариантных индексов
2417   covi       Список ковариантных индексов
2418   deri       Список индексов производной
2419   name       Возвращает имя индексного объекта
2420   concan
2421   irpmon
2422   lc0
2423   _lc2kdt0
2424   _lcprod
2425   _extlc
2426
2427 @end example
2428
2429 @subsection Замечания разработчика
2430
2431 Я (Viktor Toth) добавил поддержку тетрадного формализма,
2432 кручения и неметричности в @code{itensor}
2433 в ноябре, 2004.  Эти возможности были реконструированы на основе описаний
2434 данных в руководстве коммерческой версии Macsyma, а также с
2435 использованием результатов исполнения демонстрационных файлов Macsyma.
2436
2437 Данная функциональность должна рассматриваться как
2438 экспериментальная. Следует учесть, что доступная документация  Macsyma содержала
2439 несколько очевидных ошибок, например, неправильные комбинации
2440 индексов. Кроме того, результаты демонстрационных расчетов
2441 показали, что функциональность  тетрадного формализма  в Macsyma
2442 далеко не полна. Моей цель состоит не в том, чтобы механически воспроизвести все
2443 возможности Macsyma, включая ошибки, а в том, чтобы в итоге получить
2444 математически корректную поддержку данных видов вычислений в @code{itensor}.
2445 Выполнение этой задачи займет некоторое время.
2446