Menu
▾
▴
mupad-combinat-commits — Mailing list for CVS commit messages.
You can subscribe to this list here.
| 2004 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
(261) |
Oct
(439) |
Nov
(94) |
Dec
(189) |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2005 |
Jan
(194) |
Feb
(165) |
Mar
(185) |
Apr
(196) |
May
(475) |
Jun
(264) |
Jul
(355) |
Aug
(95) |
Sep
(372) |
Oct
(260) |
Nov
(115) |
Dec
(64) |
| 2006 |
Jan
(106) |
Feb
(144) |
Mar
(206) |
Apr
(177) |
May
(490) |
Jun
(185) |
Jul
(218) |
Aug
(111) |
Sep
(150) |
Oct
(154) |
Nov
(224) |
Dec
(221) |
| 2007 |
Jan
(113) |
Feb
(167) |
Mar
(83) |
Apr
(99) |
May
(119) |
Jun
(292) |
Jul
(142) |
Aug
(136) |
Sep
(287) |
Oct
(256) |
Nov
(222) |
Dec
(180) |
| 2008 |
Jan
(112) |
Feb
(80) |
Mar
(104) |
Apr
(97) |
May
(81) |
Jun
(64) |
Jul
(21) |
Aug
(3) |
Sep
(14) |
Oct
(10) |
Nov
(30) |
Dec
(34) |
| 2009 |
Jan
(9) |
Feb
(10) |
Mar
(15) |
Apr
(20) |
May
(43) |
Jun
(20) |
Jul
(29) |
Aug
(7) |
Sep
(2) |
Oct
|
Nov
(1) |
Dec
(11) |
| 2010 |
Jan
(6) |
Feb
(6) |
Mar
(2) |
Apr
(1) |
May
|
Jun
(2) |
Jul
(1) |
Aug
|
Sep
(1) |
Oct
(14) |
Nov
|
Dec
|
|
From: <nt...@us...> - 2010-10-02 15:02:15
|
Revision: 7608
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7608&view=rev
Author: nthiery
Date: 2010-10-02 15:02:09 +0000 (Sat, 02 Oct 2010)
Log Message:
-----------
Added tests for idempotents of KD(6) using Delta formula + old stuff
Modified Paths:
--------------
trunk/MuPAD-Combinat/experimental/2005-09-08-David.mu
Modified: trunk/MuPAD-Combinat/experimental/2005-09-08-David.mu
===================================================================
--- trunk/MuPAD-Combinat/experimental/2005-09-08-David.mu 2010-10-02 15:00:57 UTC (rev 7607)
+++ trunk/MuPAD-Combinat/experimental/2005-09-08-David.mu 2010-10-02 15:02:09 UTC (rev 7608)
@@ -2930,7 +2930,7 @@
>> K := KD(5):
->> K::Name := hold(KD3):
+>> K::Name := hold(KD5):
>> phi := K::toDualIsomorphism:
>> phiT := K::G::dualOfModuleMorphism(phi):
>> phiT(K::e(1,1,2)+K::e(2,2,2))
@@ -3643,8 +3643,10 @@
map(p, K::M @ ThetaPrime @ K::G);
//////////////////////////////////////////////////////////////////////////////
-// Compute all the unknown sacigs between I_1 and K_3 for n odd
+// Compute all the unknown sacigs between I_2 and K_4 for n odd
+read("experimental/2005-09-08-David.mu"):
+
checkK4Conjecture :=
proc(n)
begin
@@ -3674,11 +3676,12 @@
return(TRUE);
end_proc:
-for m from 1 to 50 do
+for m from 23 to 50 do
fprint(Unquoted, 0, "".(2*m+1).": ".checkK4Conjecture(2*m+1))
-end_for
+end_for:
+
Conjecture a^2k, b for k non trivial divisor of n?
n=9: k=3 p_<a^6, b> T = {3}
@@ -3691,8 +3694,112 @@
k=9 p_<a^6, b> T = {9}
n=33,35,39: OK
+//////////////////////////////////////////////////////////////////////////////
+// 2008-11-18 Check that K_2 in KQ_{2n+1} is always L^\infty(D_n)
+// Checked up to n=14
+for n from 1 to 55 do
+ K := KQ(n):
+ [a,b] := K::G::algebraGenerators::list():
+ p2 := 1/(2*n) *_plus(a^k $ k=0..2*n-1): // K::G(K::e(1)+K::e(2)):
+ K2basis := coidealAndAlgebraClosure([p2]):
+ K2 := Dom::SubFreeModule(K2basis, Categories = [Cat::FiniteDimensionalHopfAlgebraWithBasis(K::coeffRing)]):
+ K2dual := K2::Dual():
+ Dn := DihedralGroup(n):
+ print(n,nops(Dn::groupEmbeddings(K2dual::intrinsicGroup())))
+end
+
//////////////////////////////////////////////////////////////////////////////
+// 2009/09/28
+
+n := 5:
+K := KD(n):
+phi := K::toDualIsomorphism: // G -> M^*
+[aa,bb] := K::G::algebraGenerators::list():
+Psi := K::G::dualOfModuleMorphism(phi): // M -> G^*
+
+bp := Psi(K::M(bb)):
+
+duality :=
+proc(x,y,z=0) // Returns the scalar product <x, y + z * b'>
+begin
+ scalar(x,y) + scalar(bp*x*bp, z)
+end_proc:
+
+duality2 :=
+proc(x,y,z=0) // Returns the scalar product <x, y + z * b'>
+begin
+ scalar(x,y) + scalar(bp*x, z)
+end_proc:
+
+e := K::e: r := K::r:
+
+K2basis := [ e(1)+e(2), e(3)+e(4) ] . [(r(1,1,n-2*j), e(1,1,2*j)) $ j=1..(n-1)/2] . revert([(r(2,2,n-2*j), e(2,2,2*j)) $ j=1..(n-1)/2 ]):
+
+K1basis := [ e(1)+e(2)+e(3)+e(4) ] . [(r(1,1,n-2*j) + e(1,1,2*j)) $ j=1..(n-1)/2] . revert([(r(2,2,n-2*j) + e(2,2,2*j)) $ j=1..(n-1)/2 ]):
+
+eip := K::coeffRing::primitiveUnitRoot(n):
+
+K1fourrier := [ _plus(eip^(-j*k) * K1basis[j+1] $ j=0..n-1) $ k=0..n-1 ]:
+Theta := k-> K::G::algebraMorphism(table(a = aa^k, b = bb)):
+
+//matrix( [ [duality(Psi(x), K::G(y)) $ x in K1basis ] $ y in K1basis]):
+matrix( [ [duality(Psi(x), K::G(y)) $ x in K1basis ] $ y in K1fourrier]);
+
+matrix( [ [duality(Psi(x), Theta(3)(K::G(y))) $ x in K1basis ] $ y in K1fourrier]);
+
+matrix( [ [duality2(Psi(x), 0,Theta(3)(K::G(y))) $ x in K2basis ] $ y in K1fourrier]);
+
+
+// Suggestion Marie-Claude, 2/10/2009
+duality3 :=
+proc(x,y,z=0) // Returns the scalar product <x, y + z * b'>
+begin
+ scalar(x,y) + _plus( scalar(xx[1],z)*scalar(xx[2], bb) $ xx in (x::coproduct())::toCartesianProduct() )
+end_proc:
+
+matrix( [ [ (duality3(Psi(x), K::G(y), 0), duality3(Psi(x), 0, K::G(y))) $ y in K1fourrier]
+ $ x in K2basis ] )
+
+// Base de K2 en coupant au milieu les termes ci-dessus
+
+
+/*
+
+N := 6:
+K := (KD(N))::coeffRing:
+P := Dom::MultivariatePolynomial([x1,x2,x3,x4,xb4,xb3,xb2,xb1],K):
+P::conjugate := proc(p) begin return(P::fromList(map(poly2list(p), t -> [t[1], revert(t[2])]))); end:
+prog::test(conjugate(P(x1+3*x3*x4 - 2*xb4)), P(xb1+3*xb3*xb4 - 2*x4)):
+KK := Dom::Fraction(P):
+operators::overloaded::declareConversion(K, KK, KK):
+KK::primitiveUnitRoot := proc(N) begin return(KK(K::primitiveUnitRoot(N))) end:
+KK::conjugate := proc(f) begin KK(conjugate(op(f,1))) / KK(conjugate(op(f,2))) end:
+f := KK(x1) / (KK(1)-KK(xb2)):
+prog::test(conjugate(f), KK(xb1) / (KK::one - KK(x2))):
+KD6 := KD(N, KK):
+KK::convertOld := KK::convert:
+KK::convert := proc(x) begin if domtype(x) = dom then return(x); else return(dom::convertOld(x)); end_if; end_proc:
+Hdual := KD6::G::Hdual:
+H := KD6::G::H:
+h := H::list()[1]:
+hh := Hdual::list()[1]:
+KK::mult := _mult:
+
+e := KD6::e:
+q := e(1) + KK(x1)*e(1,1,4) + KK(x2)*e(1,2,4) + KK(x3)*e(2,1,4) + KK(x4)*e(2,2,4):
+
+q := KD6::G(q):
+res := coproduct(q) * (q::dom::one # q) - q # q:
+eqa := map({coeff(res)}, numer):
+
+groebner::gbasis(eqa);
+
+solve(expr(groebner::gbasis(eqa)));
+
+*/
+
+//////////////////////////////////////////////////////////////////////////////
// BUGS
//////////////////////////////////////////////////////////////////////////////
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <nt...@us...> - 2010-10-02 15:01:03
|
Revision: 7607
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7607&view=rev
Author: nthiery
Date: 2010-10-02 15:00:57 +0000 (Sat, 02 Oct 2010)
Log Message:
-----------
Added examples, pushed computations
Modified Paths:
--------------
trunk/MuPAD-Combinat/experimental/2007-03-30-Menous.mu
Modified: trunk/MuPAD-Combinat/experimental/2007-03-30-Menous.mu
===================================================================
--- trunk/MuPAD-Combinat/experimental/2007-03-30-Menous.mu 2010-10-02 15:00:00 UTC (rev 7606)
+++ trunk/MuPAD-Combinat/experimental/2007-03-30-Menous.mu 2010-10-02 15:00:57 UTC (rev 7607)
@@ -26,6 +26,8 @@
end_if;
t := t[1];
end_for;
+ if nops(t)>1 then return(_and(dom::isBad(child, k) $ child in t));
+ end_if;
return(FALSE);
end_proc;
@@ -36,11 +38,14 @@
end;
bad := combinat::treesGeneric
- ([Tree = Union(NodeType.i $ i=0..k-2),
+ ([Tree = Union(Chain.i $ i=1..k-1, Fork.i $ i=1..k),
Leaf = Atom(T::one),
- NodeType0 = Union(Leaf, dom::makeNode(Alias(Multiset(Tree, MinLength=2, MaxLength=MaxDegree)))),
- NodeType.i = dom::makeNode(Alias(NodeType.(i-1), DOM_LIST))
- $ i = 1..k-2]);
+ Chain1 = Leaf,
+ Chain.i = dom::makeNode(Alias(Chain.(i-1), DOM_LIST))
+ $ i = 2..k-1,
+ Fork1 = dom::makeNode(Alias(Multiset(Tree, MinLength=2, MaxLength=MaxDegree))),
+ Fork.i = dom::makeNode(Alias(Fork.(i-1), DOM_LIST))
+ $ i = 2..k]);
typeCut := Type::ListProduct( Type::ListOf(dom), Type::Union([[]], Type::ListProduct(dom)) );
@@ -77,10 +82,10 @@
local j;
begin
//print(cut,i,u);
- [sort([u[j]$ j=1..i-1,op(cut[1]),u[j]$j=i+1..nops(u)]),[T([NIL,op(cut[2])])]]
+ [[u[j]$ j=1..i-1,op(cut[1]),u[j]$j=i+1..nops(u)],[T([NIL,op(cut[2])])]]
end_proc:
[// The cut if the chain ends on this node
- [sort([op(u)]),[dom::one]],
+ [[op(u)],[dom::one]],
// The cuts obtained by extending the chain to one of the child nodes
updateCut(u,cut,i)
$ cut in self(u[i])
@@ -221,7 +226,7 @@
read("experimental/2007-03-30-Menous.mu"):
for deg from 1 to 20 do
showTime("combi", (M := CK::moduleMorphismMatrix(phi, ColumnIndices=map(Bad::list(deg), DOM_LIST)))):
- showTime("write", (M1 := Dom::SparseMatrix_LinBox(Dom::Rational)(M))):
+ showTime("write", (M1 := Dom::SparseMatrix_LinBox(Dom::IntegerMod(32749))(M))):
showTime("rank", (r := M1::rank())):
fprint(Unquoted, 0, "\n", deg,"\t", Bad::count(deg),"\t", M::matdim(),"\t", r);
end:
@@ -309,14 +314,14 @@
13 5132 [7957, 5132] 3380
------------------------------------------------------------------------------
Cuts by chains only
-d := 3:
-k := 2:
+d := 2:
+k := 3:
read("experimental/2007-03-30-Menous.mu"):
-for deg from 1 to 25 do
- showTime("combi", (M := CK::moduleMorphismMatrix(phiByChain, ColumnIndices=map(Bad::list(deg), DOM_LIST)))):
- showTime("write", (M1 := Dom::SparseMatrix_LinBox(Dom::Rational)(M))):
- showTime("rank", (r := M1::rankBlackBox())):
- fprint(Unquoted, 0, "\n", deg,"\t", M::matdim(),"\t", r);
+for deg from 1 to 20 do
+ showTime("combi", (M := CK::moduleMorphismMatrix(phi, ColumnIndices=map(Bad::list(deg), DOM_LIST)))):
+ showTime("write", (M1 := Dom::SparseMatrix_LinBox(Dom::IntegerMod(32749))(M))):
+ showTime("rank", (r := M1::rank())):
+ fprint(Unquoted, 0, "\n", deg,"\t", Bad::count(deg),"\t", M::matdim(),"\t", r);
end:
------------------------------------------------------------------------------
d=2, k=2
@@ -324,41 +329,26 @@
2 0 [0, 0] 0
3 1 [1, 1] 1
4 0 [0, 0] 0
-5 1 [4, 1] 1
+5 1 [6, 1] 1
6 0 [0, 0] 0
-7 2 [9, 2] 2
+7 2 [23, 2] 2
8 0 [0, 0] 0
-9 3 [19, 3] 3
+9 3 [81, 3] 3
10 0 [0, 0] 0
-11 6 [37, 6] 6
-12 0 [0, 0] 0
-13 11 [72, 11] 11
-14 0 [0, 0] 0
-15 23 [139, 23] 23
-16 0 [0, 0] 0
-17 46 [275, 46] 46
-18 0 [0, 0] 0
-19 98 [551, 98] 98
-20 0 [0, 0] 0
+11 6 [274, 6] 6
------------------------------------------------------------------------------
-d=2, k=3
+d=2, k=3:
1 1 [0, 1] 0
2 1 [0, 1] 0
3 1 [0, 1] 0
4 2 [1, 2] 1
5 3 [4, 3] 3
-6 5 [9, 5] 5
-7 9 [19, 9] 9
-8 16 [37, 16] 16
-9 30 [70, 30] 29
-10 56 [130, 56] 56
-11 107 [243, 107] 106
-12 206 [454, 206] 203
-13 402 [858, 402] 395
-14 789 [1634, 789] 764
-15 1564 [3145, 1564] 1485
-16 3115 [6106, 3115] 2926
-17 6247 [11965, 6247] 5805
+6 5 [11, 5] 5
+7 9 [30, 9] 9
+8 16 [73, 16] 16
+9 30 [174, 30] 30
+10 56 [407, 56] 56
+11 107 [938, 107] 107
------------------------------------------------------------------------------
d=2, k=4
1 1 [0, 1] 0
@@ -367,36 +357,29 @@
4 2 [0, 2] 0
5 5 [1, 5] 1
6 8 [4, 8] 3
-7 17 [11, 17] 7
-8 31 [24, 31] 13
-9 65 [50, 65] 26
-10 129 [101, 129] 51
-11 273 [205, 273] 104
-12 565 [413, 565] 208
-13 1206 [843, 1206] 429
-14 2562 [1731, 2562] 887
-15 5516 [3601, 5516] 1869
-16 11937 [7556, 11937] 3954
-17 26027 [16023, 26027] 8465
-18 56949 [34240, 56949] 18214
+7 17 [13, 17] 9
+8 31 [35, 31] 21
+9 65 [93, 65] 50
+10 129 [234, 129] 112
+11 273 [584, 273] 251
+12 565 [1426, 565] 543
+13 1206 [3472, 1206] 1184
+14 2562 [8370, 2562] 2547
+15 5516 [20132, 5516] 5506
+16 11937 [48225, 11937] 11934
------------------------------------------------------------------------------
-d=2, k=5
-------------------------------------------------------------------------------
d=3,k=2
1 1 [0, 1] 0
2 0 [0, 0] 0
3 1 [1, 1] 1
4 1 [2, 1] 1
-5 1 [5, 1] 1
-6 2 [9, 2] 2
-7 3 [16, 3] 3
-8 5 [26, 5] 5
-9 8 [44, 8] 8
-10 14 [72, 14] 14
-11 23 [119, 23] 23
-12 40 [198, 40] 40
-13 70 [333, 70] 70
-14 122 [563, 122] 122
+5 1 [7, 1] 1
+6 2 [15, 2] 2
+7 3 [36, 3] 3
+8 5 [76, 5] 5
+9 8 [166, 8] 8
+10 14 [351, 14] 14
+11 23 [747, 23] 23
------------------------------------------------------------------------------
d=3,k=3
1 1 [0, 1] 0
@@ -404,19 +387,65 @@
3 1 [0, 1] 0
4 3 [1, 3] 1
5 5 [4, 5] 3
-6 9 [9, 9] 5
-7 20 [20, 20] 11
-8 41 [43, 41] 23
-9 88 [89, 88] 45
-10 195 [185, 195] 95
-11 433 [391, 433] 206
-12 974 [835, 974] 443
-13 2225 [1816, 2225] 979
-14 5111 [4006, 5111] 2188
-15 11816 [8956, 11816] 4945
+6 9 [11, 9] 7
+7 20 [33, 20] 18
+8 41 [90, 41] 40
+9 88 [236, 88] 88
+10 195 [621, 195] 195
+11 433 [1612, 433] 433
------------------------------------------------------------------------------
d=3,k=4
+1 1 [0, 1] 0
+2 1 [0, 1] 0
+3 2 [0, 2] 0
+4 3 [0, 3] 0
+5 7 [1, 7] 1
+6 14 [4, 14] 3
+7 31 [13, 31] 9
+8 69 [38, 69] 25
+9 159 [109, 159] 67
+10 371 [304, 371] 178
+11 881 [836, 881] 466
+12 2110 [2282, 2110] 1216
+13 5132 [6204, 5132] 3160
------------------------------------------------------------------------------
// Displaying a packed matrix
output::asciiArt::fromArray(subs(expr(M), 0=" "), Packed)):
*/
+
+/*
+package("Combinat"):
+d:=2: k := 4:
+read("/home/anh/menous/modif.mu"):
+for deg from 1 to 20 do
+ showTime("combi", (M := CK::moduleMorphismMatrix(phi, ColumnIndices=map(Bad::list(deg), DOM_LIST)))):
+ showTime("write", (M1 := Dom::SparseMatrix_LinBox(Dom::IntegerMod(32749))(M))):
+ showTime("rank", (r := M1::rank())):
+ fprint(Unquoted, 0, "\n", deg,"\t", Bad::count(deg),"\t", M::matdim(),"\t", r);
+end:
+*/
+
+/*
+export(linalg)
+package("Combinat"):
+d:=2: k := 3:deg:=6:
+read("/home/anh/menous/modif.mu"):
+showTime("combi", (M := CK::moduleMorphismMatrix(phi, ColumnIndices=map(Bad::list(deg), DOM_LIST)),RowRank=combinat::rankers::onFly()[1])):
+ showTime("write", (M1 := Dom::SparseMatrix_LinBox(Dom::IntegerMod(32749))(M))):
+ showTime("rank", (r := M1::rank())):
+ fprint(Unquoted, 0, "\n", deg,"\t", Bad::count(deg),"\t", M::matdim(),"\t", r);
+*/
+
+/*
+export(linalg):
+package("Combinat"):
+d:=2: k := 3:deg:=6:
+read("/home/anh/menous/modif.mu"):
+showTime("combi",(M := CK::moduleMorphismMatrix(phiByChain, ColumnIndices=map(Bad::list(deg), DOM_LIST)))):
+N:=transpose(M):
+Bad::count(deg);
+matdim(N);
+showTime("vec",(r:=matlinsolve(N,matrix(Bad::count(deg),1,1)))):
+r;
+
+*/
\ No newline at end of file
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <nt...@us...> - 2010-10-02 15:00:07
|
Revision: 7606
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7606&view=rev
Author: nthiery
Date: 2010-10-02 15:00:00 +0000 (Sat, 02 Oct 2010)
Log Message:
-----------
Added test
Modified Paths:
--------------
trunk/MuPAD-Combinat/experimental/2006-11-27-Alain-Arbres.mu
Modified: trunk/MuPAD-Combinat/experimental/2006-11-27-Alain-Arbres.mu
===================================================================
--- trunk/MuPAD-Combinat/experimental/2006-11-27-Alain-Arbres.mu 2010-10-02 14:59:27 UTC (rev 7605)
+++ trunk/MuPAD-Combinat/experimental/2006-11-27-Alain-Arbres.mu 2010-10-02 15:00:00 UTC (rev 7606)
@@ -156,8 +156,18 @@
combinat::trees([1])):
t := combinat::trees([NIL, [NIL, [NIL], [NIL]], [NIL, [NIL, [NIL]], [NIL]], [NIL]]):
-treeWithLabelsOnLeaves(t, [1,2,3,4,5]):
+/*
+>> treeWithLabelsOnLeaves(t, [1,2,3,4,5])
+ o
+ / | \
+ /\/ \5
+ 12| 4
+ 3
+*/
+prog::test(treeWithLabelsOnLeaves(t, [1, 2, 3, 4, 5]),
+ combinat::trees([NIL, [NIL, [1], [2]], [NIL, [NIL, [3]], [4]], [5]])):
+
throwOutNonAssociatedClosing :=
proc(word)
local height;
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <nt...@us...> - 2010-10-02 14:59:33
|
Revision: 7605
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7605&view=rev
Author: nthiery
Date: 2010-10-02 14:59:27 +0000 (Sat, 02 Oct 2010)
Log Message:
-----------
Added HeckeGraph domain
Modified Paths:
--------------
trunk/MuPAD-Combinat/experimental/2006-06-27-HeckeCoxeter.mu
Modified: trunk/MuPAD-Combinat/experimental/2006-06-27-HeckeCoxeter.mu
===================================================================
--- trunk/MuPAD-Combinat/experimental/2006-06-27-HeckeCoxeter.mu 2010-10-02 14:58:43 UTC (rev 7604)
+++ trunk/MuPAD-Combinat/experimental/2006-06-27-HeckeCoxeter.mu 2010-10-02 14:59:27 UTC (rev 7605)
@@ -981,7 +981,7 @@
/*
A := Dom::MonoidAlgebra(NonDecreasingParkingFunctions(5)): A::basis::list():
A::simpleModulesDimensions();
-sort(A::representationTheory()[dimProjectiveModules]);
+sort(A::projectiveModulesDimensions())
viewTeX((A::cartanInvariantsGraph())::TeX())
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
@@ -1040,6 +1040,16 @@
end:
*/
+domain HeckeGraph(W: Cat::CoxeterGroup)
+ inherits Dom::BaseDomain;
+ category Cat::CombinatorialModule;
+
+ moduleGenerators := [W::one];
+
+ operators := classes::valuesOfTable(i = W::heckeGenerator(i) $ i in W::coxeterGroupGenerators::keys);
+end_domain:
+
+
domain affineGraph(W: Cat::CoxeterGroup, omega: Type::AnyType)
inherits Dom::BaseDomain;
category Cat::CombinatorialModule;
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <nt...@us...> - 2010-10-02 14:58:49
|
Revision: 7604
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7604&view=rev
Author: nthiery
Date: 2010-10-02 14:58:43 +0000 (Sat, 02 Oct 2010)
Log Message:
-----------
Updated facts about *-Combinat at the time of Sage Days 10
Modified Paths:
--------------
trunk/MuPAD-Combinat/lib/DOC/demo/facts.tex
Modified: trunk/MuPAD-Combinat/lib/DOC/demo/facts.tex
===================================================================
--- trunk/MuPAD-Combinat/lib/DOC/demo/facts.tex 2010-10-02 14:57:20 UTC (rev 7603)
+++ trunk/MuPAD-Combinat/lib/DOC/demo/facts.tex 2010-10-02 14:58:43 UTC (rev 7604)
@@ -1,20 +1,24 @@
\begin{frame}
-\frametitle{\texttt{MuPAD-Combinat} figures}
+\frametitle{\texttt{*-Combinat} figures}
\begin{itemize}
-\item Abbad, Bandlow, Carr\xE9, Chapotton, Descouens, Gomez-Diaz, Hivert,
- Laugerotte, Lemeur, Molinero, Novelli, Nzeutchap, Schilling, Wang,
- Zabrocki, ...
-\item 25+ research articles
-\item Official MuPAD library since 2002, NSF Sponsored
-\item 7 years, 10 official releases, 6 stable ones
-\item GNU/Linux, MacOS X, Windows, Zaurus
-\item 115000 lines of MuPAD, 15000 lines of C++\\
-\item 32000 lines of tests, 600 pages of doc
+\item Community: Abbad, Bandlow, \emph{Borie}, Bump, Carr\xE9, Chapoton,
+ Denton, Descouens, Gomez-Diaz, \emph{Hansen}, Hemmecke,
+ \emph{Hivert}, Jones, Laugerotte, Lecouvey, Lemeur, \emph{Miller},
+ Molinero, Musiker, Novelli, Nzeutchap, Qiang, Rubey, Schilling,
+ Shimozono, \emph{Thi\xE9ry}, \emph{Tevlin}, Walker, Zabrocki,
+ \emph{Zimmermann}
+\item End result: 50 publications
+%\item Official MuPAD library since 2002, NSF Sponsored
+%\item 8 years, 10 official releases, 6 stable ones
+%\item GNU/Linux, MacOS X, Windows, Zaurus
+\item 600 classes, 5000 methods, 130k lines of \texttt{MuPAD}\\
+ 60k lines of \texttt{Sage}
+\item 32k lines of tests, 600 pages of doc
%\item In 2005: 1500 messages on the mailing list, 5000 visits of the
% web page and 400 downloads.
-\item Integrated software: $\mu$-EC, CS, PerMuVAR, Symmetrica, lrcalc,
- Nauty, rigged configuration kernel
-\item How many users?
+%\item Integrated software: $\mu$-EC, CS, PerMuVAR, Symmetrica, lrcalc,
+% Nauty, rigged configuration kernel
+%\item How many users?
\end{itemize}
\end{frame}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <nt...@us...> - 2010-10-02 14:57:26
|
Revision: 7603
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7603&view=rev
Author: nthiery
Date: 2010-10-02 14:57:20 +0000 (Sat, 02 Oct 2010)
Log Message:
-----------
Added test file for BaseCategory
Added Paths:
-----------
trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/TEST/BaseCategory.tst
Added: trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/TEST/BaseCategory.tst
===================================================================
--- trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/TEST/BaseCategory.tst (rev 0)
+++ trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/TEST/BaseCategory.tst 2010-10-02 14:57:20 UTC (rev 7603)
@@ -0,0 +1,143 @@
+/*****************************************************************************
+ $Id: UseOverloading.tst 1879 2003-09-23 18:08:11Z nthiery $
+ File: lib/EXPERIMENTAL/TEST/BaseDomain.tst
+ Authors: Nicolas M. Thi\xE9ry <nt...@us...>
+ Purpose: Test file for the library 'experimental::BaseDomain'
+ Created: 04/12/2002
+ License: LGPL
+*****************************************************************************/
+
+prog::testinit("BaseCategory"):
+
+prog::testfunc("initDomainAdd"):
+
+l:=[]:
+
+domain domA
+ inherits Dom::BaseDomain;
+ category Cat::UseOverloading;
+
+ initDomainAdd := () -> (l:=append(l,[dom, "domA"]));
+end_domain:
+
+prog::test(l,
+ [[domA, "domA"]]):
+l := []:
+
+category catA
+ category Cat::UseOverloading;
+
+ initDomainAdd := () -> (l:=append(l,[dom, "catA"]));
+end_category:
+
+category catB
+ category catA;
+
+ initDomainAdd := () -> (l:=append(l,[dom, "catB"]));
+end_category:
+
+domain domB
+ inherits domA;
+ category catB;
+
+ initDomainAdd := () -> (l:=append(l,[dom, "domB"]));
+end_domain:
+
+prog::test(l,
+ [[domB, "catA"], [domB, "catB"],
+ [domB, "domA"], [domB, "domB"]]):
+l := []:
+
+domain domC
+ inherits domB;
+ category catB;
+
+ initDomainAdd := () -> (l:=append(l,[dom, "D"]));
+end_domain:
+
+prog::test(l,
+ [[domC, "catA"], [domC, "catB"],
+ [domC, "domA"], [domC, "domB"], [domC, "D"]]):
+
+//////////////////////////////////////////////////////////////////////////////
+prog::testfunc("conversions"):
+
+// Create a bunch of domains and categories, most but not all in Cat::BaseCategory,
+// with conversions declared at various levels and conversion circuits, and check
+// that the conversions work appropriately
+
+domain other1 conversions := () -> [DOM_INT = intToOther1]; end_domain:
+domain other2 end_domain:
+domain other3 end_domain:
+domain other4
+ inherits Dom::BaseDomain;
+ category Cat::BaseCategory;
+ conversionsAdd := [() -> dom4 = dom4ToOther4];
+end_domain:
+domain other5 end_domain:
+
+category cat1
+ category Cat::BaseCategory;
+ conversionsAdd := [ other1 = fromOther1 ];
+end:
+category cat2
+ category cat1;
+ conversionsAdd := [ other2 = fromOther2 ];
+end_category:
+
+domain dom3
+ inherits Dom::BaseDomain;
+ conversionsAdd := [ other3 = fromOther3 ];
+end_domain:
+
+domain dom4
+ inherits dom3;
+ category cat2;
+ conversionsAdd := [ other4 = fromOther4 ];
+end_domain:
+
+operators::overloaded::declareConversion(other5, dom4, fromOther5):
+prog::test(dom4::conversions(),
+ table(dom4=id, other1=fromOther1,other2=fromOther2,other3=fromOther3,other4=fromOther4,other5=fromOther5)):
+prog::test(dom4::conversion(dom3),
+ FAIL):
+prog::test(dom4::conversion(dom4),
+ []):
+prog::test(dom4::conversion(other1),
+ [fromOther1]):
+prog::test(dom4::conversion(DOM_INT),
+ [fromOther1, intToOther1]):
+prog::test(dom4::conversion(other2),
+ [fromOther2]):
+prog::test(dom4::conversion(other4),
+ [fromOther4]):
+prog::test(other4::conversion(dom4),
+ [dom4ToOther4]):
+
+//////////////////////////////////////////////////////////////////////////////
+prog::testfunc("convert"):
+
+dom4::convert::declareSignature([DOM_STRING], fromString):
+operators::overloaded::declareConversion(DOM_COMPLEX, dom4, fromComplex, Explicit):
+
+prog::test(dom4::convertImplicit("bla"), FAIL):
+prog::test(dom4::convertImplicit(I), FAIL):
+prog::test(dom4::convert("bla"), fromString("bla")):
+prog::test(dom4::convert(I), fromComplex(I)):
+prog::test(dom4::convert(1), fromOther1(intToOther1(1))):
+prog::test(dom4::convert(new(other1)), fromOther1(new(other1))):
+prog::test(dom4::convert(new(dom3)), FAIL):
+
+
+//////////////////////////////////////////////////////////////////////////////
+prog::testfunc("conversionsStronglyConnectedComponent"):
+
+prog::test(dom4::conversionsStronglyConnectedComponent(),
+ {dom4, other4}):
+
+prog::testexit():
+
+// Local Variables:
+// mode: mupad
+// End:
+
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <nt...@us...> - 2010-10-02 14:56:14
|
Revision: 7602
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7602&view=rev
Author: nthiery
Date: 2010-10-02 14:56:08 +0000 (Sat, 02 Oct 2010)
Log Message:
-----------
Commited missing file containing the code for Graph::covers and Graph::transitiveClosure
Added Paths:
-----------
trunk/MuPAD-Combinat/lib/GRAPH/closure.mu
Added: trunk/MuPAD-Combinat/lib/GRAPH/closure.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/GRAPH/closure.mu (rev 0)
+++ trunk/MuPAD-Combinat/lib/GRAPH/closure.mu 2010-10-02 14:56:08 UTC (rev 7602)
@@ -0,0 +1,38 @@
+/**
+ * Transitive closure of a graph
+ *
+ * @param graph A directed graph in Graph
+ * @return The transitive closure of graph, as a graph
+ **/
+Graph::transitiveClosure :=
+proc(graph: Graph) : Graph
+ local eq;
+begin
+ Graph(Graph::getVertices(graph),
+ [ [ op(eq,1) ]
+ $ eq in select(Graph::shortestPathAllPairs(graph)[1],
+ eq -> not contains({0,infinity}, op(eq,2))) ],
+ Directed
+ );
+end:
+
+/**
+ * cover, or Hasse diagram, of an acyclic graph
+ *
+ * @param graph A directed graph in Graph
+ * @return The transitive closure of graph, as a graph
+ **/
+Graph::cover :=
+proc(graph: Graph) : Graph
+ local vertices, successors, cover, eq, v1;
+begin
+ successors := map(Graph::getEdgesLeaving(graph), DOM_SET@op);
+ vertices := combinat::linearExtensions::first(graph);
+ cover := table();
+ for v in revert(vertices) do
+ cover[v] := successors[v] minus
+ _union({v}, cover[v1] $ v1 in successors[v])
+ end_for;
+ Graph(vertices, [[op(eq,1),v1] $ v1 in op(eq,2) $ eq in cover ],
+ Directed);
+end:
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <nt...@us...> - 2010-10-02 14:54:01
|
Revision: 7601
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7601&view=rev
Author: nthiery
Date: 2010-10-02 14:53:54 +0000 (Sat, 02 Oct 2010)
Log Message:
-----------
Added demo around Kac algebras
Added Paths:
-----------
trunk/MuPAD-Combinat/lib/DOC/demo/kd.tex
Added: trunk/MuPAD-Combinat/lib/DOC/demo/kd.tex
===================================================================
--- trunk/MuPAD-Combinat/lib/DOC/demo/kd.tex (rev 0)
+++ trunk/MuPAD-Combinat/lib/DOC/demo/kd.tex 2010-10-02 14:53:54 UTC (rev 7601)
@@ -0,0 +1,341 @@
+% L'algèbre $KD(n)$ est pour l'instant implantée dans une feuille de
+% travail séparée que l'on charge ici:
+\begin{Mexin}
+read("experimental/2005-09-08-David.mu"):
+\end{Mexin}
+% \Mup{KD(3)} modélise l'algèbre abstraite; après l'avoir construite
+\begin{Mexin}
+KD3 := KD(3):
+\end{Mexin}
+\begin{Mexout}
+\end{Mexout}
+% nous demandons quelles sont ses propriétés connues:
+\begin{Mexin}
+KD3::categories
+\end{Mexin}
+\begin{Mexout}
+ [Cat::HopfAlgebraWithSeveralBases(Q(II, epsilon)),
+ TwistedDihedralOrQuaternionGroupAlgebra(3),
+ Cat::AlgebraWithSeveralBases(Q(II, epsilon)),
+ Cat::Algebra(Q(II, epsilon)),
+ Cat::ModuleWithSeveralBases(Q(II, epsilon)),
+ Cat::Ring, Cat::Module(Q(II, epsilon)),
+ Cat::DomainWithSeveralRepresentations, Cat::Rng, Cat::SemiRing,
+ Cat::LeftModule(KD(3, Q(II, epsilon))),
+ Cat::LeftModule(Q(II, epsilon)), Cat::RightModule(Q(II, epsilon)),
+ Cat::UseOverloading, Cat::FacadeDomain, Cat::SemiRng, Cat::Monoid,
+ Cat::AbelianGroup, Cat::SemiGroup, Cat::CancellationAbelianMonoid,
+ Cat::AbelianMonoid, Cat::AbelianSemiGroup, Cat::Object,
+ Cat::BaseCategory]
+\end{Mexout}
+% À quelques exceptions près, ce sont des informations mathématiques.
+
+% Pour faire des calculs, nous avons besoin d'une représentation
+% concrète de cette algèbre. Celle utilisant la base du groupe est
+% modélisée par \Mup{KD3::group}. Nous commençons par introduire des
+% notations courtes pour ses générateurs:
+\begin{Mexin}
+[aa,bb] := KD3::group::algebraGenerators::list()
+\end{Mexin}
+\begin{Mexout}
+ [B(a), B(b)]
+\end{Mexout}
+% Les quelques calculs suivants, dans la base du groupe, montrent que le
+% produit n'est pas déformé:
+\begin{Mexin}
+bb^2
+\end{Mexin}
+\begin{Mexout}
+ B(1)
+\end{Mexout}
+\begin{Mexin}
+aa^2, aa^6, bb*aa
+\end{Mexin}
+\begin{Mexout}
+ 2 5
+ B(a ), B(1), B(a b)
+\end{Mexout}
+\begin{Mexin}
+(1 - aa^3)*(bb + aa^3) + 1/2*bb*aa^3
+\end{Mexin}
+\begin{Mexout}
+ 3
+ 1/2 B(a b)
+\end{Mexout}
+% De part la théorie des représentations, l'algèbre $KD(3)$ admet une
+% autre représentation concrète comme algèbre de matrices par blocs,
+% modélisées par \Mup{KD3::matrix}. Nous utilisons ici l'isomorphisme
+% entre les deux représentations (transformée de Fourier, d'où la
+% présence de \Mup{epsilon} qui représente une racine $\epsilon$ de l'unité).
+\begin{Mexin}
+KD3::M(aa + 2*bb)
+\end{Mexin}
+\begin{Mexout}
+ +- -+
+ | 3, 0, 0, 0, 0, 0, 0, 0 |
+ | |
+ | 0, -1, 0, 0, 0, 0, 0, 0 |
+ | |
+ | 0, 0, -3, 0, 0, 0, 0, 0 |
+ | |
+ | 0, 0, 0, 1, 0, 0, 0, 0 |
+ | |
+ | 0, 0, 0, 0, epsilon, 2, 0, 0 |
+ | |
+ | 0, 0, 0, 0, 2, 1 - epsilon, 0, 0 |
+ | |
+ | 0, 0, 0, 0, 0, 0, epsilon - 1, 2 |
+ | |
+ | 0, 0, 0, 0, 0, 0, 2, -epsilon |
+ +- -+
+\end{Mexout}
+% Cet isomorphisme n'a été explicitement implanté que dans un sens (en
+% donnant l'image de $a$ et $b$); l'isomorphisme inverse est construit
+% automatiquement par inversion de matrices.
+
+% Le coproduit est déformé par un cocycle du sous-groupe $\langle
+% a^3,b\rangle$. Pour les éléments de ce sous-groupe, le coproduit n'est
+% donc pas déformé (\# dénote le produit tensoriel $\otimes$):
+\begin{Mexin}
+coproduct(aa^3), coproduct(bb)
+\end{Mexin}
+\begin{Mexout}
+ 3 3
+ B(a ) # B(a ), B(b) # B(b)
+\end{Mexout}
+% Par contre, le coproduit de $a$ est compliqué:
+\begin{Mexin}
+coproduct(aa)
+\end{Mexin}
+\begin{Mexout}
+ 4 4 / II \ 4 5 / II \ 4 2
+ 1/16 B(a b) # B(a b) + | - -- - 1/16 | B(a b) # B(a ) + | -- - 1/16 | B(a b) # B(a b) +
+ \ 8 / \ 8 /
+
+ ... 100 lignes coupées ...
+
+ 2
+ -1/16 B(a) # B(a ) + 7/16 B(a) # B(a)
+\end{Mexout}
+
+% Nous considérons maintenant l'antipode. C'est une application linéaire
+% dont la matrice est donnée par:
+% \begin{Mexin}
+% KD3::G::moduleMorphismMatrix(KD3::G::antipode)
+% \end{Mexin}
+% \begin{Mexout}
+% +- -+
+% | 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
+% | |
+% | 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
+% | |
+% | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 |
+% | |
+% | 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 |
+% | |
+% | 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 |
+% | |
+% | 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 |
+% | |
+% | 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 |
+% | |
+% | 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 |
+% | |
+% | 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 |
+% | |
+% | 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 |
+% | |
+% | 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
+% | |
+% | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 |
+% +- -+
+% \end{Mexout}
+% et dont le noyau est trivial:
+% \begin{Mexin}
+% KD3::G::kernelOfModuleMorphism(KD3::G::antipode)
+% \end{Mexin}
+% \begin{Mexout}
+% []
+% \end{Mexout}
+
+% Pour illustrer des calculs tensoriels typiques, nous vérifions que
+% l'antipode est correcte, c'est-à-dire que la formule $\mu \circ (\id
+% \otimes S) \circ \Delta$ redonne bien la counité de l'algèbre de Hopf:
+\begin{Mexin}
+K := KD3::G: // un simple raccourci
+checkAntipode := K::mu @ ( K::id # K::antipode ) @ K::coproduct:
+\end{Mexin}
+\begin{Mexin}
+checkAntipode(x) $ x in K::basis::list()
+\end{Mexin}%$
+\begin{Mexout}
+ B(1), B(1), B(1), B(1), B(1), B(1), B(1), B(1), B(1), B(1), B(1), B(1)
+\end{Mexout}
+
+
+\begin{Mexin}
+automorphismGroup := KD3::G::algebraEmbeddings(KD3::G)
+\end{Mexin}
+\begin{Mexin}
+for phi in automorphismGroup do
+ fprint(Unquoted,0, _concat("-" $ 78)):
+ print(hold(phi)(a) = phi(KD3::G::algebraGenerators[a]));
+ print(hold(phi)(b) = phi(KD3::G::algebraGenerators[b]));
+end:
+\end{Mexin}
+
+% Notre étude concernait les coidéaux de $KD(3)$, c'est à dire des
+% sous-algèbres «stables à droite» pour le coproduit. Notons $e$ les
+% unités matricielles de l'algèbre.
+\begin{Mexin}
+e := KD3::e:
+\end{Mexin}
+% Nous calculons maintenant une base du coidéal $K_2:=I(e_1+e_2)$ engendré
+% par $e_1+e_2$:
+\begin{Mexin}
+K2basis := coidealAndAlgebraClosure([ e(1)+e(2) ])
+\end{Mexin}
+\begin{Mexout}
+ -- +- -+ +- -+ +- -+ --
+ | | 1, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | |
+ | | | | | | | |
+ | | 0, 1, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | |
+ | | | | | | | |
+ | | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 1, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | |
+ | | | | | | | |
+ | | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 1, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | |
+ | | |, | |, ..., | | |
+ | | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | |
+ | | | | | | | |
+ | | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | |
+ | | | | | | | |
+ | | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | |
+ | | | | | | | |
+ | | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 1 | |
+ -- +- -+ +- -+ +- -+ --
+\end{Mexout}
+% +- -+ +- -+
+% | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 |
+% | | | |
+% | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 |
+% | | | |
+% | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 |
+% | | | |
+% | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 |
+% | |, | |,
+% | 0, 0, 0, 0, 0, -1, 0, 0 | | 0, 0, 0, 0, 1, 0, 0, 0 |
+% | | | |
+% | 0, 0, 0, 0, 1, 0, 0, 0 | | 0, 0, 0, 0, 0, 1, 0, 0 |
+% | | | |
+% | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 |
+% | | | |
+% | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 |
+% +- -+ +- -+
+
+% +- -+ +- -+ --
+% | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | |
+% | | | | |
+% | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | |
+% | | | | |
+% | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | |
+% | | | | |
+% | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | |
+% | |, | | |
+% | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | |
+% | | | | |
+% | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | |
+% | | | | |
+% | 0, 0, 0, 0, 0, 0, 1, 0 | | 0, 0, 0, 0, 0, 0, 0, 0 | |
+% | | | | |
+% | 0, 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0, 1 | |
+% +- -+ +- -+ --
+%\end{Mexout}
+% \begin{Mexin}
+% expose(KD3::G::algebraClosure)
+% \end{Mexin}
+% \begin{Mexout}
+% proc(generators : Type::ListOf(KD3::G)) : Type::ListOf(KD3::G)
+% name KD3::G::algebraClosure;
+% begin
+% userinfo(3, "Computing the (non unital!) algebra closure");
+% dom::moduleClosure(generators, [proc(x : dom) : Type::SequenceOf(do\
+% m)
+% local generator;
+% begin
+% x*generator $ generator in generators
+% end_proc])
+% end_proc
+% \end{Mexout}
+% On reconnaît $e_1+e_2$ dans le premier élément.
+
+% Manipuler directement une telle base n'est pas commode pour étudier
+% les propriétés algébriques de $K_2$. Nous construisons donc un objet
+% qui modélise cette sous-algèbre, en promettant à \mupad qu'il s'agit
+% d'une sous-algèbre de Hopf (ce que nous savions par ailleurs).
+\begin{Mexin}
+K2 := Dom::SubFreeModule(K2basis,
+ [Cat::FiniteDimensionalHopfAlgebraWithBasis(KD3::coeffRing)]):
+\end{Mexin}
+% Nous pouvons maintenant demander si cette sous-algèbre est commutative
+% ou cocommutative:
+\begin{Mexin}
+K2::isCommutative(), K2::isCocommutative()
+\end{Mexin}
+\begin{Mexout}
+ TRUE, FALSE
+\end{Mexout}
+% Nous en déduisons que c'est forcément l'algèbre duale d'une algèbre de
+% groupe que nous souhaitons retrouver. Pour cela, nous construisons
+% l'algèbre duale de $K_2$:
+\begin{Mexin}
+K2dual := K2::Dual():
+\end{Mexin}
+% L'algorithmique sous-jacente est triviale: les opérateurs sont définis
+% par simple transposition de ceux de l'algèbre originale. Mais il est
+% pratique de ne pas avoir à s'en soucier.
+
+% Calculons les éléments de type groupe de cette algèbre (ici,
+% l'algorithmique est non triviale!):
+\begin{Mexin}
+K2dual::groupLikeElements()
+\end{Mexin}
+\begin{Mexout}
+ [B([1, 1]), B([7, 7]), B([3, 3]), B([8, 8]), B([5, 5]) + -II B([6, 5]), B([5, 5]) + II B([6, 5])]
+\end{Mexout}
+% Ces éléments forment un groupe, le groupe intrinsèque. Pour le
+% déterminer, il reste à reconnaître la règle de produit.
+\begin{Mexin}
+G := K2dual::intrinsicGroup():
+G::list()
+\end{Mexin}
+\begin{Mexout}
+ [[], [1], [1, 1], [2], [1, 2], [1, 1, 2]]
+\end{Mexout}
+\begin{Mexin}
+D3 := DihedralGroup(3):
+nops(D3::groupEmbeddings(G))
+\end{Mexin}
+
+% $G$ modélise le groupe; ses éléments on été exprimés en fonction de
+% générateurs choisis au hasard. C'est brutal, \mupad n'ayant que des
+% fonctionnalités élémentaires pour les groupes. Cela est cependant
+% suffisant ici: on reconnaît à nouveau un groupe dihédral. Nous
+% finissons en calculant à titre de vérification quelques informations
+% sur la théorie des représentations:
+\begin{Mexin}
+K2dual::isSemiSimple()
+\end{Mexin}
+\begin{Mexout}
+ TRUE
+\end{Mexout}
+\begin{Mexin}
+K2dual::simpleModulesDimensions()
+\end{Mexin}
+\begin{Mexout}
+ [2, 1, 1]
+\end{Mexout}
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: t
+%%% End:
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <nt...@us...> - 2010-10-02 14:51:18
|
Revision: 7600
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7600&view=rev
Author: nthiery
Date: 2010-10-02 14:51:12 +0000 (Sat, 02 Oct 2010)
Log Message:
-----------
Micro improvement to the short demo
Modified Paths:
--------------
trunk/MuPAD-Combinat/lib/DOC/demo/combinatShort.tex
Modified: trunk/MuPAD-Combinat/lib/DOC/demo/combinatShort.tex
===================================================================
--- trunk/MuPAD-Combinat/lib/DOC/demo/combinatShort.tex 2010-10-02 14:49:44 UTC (rev 7599)
+++ trunk/MuPAD-Combinat/lib/DOC/demo/combinatShort.tex 2010-10-02 14:51:12 UTC (rev 7600)
@@ -11,6 +11,14 @@
\eng{Many standard combinatorial classes are predefined in
MuPAD-Combinat. Each is represented by a library with
a standardized interface:}
+\begin{Mexin}
+partitions::list(5)
+\end{Mexin}
+\begin{Mexin}
+partitions::count(10)
+\end{Mexin}
+
+
\begin{Mexin}
trees::list(5)
\end{Mexin}
@@ -28,7 +36,7 @@
| --
\end{Mexout}
\begin{Mexin}
-trees::count(5)
+trees::count(6)
\end{Mexin}
\begin{Mexin}
trees::random(50)
@@ -37,7 +45,12 @@
\eng{This also applies for several libraries which are based on
\Mup{combinat::decomposableObjects}. For example, here is the
recurrence relation for binary trees: }
+
\begin{Mexin}
+print(eq) $ eq in binaryTrees::grammar::specification
+\end{Mexin}
+
+\begin{Mexin}
r := binaryTrees::grammar::recurrenceRelation():
assume(n>0):
u(n) = factor(op(solve(r, u(n)),1))
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <nt...@us...> - 2010-10-02 14:49:50
|
Revision: 7599
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7599&view=rev
Author: nthiery
Date: 2010-10-02 14:49:44 +0000 (Sat, 02 Oct 2010)
Log Message:
-----------
Added VertexId and VertexRanker options to Graph::DotTeX
Modified Paths:
--------------
trunk/MuPAD-Combinat/lib/GRAPH/dotTeX.mu
Modified: trunk/MuPAD-Combinat/lib/GRAPH/dotTeX.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/GRAPH/dotTeX.mu 2010-10-02 14:48:22 UTC (rev 7598)
+++ trunk/MuPAD-Combinat/lib/GRAPH/dotTeX.mu 2010-10-02 14:49:44 UTC (rev 7599)
@@ -4,7 +4,7 @@
Graph::dotTeX :=
proc(G: Graph) : DOM_STRING
- local weights, vertexRanker, vertex, child, result, options, edge, fixquoting, rankdir, vertexOptions, edgeOptions, arrow, knownEdges, pair, group;
+ local weights, vertexRanker, vertexId, vertex, child, result, options, edge, fixquoting, rankdir, vertexOptions, edgeOptions, arrow, knownEdges, pair, group;
begin
options := prog::getOptions([ Groups = [],
EdgeColors = table(),
@@ -14,7 +14,7 @@
VertexOptions = (()->{}),
Loops = TRUE,
Dot2TeXOptions = "",
- RankSep, NodeSep
+ RankSep, NodeSep, VertexId, NodeTeX = generate::TeX
],
table(EdgeColors = Type::TableOf(Graph::getEdges(G), DOM_STRING),
Direction = [Left, Right, Up, Down],
@@ -24,6 +24,7 @@
Groups = Type::ListOf(DOM_LIST),
VertexOptions = Type::Morphism(),
EdgeOptions = Type::Morphism(),
+ VertexId = Type::Morphism(),
Loops = DOM_BOOL,
Dot2TeXOptions = DOM_STRING
),
@@ -38,7 +39,12 @@
if weights = FAIL then
weights := table();
end_if;
- vertexRanker := combinat::rankers::onFly()[1];
+ if contains(options, VertexId) then
+ vertexId := options[VertexId];
+ else
+ vertexRanker := combinat::rankers::onFly()[1];
+ vertexId := node -> "N_".vertexRanker(node);
+ end_if;
// vertexRanker := dom::vertexRanker;
rankdir := table(Left = "RL", Right = "LR", Up = "BT");
@@ -70,10 +76,16 @@
for vertex in dom::getVertices(G) do
vertexOptions := table(op(options[VertexOptions](vertex)));
result := _concat(result,
- "N_", vertexRanker(vertex),
+ vertexId(vertex),
" [ label = \" \", texlbl = \"$",
- fixquoting(generate::TeX(vertex)),
+ fixquoting(options[NodeTeX](vertex)),
"$\",",
+ if contains(vertexOptions, Coordinates) then
+ " x = ".vertexOptions[Coordinates][1].", ",
+ " y = ".vertexOptions[Coordinates][2].", "
+ else
+ ()
+ end_if,
if contains(vertexOptions, Color) then
"lblstyle = ".vertexOptions[Color].", "
else
@@ -103,11 +115,11 @@
end_if;
result:= _concat(result,
if edgeOptions[Backward] then
- "N_".vertexRanker(child), arrow,
- "N_".vertexRanker(vertex)
+ vertexId(child), arrow,
+ vertexId(vertex)
else
- "N_".vertexRanker(vertex), arrow,
- "N_".vertexRanker(child)
+ vertexId(vertex), arrow,
+ vertexId(child)
end_if,
" [ ",
if not edgeOptions[Directed] then
@@ -159,8 +171,8 @@
for group in options[Groups] do
for pair in combinat::subwords(group, 2) do
result := _concat(result,
- "N_" .vertexRanker(pair[1]), " -- ",
- " N_".vertexRanker(pair[2]),
+ vertexId(pair[1]), " -- ",
+ " ".vertexId(pair[2]),
" [ weight = 2,",
" constraint = \"false\",",
" style = \"invis\" ",
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <nt...@us...> - 2010-10-02 14:48:28
|
Revision: 7598
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7598&view=rev
Author: nthiery
Date: 2010-10-02 14:48:22 +0000 (Sat, 02 Oct 2010)
Log Message:
-----------
Added functions Category::constructorName and Category::args
Modified Paths:
--------------
trunk/MuPAD-Combinat/lib/MUPADBACKPORT/DOMAINS/CONSTR/Category.mu
Added Paths:
-----------
trunk/MuPAD-Combinat/lib/MUPADBACKPORT/DOMAINS/CONSTR/TEST/Category.tst
Modified: trunk/MuPAD-Combinat/lib/MUPADBACKPORT/DOMAINS/CONSTR/Category.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/MUPADBACKPORT/DOMAINS/CONSTR/Category.mu 2010-10-02 14:47:05 UTC (rev 7597)
+++ trunk/MuPAD-Combinat/lib/MUPADBACKPORT/DOMAINS/CONSTR/Category.mu 2010-10-02 14:48:22 UTC (rev 7598)
@@ -84,6 +84,33 @@
new(Category, CC, clos)
end_proc:
+// Returns the name of the constructor
+Category::constructorName :=
+proc(Ca: Category)// : DOM_STRING / DOM_EXPR
+ option noDebug;
+ local C, p;
+begin
+ C:= extop(Ca, 2);
+ p:= op(C, 1);
+ op(p, 6);
+end_proc:
+
+// Returns the arguments passed to the category constructor
+Category::args :=
+proc(Ca: Category)
+ option noDebug;
+ local C, p;
+begin
+ C:= extop(Ca, 2);
+ p:= op(C, 1);
+ if op(p,1) = NIL then
+ null()
+ else
+ p:= op(C,[0,2]);
+ op(C, p..(p+op(C,[0,3])-1))
+ end
+end_proc:
+
/*++
print -- print category
Added: trunk/MuPAD-Combinat/lib/MUPADBACKPORT/DOMAINS/CONSTR/TEST/Category.tst
===================================================================
--- trunk/MuPAD-Combinat/lib/MUPADBACKPORT/DOMAINS/CONSTR/TEST/Category.tst (rev 0)
+++ trunk/MuPAD-Combinat/lib/MUPADBACKPORT/DOMAINS/CONSTR/TEST/Category.tst 2010-10-02 14:48:22 UTC (rev 7598)
@@ -0,0 +1,12 @@
+prog::testinit("Category"):
+
+ /*
+prog::testfunc("Category::constructorName"):
+
+prog::test(Category::constructorName(Cat::UseOverloading),
+ hold(slot)(Cat, "UseOverloading")):
+prog::test(CategoryConstructorName(Cat::Algebra(Dom::Rational)),
+ hold(slot)(Cat, "Algebra")):
+ */
+
+prog::testexit():
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <nt...@us...> - 2010-10-02 14:47:12
|
Revision: 7597
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7597&view=rev
Author: nthiery
Date: 2010-10-02 14:47:05 +0000 (Sat, 02 Oct 2010)
Log Message:
-----------
Commited old changes (improvements?) to HeckeGroup code
Modified Paths:
--------------
trunk/MuPAD-Combinat/lib/EXAMPLES/HeckeGroupAlgebra.mu
trunk/MuPAD-Combinat/lib/EXAMPLES/TEST/HeckeGroupAlgebra.tst
Modified: trunk/MuPAD-Combinat/lib/EXAMPLES/HeckeGroupAlgebra.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/EXAMPLES/HeckeGroupAlgebra.mu 2010-10-02 14:45:01 UTC (rev 7596)
+++ trunk/MuPAD-Combinat/lib/EXAMPLES/HeckeGroupAlgebra.mu 2010-10-02 14:47:05 UTC (rev 7597)
@@ -26,7 +26,9 @@
domain HGAT::V(W: Cat::CoxeterGroup,
R=Dom::ExpressionField(): Cat::Ring)
- inherits Dom::FreeModule(W, R, RankerBasis = combinat::rankers::fromList(W::list()));
+ inherits Dom::FreeModule(W, R,
+ RankerBasis = [combinat::setOptionRemember(W::rank),
+ combinat::setOptionRemember(W::unrank)]);
category Cat::FiniteDimensionalModuleWithBasis(R);
end_domain:
@@ -36,7 +38,9 @@
R=Dom::ExpressionField(): Cat::Ring)
category Cat::FiniteDimensionalAlgebraWithBasis(R);
- interfaceAdd := hold(affineHeckeAlgebraEmbedding);
+ interfaceAdd := {hold(affineHeckeAlgebraEmbedding), text2expr("W"), hold(V),
+ hold(s), hold(pi), hold(opi), hold(fromW), hold(algebraGenerators)
+ };
W := W;
@@ -48,7 +52,6 @@
algebraGenerators := dom::s::list() . dom::pi::list();
// spiBasis := ;
-
// override by better when possible!
fromW :=
@@ -62,17 +65,26 @@
begin
HGAT::AffineHeckeAlgebraEmbedding(dom, args())
end_proc;
-
- opi:= classes::valuesOfTable(i = dom::pi[i] * dom::s[i]
- $ i in W::coxeterGroupGenerators::keys);
+ opii :=
+ proc(i: Type::Union(W::coxeterGroupGenerators::keys,{0})) : dom
+ begin
+ // unlike pi[i] *s[i], this formula requires no computation of products,
+ // and it is independent on the product orientation
+ 1+dom::s[i] - dom::pi[i];
+ end_proc;
+
+ opi:= classes::valuesOfTableWithHiddenKeys
+ (table(i = dom::opii(i) $ i in W::coxeterGroupGenerators::keys),
+ table(0 = dom::opii(0)));
+
hamiltonian :=
/**
* Returns the hamiltonian, as an element of the
* algebra of the symmetric group
**/
proc(x) : dom
- local i, j, s;
+ local i, j;
begin
if args(0) = 0 then
// The roots of the hermite polynomial, expressed via radical expressions
@@ -90,7 +102,38 @@
end_category:
protect(Cat):
+/**
+ X := HGAT::X(exponentSet, f)
+
+ returns a gadget X such that X^bla yields f(bla)
+ **/
+domain HGAT::X
+ inherits Dom::BaseDomain;
+ category Cat::Object;
+ new :=
+ proc(exponentSet, exp: Type::Morphism())
+ begin
+ new(dom, exponentSet, exp);
+ end_proc;
+
+ get_exponentSet :=
+ proc(X: dom)
+ begin
+ extop(X,1);
+ end_proc;
+
+ _power :=
+ proc(X: dom, e)
+ begin
+ Precondition(testtype(e, X::exponentSet));
+ extop(X,2)(e);
+ end_proc;
+
+ expr := X -> hold(X);
+
+end_domain:
+
domain HGAT::AffineHeckeAlgebraEmbedding
(HGA: Cat::HeckeGroupAlgebra,
Eigenvalues = [hold(q1),hold(q2)], // The two eigenvalues of the T's
@@ -98,41 +141,92 @@
direction = Down: [Up, Down]
)
local Pi, oPi, Q1, Q2;
+ inherits Dom::BaseDomain;
+ category Cat::FacadeDomain(HGA);
Ti :=
- proc(i: HGA::W::coxeterGroupGenerators::keys) : HGA
+ proc(i: Type::Union(HGA::W::coxeterGroupGenerators::keys,{0})) : HGA
option remember;
begin
(Q1+Q2) * Pi[i] - Q1 * HGA::s[i];
end_proc;
- T := classes::valuesOfTable(i = dom::Tq(i)
- $ i in HGA::W::coxeterGroupGenerators::keys);
+ T := classes::valuesOfTableWithHiddenKeys // This calls for a zip on classes::valuesOfTableWithHiddenKeys
+ (table(i = dom::Ti(i) $ i in HGA::W::coxeterGroupGenerators::keys),
+ table(0 = dom::Ti(0)));
// Essentially the inverse of Ti (Ti*oTi =Q1*Q2)
oTi :=
proc(i: HGA::W::coxeterGroupGenerators::keys) : HGA
option remember;
begin
- (Q1+Q2) * (Pi[i]-1) - Q1 * HGA::s[i];
+ (Q1+Q2) * oPi[i] - Q2 * HGA::s[i];
end_proc;
- T := classes::valuesOfTable(i = dom::Ti(i)
- $ i in HGA::W::coxeterGroupGenerators::keys);
- oT := classes::valuesOfTable(i = dom::oTi(i)
- $ i in HGA::W::coxeterGroupGenerators::keys);
+ oT := classes::valuesOfTableWithHiddenKeys // This calls for a zip on classes::valuesOfTableWithHiddenKeys
+ (table(i = dom::oTi(i) $ i in HGA::W::coxeterGroupGenerators::keys),
+ table(0 = dom::oTi(0)));
+ rootSystem := combinat::rootSystem(HGA::W::cartanType);
+ indexSet := dom::rootSystem::indexSet;
+ rootLattice := (combinat::rootSystem(HGA::W::cartanType))::rootLattice;
+ ambientLattice := (combinat::rootSystem(HGA::W::cartanType))::ambientLattice;
+ affineRootSystem := combinat::rootSystem(dom::rootSystem::affineCartanType);
+ affineWeightLattice := dom::affineRootSystem::weightLattice;
+ // embedding of the classical root lattice at level 0 of the affine weight lattice
+ Q0ToP := dom::rootLattice::moduleMorphism(dom::affineWeightLattice::simpleRoot);
+
+ // returns the eigenvalue of X^\lambda on w0, computed from the alcove walk definition
+
+
+ Xlambda :=
+ proc(lambda: dom::rootLattice) : HGA
+ local walk, plusminus;
+ begin
+ walk := (dom::Q0ToP(lambda))::alcoveWalkOfTranslation();
+ plusminus := _plus(op(map(walk, op, 2)));
+ assert(plusminus mod 2 = 0);
+ // Note: this really is a morphism from the alcove walk algebra/monoid!
+ HGA::mult(dom::T[stp[1]]^stp[2] $ stp in walk) / (-Q1*Q2)^(plusminus/2)
+ end_proc;
+
+ Xi :=
+ proc(i: dom::indexSet) : HGA
+ option remember;
+ begin
+ dom::Xlambda(dom::rootLattice::simpleRoots[i]);
+ end_proc;
+ XlambdaViaSimpleRoots :=
+ dom::rootLattice::moduleMorphism(dom::Xi,
+ Zero = HGA::one, Plus=HGA::mult, Multcoeffs = _power);
+ // We would like an exponent notation instead of indexed one
+ X := HGAT::X(dom::rootLattice, dom::XlambdaViaSimpleRoots);
+
+ // The almost intertwining operators of Arun Ram's "Calibrated representations
+ // of affine Hecke algebras" p. 7 arxiv:math/0401323v2
+ taui :=
+ if dom::fromWeight <> FAIL then
+ proc(i: dom::indexSet): HGA
+ begin
+ dom::T[i] - (Q1+Q2) * 1/(1-dom::X^-dom::rootLattice::simpleRoots[i]);
+ end_proc;
+ end_if;
+
+ tau :=
+ if dom::taui <> FAIL then
+ classes::valuesOfTable(i = dom::taui(i)
+ $ i in HGA::W::coxeterGroupGenerators::keys);
+ end_if;
+
// Everything below is mostly type A!
- ambientLattice := (combinat::rootSystem(HGA::W::cartanType))::ambientLattice;
-
Omega := HGA::mult(HGA::s[i] $ i in HGA::W::coxeterGroupGenerators::keys);
Yi :=
proc(i: dom::ambientLattice::basisIndices) : HGA
begin
- HGA::mult(dom::oTi(j) $ j in revert([$1..i-1]), // specific to type A!
+ HGA::mult(-dom::oTi(j) $ j in revert([$1..i-1]), // specific to type A!
dom::Omega,
dom::Ti (j) $ j in revert([$i..HGA::W::coxeterGroupGenerators::count()])):
end_proc;
@@ -142,27 +236,65 @@
fromWeight :=
if 1/dom::Y[1] <> FAIL then
- proc(w: dom::ambientLattice) : HGA
+ proc(w: dom::rootSystem::ambientLattice) : HGA
+ local i;
begin
- HGA::mult(dom::Y[i]^w[i] $ i in dom::ambientLattice::basisIndices);
+ HGA::mult(dom::Y[i]^w[i] $ i in dom::rootSystem::ambientLattice::basisIndices);
end_proc;
end_if;
- // The almost intertwining operators of Arun Ram's "Calibrated representations
- // of affine Hecke algebras" p. 7 arxiv:math/0401323v2
- taui :=
- if dom::fromWeight <> FAIL then
- proc(i: HGA::W::coxeterGroupGenerators::keys): HGA
+ eigenvalueOfX :=
+ proc(lambda: dom::rootLattice) : Dom::ExpressionField()
+ local walk, plusminus;
begin
- dom::T[i] - (Q1+Q2) * 1/(1-dom::fromWeight(-dom::ambientLattice::simpleRoots[i]));
+ walk := (dom::Q0ToP(lambda))::alcoveWalkOfTranslation();
+ // The number of positive crossing minus negative crossing in the walk
+ plusminus := _plus(op(map(walk, op, 2)));
+ assert(plusminus mod 2 = 0);
+ // Note: this really is a morphism from the alcove walk algebra/monoid!
+ (-Q2/Q1)^(plusminus/2)
end_proc;
- end_if;
- tau :=
- if dom::taui <> FAIL then
- classes::valuesOfTable(i = dom::taui(i)
- $ i in HGA::W::coxeterGroupGenerators::keys);
- end_if;
+
+ calibratedGraph :=
+ proc()
+ option escape;
+ local W, alpha, s, nodes, backwardEdges, w, i;
+ begin
+ W := Dom::WeylGroup(dom::rootLattice);
+ alpha := dom::rootLattice::simpleRoots;
+ s := W::coxeterGroupGenerators;
+ nodes :=
+ classes::valuesOfTable(w = [dom::eigenvalueOfX(w::action(alpha[i])) $ i in alpha::keys]
+ $ w in W::list());
+ backwardEdges := {};
+ edges :=
+ [
+ if w::hasDescent(i) then
+ if nodes[w][i] <> 0 then
+ [nodes[w], nodes[w*s[i]]]
+ else
+ null();
+ end_if;
+ else
+ if nodes[w*s[i]][i] <> -q2/q1 and nodes[w*s[i]][i] <> -q1/q2 then
+ backwardEdges := backwardEdges union {[nodes[w], nodes[w*s[i]]]};
+ [nodes[w], nodes[w*s[i]]]
+ else
+ null();
+ end_if;
+ end_if
+ $ i in s::keys
+ $ w in W::list()
+ ];
+ nodes := [op({op(nodes::list())})];
+ if nops(nodes) <> W::count() then
+ warning("non calibrated!")
+ end_if;
+ [Graph(nodes, edges, Directed),
+ EdgeOptions = ((edge) -> if contains(backwardEdges, edge) then Backward else null() end_if)];
+ end_proc;
+
begin
if direction = Down then
Pi := HGA::pi;
@@ -240,7 +372,9 @@
*
* Remove from sigma the reculs that are descents of pi
**/
+ /*
straighten :=
+ // Rewrite using cosets ...
proc(l: dom::typePairOfPermutationsOfN) : dom
local pi, sigma, si, i, j;
begin
@@ -267,7 +401,7 @@
end_for;
[pi, permutations::inverse(sigma)];
end_proc;
-
+ */
end_domain:
@@ -277,13 +411,23 @@
V := HW::matrices::V;
- s := classes::valuesOfTable(i = dom::V::moduleMorphism(dom::V::term @ HW::W::onRightGenerator(i))
- $ i in HW::W::coxeterGroupGenerators::keys);
+ s := classes::valuesOfTableWithHiddenKeys
+ (table(i = dom::V::moduleMorphism(dom::V::term @ HW::W::onRightGenerator(i))
+ $ i in HW::W::coxeterGroupGenerators::keys),
+ if HW::W::s0 <> FAIL then
+ table(0 = dom::V::moduleMorphism(dom::V::term @ HW::W::onRight(HW::W::s0)))
+ else
+ table()
+ end_if
+ );
sLeft := classes::valuesOfTable(i = dom::V::moduleMorphism(dom::V::term @ HW::W::onLeftGenerator(i))
$ i in HW::W::coxeterGroupGenerators::keys);
- pi := classes::valuesOfTable(i = dom::V::moduleMorphism(dom::V::term @ HW::W::heckeGenerator(i))
- $ i in HW::W::coxeterGroupGenerators::keys);
+ pi := classes::valuesOfTableWithHiddenKeys
+ (table(i = dom::V::moduleMorphism(dom::V::term @ HW::W::heckeGenerator(i))
+ $ i in HW::W::coxeterGroupGenerators::keys),
+ table(0 = dom::V::moduleMorphism(dom::V::term @ HW::W::pi0))
+ );
end_domain:
domain HGAT::matrices(HW)
@@ -297,6 +441,7 @@
convertFromMatrices := dom::getEntryFrom(Matrices, "convert");
convert :=
proc(x) : Type::Union(dom, DOM_FAIL)
+ local result;
begin
if args(0) = 1 and (result := dom::convertImplicit(x)) <> FAIL then
return(result);
@@ -417,6 +562,7 @@
piFromW := w -> dom::term([W::one, w]);
one:= dom::term([W::one, W::one]);
+ // TODO: add s[0] and pi[0]!
s := classes::map(W::coxeterGroupGenerators, dom::fromW);
pi := classes::map(W::coxeterGroupGenerators, dom::piFromW);
@@ -438,12 +584,13 @@
(Type::ListProduct(dom::coeffRing,
Type::ListOf(dom::algebraGenerators::keys)))
begin
- [
- [op(term,1),
- map((op(term,[2,1]))::reducedWord(), i -> [1,i]).
- map((op(term,[2,2]))::reducedWord(), i -> [2,i])]
- $ term in x::toList()
- ]
+ map(x::toList(),
+ proc(term)
+ begin
+ [op(term,1),
+ map((op(term,[2,1]))::reducedWord(), i -> [1,i]).
+ map((op(term,[2,2]))::reducedWord(), i -> [2,i])]
+ end_proc):
end_proc;
toMatrices :=
@@ -472,6 +619,7 @@
unrank := combinat::rankers::fromList(W::list())[2];
inverseOnSupport :=
proc(rowcol: HW::matrices::basisIndices) : Type::Union(DOM_FAIL, dom::basisIndices)
+ local result;
begin
result := [unrank(rowcol[1])^-1, unrank(rowcol[2])];
if dom::basisIndices::isReduced(result) then
@@ -500,7 +648,7 @@
interfaceAdd := {hold(matrices), hold(byClosure),
hold(byEquations), hold(sigmapi)
};
-
+ bases := { dom::sigmapi };
W := W;
operators := HGAT::operators(dom);
matrices := HGAT::matrices(dom);
Modified: trunk/MuPAD-Combinat/lib/EXAMPLES/TEST/HeckeGroupAlgebra.tst
===================================================================
--- trunk/MuPAD-Combinat/lib/EXAMPLES/TEST/HeckeGroupAlgebra.tst 2010-10-02 14:45:01 UTC (rev 7596)
+++ trunk/MuPAD-Combinat/lib/EXAMPLES/TEST/HeckeGroupAlgebra.tst 2010-10-02 14:47:05 UTC (rev 7597)
@@ -16,113 +16,165 @@
R := Dom::ExpressionField()://id, iszero@normal):
HW := examples::HeckeGroupAlgebra(W, R):
// Check that the natural representation is indexed appropriately
+if n=3 then
prog::test((HW::matrices::V::term(W([3, 2, 1])))::sparseVector(),
matrix([[0], [0], [0], [0], [0], [1]])):
prog::test((HW::matrices::V::term(W([1, 2, 3])))::sparseVector(),
matrix([[1], [0], [0], [0], [0], [0]])):
+end_if:
prog::test((HW::matrices::V::genericElement(a))::sparseVector(),
- matrix([[a(W([1, 2, 3]))], [a(W([1, 3, 2]))], [a(W([2, 1, 3]))], [a(W([2, 3, 1]))], [a(W([3, 1, 2]))], [a(W([3, 2, 1]))]])):
+ matrix([[a(W(p))] $ p in combinat::permutations(n)])):
+checkHeckeRelations :=
+proc(t: Cat::CombinatorialClass, cartanType: combinat::cartanType, q1=-1, q2=1)
+begin
+ M := combinat::coxeterMatrix(cartanType);
+ for i in M::rowIndices do
+ for j in M::rowIndices do
+ if j=i then
+ if q1 <> BraidOnly then
+ prog::test(iszero(normal((t[i]-q1)*(t[i]-q2))))
+ end_if;
+ else
+ m := (M[i,j]-1)/2;
+ prog::test(iszero(normal( t[i] * (t[j]*t[i])^m - (t[j]*t[i])^m * t[j] )));
+ end_if;
+ end_for;
+ end_for;
+end_proc:
+
for H in [HW::matrices/*, HW::byClosure, HW::byEquations*/] do
embedding := H::affineHeckeAlgebraEmbedding([q1,q2]);
s := H::s: pi := H::pi: opi := H::opi: sLeft := H::sLeft:
T := embedding::T: oT := embedding::oT: tau := embedding::tau;
Y := embedding::Y:
V := H::V:
- ambientLattice := embedding::ambientLattice;
+ rootLattice := embedding::rootLattice;
Omega := embedding::Omega:
- // some relatively generic weight
- lambda := ambientLattice::rho;
- for i from 1 to n-1 do
+ affineCartanType := rootLattice::rootSystem::affineCartanType;
+ prog::testfunc("s, pi, opi");
+ checkHeckeRelations(s, affineCartanType, -1, 1);
+ checkHeckeRelations(sLeft, W::cartanType, -1, 1);
+ checkHeckeRelations(pi, affineCartanType, 0, 1); // FAILS for A_1^1!!!
+ checkHeckeRelations(opi, affineCartanType, 0, 1);
+ for i from 0 to n-1 do
prog::test(iszero(s[i] * pi[i] - pi[i]));
- prog::test(iszero(pi[1] + opi[1] - s[1] -1));
+ prog::test(iszero(pi[i] + opi[i] - s[i] -1));
+ end_for;
- prog::test(iszero(normal(oT[i] - (T[i] -q1-q2))));
- prog::test(iszero(normal(T[i] * oT[i] + q1*q2 )));
- prog::test(iszero(mapcoeffs(Y[1], subs,q1=-1,q2=1) - R(1))):
- prog::test(iszero(mapcoeffs(Y[1], subs,q1=1,q2=-1) - R(1))):
- prog::test(iszero(normal(Y[i] * Y[i+1] - Y[i+1] * Y[i])));
+ //////////////////////////////////////////////////////////////////////////
+ prog::testfunc("T and oT");
+ checkHeckeRelations(T, affineCartanType, q1, q2):
+ checkHeckeRelations(oT, affineCartanType, q1, q2):
+ for i from 0 to n-1 do
+ prog::test(iszero(normal(T[i] + oT[i] - (q1+q2))));
+ prog::test(iszero(normal(T[i] * oT[i] - (q1*q2))));
+ end_for;
+
+ //////////////////////////////////////////////////////////////////////////
+ if Y <> FAIL and Omega <> FAIL then
+ prog::testfunc("Y and Omega");
+ for i from 1 to n do
+ prog::test(iszero(mapcoeffs(Y[i], subs, q1=-1, q2= 1) - R(1))):
+ prog::test(iszero(mapcoeffs(Y[i], subs, q1= 1, q2=-1) - R(1))):
+ if i < n then
+ prog::test(iszero(normal(Y[i] * Y[i+1] - Y[i+1] * Y[i])));
+ end_if;
// Commutation between Y and T
if H = HW::matrices then
prog::test(iszero(normal(Y[1] * T[1] - T[1] * Y[2] -(q1+q2)*(Y[1]-Y[2])/(1-Y[2]/Y[1])))):
end_if;
- if i < n-1 then
- prog::test(iszero(normal(T[i+1] * Omega - Omega * T[i]))):
- end_if;
+ prog::test(iszero(normal(T[i mod n] * Omega - Omega * T[i-1]))):
end_for;
- if tau <> FAIL then
- for i from 1 to n-1 do
- prog::test(iszero(normal(embedding::fromWeight(lambda) * tau[i] -
- tau[i] *embedding::fromWeight(ambientLattice::simpleReflections[i](lambda)))));
- Xalphai := embedding::fromWeight(ambientLattice::simpleRoots[i]):
+ end_if;
+ // Check with definition of the Y's by Arun's def
+ // t[2] := s[0]*s[1]*s[0]*s[2]
+
+ prog::testfunc("X and tau");
+ X := embedding::X;
+ alpha := rootLattice::simpleRoots;
+ sQ := rootLattice::simpleReflections;
+ for i from 1 to n-1 do
+ for lambda in rootLattice::simpleRoots do
+ prog::test(iszero(mapcoeffs(X^lambda, subs, q1=-1, q2=1)-1));
+ // at q1=-q2, T[i] is a multiple of s[i], so the X should degenerate to identity
+ prog::test(iszero(mapcoeffs(X^lambda, subs, q1=-q2)-1));
+ for lambda2 in rootLattice::simpleRoots do
+ prog::test(iszero(normal(X^lambda * X^lambda2 - X^lambda2 * X^lambda)));
+ prog::test(iszero(normal(X^(lambda+lambda2) - X^lambda2 * X^lambda)));
+ end_for;
+ prog::test(iszero(normal(X^lambda * tau[i] -
+ tau[i] *X^(sQ[i](lambda)))));
+ end_for;
+ checkHeckeRelations(tau, W::cartanType, BraidOnly);
// quadratic relation from Arun's paper
- tau[i]^2 - ( q1+ q2 * Xalphai) * ( q1+q2* 1/Xalphai) / (1-Xalphai) / (1-1/Xalphai):
+ tau[i]^2 - ( q1+ q2 * X^alpha[i]) * ( q1+q2*X^-alpha[i]) / (1-X^alpha[i]) / (1-X^-alpha[i]):
// The tau_i's preserve antisymmetries
- for j from 1 to n-1 do
- prog::test(iszero(normal((sLeft[j]-1) * tau[i] * (sLeft[j]+1))));
- end_for;
+ for j from 1 to n-1 do
+ prog::test(iszero(normal((sLeft[j]-1) * tau[i] * (sLeft[j]+1))));
end_for;
-
- ratio :=
- proc(v, w)
- local r;
- begin
- if lterm(v) <> lterm(w) then
- return(FAIL):
- end_if;
- r := lcoeff(v)/lcoeff(w):
- if not iszero(normal(r*w - v)) then
- return(FAIL)
- end_if;
- r
- end:
- eigenvector :=
- proc(w: W)
- option remember;
- local i, wi;
- begin
- if w = W::one then return(V::term(W::maximalElement())) end_if;
- i := w::firstDescent():
- wi := w*W::coxeterGroupGenerators[i];
+ end_for;
+
+ prog::testfunc("hamiltonian");
+ ratio :=
+ proc(v, w)
+ local r;
+ begin
+ if lterm(v) <> lterm(w) then
+ return(FAIL):
+ end_if;
+ r := lcoeff(v)/lcoeff(w):
+ if not iszero(normal(r*w - v)) then
+ return(FAIL)
+ end_if;
+ r
+ end:
+ eigenvector :=
+ proc(w: W)
+ option remember;
+ local i, wi;
+ begin
+ if w = W::one then return(V::term(W::maximalElement())) end_if;
+ i := w::firstDescent():
+ wi := w*W::coxeterGroupGenerators[i];
// If just factor is done, zero coeffs are not discarded
// See comment in FreeModulePoly::mapcoeffs
- return(mapcoeffs(normal(eigenvector(wi) * tau[i]), factor))
- end:
- eigenvectors := classes::indexed(W, eigenvector):
- eigenvalues := [ (-q1)^k*q2^(n-1-k) $ k=0..n-1 ]:
- antisymmetries :=
- proc(v)
- begin
- select([$1..n-1], i->iszero(normal(v::mapsupport((W::coxeterGroupGenerators[i])::onLeft())+v)))
- end_proc;
- for w in W do
- prog::test(w([normal(ratio(eigenvectors[w]*Y[i], eigenvectors[w])) $ i=1..n]), [ (-q1)^k*q2^(n-1-k) $ k=0..n-1 ]):
+ return(mapcoeffs(normal(eigenvector(wi) * tau[i]), factor))
+ end:
+ eigenvectors := classes::indexed(W, eigenvector):
+ eigenvalues := [ (-q1)^k*q2^(n-1-k) $ k=0..n-1 ]:
+ antisymmetries :=
+ proc(v)
+ begin
+ select([$1..n-1], i->iszero(normal(v::mapsupport((W::coxeterGroupGenerators[i])::onLeft())+v)))
+ end_proc;
+ for w in W do
+ prog::test(w([normal(ratio(eigenvectors[w]*Y[i], eigenvectors[w])) $ i=1..n]), [ (-q1)^k*q2^(n-1-k) $ k=0..n-1 ]):
// since we start from w_0, the dynkin diagram is inverted (i->n-i)
- prog::test(antisymmetries(eigenvectors[w]), sort(map(w::recoils(),i->n-i))):
- end_for:
- w0 := W::maximalElement():
+ prog::test(antisymmetries(eigenvectors[w]), sort(map(w::recoils(),i->n-i))):
+ end_for:
+ w0 := W::maximalElement():
- idempotent :=
- proc(w: W) : H
- begin
- normal(_mult((Y[i]-eigenvalues[w(j)])/(eigenvalues[w(i)]-eigenvalues[w(j)]) $ j in {$1..n} minus {i} $ i=1..n)):
- end_proc:
- idempotents := classes::indexed(W, idempotent):
+ idempotent :=
+ proc(w: W) : H
+ begin
+ normal(_mult((Y[i]-eigenvalues[w(j)])/(eigenvalues[w(i)]-eigenvalues[w(j)]) $ j in {$1..n} minus {i} $ i=1..n)):
+ end_proc:
+ idempotents := classes::indexed(W, idempotent):
// Check that the idempotents form a maximal decomposition of the identity
// and that we get the same eigenvectors
- prog::test(iszero(H::plus(idempotents[w] $ w in W::list()) - 1));
- for w1 in W do
- for w2 in W do
- p1 := idempotents[w1]:
- p2 := idempotents[w2]:
- if w1 <> w2 then
- prog::test(iszero(p1*p2));
- else
- prog::test(iszero(p1*p1-p1));
- end_if;
- end_for;
- prog::test(iszero(eigenvectors[w1]*p1-eigenvectors[w1]))
- end_for:
- end_if;
+ prog::test(iszero(H::plus(idempotents[w] $ w in W::list()) - 1));
+ for w1 in W do
+ for w2 in W do
+ p1 := idempotents[w1]:
+ p2 := idempotents[w2]:
+ if w1 <> w2 then
+ prog::test(iszero(p1*p2));
+ else
+ prog::test(iszero(p1*p1-p1));
+ end_if;
+ end_for;
+ prog::test(iszero(eigenvectors[w1]*p1-eigenvectors[w1]))
+ end_for:
h1 := s[1] + s[2]:
h2 := s[1]*s[2] + s[2]*s[1]:
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <nt...@us...> - 2010-10-02 14:45:07
|
Revision: 7596
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7596&view=rev
Author: nthiery
Date: 2010-10-02 14:45:01 +0000 (Sat, 02 Oct 2010)
Log Message:
-----------
Added hasRecoil method, and (apparently) improved option handling
Modified Paths:
--------------
trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/CoxeterGroup.mu
Modified: trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/CoxeterGroup.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/CoxeterGroup.mu 2010-10-02 14:43:49 UTC (rev 7595)
+++ trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/CoxeterGroup.mu 2010-10-02 14:45:01 UTC (rev 7596)
@@ -93,6 +93,11 @@
begin
contains({op(dom::descents(x))},i);
end_proc;
+ hasRecoil :=
+ proc(x: dom, i: dom::coxeterGroupGenerators::keys) : DOM_BOOL
+ begin
+ dom::hasDescent(x^-1, i)
+ end_proc;
// mult2 could be defined from multByReflectionOnLeft / multByReflectionOnRight
// using hasDescent / reduced word
@@ -299,9 +304,9 @@
option escape, remember;
local options;
begin
- options := prog::getOptions([Direction=Right, Increase = TRUE]
- [Direction=[Left, Right],
- Increase= DOM_BOOL]);
+ options := prog::getOptions([Direction=Right, Increase = TRUE],
+ table(Direction=[Left, Right],
+ Increase= DOM_BOOL));
proc(x: dom) : dom
begin
if dom::hasDescent(x, reflection) = options[Increase] then
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <nt...@us...> - 2010-10-02 14:43:55
|
Revision: 7595
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7595&view=rev
Author: nthiery
Date: 2010-10-02 14:43:49 +0000 (Sat, 02 Oct 2010)
Log Message:
-----------
Added coercion for more robustness
Modified Paths:
--------------
trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/HopfAlgebraWithBasis.mu
Modified: trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/HopfAlgebraWithBasis.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/HopfAlgebraWithBasis.mu 2009-11-26 23:34:25 UTC (rev 7594)
+++ trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/HopfAlgebraWithBasis.mu 2010-10-02 14:43:49 UTC (rev 7595)
@@ -122,7 +122,7 @@
begin
Precondition(testtype(hdual, H::Dual(dom::coeffRing)));
dom::plus(dom::multcoeffs(HtoDom(h),
- operators::scalar(hdual, h) / H::count())
+ operators::scalar(hdual, h) / dom::coeffRing(H::count()))
$ h in H::list());
end_proc;
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: Jollie D. <fl...@br...> - 2010-09-04 10:25:03
|
Your wife photos |
|
From: Taunya P. <app...@ad...> - 2010-06-15 10:48:46
|
{\rtf1\ansi\ansicpg1251\deff0\deflang1049{\fonttbl{\f0\fswiss\fprq2\fcharset204{\*\fname Arial;}Arial CYR;}{\f1\fswiss\fcharset204{\*\fname Arial;}Arial CYR;}}
{\colortbl ;\red0\green0\blue255;\red0\green128\blue0;}
{\*\generator Msftedit 1.25.48.9892;}\viewkind4\uc1\pard\sa200\sl276\slmult1\lang9\f0\fs32{\field{\*\fldinst{HYPERLINK "h{\*\dd 1.25.48.9892;}ttp://gamezcasino.info"}}{\fldrslt{\ul\cf1 http://gamezcasino.info}}}\f0\cf1\b\fs32 - ONLINE CASINO!\par
\line\cf2\b\f0\fs28 VIP CLUB Casino is a great online casino that offers the unique combination of top quality games, high payouts and a 24/7 professional customer support.\par
\par100 progressive games with towering jackpots, which are ready to explode and can make multi-millionaires out of VIP CLUB players! Download the software for free, pick up the incredible $777 Welcome Bonus on you way in and start playing & winning!\par
}
|
|
From: Mrazik <enr...@wo...> - 2010-03-22 12:41:46
|
And the West, and the advent of the Kingdom of the Lord of Hosts be proclaimed in all the five continents of the globe." "The moment," He most significantly adds, "this Divine Message is carried forward by the American believers from the shores of America, and is propagated throughout the continents of Europe, of Asia, of Africa, and of Australasia, and as far as the islands of the Pacific, this community will find itself securely established upon the throne of an everlasting dominion. Then will all the peoples of the world witness that this community is spiritually illumined and divinely guided. Then will the whole earth resound with the praises of its majesty and greatness." No reader of these words, so vibrant with promises that not even the triumphant consummation of the Seven Year Plan can fulfill, can expect a community that has been raised so high, and endowed so richly, to remain content with any laurels it may win in the immediate future. To rest upon such laurels would indeed be tantamount to a betrayal of the trust placed in that community by 'Abdu'l-Baha. To cut short the chain of victories that must lead it on to that supreme triumph when "the whole earth may be stirred and shaken" by the results of its achievements would shatter His hopes. To vacillate, and fail to "propagate through the continents of Europe, of Asia, of Africa, and of Australasia, and as far as the islands of the Pacific" a Message so magnificently proclaimed by it in the American c |
|
From: Get V. S. A. P. on www.ce59.c. <gla...@he...> - 2010-01-29 22:01:44
|
bisul phate foreh ock bisul phate parie tal print ably notio nal oilme n throm bose seria lisin g topkn ot camsh afts issue r munt legit imacy popul arise r agele ss excep ting coleo ptera n nazif ying debat er waupu n foreh ock taxid ermy decas yllab le needl ework er black s discu ssion s atres ia delud e ciphe rtext weal pedan tise panic longw ays popul arise r copac etic debat er pedes trian virag o scrap py untra nspos ed pomad e mutag enici ty prote ase |
|
From: Gremillion <fru...@th...> - 2009-12-05 19:03:34
|
Onwards, during a number of years, his letters to her evinced it, yet not consistently; the old distrust recurs, and also a growing tendency to utilize her as a servant in his concerns. Having once dipped in her purse, he did not hesitate to hold out his hand, on each occasion that his needs, real or fancied, prompted him, being confident of requiting her in the future. His refrain was ever the same: "Sooner or later, politics, journalism, a marriage, or a big piece of business luck will make me a Croesus. We must suffer a little longer." And he finished by exhausting her last penny of capital, and reduced her to depend on an allowance he gave her, irregularly--an allowance which, when he died, had to be continued to her from the purse of another. Madame Balzac was sacrificed to his improvidence and stupendous egotism; nor can the tenderness of his language--more frequently than not called forth by some fresh immolation of her comfort to his interests--disguise this unpleasing side of his character and action. While he was recouping his strength and spirits, on the 1832 holiday, she was in Paris negotiating with Pichot of the _Revue de Paris_, with Gosselin and other publishers, arranging for proofs, and also for an advance of cas |
|
From: <hi...@us...> - 2009-11-27 00:43:08
|
Revision: 7594
http://mupad-combinat.svn.sourceforge.net/mupad-combinat/?rev=7594&view=rev
Author: hivert
Date: 2009-11-26 23:34:25 +0000 (Thu, 26 Nov 2009)
Log Message:
-----------
Lot of bazar...
Modified Paths:
--------------
trunk/MuPAD-Combinat/lib/COMBINAT/DOC/dyckWords.mupdoc
trunk/MuPAD-Combinat/lib/COMBINAT/partitions.mu
trunk/MuPAD-Combinat/lib/COMBINAT/permutationsSigned.mu
trunk/MuPAD-Combinat/lib/COMBINAT/shuffle.mu
trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/FiniteDimensionalAlgebraWithBasis.mu
trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/Poset.mu
trunk/MuPAD-Combinat/lib/DOMAINS/DOMAIN/DOC/TensorProductOfFreeModules.mupdoc
trunk/MuPAD-Combinat/lib/DOMAINS/DOMAIN/PermutationGroupOnSets.mu
trunk/MuPAD-Combinat/lib/DOMAINS/DOMAIN/TensorProductOfFreeModules.mu
trunk/MuPAD-Combinat/lib/EXAMPLES/HeckeAlgebra.mu
trunk/MuPAD-Combinat/lib/EXAMPLES/LodayRoncoAlgebra.mu
trunk/MuPAD-Combinat/lib/EXAMPLES/MultivariatePolynomials.mu
trunk/MuPAD-Combinat/lib/EXAMPLES/SymmetricFunctionsTools/LambdaOperations.mu
trunk/MuPAD-Combinat/lib/EXAMPLES/SymmetricGroupAlgebra.mu
trunk/MuPAD-Combinat/lib/EXPERIMENTAL/AlgTools.mu
trunk/MuPAD-Combinat/lib/EXPERIMENTAL/FreeSymmetricFunctions.mu
trunk/MuPAD-Combinat/lib/EXPERIMENTAL/kShapes.mu
trunk/MuPAD-Combinat/lib/EXPERIMENTAL/kShapesPoset.mu
trunk/MuPAD-Combinat/lib/init.mu
Modified: trunk/MuPAD-Combinat/lib/COMBINAT/DOC/dyckWords.mupdoc
===================================================================
--- trunk/MuPAD-Combinat/lib/COMBINAT/DOC/dyckWords.mupdoc 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/COMBINAT/DOC/dyckWords.mupdoc 2009-11-26 23:34:25 UTC (rev 7594)
@@ -255,7 +255,7 @@
<call><arg type='Dyck word'>w</arg>
</call><eng>Returns the dinv statistic on the Dyck word <expr>w</expr>. Let <expr>a_i</expr>
be the number of cells below the Dyck path and above the diagonal in the <expr>ith</expr>
-row (the arm sequence). The dinv statistic is the number of <expr>1<= i < j <=n</expr> such that
+row (the arm sequence). The dinv statistic is the number of <expr>1<= i < j <=n</expr> such that
<expr>a_i = a_j</expr> or <expr>a_i = a_j + 1</expr>.</eng>
</methoddetails>
Modified: trunk/MuPAD-Combinat/lib/COMBINAT/partitions.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/COMBINAT/partitions.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/COMBINAT/partitions.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -1215,14 +1215,24 @@
lequalYoungLattice:= dom::contains;
- listSubpartitions:=proc(mu: dom, n=FAIL:Type::NonNegInt)
+ listSubpartitions:=proc(mu: dom, n=FAIL:Type::NonNegInt) local i,spk,out;
begin
if n=FAIL then
- dom::list(0..dom::size(mu), Outer=mu);
+ spk:={mu};
+ out:=[];
+ for i from 1 to dom::size(mu)+1 do
+ out:=append(out,(op(spk)));
+ spk:=map(map(spk,dom::predYoungLattice),op);
+ end_for;
+ out;
elif n<=dom::size(mu) then
- dom::list(n, Outer=mu);
+ spk:={mu};
+ for i from 1 to dom::size(mu)-n do
+ spk:=map(map(spk,dom::predYoungLattice),op);
+ end_for;
+ [op(spk)];
else
- [];
+ {};
end_if;
end_proc;
Modified: trunk/MuPAD-Combinat/lib/COMBINAT/permutationsSigned.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/COMBINAT/permutationsSigned.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/COMBINAT/permutationsSigned.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -47,6 +47,18 @@
l -> zip(op(l), _mult));
end_proc;
+ random :=
+ proc(n: Type::NonNegInt)
+ local res, rnd, i;
+ begin
+ res := permutations::random(n);
+ rnd := random(2);
+ for i from 1 to n do
+ if rnd() = 1 then res[i] := -res[i]; end_if;
+ end_for;
+ res;
+ end_proc;
+
mult2 :=
proc(p1: dom, p2: dom) : dom
local i;
@@ -75,4 +87,71 @@
map(words::descents([0].p), _subtract, 1):
end_proc;
+ inversionsNumber :=
+ proc(p : dom)
+ local res;
+ begin
+ res := permutations::inversionsNumber(p);
+ for i in p do
+ if i < 0 then res := res - i; end_if;
+ end_for;
+ res;
+ end_proc;
+
+ fromReducedWord :=
+ proc(word: Type::ListOf(Type::NonNegInt),
+ p=FAIL: Type::Union(Type::NonNegInt, dom, DOM_FAIL) ) : dom
+ begin
+ maxi := max(-1, i $ i in word);
+ if args(0)=1 then
+ p:=[$1..maxi+1];
+ elif domtype(p)=DOM_INT then
+ if testargs() and p <= maxi then
+ error("The transposition ("
+ .expr2text(maxi,maxi+1)
+ .") is not in the group B"
+ .expr2text(p));
+ end_if;
+ p:=[$1..p];
+ elif domtype(p)=DOM_LIST then
+ if testargs() and nops(p) <= maxi then
+ error("The transposition ("
+ .expr2text(maxi,maxi+1)
+ .") is not in the group B"
+ .expr2text(p));
+ end_if;
+ end_if;
+ for i in word do
+ if i=0 then p[1] := -p[1]
+ else
+ tmp := p[i];
+ p[i]:=p[i+1];
+ p[i+1]:=tmp;
+ end_if;
+ end_for;
+ p;
+ end;
+
+ reducedWord :=
+ proc(p : dom)
+ local res, i, tmp;
+ begin
+ res := [];
+ while TRUE do
+ if p[1] < 0 then
+ res := append(res, 0);
+ p[1] := -p[1];
+ end_if;
+ i := 1;
+ while i < nops(p) and p[i] < p[i+1] do
+ i := i+1;
+ end_while;
+ if i = nops(p) then return(revert(res)); end_if;
+ res := append(res, i);
+ tmp := p[i];
+ p[i]:=p[i+1];
+ p[i+1]:=tmp;
+ end_while;
+ end;
+
end_domain:
Modified: trunk/MuPAD-Combinat/lib/COMBINAT/shuffle.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/COMBINAT/shuffle.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/COMBINAT/shuffle.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -45,17 +45,28 @@
len2 := nops(word2);
combinat::generators::map
(combinat::integerVectors::generator(len1, len1+len2, MaxPart=1),
- proc(vect)
- local i1, i2;
- begin
- i1 := 0; i2 := 0;
- map(vect,
- x -> if x=1 then i1:=i1+1; word1[i1];
- else i2:=i2+1; word2[i2];
- end_if
- )
- end_proc)
+ dom::fromZeroOneVector, word1, word2);
end_proc;
+
+ fromZeroOneVector :=
+ proc(vect : Type::ListOf(Type::Union(Type::Singleton(0),
+ Type::Singleton(1))),
+ word1: dom::typeWords, word2: dom::typeWords)
+ local i1, i2;
+ begin
+ if testargs() and
+ (nops(vect) <> nops(word1) + nops(word2)
+ or _plus(op(vect)) <> nops(word1)) then
+ error("Length Mismatch: ".expr2text(vect).
+ " and ".expr2text(word1).", ".expr2text(word2));
+ end_if;
+ i1 := 0; i2 := 0;
+ map(vect,
+ x -> if x=1 then i1:=i1+1; word1[i1];
+ else i2:=i2+1; word2[i2];
+ end_if)
+ end_proc;
+
begin
end_domain:
Modified: trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/FiniteDimensionalAlgebraWithBasis.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/FiniteDimensionalAlgebraWithBasis.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/FiniteDimensionalAlgebraWithBasis.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -84,8 +84,8 @@
// Should use AssumeSemiSimple when this is known!
makeCartanInvariantsGraph :=
- proc(representationTheory: DOM_TABLE)
- local nVertices, vertexLabels, edgeWeights, i, j;
+ proc(representationTheory: DOM_TABLE, extended=TRUE)
+ local nVertices, vertexLabels, edgeWeights, i, j, wgt;
begin
// TODO: join symmetric arrows into a single one
nVertices := nops(representationTheory[dimSimpleModules]);
@@ -96,10 +96,12 @@
edgeWeights := table();
for i from 1 to nVertices do
for j from 1 to nVertices do
- if (i<>j and representationTheory[qCartanInvariantsMatrix][i,j] <> 0) or
- (i=j and representationTheory[qCartanInvariantsMatrix][i,j] <> 1) then
- edgeWeights[[vertexLabels[i], vertexLabels[j]]] :=
- representationTheory[qCartanInvariantsMatrix][i,j];
+ wgt := representationTheory[qCartanInvariantsMatrix][i,j];
+ if not extended then wgt := coeff(wgt, q); end_if;
+ if (i<>j and wgt <> 0) or
+ (extended and i=j and wgt <> 1) or
+ (not extended and i=j and wgt <> 0) then
+ edgeWeights[[vertexLabels[j], vertexLabels[i]]] := wgt
end_if;
end_for;
end_for;
Modified: trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/Poset.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/Poset.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/DOMAINS/CATEGORY/Poset.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -23,7 +23,7 @@
_lessDefault :=
proc(e : dom::nodes, f : dom::nodes) : DOM_BOOL
begin
- bool(dom::_lequal(e, f) and (e <> f));
+ bool(dom::_leequal(e, f) and (e <> f));
end_proc;
_leequalDefault :=
proc(e : dom::nodes, f : dom::nodes) : DOM_BOOL
Modified: trunk/MuPAD-Combinat/lib/DOMAINS/DOMAIN/DOC/TensorProductOfFreeModules.mupdoc
===================================================================
--- trunk/MuPAD-Combinat/lib/DOMAINS/DOMAIN/DOC/TensorProductOfFreeModules.mupdoc 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/DOMAINS/DOMAIN/DOC/TensorProductOfFreeModules.mupdoc 2009-11-26 23:34:25 UTC (rev 7594)
@@ -38,74 +38,95 @@
</categories>
<details>
-<eng><expr><cmd>Dom::TensorProductOfFreeModules</cmd>([F1,F2,...])</expr> creates the tensor product of the free
- modules in <expr>[F1,F2,...]</expr>. The module must be modules over the
- same coefficient ring <expr>R</expr> over which the tensor product is taken.</eng>
-<eng>The user don't need to create a <expr><cmd>Dom::TensorProductOfFreeModules</cmd></expr>. It is automatically
- created by a call to <expr>operators::tensor</expr>. However the overloading
- mechanism may slow down computations. Thus it may be faster to call
- directly the methods <expr>tensorConstructor</expr> and
+<eng><expr><cmd>Dom::TensorProductOfFreeModules</cmd>([F1,F2,...])</expr>
+ creates the tensor product of the free modules in
+ <expr>[F1,F2,...]</expr>. The module must be modules over the same
+ coefficient ring <expr>R</expr> over which the tensor product is
+ taken.</eng>
+
+<eng>Usually, the user doesn't need to create a
+ <expr><cmd>Dom::TensorProductOfFreeModules</cmd></expr>. It is
+ automatically created by a call to
+ <expr>operators::tensor</expr>. However the overloading mechanism
+ may slow down computations. Thus it may be faster to call directly
+ the methods <expr>tensorConstructor</expr> and
<expr>tensorConstructorFromSignature</expr>.</eng>
-<eng>The system takes care of associativity, that is if some free modules in
- the list <expr>ListF</expr> are themselves tensor products, the list is
- flattened. More precisely, each element <expr>Fi</expr> of the list <expr>ListF</expr>
- is replaced recursively by it's entry <expr>Fi::modules</expr>. This is done
- <emphasis>before</emphasis> the creation of the domain. Consequently, the result of a
- constructor call <expr><cmd>Dom::TensorProductOfFreeModules</cmd>(ListF)</expr> only depends on the flattening of
- <expr>ListF</expr>.</eng>
-<eng>If <expr>dom1</expr> is a tensor products, a valid <emphasis>signature</emphasis> is a list
- of free modules whose flattening is equal to <expr>M::modules</expr>. Several
- accessors can be constructed from a valid signature, a default is provided
+
+<eng>The system takes care of associativity, that is if some free
+ modules in the list <expr>ListF</expr> are themselves tensor
+ products, the list is flattened. More precisely, each element
+ <expr>Fi</expr> of the list <expr>ListF</expr> which is a
+ <expr><cmd>Dom::TensorProductOfFreeModules</cmd></expr> is
+ replaced recursively by it's entry <expr>Fi::modules</expr>. The
+ result is stored in <expr>dom::modules</expr>. This is done
+ <emphasis>before</emphasis> the creation of the
+ domain. Consequently, the result of a constructor call
+ <expr><cmd>Dom::TensorProductOfFreeModules</cmd>(ListF)</expr>
+ only depends on the flattening of <expr>ListF</expr>.</eng>
+
+<eng>If <expr>M</expr> is a tensor products, a valid
+ <emphasis>signature</emphasis> is a list of free modules whose
+ flattening is equal to <expr>M::modules</expr>. Several accessors
+ can be constructed from a valid signature, a default is provided
with the signature <expr>dom::modules</expr>.</eng>
-<eng>A special combinatorial class <expr>dom::basisIndices</expr> is created to
- hold the indices. The elements of this class are
+
+<eng>A special combinatorial class <expr>dom::basisIndices</expr> is
+ created to hold the indices. The elements of this class are
<expr>Type::ListProduct(F1::basisIndices, F2::basisIndices,
- ...</expr>. Currently, the system tries to build a grading for the combinatorial
- class <expr>dom::basisIndices</expr> from the grading of the
- <expr>Fi::basisIndices</expr>. This feature is experimental and may change in the
+ ...</expr>. Currently, the system tries to build a grading for the
+ combinatorial class <expr>dom::basisIndices</expr> from the
+ grading of the <expr>Fi::basisIndices</expr>. This feature is
+ experimental and may change in the future.</eng>
+
+<eng>If all the <expr>Fi's</expr> are
+ <cmd>Cat::AlgebraWithBasis</cmd>, the domain created is also an
+ algebra from the category <cmd>Cat::AlgebraWithBasis</cmd> and the
+ methods <expr>one</expr>, <expr>mult2Basis</expr>,
+ <expr>mult2</expr> and <expr>mult</expr> are defined
+ accordingly. This feature is experimental and may change in the
future.</eng>
-<eng>If all the <expr>Fi's</expr> are <cmd>Cat::AlgebraWithBasis</cmd>, the domain
- created is also a algebra from the category <cmd>Cat::AlgebraWithBasis</cmd>
- and the methods <expr>one</expr>, <expr>mult2Basis</expr>, <expr>mult2</expr> and <expr>mult</expr>
- are defined accordingly. This feature is experimental and may change in
- the future.</eng>
+
<eng>The interface is not yet fully stable, they are several missing
accessors.</eng>
</details>
<domainentry name='modules'>
<eng>the lists of modules whose <expr>dom</expr> is the tensor
- product. This list is flattened so that it contains no tensor products.</eng>
+ product. This list is flattened so that it contains no tensor
+ products.</eng>
</domainentry>
<domainentry name='basisIndices'>
-<eng>the combinatorial class <expr>baseClass</expr> of the indices of the basis.</eng>
+<eng>the combinatorial class <expr>baseClass</expr> of the indices of
+ the basis.</eng>
</domainentry>
+
<methoddetails>
- <info name='tensorConstructorFromSignature'><eng>tensor constructor</eng>
+<info name='tensorConstructorFromSignature'><eng>tensor constructor</eng>
</info>
-
-<call><arg type='signature'>lambda</arg></call><eng>Returns a function which build a tensor product from list of elements
- of type <expr>Type::ListProductop(signature)</expr>.</eng>
+<call><arg type='signature'>lambda</arg></call>
+<eng>Returns a function which build a tensor product from list of
+ elements of type
+ <expr>Type::ListProduct(op(signature))</expr>.</eng>
</methoddetails>
<methoddetails>
- <info name='tensorConstructor'><eng>tensor constructor</eng>
-</info>
-
-<call><arg type='Type::ListProduct(op(dom::modules))'>ListF</arg></call><eng>Build the tensor products from the elements of the modules from the
- list <expr>ListF</expr>. This is the method
- <expr>tensorConstructorFromSignature</expr> called with the signature
- <expr>dom::modules</expr>.</eng>
+<info name='tensorConstructor'><eng>tensor constructor</eng></info>
+<call><arg type='Type::ListProduct(op(dom::modules))'>ListF</arg></call>
+<eng>Build the tensor products from the elements of the modules from
+ the list <expr>ListF</expr>. This is defined as the result of the
+ method <expr>dom::tensorConstructorFromSignature</expr> called
+ with the signature <expr>dom::modules</expr>.</eng>
</methoddetails>
<methoddetails>
- <info name='toCartesianProductFromSignature'><eng>tensor analyzer</eng>
+<info name='toCartesianProductFromSignature'><eng>tensor analyzer</eng>
</info>
-
-<call><arg type='signature'>lambda</arg></call><eng>Returns a function which returns a lists of
- <expr>Type::ListProduct(op(dom::modules))</expr> from an element of <expr>dom</expr>.</eng>
+<call><arg type='signature'>lambda</arg></call>
+<eng>Returns a function which returns a lists of
+ <expr>Type::ListProduct(op(dom::modules))</expr> from an element
+ of <expr>dom</expr>.</eng>
</methoddetails>
<methoddetails>
Modified: trunk/MuPAD-Combinat/lib/DOMAINS/DOMAIN/PermutationGroupOnSets.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/DOMAINS/DOMAIN/PermutationGroupOnSets.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/DOMAINS/DOMAIN/PermutationGroupOnSets.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -111,6 +111,17 @@
end_if;
end_proc;
+
+ cycleType2perm :=
+ proc(ct)
+ local res, i, j, k, tp;
+ begin
+ i := 0;
+ Group(combinat::permutations::fromCycles
+ ([[(i := i+1) $ j=1..tp] $ k=1..ct[tp] $ tp=1..nops(ct)]));
+ end_proc;
+
+
/*--
cycleTypes:
@@ -188,7 +199,8 @@
ct:=op(cycleType,1);
userinfo(5, "working on cycle type", ct);
/* compute the cycle type of an induced permutation */
- a:=dom::cycleType(dom::induced(combinat::cycleType2perm(ct)));
+// a:=dom::cycleType(dom::induced(combinat::cycleType2perm(ct)));
+ a:=dom::cycleType(dom::induced(dom::cycleType2perm(ct)));
if contains(t,a) then
t[a]:=t[a]+op(cycleType,2);
else
Modified: trunk/MuPAD-Combinat/lib/DOMAINS/DOMAIN/TensorProductOfFreeModules.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/DOMAINS/DOMAIN/TensorProductOfFreeModules.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/DOMAINS/DOMAIN/TensorProductOfFreeModules.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -141,6 +141,8 @@
info_str := "Dom::TensorProductOfFreeModules -- The domain of Tensor Product of Free Module";
+ Name := operators::tensorSymbolic(op(modules));
+
//////////////////////////////////////////////////////////////////////////////
// Basic informations. These are needed outside the domain.
basisIndices := basisIndices;
Modified: trunk/MuPAD-Combinat/lib/EXAMPLES/HeckeAlgebra.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/EXAMPLES/HeckeAlgebra.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/EXAMPLES/HeckeAlgebra.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -42,7 +42,7 @@
end_domain;
/*********************************************
- Hecke Algebra on the Yang-Baxter bases
+ Hecke Algebra on the defining basis
**********************************************/
domain HeckeAlgebraT::T(R: DOM_DOMAIN, N:Type::NonNegInt, q)
@@ -52,7 +52,14 @@
info_str := "Domain for the Hecke algebra expanded on the trivial basis T_sigma ";
basisName := hold(T);
-
+
+ Ti := i -> dom(subsop([$1..N], i=i+1, i+1=i));
+
+ algebraGenerators := proc() local i;
+ begin
+ [dom::Ti(i) $ i=1..N-1];
+ end_proc;
+
tiActBasis :=
proc(perm: dom::basisIndices,
i: dom::type1N1) : dom
@@ -63,7 +70,7 @@
dom::term(permI);
else // Ti^2 = (q1+q2)*Ti -q1*q2
dom::plus2(dom::monomial(-dom::q1*dom::q2, permI),
- dom::monomial(dom::q1+dom::q2, perm));
+ dom::monomial( dom::q1+dom::q2, perm));
end_if;
end_proc;
Modified: trunk/MuPAD-Combinat/lib/EXAMPLES/LodayRoncoAlgebra.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/EXAMPLES/LodayRoncoAlgebra.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/EXAMPLES/LodayRoncoAlgebra.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -80,7 +80,7 @@
begin
n := BT::size(t);
class := PBT::class(t);
- dom::tensorSquare::_plus(
+ dom::tensorSquare::plus(
(tc1 := [op(tc, 1..i)]; tc2 := [op(tc, i+1..n)];
if PBT::isCanonical(tc1) and PBT::isCanonical(tc2) then
dom::tensorSquare::term([PBT::UP(tc1), PBT::UP(tc2)])
@@ -199,7 +199,7 @@
begin
canon := PBT::canonicalWord(t);
n := nops(canon);
- dom::tensorSquare::_plus(
+ dom::tensorSquare::plus(
(tc1 := PBT::UP(select(canon, _leequal, i));
tc2 := PBT::UP(select(canon, (z,i) ->(z > i), i));
dom::tensorSquare::term([tc1, tc2]))
Modified: trunk/MuPAD-Combinat/lib/EXAMPLES/MultivariatePolynomials.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/EXAMPLES/MultivariatePolynomials.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/EXAMPLES/MultivariatePolynomials.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -156,6 +156,21 @@
//////////////////////////////////////////////////////////////////////////////
+// Domain polynomial on the demazure character basis
+//////////////////////////////////////////////////////////////////////////////
+domain PolT::Demazure(N: Type::NonNegInt,
+ R = Dom::ExpressionField(): Cat::Ring)
+ inherits Dom::FreeModule(R, combinat::compositionsWithZero(N));
+ category Cat::GradedAlgebraWithBasis(R);
+
+ basisName := hold(K);
+ printTerm := dom::exprTermIndex;
+ exprTerm := dom::exprTermIndex;
+
+end_domain;
+
+
+//////////////////////////////////////////////////////////////////////////////
// Construct the universal decomposition algebra:
// This is K[E_1,...,E_N][x_1,...,x_N] / I, where I is the ideal
@@ -408,6 +423,7 @@
//Cat::GradedHopfAlgebra, TODO
Cat::CommutativeRing;
+
info_str := "Multivariate polynomials on several basis";
interfaceAdd := {
@@ -428,6 +444,7 @@
M := PolT::Monomes(nops(Variables));
U := PolT::NonSymmetricHL(nops(Variables), R);
UH := PolT::NonSymmetricHLDual(nops(Variables), R);
+ K := PolT::Demazure(nops(Variables), R);
dividedDifference := (x,i) -> dom::monomial::dividedDifference(x,i);
isobaricDividedDifference := (x,i) -> dom::monomial::isobaricDividedDifference(x,i);
@@ -448,7 +465,7 @@
trans := combinat::permutations::inversionFromReducedWordForYangBaxter(redw, i);
// Deciding what transposition trans is
cycle := op(select(combinat::permutations::cycles(trans), x->nops(x)<>1));
- print(redw[i],translation(cycle));
+// print(redw[i],translation(cycle));
res := divDiff(res, redw[i]) + translation(cycle)*res;
end_for;
return(simplify(res));
@@ -481,10 +498,11 @@
begin
part := revert(sort(comp));
monome := dom::m(_mult(Variables[i]^(part[i]) $i=1..nops(part))); //The starting dominant monomial
- dom::squareDividedDifference(
- monome,
- combinat::permutations::inverse(
- combinat::permutations::mult2([3,2,1], combinat::words::standard(comp))));
+ dom::squareDividedDifference
+ (monome,
+ combinat::permutations::inverse
+ (combinat::permutations::mult2(revert([$1..nops(Variables)]),
+ combinat::words::standard(comp))), 0);
end_proc;
DemazureCharacterDual :=
@@ -495,7 +513,7 @@
monome := dom::m(_mult(Variables[i]^(part[i]) $i=1..nops(part))); //The starting dominant monomial
dom::nablaDividedDifference(
monome,
- combinat::permutations::inverse(combinat::words::standard(map(comp,x->-x))));
+ combinat::permutations::inverse(combinat::words::standard(map(comp,x->-x))), 0);
end_proc;
// Computation of the Schubert Polynomials
@@ -516,7 +534,21 @@
(dom::uda, dom::m ) = (x->dom::uda::toPoly(x, dom::m)),
(dom::ed , dom::m ) = (x->dom::ed ::toPoly(x, dom::m)),
(dom::m , dom::ed) = dom::ed::fromPoly,
- (dom::m , dom::M ) = (x->dom::M::fromList([op(x)]))
+ (dom::m , dom::M ) = (x->dom::M::fromList([op(x)])),
+ (dom::m , dom::K ) = prog::bless(
+ proc(p : Dom)
+ local res, co, mon, hd, tt;
+ begin
+ res := dom::K::zero;
+ while not iszero(p) do
+ mon := op(poly2list(lmonomial(p)));
+ [co, hd] := mon;
+ tt := dom::DemazureCharacter(hd);
+ res := res + dom::K::monomial(op(mon));
+ p := p - co*tt;
+ end_while;
+ res;
+ end_proc, dom)
);
basisChangesBasis :=
@@ -524,6 +556,8 @@
(dom::U , dom::m ) = (x-> dom::DemazureCharacter(x)),
(dom::M , dom::U ) = dom::invertBasisChange(dom::U, dom::M),
(dom::UH , dom::m ) = (x-> dom::DemazureCharacterDual(x)),
- (dom::M , dom::UH) = dom::invertBasisChange(dom::UH, dom::M)
+ (dom::M , dom::UH) = dom::invertBasisChange(dom::UH, dom::M),
+ (dom::K , dom::m ) = dom::DemazureCharacter
);
+
end_domain:
Modified: trunk/MuPAD-Combinat/lib/EXAMPLES/SymmetricFunctionsTools/LambdaOperations.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/EXAMPLES/SymmetricFunctionsTools/LambdaOperations.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/EXAMPLES/SymmetricFunctionsTools/LambdaOperations.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -124,4 +124,4 @@
end_proc;
-end_domain:
\ No newline at end of file
+end_domain:
Modified: trunk/MuPAD-Combinat/lib/EXAMPLES/SymmetricGroupAlgebra.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/EXAMPLES/SymmetricGroupAlgebra.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/EXAMPLES/SymmetricGroupAlgebra.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -68,9 +68,7 @@
dom::term(subsop([$1..N], i=i+1, i+1=i));
end_proc;
- algebraGenerators :=
- proc() local i;
- begin [dom::ti(i) $ i=1..N-1]; end_proc;
+ algebraGenerators := classes::valuesOfTable( i=dom::ti(i) $ i=1..N-1 );
mult2Basis := dom::term @ permutations::_mult;
Modified: trunk/MuPAD-Combinat/lib/EXPERIMENTAL/AlgTools.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/EXPERIMENTAL/AlgTools.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/EXPERIMENTAL/AlgTools.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -8,7 +8,10 @@
License: LGPL
*****************************************************************************/
-
+%if Dom::MonoidAlgebra=FAIL then
+ domain Dom::MonoidAlgebra
+ end_domain;
+end_if;
userinfo2 := (a,b,c) -> print(a,c):
domain experimental::algTools
Modified: trunk/MuPAD-Combinat/lib/EXPERIMENTAL/FreeSymmetricFunctions.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/EXPERIMENTAL/FreeSymmetricFunctions.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/EXPERIMENTAL/FreeSymmetricFunctions.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -206,7 +206,7 @@
inherits Dom::FreeModule(Ring, Tab);
basisName := toBeDefined;
- printTerm := z -> Tab::printPretty(z);
+ printTerm := z -> Tab::print(z);
exprTerm := dom::exprTermIndex;
oneBasis := Tab::empty;
degreeBasis := Tab::size;
Modified: trunk/MuPAD-Combinat/lib/EXPERIMENTAL/kShapes.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/EXPERIMENTAL/kShapes.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/EXPERIMENTAL/kShapes.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -48,7 +48,6 @@
hold(conjugate),
hold(addBase), hold(addPossibleNextRow), hold(addRectangle),
hold(baseHeights),
- hold(conjugate),
hold(fromWeight), hold(leftRightSeq),
hold(listIrreducible), hold(nextIrreducible), hold(possibleNextRows),
hold(reduce), hold(reduceRectangle),
Modified: trunk/MuPAD-Combinat/lib/EXPERIMENTAL/kShapesPoset.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/EXPERIMENTAL/kShapesPoset.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/EXPERIMENTAL/kShapesPoset.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -566,13 +566,11 @@
expandK :=
proc(src, K)
- local res;
begin
if nops(src) + src[1] <= K then return([[1, src]]); end_if;
- res := expandKOneStep(src, K);
- map(res,
+ map(expandKOneStep(src, K),
proc(z)
- local co, sh, res;
+ local co, sh;
begin
[co, sh] := z;
op(map(expandK(sh, K+1),
Modified: trunk/MuPAD-Combinat/lib/init.mu
===================================================================
--- trunk/MuPAD-Combinat/lib/init.mu 2008-12-12 14:10:57 UTC (rev 7593)
+++ trunk/MuPAD-Combinat/lib/init.mu 2009-11-26 23:34:25 UTC (rev 7594)
@@ -386,7 +386,7 @@
EdgeOptions = (() -> {Backward}) )
end;
- pdfViewer := "ghostview";
+ pdfViewer := "kpdf";
dot2tex := "";
// This is very UNIX/KDE specific
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: Shy <he...@ai...> - 2009-09-04 18:19:14
|
Va at the Palazzo Fiano, and I can put you down wherever you like.' 'Thanks,' answered Andrea, nothing loath. On the Corso they were obliged to proceed very slowly, the whole roadway being taken up by a seething, tumultuous crowd. From the Piazza di Montecitorio and the Piazza Colonna came a perfect uproar that swelled and rose and fell and rose again, mingled with shrill trumpet-blasts. The tumult increased as the gray cold twilight deepened. Horror at the tragedy enacted in a far-off land made the populace howl with rage; men broke through the dense crowd running and waving great bundles of newspapers. Through all the clamour, the one word Africa rang distinctly. 'And all this for four hundred brutes who had died the death of brutes!' murmured Andrea, withdrawing his head from the carriage win |
|
From: Ione <con...@we...> - 2009-09-01 21:53:33
|
Idenote: Powers of the vestry.] It was the vestry, thus constituted, that apportioned the parish taxes, appointed the churchwardens, presented the minister for induction into office, and acted as overseers of the poor. The minister presided in all vestry meetings. His salary was paid in tobacco, and in 1696 it was fixed by law at 16,000 pounds of tobacco yearly. In many parishes the churchwardens were the collectors of the parish taxe |
|
From: Verros R. <gn...@vi...> - 2009-08-28 18:27:55
|
Stinctly of that quality which to a lesser degree is due to any sense of social security; my power is that of one who works in an environment that reenforces him. I experience the objective or even cosmical character of my enterprises. They have a momentum which makes me their instrument rather than their perpetrator. A paradoxical relation between religion and morality has always interested observers of custom and history. Religion is |
|
From: Sanfelix H. <sal...@va...> - 2009-08-26 21:12:52
|
Il they are forty. At forty, they are worn out. At forty, they are sent to the Home of the Useless, where |
|
From: Faley<fa...@if...> - 2009-07-27 13:27:06
|
Why tbhe Clitoris is Hiddden.www.wood96. com |
212 messages has been excluded from this view by a project administrator.
