Quelle setup.gi
Sprache: unbekannt
|
|
#############################################################################
##
#W setup.gi GUARANA package Bjoern Assmann
##
## Methods for setting up the data structures that are needed for
## Mal'cev collection.
##
#H @(#)$Id$
##
#Y 2006
##
##
#############################################################################
##
#F GUARANA.PcpGroupByPcs( G, pcs )
##
## IN
## G ........................ polycyclically presented group
## pcs ...................... polycyclic sequence of G
##
## OUT
## Polycyclically presented group isomorphic to G, with
## a polycyclic presentation with respect to pcs.
##
GUARANA.PcpGroupByPcs := function (G, pcs )
local sers, l, H, i;
# built corresponding series
sers := [];
l := Length( pcs );
for i in [1..l+1] do
Add( sers, Subgroup( G, pcs{[i..l]} ));
od;
# get pcp
H := PcpGroupBySeries( sers );
return H;
end;
#############################################################################
##
## IN
## G ................... polycyclic group whose polycyclic presentation
## is given with respect to a nice polycyclic
## sequence, that is a sequence that fullfills
## all requirements that are needed for the
## Malcev collection.
## pcs = (f_1,...f_r,c_{r+1},...,c_{r+s},n_{r+s+1},...,n_{r+s+t})
## (n_{r+s+1},...,n_{r+s+t}) is a Mal'cev basis of a normal
## T group N.
## C =< c_{r+1},...,c_{r+s} > is a T-group and an
## almost nilpotent supplement to N in G.
## G/CN is finite.
## indeces ............. list containing three lists l1,l2,l3
## l1 = [1...r]
## l2 = [r+1,...,r+s]
## l3 = [r+s+1,...,r+s+t]
## N ................... normal T-group of N.
## NN .................. pcp group isomorphic to N.
## Note that in the gap sense NN is not a subgroup
## of G. N and NN must have the same underlying
## Mal'cev basis.
## C .................. T-group as described above.
## CC ................. pcp group isomorphic to C.
## The polycyclic presentation of CC must be
## given with respect to Mal'cev basis
## starting with (c_{r+s},...,c_{r+s}).
## CC!.bijection must be a bijection between
## CC and C.
##
## Example
## ll := GUARANA.SomePolyMalcevExams( 3 );
## R := GUARANA.InitialSetupMalcevCollector( ll );
##
## TODO
## Maybe add some tests to check whether the input is correct.
##
GUARANA.InitialSetupMalcevCollector := function( args )
local G, indeces, N, NN, C, CC, lengths, cn_fam, cn_elms_type, obj,
g_fam, g_elms_type, rels;
G := args[1];
indeces := args[2];
N := args[3];
NN := args[4];
C := args[5];
CC := args[6];
lengths := [ Length(indeces[1]), Length( indeces[2] ),
Length( indeces[3] ) ];
rels := RelativeOrdersOfPcp( Pcp(G ) );
# create family and types for elements of CN and ...
cn_fam := NewFamily( "MalcevCNFamily",
IsMalcevCNElement,
IsMalcevCNElement );
cn_elms_type := NewType( cn_fam, IsMalcevCNElementRep );
g_fam := NewFamily( "MalcevGFamily",
IsMalcevGElement,
IsMalcevGElement );
g_elms_type := NewType( g_fam, IsMalcevGElementRep );
obj := rec( G := G, indeces := indeces, lengths := lengths,
N := N, NN := NN,
C := C, CC := CC,
rels := rels,
mo_NN := "unknown" , mo_CC := "unknown",
cn_fam := cn_fam,
cn_elms_type := cn_elms_type,
g_fam := g_fam,
g_elms_type := g_elms_type,
mult_method := "standard"
# if we set this to symbolic then we have symbolic
# du Sautoy collection, (only prototype implementation).
);
obj := Objectify( NewType( MalcevCollectorFamily,
IsMalcevCollectorRep and
IsMutable ),
obj );
return obj;
end;
#############################################################################
##
## Funtions to view and print a Malcev collector
##
InstallMethod( PrintObj, "for Malcev collector", [ IsMalcevCollectorRep ],
function( malColl )
Print( "<<Malcev collector>>\n",
" F : ", malColl!.rels{malColl!.indeces[1]} , "\n",
" C : ", malColl!.mo_CC, "\n",
" N : ", malColl!.mo_NN );
end );
#F GUARANA.MO_AddTGroupRecs( malcevCollector )
#F GUARANA.AddMalcevObjects( malcevCollector )
##
##
## EFFECT
## T-group records of C,N,
## respectively Malcev objects of L(N),L(C) are
## added to malCol.
##
GUARANA.MO_AddTGroupRecs := function( malcevCollector )
malcevCollector!.recNN := GUARANA.TGroupRec( [malcevCollector!.NN ]);
malcevCollector!.recCC := GUARANA.TGroupRec( [malcevCollector!.CC] );
end;
GUARANA.AddMalcevObjects := function( malCol )
malCol!.mo_NN := MalcevObjectConstruction( malCol!.recNN );
malCol!.mo_CC := MalcevObjectConstruction( malCol!.recCC );
end;
#############################################################################
##
#F GUARANA.MO_ComputeLieAutMatrix( malCol, g )
##
## IN
## g ....................... element of parent group G.
## malCol .................. Malcev collector
##
## OUT
## matrix of the Lie algebra automorphism of L(N) corresponding to
## the group autmorphism of N, that maps n to n^g
##
GUARANA.MO_ComputeLieAutMatrix := function( malCol, g )
local pcpN, autMat, exps, n, n_i_g, log_n_i_g, coeff, i;
# catch trivial case
if HirschLength( malCol!.N ) = 0 then
return EmptyMatrix( 0 );
fi;
pcpN := Pcp( malCol!.N );
autMat := [];
exps := LinearActionOnPcp( [g], pcpN )[1];
n := Length( exps );
for i in [1..n] do
# compute coefficients of log n_i^g
n_i_g := MalcevGrpElementByExponents( malCol!.mo_NN, exps[i] );
log_n_i_g := Log( n_i_g );
coeff := Coefficients( log_n_i_g );
Add( autMat, coeff );
od;
return autMat;
end;
#############################################################################
##
#F GUARANA.Add_C_LieAuts( malCol )
##
## all lie automorphism matrices corresponding to the basis elms of C
## are added to the Malcev collector.
##
GUARANA.Add_C_LieAuts := function( malCol )
local lieAuts, pcpC, c, autMat, i;
lieAuts := [];
pcpC := Pcp( malCol!.C );
# compute lie auts corresponding to conjugation action
for i in [1..Length(pcpC)] do
c := pcpC[i];
autMat := GUARANA.MO_ComputeLieAutMatrix( malCol, c );
Add( lieAuts, autMat );
od;
malCol!.C_lieAuts := lieAuts;
end;
#############################################################################
##
#F GUARANA.Add_G_LieAuts( malCol )
##
## all lie automorphism matrices corresponding to the pcs elms of G
## are added to the Malcev collector.
##
GUARANA.Add_G_LieAuts := function( malCol )
local lieAuts, pcpG, g, autMat, i;
lieAuts := [];
pcpG := Pcp( malCol!.G );
# compute lie auts corresponding to conjugation action
for i in [1..Length(pcpG)] do
g := pcpG[i];
autMat := GUARANA.MO_ComputeLieAutMatrix( malCol, g );
Add( lieAuts, autMat );
od;
malCol!.G_lieAuts := lieAuts;
end;
#############################################################################
##
#F GUARANA.MO_MapFromCCtoNN( malCol, cc )
##
## IN
## malCol ...................... .. Malcev collector of G
## cc ............................. group element of CC corresponding
##
## OUT
## the corresponding elment in NN if c in C \cap N.
## fail otherwise.
##
GUARANA.MO_MapFromCCtoNN := function( malCol, cc )
local isoCC_C, c, isoNN_N, nn;
# map from CC to C \cap N
isoCC_C := malCol!.CC!.bijection;
c := Image( isoCC_C, cc );
# map from C \cap N to NN
if c in malCol!.N then
isoNN_N := malCol!.NN!.bijection;
nn := PreImage( isoNN_N, c );
return nn;
else
return fail;
fi;
end;
#############################################################################
##
#F GUARANA.MO_AddImgsOf_LCcapN_in_LN( malCol )
##
## Coefficient vectors with respect to the basis of L(N)
## of the part of the Malcev basis
## of C that lies in N are stored.
##
## Example
## ll := GUARANA.SomePolyMalcevExams( 9 );
## R := GUARANA.InitialSetupMalcevCollector( ll );
## GUARANA.AddTGroupRecs( R );
## GUARANA.AddMalcevObjects( R );
##
GUARANA.MO_AddImgsOf_LCcapN_in_LN := function( malCol )
local hl_fa, hl_c, basis, elms_NN, nn, imgs_LCapN_in_LN, nn2, log_nn, i;
# Get malcev basis of C \cap N < C.
# Note that this malcev basis corresponds to the basis of
# L(C \cap N ) < L(C )
hl_fa := Length( malCol!.indeces[2] ); # hirschlength of CN/N
hl_c := HirschLength( malCol!.CC );
basis := Pcp( malCol!.CC ){[hl_fa+1..hl_c]};
# get its image in NN
elms_NN := [];
for i in [1..Length(basis)] do
nn := GUARANA.MO_MapFromCCtoNN( malCol, basis[i] );
Add( elms_NN, nn );
od;
# get its image in L(N)
imgs_LCapN_in_LN := [];
for i in [1..Length(elms_NN)] do
nn := elms_NN[i];
nn2 := MalcevGrpElementByExponents( malCol!.mo_NN, Exponents(nn) );
log_nn := Log( nn2 );
Add( imgs_LCapN_in_LN, log_nn );
od;
malCol!.imgs_LCapN_in_LN := imgs_LCapN_in_LN;
end;
#############################################################################
##
#F GUARANA.MO_MapFromLCcapNtoLN( malCol, l_cc )
##
## IN
## malCol... .................... malcev collector
## l_cc ......................... lie algebra element of L(C)
## (in fact L(CC)) given
## as Malcev lie element.
##
## OUT
## Coefficient vector of the corresponding in element in L(NN)
## if l_cc in L(C\cap N ). Ohterwise fail is returned.
##
##
GUARANA.MapFromLCcapNtoLN := function( malCol, l_cc )
local hl_fa, coeffs, coeffs_1, hl_C, coeffs_2, imgs;
# catch trivial case
if l_cc = 0*l_cc then
return MalcevLieElementByWord( malCol!.mo_NN, [[],[]] );
fi;
# test wheter l_cc in L(C\cap N ) by checking whether the first
# hl(CN/N) coordinates of l_cc are equal to zero.
hl_fa := Length( malCol!.indeces[2] );# hirsch lenght of CN/N
coeffs := Coefficients( l_cc );
coeffs_1 := coeffs{[1..hl_fa]};
if coeffs_1 <> coeffs_1*0 then
return fail;
fi;
# map it to L(N)
hl_C := Length( coeffs );
coeffs_2 := coeffs{[hl_fa+1..hl_C]};
imgs := malCol!.imgs_LCapN_in_LN;
if Length( coeffs_2 ) <> Length( imgs ) then
Error( " " );
fi;
return LinearCombination( imgs, coeffs_2 );
end;
## IN elm ..................... MalcevGenElement of C
## that lies in the intersection of C and N
##
## OUT
## The
GUARANA.MapFrom_MOC_2_MON := function( malCol, elm )
local x, x_img;
x := LieElement( elm );
x_img := GUARANA.MapFromLCcapNtoLN( malCol, x );
if x_img = fail then
return fail;
else
return MalcevGenElementByLieElement( x_img );
fi;
end;
#############################################################################
##
#F GUARANA.G_CN_WeightVector( rels )
##
## IN
## rels ....................... relative orders of G/CN
##
## OUT
## A weight vector that can be used to associate a number
## to the exponent vector of a group element of G/CN
## and vice versa.
##
GUARANA.G_CN_WeightVector := function( rels )
local vec, n, i;
# catch trivial case
if Length( rels ) = 0 then
return [];
fi;
vec := [1];
n := Length( rels );
for i in [1..n-1] do
Add( vec, vec[i]*rels[n-i+1] );
od;
return Reversed( vec );
end;
#############################################################################
##
#F GUARANA.G_CN_ExpVectorToNumber( exp, w_vec )
#F GUARANA.G_CN_NumberToExpVector( num, w_vec )
##
## IN
## exp .................... exponent vector of an element of G/CN
## n ...................... number of an element of G/CN
## w_vec .................. a weight vector
##
## OUT
## The number corresponding to exp, or the exponent vector corresponding to n
##
GUARANA.G_CN_ExpVectorToNumber := function( exp, w_vec )
local num;
num := ScalarProduct( exp, w_vec );
return num+1;
end;
GUARANA.G_CN_NumberToExpVector := function( num, w_vec )
local exp, n, div, i, num2;
num2 := num -1;
exp := [];
n := Length( w_vec );
for i in [1..n] do
div := Int( num2/w_vec[i] );
Add( exp, div );
num2 := num2 - div*w_vec[i];
od;
return exp;
end;
#############################################################################
##
#F GUARANA.MO_G_CN_InitialSetup( malCol )
#F GUARANA.MO_G_CN_AddMultTable( malCol )
#F GUARANA.MO_G_CN_Setup( malCol )
##
## EFFECT
## The multiplication table of G/CN is added to the malcev collector
##
GUARANA.MO_G_CN_InitialSetup := function( malCol )
local rels_G, rels, w_vec, order;
# compute weight vector
rels_G := RelativeOrdersOfPcp( Pcp(malCol!.G ) );
rels := rels_G{ malCol!.indeces[1] };
w_vec := GUARANA.G_CN_WeightVector( rels );
# compute order of the finite quotient G/CN
order := Product( rels );
# add info record
malCol!.G_CN := rec( w_vec := w_vec,
order := order,
rels := rels );
end;
GUARANA.MO_G_CN_AddMultTable := function( malCol )
local prods, collG, order, w_vec, exp_g, exp_h, g, h, k, i, j, exps_k;
prods := [];
collG := Collector( malCol!.G );
# catch trivial case
if Length( malCol!.G_CN.rels ) = 0 then
return prods;
fi;
# go through all possible products and store their normal form
order := malCol!.G_CN.order;
w_vec := malCol!.G_CN.w_vec;
for i in [1..order] do
Add( prods, [] );
for j in [1..order] do
exp_g := GUARANA.G_CN_NumberToExpVector( i, w_vec );
exp_h := GUARANA.G_CN_NumberToExpVector( j, w_vec );
g := GUARANA.GrpElmByExpsAndCollNC( collG, exp_g );
h := GUARANA.GrpElmByExpsAndCollNC( collG, exp_h );
k := g*h;
# only save exp vector, since the generation of
# malcevGelements is a little bit expensive
Add( prods[i], Exponents( k ) );
#exps_k := Exponents( k );
#Add( prods[i], MalcevGElementByExponentsNC( malCol, exps_k ));
od;
od;
malCol!.G_CN.multTable := prods;
end;
GUARANA.MO_G_CN_Setup := function( malCol )
GUARANA.MO_G_CN_InitialSetup( malCol );
GUARANA.MO_G_CN_AddMultTable( malCol );
end;
#############################################################################
##
#F GUARANA.MO_G_CN_LookUpProduct( malCol, exp1, exp2 )
##
## IN
## malCol ....................... malcev collector
## exp1, exp2 ...................... exponent vector of two elments g1,g2
## of G/CN
##
## OUT
## MalcevGElement g1*g2
##
GUARANA.MO_G_CN_LookUpProduct := function( malCol, exp1, exp2 )
local w_vec, num1, num2,exp_vec;
w_vec := malCol!.G_CN.w_vec;
# catch case G/CN = 1
if Length( w_vec ) = 0 then
return GUARANA.G_Identity( malCol );
fi;
# get exp vector
num1 := GUARANA.G_CN_ExpVectorToNumber( exp1, w_vec );
num2 := GUARANA.G_CN_ExpVectorToNumber( exp2, w_vec );
exp_vec := malCol!.G_CN.multTable[num1][num2];
return MalcevGElementByExponentsNC( malCol, exp_vec );
end;
GUARANA.GetCNElmentByGExpVector := function( malCol, exps )
local indeces, exps_cn, cn_elm;
indeces := malCol!.indeces;
if exps{indeces[1]} <> 0*exps{indeces[1]} then
Error( "Exponent vector does not correspond to CN element \n" );
else
exps_cn := exps{ Concatenation(indeces[2],indeces[3]) };
cn_elm := MalcevCNElementByExponents( malCol, exps_cn );
return cn_elm;
fi;
end;
#############################################################################
##
#F GUARANA.MO_CconjF_AddInfo( malCol )
##
## EFFECT
## Let (f_1,...,f_r,c_1,...,c_s,n_1,...,n_t ) be a pcs suitable
## for Malcev collection. This function stores
## all normal forms of the type
## c_i^f ( where f is product of the f_j )
## in the Malcev collector.
##
GUARANA.MO_CconjF_AddInfo := function( malCol )
local CconjF, pcpG, indeces, order, w_vec, ind_C, cconjF,
exp_f, c_i, f, k, exps_k, cn_elm, i, j;
CconjF := [];
pcpG := Pcp( malCol!.G );
indeces := malCol!.indeces;
# catch trivial case
if Length( malCol!.G_CN.rels ) = 0 then
malCol!.CconjF := CconjF;
return 0;
fi;
order := malCol!.G_CN.order;
w_vec := malCol!.G_CN.w_vec;
ind_C := malCol!.indeces[2];
# go through all c_i
for i in ind_C do
cconjF := [];
exp_f := GUARANA.G_CN_NumberToExpVector( i, w_vec );
# go through all elms of finite part
for j in [1..order] do
exp_f := GUARANA.G_CN_NumberToExpVector( j, w_vec );
c_i := pcpG[i];
f := GUARANA.GrpElmByExpsAndPcs( pcpG, exp_f );
k := c_i^f;
# Add( cconjF, Exponents( k ) );
exps_k := Exponents( k );
# get corresponding Malcev CN element
cn_elm := GUARANA.GetCNElmentByGExpVector( malCol, exps_k );
# get also lie information about cn
Coefficients( cn_elm!.c );
Coefficients( cn_elm!.n );
Add( cconjF, cn_elm );
od;
Add( CconjF, cconjF );
od;
malCol!.CconjF := CconjF;
end;
#############################################################################
##
#F GUARANA.MO_CconjF_LookUp( malCol, i, exp_f )
##
## IN
## malCol ....................... Malcev collector
## i ............................... index of c_i, which is a part
## of the pcs of CN/N.
## i determines the position of c_i in
## the pcs of CN/N.
## exp_f ........................... short exponent vector (with respect
## to G/CN) of an element of the finite
## part.
##
## OUT
## (c_i)^f as stored in the Malcev record.
##
GUARANA.MO_CconjF_LookUp := function( malCol, i, exp_f )
local w_vec, num_f;
# check input
if not i+malCol!.lengths[1] in malCol!.indeces[2] then
Error( " \n" );
fi;
# catch trivial case G/CN =1
#TODO
# get number that corresponds to f
w_vec := malCol!.G_CN.w_vec;
num_f := GUARANA.G_CN_ExpVectorToNumber( exp_f, w_vec );
return malCol!.CconjF[i][num_f];
end;
#############################################################################
##
#F GUARANA.MO_F_AddInverseInfo( malCol )
##
## IN
## malCol ....................... Malcev record
##
## EFFECT
## Store f^-1 for all representatives f of the finite part G/CN
##
GUARANA.MO_F_AddInverseInfo := function( malCol )
local inversesF, pcpG, order, w_vec, exp_f, f, f_inv, exps, elm, j;
inversesF := [];
pcpG := Pcp( malCol!.G );
# catch trivial case
if Length( malCol!.G_CN.rels ) = 0 then
malCol!.inversesF := inversesF;
return 0;
fi;
order := malCol!.G_CN.order;
w_vec := malCol!.G_CN.w_vec;
# go through all elms of finite part
for j in [1..order] do
exp_f := GUARANA.G_CN_NumberToExpVector( j, w_vec );
f := GUARANA.GrpElmByExpsAndPcs( pcpG, exp_f );
f_inv := f^-1;
#Add( inversesF, Exponents( f_inv ) );
exps := Exponents( f_inv );
elm := MalcevGElementByExponents( malCol, exps );
Add( inversesF, elm );
od;
malCol!.inversesF := inversesF;
return 0;
end;
#############################################################################
##
#F GUARANA.MO_F_LookupInverse( malCol, exp_f )
##
## IN
## malCol ........................... malcev Record
## exp_f ........................... short exponent vector (with respect
## to G/CN) of an element of the finite
## part.
##
## OUT
## f^-1 as stored in the Malcev record.
##
GUARANA.MO_F_LookupInverse := function( malCol, exp_f )
local w_vec, num_f;
# catch trivial case G/CN = 1
if Length( exp_f )=0 then
return GUARANA.G_Identity( malCol );
fi;
# get number that corresponds to f
w_vec := malCol!.G_CN.w_vec;
num_f := GUARANA.G_CN_ExpVectorToNumber( exp_f, w_vec );
return malCol!.inversesF[num_f];
end;
#############################################################################
##
#F GUARANA.MO_AddCompleteMalcevInfo( malCol )
##
## IN
## malCol .................... Malcev collector as given by
## InitialSetupMalcevCollector.
## EFFECT
## All information/data structures that are needed to do the
## Malcev collection are added.
##
## Example
## ll := GUARANA.SomePolyMalcevExams( 3 );
## R := GUARANA.InitialSetupCollecRecord( ll );
## GUARANA.MO_AddCompleteMalcevInfo( R );
##
GUARANA.MO_AddCompleteMalcevInfo := function( malCol )
GUARANA.MO_AddTGroupRecs( malCol );
GUARANA.AddMalcevObjects( malCol );
GUARANA.Add_C_LieAuts( malCol );
GUARANA.Add_G_LieAuts( malCol );
GUARANA.MO_AddImgsOf_LCcapN_in_LN( malCol );
GUARANA.MO_G_CN_Setup( malCol );
GUARANA.MO_CconjF_AddInfo( malCol );
GUARANA.MO_F_AddInverseInfo( malCol );
end;
GUARANA.SetAllMethodsToSymbolic := function( malCol )
local mo_CC, mo_NN;
mo_CC := malCol!.mo_CC;
mo_NN := malCol!.mo_NN;
SetLogAndExpMethod( mo_CC, "pols" );
#SetStarMethod( mo_CC, "pols" );
SetLogAndExpMethod( mo_NN, "pols" );
#SetStarMethod( mo_NN, "pols" );
end;
#############################################################################
##
#F GUARANA.SetupMalcevCollector( args )
##
## IN
## G ................... polycyclic group whose polycyclic presentation
## is given with respect to a nice polycyclic
## sequence, that is a sequence that fullfills
## all requirements that are needed for the
## Malcev collection.
## pcs = (f_1,...f_r,c_{r+1},...,c_{r+s},n_{r+s+1},...,n_{r+s+t})
## (n_{r+s+1},...,n_{r+s+t}) is a Mal'cev basis of a normal
## T group N.
## C =< c_{r+1},...,c_{r+s} > is a T-group and an
## almost nilpotent supplement to N in G.
## G/CN is finite.
## indeces ............. list containing three lists l1,l2,l3
## l1 = [1...r]
## l2 = [r+1,...,r+s]
## l3 = [r+s+1,...,r+s+t]
## N ................... normal T-group of N.
## NN .................. pcp group isomorphic to N.
## Note that in the gap sense NN is not a subgroup
## of G. N and NN must have the same underlying
## Mal'cev basis.
## C .................. T-group as described above.
## CC ................. pcp group isomorphic to C.
## The polycyclic presentation of CC must be
## given with respect to Mal'cev basis
## starting with (c_{r+s},...,c_{r+s}).
## CC!.bijection must be a bijection between
## CC and C.
##
## OUT
## Malcev record that contains all data needed for Mal'cev collection.
##
## Example
## ll := GUARANA.SomePolyMalcevExams( 3 );
## R := GUARANA.SetupMalcevCollector( ll );
##
##
GUARANA.SetupMalcevCollector := function( args )
local malCol;
malCol := GUARANA.InitialSetupMalcevCollector( args );
GUARANA.MO_AddCompleteMalcevInfo( malCol );
GUARANA.SetAllMethodsToSymbolic( malCol );
# add dt polynomials and set them as defaul method
# TODO: Should we add them before we setup the malcev correspondence ?
AddDTPolynomials( malCol!.mo_NN );
AddDTPolynomials( malCol!.mo_CC );
SetMultiplicationMethod( malCol!.mo_NN , GUARANA.MultMethodIsCollection );
SetMultiplicationMethod( malCol!.mo_CC, GUARANA.MultMethodIsCollection );
return malCol;
end;
InstallGlobalFunction( MalcevCollectorConstruction,
function( args )
return GUARANA.SetupMalcevCollector( args );
end);
#############################################################################
##
#E
[ Dauer der Verarbeitung: 0.4 Sekunden
(vorverarbeitet)
]
|
2026-04-02
|
