Spracherkennung für: .gi vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]
#(C) Graham Ellis, 2005-2006
#####################################################################
#####################################################################
#####################################################################
InstallGlobalFunction(TensorWithIntegers,
function(X)
local TensorWithZ_Obj,
TensorNFWithZ_Obj,
TensorWithZ_Arr;
if EvaluateProperty(X,"characteristic")>0 then
Print("ERROR: You should use the function TensorWithIntegersModP(). \n");
return fail; fi;
#####################################################################
#####################################################################
TensorWithZ_Obj:=function(R)
local
BoundaryC,
LengthC,
M;
if "tensorWithIntRec" in NamesOfComponents(R) then
return R!.tensorWithIntRec; fi;
if IsBound(R!.action) then
return TensorNFWithZ_Obj(R); fi;
LengthC:=EvaluateProperty(R,"length");
M:=[1..LengthC];
#####################################################################
BoundaryC:=function(n,k)
local returnvec, bound, x, i;
if n <0 then return false; fi;
if n=0 then return [0]; fi;
returnvec:=0*[1..R!.dimension(n-1)];
# 0*[1..n] is faster than List([1..n],i->0)
# in (seemingly) any case.
# For large n, NullMat(1,n)[1] is faster than 0*[1..n].
bound:=R!.boundary(n,k);
for x in [1..Size(bound)]
do
i:=AbsInt(bound[x][1]);
returnvec[i]:=returnvec[i]+SignInt(bound[x][1]);
od;
return returnvec;
end;
#####################################################################
R!.tensorWithIntRec:= Objectify(HapChainComplex,
rec(
dimension:=R!.dimension,
boundary:=BoundaryC,
properties:=
[["length",LengthC],
["connected",true],
["type", "chainComplex"],
["characteristic",
EvaluateProperty(R,"characteristic")] ]));
return R!.tensorWithIntRec;
end;
#####################################################################
#####################################################################
#####################################################################
#####################################################################
TensorNFWithZ_Obj:=function(R)
local
BoundaryC,
LengthC,
M;
if "tensorWithIntRec" in NamesOfComponents(R) then
return R!.tensorWithIntRec; fi;
LengthC:=EvaluateProperty(R,"length");
M:=[1..LengthC];
#####################################################################
BoundaryC:=function(n,k)
local returnvec, bound, x, i;
if n <0 then return false; fi;
if n=0 then return [0]; fi;
returnvec:=0*[1..R!.dimension(n-1)];
bound:=R!.boundary(n,k);
for x in [1..Size(bound)]
do
i:=AbsInt(bound[x][1]);
returnvec[i]:=returnvec[i]+SignInt(bound[x][1])*R!.action(n-1,i,bound[x][2]);
od;
return returnvec;
end;
#####################################################################
R!.tensorWithIntRec:= Objectify(HapChainComplex,
rec(
dimension:=R!.dimension,
boundary:=BoundaryC,
properties:=
[["length",LengthC],
["connected",true],
["type", "chainComplex"],
["characteristic",
EvaluateProperty(R,"characteristic")] ]));
return R!.tensorWithIntRec;
end;
#####################################################################
#####################################################################
#####################################################################
#####################################################################
TensorWithZ_Arr:=function(F)
local
R,S,RhomS, #R->S is an equivariant chain
CmapR, SmapD, #map. C->D is the chain map
C,D,ChomD, #got by killing the actions.
DimensionS,
DimensionC,
x;
R:=F!.source;
S:=F!.target;
DimensionS:=S!.dimension;
C:=TensorWithZ_Obj(R);
D:=TensorWithZ_Obj(S);
DimensionC:=C!.dimension;
#####################################################################
RhomS:=function(w,n)
local x,y,v;
v:=[];
for x in w do
y:=F!.mapping([[x[2],1]],n);
Apply(y,t->[x[1]*SignInt(t[1]),AbsInt(t[1])]);
Append(v,y);
od;
return v;
end;
#####################################################################
#####################################################################
CmapR:=function(v,n)
local i,j,w,x;
w:=[];
for i in [1..DimensionC(n)] do
if not v[i]=0 then
Add(w,[v[i],i]);
fi;
od;
return w;
end;
#####################################################################
#####################################################################
SmapD:=function(w,n)
local i,x,v;
v:=List([1..DimensionS(n)],x->0);
for x in w do
v[x[2]]:=v[x[2]]+x[1];
od;
return v;
end;
#####################################################################
#####################################################################
ChomD:=function(v,n)
local ans;
return SmapD(RhomS(CmapR(v,n),n),n);
end;
#####################################################################
return Objectify(HapChainMap,
rec(
source:=C,
target:=D,
mapping:=ChomD,
properties:=[ ["type","chainMap"],
["characteristic", Maximum(
EvaluateProperty(X!.source,"characteristic"),
EvaluateProperty(X!.target,"characteristic"))]
]));
end;
#####################################################################
#####################################################################
if IsHapEquivariantChainComplex(X) then
return TensorWithZ_Obj(X); fi;
if EvaluateProperty(X,"type") = "resolution"
or
EvaluateProperty(X,"type") = "chaincomplex" then
return TensorWithZ_Obj(X); fi;
if EvaluateProperty(X,"type") = "equivariantChainMap" then
return TensorWithZ_Arr(X); fi;
Print("ERROR: Input should be a resolution or equivariant map between resolutions. \n");
end);
#####################################################################
#####################################################################
#####################################################################
#####################################################################
#####################################################################
InstallGlobalFunction(FilteredTensorWithIntegers,
function(R)
local
C, ln;
if not IsBound(R!.filteredDimension)
or
not IsInt(EvaluateProperty(R,"filtration_length"))
then Print("This function must be applied to a filtered resolution.\n");
return fail;
fi;
ln:=EvaluateProperty(R,"filtration_length");
C:=TensorWithIntegers(R);
return Objectify(HapFilteredChainComplex,
rec(
dimension:=C!.dimension,
filteredDimension:=R!.filteredDimension,
boundary:=C!.boundary,
pseudoBoundary:=R!.pseudoBoundary,
properties:=
[["length",EvaluateProperty(R,"length")],
["connected",true],
["type", "chainComplex"],
["filtration_length",ln],
["initial_inclusion",EvaluateProperty(R,"initial_inclusion")],
["characteristic",
EvaluateProperty(R,"characteristic")] ]));
end);
#####################################################################
#####################################################################
#####################################################################
#####################################################################
InstallGlobalFunction(FilteredTensorWithIntegersModP,
function(R,prime)
local
C, ln;
if not IsBound(R!.filteredDimension)
or
not IsInt(EvaluateProperty(R,"filtration_length"))
then Print("This function must be applied to a filtered resolution.\n");
return fail;
fi;
ln:=EvaluateProperty(R,"filtration_length");
C:=TensorWithIntegersModP(R,prime);
return Objectify(HapFilteredChainComplex,
rec(
dimension:=C!.dimension,
filteredDimension:=R!.filteredDimension,
boundary:=C!.boundary,
pseudoBoundary:=R!.pseudoBoundary,
properties:=
[["length",EvaluateProperty(R,"length")],
["connected",true],
["type", "chainComplex"],
["filtration_length",ln],
["initial_inclusion",EvaluateProperty(R,"initial_inclusion")],
["characteristic",prime]
]));
end);
#####################################################################
#####################################################################
#####################################################################
#####################################################################
InstallGlobalFunction(TensorWithIntegersSparse,
function(R)
local
BoundaryRec,
BoundaryC,
LengthC;
LengthC:=EvaluateProperty(R,"length");
BoundaryRec:=List([1..LengthC],n->[] );
#####################################################################
BoundaryC:=function(n,k)
local bound, x, i;
if n <0 then return false; fi;
if n=0 then return []; fi;
#if not IsBound(BoundaryRec[n][k]) then
if true then
bound:=StructuralCopy(R!.boundary(n,k));
Apply(bound,x->[x[1],1]);
bound:=AlgebraicReduction(bound);
Apply(bound,x->[AbsInt(x[1]),SignInt(x[1])]);
bound:=Collected(bound);
Apply(bound,x->[x[1][1],x[1][2]*x[2]]);
BoundaryRec[n][k]:=bound;
fi;
return BoundaryRec[n][k];
end;
#####################################################################
return Objectify(HapSparseChainComplex,
rec(
dimension:=R!.dimension,
boundary:=BoundaryC,
properties:=
[["length",LengthC],
["connected",true],
["type", "chainComplex"],
["characteristic",
EvaluateProperty(R,"characteristic")] ]));
end);
#####################################################################
#####################################################################
#####################################################################
#####################################################################
InstallGlobalFunction(SparseChainComplexToChainComplex,
function(C)
local Boundary,zero, char;
char:=EvaluateProperty(C,"characteristic");
if char<=0 then zero:=0; else zero:=Zero(GF(char)); fi;
########################################
Boundary:=function(n,k)
local B, x;
B:=[1..C!.dimension(n-1)]*zero;
for x in C!.boundary(n,k) do
B[x[1]]:=B[x[1]]+x[2];
od;
return B;
end;
########################################
return Objectify(HapChainComplex,
rec(
dimension:=C!.dimension,
boundary:=Boundary,
properties:=
[["length",Length(C)],
["connected",EvaluateProperty(C,"connected")],
["type", "chainComplex"],
["characteristic", char] ]));
end);
#####################################################################
#####################################################################
#####################################################################
#####################################################################
InstallGlobalFunction(ChainComplexToSparseChainComplex,
function(C)
local Boundary,zero, char,bound;
char:=EvaluateProperty(C,"characteristic");
if char<=0 then zero:=0; else zero:=Zero(GF(char)); fi;
bound:=List([1..Length(C)],i->[]);
########################################
Boundary:=function(n,k)
local B,v,i;
if not IsBound(bound[n][k]) then
B:=[];
v:=C!.boundary(n,k);
for i in [1..Length(v)] do
if not v[i]=0 then Add(B,[i,v[i]]); fi;
od;
bound[n][k]:=B;
fi;
return bound[n][k];
end;
########################################
return Objectify(HapSparseChainComplex,
rec(
dimension:=C!.dimension,
boundary:=Boundary,
properties:=
[["length",Length(C)],
["connected",EvaluateProperty(C,"connected")],
["type", "chainComplex"],
["characteristic", char] ]));
end);
#####################################################################
#####################################################################
