/usr/share/axiom-20170501/src/algebra/LEXP.spad is in axiom-source 20170501-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | )abbrev domain LEXP LieExponentials
++ Author: Michel Petitot (petitot@lifl.fr).
++ Date Created: 91
++ Date Last Updated: 7 Juillet 92
++ Fix History: compilation v 2.1 le 13 dec 98
++ Description:
++ Management of the Lie Group associated with a
++ free nilpotent Lie algebra. Every Lie bracket with
++ length greater than \axiom{Order} are assumed to be null.
++ The implementation inherits from the \spadtype{XPBWPolynomial}
++ domain constructor: Lyndon coordinates are exponential coordinates
++ of the second kind.
LieExponentials(VarSet, R, Order) : SIG == CODE where
VarSet : OrderedSet
I ==> Integer
RN ==> Fraction(I)
R : Join(CommutativeRing, Module RN)
PI ==> PositiveInteger
Order : PI
EX ==> OutputForm
NNI ==> NonNegativeInteger
LWORD ==> LyndonWord(VarSet)
LWORDS ==> List LWORD
BASIS ==> PoincareBirkhoffWittLyndonBasis(VarSet)
TERM ==> Record(k:BASIS, c:R)
LTERMS ==> List(TERM)
LPOLY ==> LiePolynomial(VarSet,R)
XDPOLY ==> XDistributedPolynomial(VarSet,R)
PBWPOLY==> XPBWPolynomial(VarSet, R)
TERM1 ==> Record(k:LWORD, c:R)
EQ ==> Equation(R)
SIG ==> Group with
exp : LPOLY -> $
++ \axiom{exp(p)} returns the exponential of \axiom{p}.
log : $ -> LPOLY
++ \axiom{log(p)} returns the logarithm of \axiom{p}.
listOfTerms : $ -> LTERMS
++ \axiom{listOfTerms(p)} returns the internal representation
++ of \axiom{p}.
coerce : $ -> XDPOLY
++ \axiom{coerce(g)} returns the internal representation of \axiom{g}.
coerce : $ -> PBWPOLY
++ \axiom{coerce(g)} returns the internal representation of \axiom{g}.
mirror : $ -> $
++ \axiom{mirror(g)} is the mirror of the internal representation
++ of \axiom{g}.
varList : $ -> List VarSet
++ \axiom{varList(g)} returns the list of variables of \axiom{g}.
LyndonBasis : List VarSet -> List LPOLY
++ \axiom{LyndonBasis(lv)} returns the Lyndon basis of the nilpotent free
++ Lie algebra.
LyndonCoordinates : $ -> List TERM1
++ \axiom{LyndonCoordinates(g)} returns the exponential coordinates
++ of \axiom{g}.
identification : ($,$) -> List EQ
++ \axiom{identification(g,h)} returns the list of equations
++ \axiom{g_i = h_i}, where \axiom{g_i} (resp. \axiom{h_i}) are
++ exponential coordinates of \axiom{g} (resp. \axiom{h}).
CODE ==> PBWPOLY add
Rep := PBWPOLY
compareTerm1s: (TERM1, TERM1) -> Boolean
out: TERM1 -> EX
ident: (List TERM1, List TERM1) -> List EQ
ident(l1, l2) ==
import(TERM1)
null l1 => [equation(0$R,t.c)$EQ for t in l2]
null l2 => [equation(t.c, 0$R)$EQ for t in l1]
u1 : LWORD := l1.first.k; c1 :R := l1.first.c
u2 : LWORD := l2.first.k; c2 :R := l2.first.c
u1 = u2 =>
r: R := c1 - c2
r = 0 => ident(rest l1, rest l2)
cons(equation(c1,c2)$EQ , ident(rest l1, rest l2))
lexico(u1, u2)$LWORD =>
cons(equation(0$R,c2)$EQ , ident(l1, rest l2))
cons(equation(c1,0$R)$EQ , ident(rest l1, l2))
compareTerm1s(u:TERM1, v:TERM1):Boolean == lexico(v.k, u.k)$LWORD
out(t:TERM1):EX ==
t.c =$R 1 => char("e")$Character :: EX ** t.k ::EX
char("e")$Character :: EX ** (t.c::EX * t.k::EX)
identification(x,y) ==
l1: List TERM1 := LyndonCoordinates x
l2: List TERM1 := LyndonCoordinates y
ident(l1, l2)
LyndonCoordinates x ==
lt: List TERM1 := [[l::LWORD, t.c]$TERM1 for t in listOfTerms x | _
(l := retractIfCan(t.k)$BASIS) case LWORD ]
lt := sort(compareTerm1s,lt)
x:$ * y:$ == product(x::Rep, y::Rep, Order::I::NNI)$Rep
exp p == exp(p::Rep , Order::I::NNI)$Rep
log p == LiePolyIfCan(log(p,Order::I::NNI))$Rep :: LPOLY
coerce(p:$):EX ==
p = 1$$ => 1$R :: EX
lt : List TERM1 := LyndonCoordinates p
reduce(_*, [out t for t in lt])$List(EX)
LyndonBasis(lv) ==
[LiePoly(l)$LPOLY for l in LyndonWordsList(lv,Order)$LWORD]
coerce(p:$):PBWPOLY == p::Rep
inv x ==
x = 1 => 1
lt:LTERMS := listOfTerms mirror x
lt:= [[t.k, (odd? length(t.k)$BASIS => - t.c; t.c)]$TERM for t in lt ]
lt pretend $
|