def Conic(base_field, F=None, names=None, unique=True):
r"""
Return the plane projective conic curve defined by ``F``
over ``base_field``.
The input form ``Conic(F, names=None)`` is also accepted,
in which case the fraction field of the base ring of ``F``
is used as base field.
INPUT:
- ``base_field`` -- The base field of the conic.
- ``names`` -- a list, tuple, or comma separated string
of three variable names specifying the names
of the coordinate functions of the ambient
space `\Bold{P}^3`. If not specified or read
off from ``F``, then this defaults to ``'x,y,z'``.
- ``F`` -- a polynomial, list, matrix, ternary quadratic form,
or list or tuple of 5 points in the plane.
If ``F`` is a polynomial or quadratic form,
then the output is the curve in the projective plane
defined by ``F = 0``.
If ``F`` is a polynomial, then it must be a polynomial
of degree at most 2 in 2 variables, or a homogeneous
polynomial in of degree 2 in 3 variables.
If ``F`` is a matrix, then the output is the zero locus
of `(x,y,z) F (x,y,z)^t`.
If ``F`` is a list of coefficients, then it has
length 3 or 6 and gives the coefficients of
the monomials `x^2, y^2, z^2` or all 6 monomials
`x^2, xy, xz, y^2, yz, z^2` in lexicographic order.
If ``F`` is a list of 5 points in the plane, then the output
is a conic through those points.
- ``unique`` -- Used only if ``F`` is a list of points in the plane.
If the conic through the points is not unique, then
raise ``ValueError`` if and only if ``unique`` is True
OUTPUT:
A plane projective conic curve defined by ``F`` over a field.
EXAMPLES:
Conic curves given by polynomials ::
sage: X,Y,Z = QQ['X,Y,Z'].gens()
sage: Conic(X^2 - X*Y + Y^2 - Z^2)
Projective Conic Curve over Rational Field defined by X^2 - X*Y + Y^2 - Z^2
sage: x,y = GF(7)['x,y'].gens()
sage: Conic(x^2 - x + 2*y^2 - 3, 'U,V,W')
Projective Conic Curve over Finite Field of size 7 defined by U^2 + 2*V^2 - U*W - 3*W^2
Conic curves given by matrices ::
sage: Conic(matrix(QQ, [[1, 2, 0], [4, 0, 0], [7, 0, 9]]), 'x,y,z')
Projective Conic Curve over Rational Field defined by x^2 + 6*x*y + 7*x*z + 9*z^2
sage: x,y,z = GF(11)['x,y,z'].gens()
sage: C = Conic(x^2+y^2-2*z^2); C
Projective Conic Curve over Finite Field of size 11 defined by x^2 + y^2 - 2*z^2
sage: Conic(C.symmetric_matrix(), 'x,y,z')
Projective Conic Curve over Finite Field of size 11 defined by x^2 + y^2 - 2*z^2
Conics given by coefficients ::
sage: Conic(QQ, [1,2,3])
Projective Conic Curve over Rational Field defined by x^2 + 2*y^2 + 3*z^2
sage: Conic(GF(7), [1,2,3,4,5,6], 'X')
Projective Conic Curve over Finite Field of size 7 defined by X0^2 + 2*X0*X1 - 3*X1^2 + 3*X0*X2 - 2*X1*X2 - X2^2
The conic through a set of points ::
sage: C = Conic(QQ, [[10,2],[3,4],[-7,6],[7,8],[9,10]]); C
Projective Conic Curve over Rational Field defined by x^2 + 13/4*x*y - 17/4*y^2 - 35/2*x*z + 91/4*y*z - 37/2*z^2
sage: C.rational_point()
(10 : 2 : 1)
sage: C.point([3,4])
(3 : 4 : 1)
sage: a=AffineSpace(GF(13),2)
sage: Conic([a([x,x^2]) for x in range(5)])
Projective Conic Curve over Finite Field of size 13 defined by x^2 - y*z
"""
if not (is_IntegralDomain(base_field) or base_field == None):
if names is None:
names = F
F = base_field
base_field = None
if isinstance(F, (list,tuple)):
if len(F) == 1:
return Conic(base_field, F[0], names)
if names == None:
names = 'x,y,z'
if len(F) == 5:
L=[]
for f in F:
if isinstance(f, SchemeMorphism_point_affine):
C = Sequence(f, universe = base_field)
if len(C) != 2:
raise TypeError, "points in F (=%s) must be planar"%F
C.append(1)
elif isinstance(f, SchemeMorphism_point_projective_field):
C = Sequence(f, universe = base_field)
elif isinstance(f, (list, tuple)):
C = Sequence(f, universe = base_field)
if len(C) == 2:
C.append(1)
else:
raise TypeError, "F (=%s) must be a sequence of planar " \
"points" % F
if len(C) != 3:
raise TypeError, "points in F (=%s) must be planar" % F
P = C.universe()
if not is_IntegralDomain(P):
raise TypeError, "coordinates of points in F (=%s) must " \
"be in an integral domain" % F
L.append(Sequence([C[0]**2, C[0]*C[1], C[0]*C[2], C[1]**2,
C[1]*C[2], C[2]**2], P.fraction_field()))
M=Matrix(L)
if unique and M.rank() != 5:
raise ValueError, "points in F (=%s) do not define a unique " \
"conic" % F
con = Conic(base_field, Sequence(M.right_kernel().gen()), names)
con.point(F[0])
return con
F = Sequence(F, universe = base_field)
base_field = F.universe().fraction_field()
temp_ring = PolynomialRing(base_field, 3, names)
(x,y,z) = temp_ring.gens()
if len(F) == 3:
return Conic(F[0]*x**2 + F[1]*y**2 + F[2]*z**2)
if len(F) == 6:
return Conic(F[0]*x**2 + F[1]*x*y + F[2]*x*z + F[3]*y**2 + \
F[4]*y*z + F[5]*z**2)
raise TypeError, "F (=%s) must be a sequence of 3 or 6" \
"coefficients" % F
if is_QuadraticForm(F):
F = F.matrix()
if is_Matrix(F) and F.is_square() and F.ncols() == 3:
if names == None:
names = 'x,y,z'
temp_ring = PolynomialRing(F.base_ring(), 3, names)
F = vector(temp_ring.gens()) * F * vector(temp_ring.gens())
if not is_MPolynomial(F):
raise TypeError, "F (=%s) must be a three-variable polynomial or " \
"a sequence of points or coefficients" % F
if F.total_degree() != 2:
raise TypeError, "F (=%s) must have degree 2" % F
if base_field == None:
base_field = F.base_ring()
if not is_IntegralDomain(base_field):
raise ValueError, "Base field (=%s) must be a field" % base_field
base_field = base_field.fraction_field()
if names == None:
names = F.parent().variable_names()
pol_ring = PolynomialRing(base_field, 3, names)
if F.parent().ngens() == 2:
(x,y,z) = pol_ring.gens()
F = pol_ring(F(x/z,y/z)*z**2)
if F == 0:
raise ValueError, "F must be nonzero over base field %s" % base_field
if F.total_degree() != 2:
raise TypeError, "F (=%s) must have degree 2 over base field %s" % \
(F, base_field)
if F.parent().ngens() == 3:
P2 = ProjectiveSpace(2, base_field, names)
if is_PrimeFiniteField(base_field):
return ProjectiveConic_prime_finite_field(P2, F)
if is_FiniteField(base_field):
return ProjectiveConic_finite_field(P2, F)
if is_RationalField(base_field):
return ProjectiveConic_rational_field(P2, F)
if is_NumberField(base_field):
return ProjectiveConic_number_field(P2, F)
return ProjectiveConic_field(P2, F)
raise TypeError, "Number of variables of F (=%s) must be 2 or 3" % F
def Conic(base_field, F=None, names=None, unique=True):
r"""
Return the plane projective conic curve defined by ``F``
over ``base_field``.
The input form ``Conic(F, names=None)`` is also accepted,
in which case the fraction field of the base ring of ``F``
is used as base field.
INPUT:
- ``base_field`` -- The base field of the conic.
- ``names`` -- a list, tuple, or comma separated string
of three variable names specifying the names
of the coordinate functions of the ambient
space `\Bold{P}^3`. If not specified or read
off from ``F``, then this defaults to ``'x,y,z'``.
- ``F`` -- a polynomial, list, matrix, ternary quadratic form,
or list or tuple of 5 points in the plane.
If ``F`` is a polynomial or quadratic form,
then the output is the curve in the projective plane
defined by ``F = 0``.
If ``F`` is a polynomial, then it must be a polynomial
of degree at most 2 in 2 variables, or a homogeneous
polynomial in of degree 2 in 3 variables.
If ``F`` is a matrix, then the output is the zero locus
of `(x,y,z) F (x,y,z)^t`.
If ``F`` is a list of coefficients, then it has
length 3 or 6 and gives the coefficients of
the monomials `x^2, y^2, z^2` or all 6 monomials
`x^2, xy, xz, y^2, yz, z^2` in lexicographic order.
If ``F`` is a list of 5 points in the plane, then the output
is a conic through those points.
- ``unique`` -- Used only if ``F`` is a list of points in the plane.
If the conic through the points is not unique, then
raise ``ValueError`` if and only if ``unique`` is True
OUTPUT:
A plane projective conic curve defined by ``F`` over a field.
EXAMPLES:
Conic curves given by polynomials ::
sage: X,Y,Z = QQ['X,Y,Z'].gens()
sage: Conic(X^2 - X*Y + Y^2 - Z^2)
Projective Conic Curve over Rational Field defined by X^2 - X*Y + Y^2 - Z^2
sage: x,y = GF(7)['x,y'].gens()
sage: Conic(x^2 - x + 2*y^2 - 3, 'U,V,W')
Projective Conic Curve over Finite Field of size 7 defined by U^2 + 2*V^2 - U*W - 3*W^2
Conic curves given by matrices ::
sage: Conic(matrix(QQ, [[1, 2, 0], [4, 0, 0], [7, 0, 9]]), 'x,y,z')
Projective Conic Curve over Rational Field defined by x^2 + 6*x*y + 7*x*z + 9*z^2
sage: x,y,z = GF(11)['x,y,z'].gens()
sage: C = Conic(x^2+y^2-2*z^2); C
Projective Conic Curve over Finite Field of size 11 defined by x^2 + y^2 - 2*z^2
sage: Conic(C.symmetric_matrix(), 'x,y,z')
Projective Conic Curve over Finite Field of size 11 defined by x^2 + y^2 - 2*z^2
Conics given by coefficients ::
sage: Conic(QQ, [1,2,3])
Projective Conic Curve over Rational Field defined by x^2 + 2*y^2 + 3*z^2
sage: Conic(GF(7), [1,2,3,4,5,6], 'X')
Projective Conic Curve over Finite Field of size 7 defined by X0^2 + 2*X0*X1 - 3*X1^2 + 3*X0*X2 - 2*X1*X2 - X2^2
The conic through a set of points ::
sage: C = Conic(QQ, [[10,2],[3,4],[-7,6],[7,8],[9,10]]); C
Projective Conic Curve over Rational Field defined by x^2 + 13/4*x*y - 17/4*y^2 - 35/2*x*z + 91/4*y*z - 37/2*z^2
sage: C.rational_point()
(10 : 2 : 1)
sage: C.point([3,4])
(3 : 4 : 1)
sage: a=AffineSpace(GF(13),2)
sage: Conic([a([x,x^2]) for x in range(5)])
Projective Conic Curve over Finite Field of size 13 defined by x^2 - y*z
"""
if not (is_IntegralDomain(base_field) or base_field == None):
if names is None:
names = F
F = base_field
base_field = None
if isinstance(F, (list,tuple)):
if len(F) == 1:
return Conic(base_field, F[0], names)
if names == None:
names = 'x,y,z'
if len(F) == 5:
L=[]
for f in F:
if isinstance(f, SchemeMorphism_point_affine):
C = Sequence(f, universe = base_field)
if len(C) != 2:
raise TypeError, "points in F (=%s) must be planar"%F
C.append(1)
elif isinstance(f, SchemeMorphism_point_projective_field):
C = Sequence(f, universe = base_field)
elif isinstance(f, (list, tuple)):
C = Sequence(f, universe = base_field)
if len(C) == 2:
C.append(1)
else:
raise TypeError, "F (=%s) must be a sequence of planar " \
"points" % F
if len(C) != 3:
raise TypeError, "points in F (=%s) must be planar" % F
P = C.universe()
if not is_IntegralDomain(P):
raise TypeError, "coordinates of points in F (=%s) must " \
"be in an integral domain" % F
L.append(Sequence([C[0]**2, C[0]*C[1], C[0]*C[2], C[1]**2,
C[1]*C[2], C[2]**2], P.fraction_field()))
M=Matrix(L)
if unique and M.rank() != 5:
raise ValueError, "points in F (=%s) do not define a unique " \
"conic" % F
con = Conic(base_field, Sequence(M.right_kernel().gen()), names)
con.point(F[0])
return con
F = Sequence(F, universe = base_field)
base_field = F.universe().fraction_field()
temp_ring = PolynomialRing(base_field, 3, names)
(x,y,z) = temp_ring.gens()
if len(F) == 3:
return Conic(F[0]*x**2 + F[1]*y**2 + F[2]*z**2)
if len(F) == 6:
return Conic(F[0]*x**2 + F[1]*x*y + F[2]*x*z + F[3]*y**2 + \
F[4]*y*z + F[5]*z**2)
raise TypeError, "F (=%s) must be a sequence of 3 or 6" \
"coefficients" % F
if is_QuadraticForm(F):
F = F.matrix()
if is_Matrix(F) and F.is_square() and F.ncols() == 3:
if names == None:
names = 'x,y,z'
temp_ring = PolynomialRing(F.base_ring(), 3, names)
F = vector(temp_ring.gens()) * F * vector(temp_ring.gens())
if not is_MPolynomial(F):
raise TypeError, "F (=%s) must be a three-variable polynomial or " \
"a sequence of points or coefficients" % F
if F.total_degree() != 2:
raise TypeError, "F (=%s) must have degree 2" % F
if base_field == None:
base_field = F.base_ring()
if not is_IntegralDomain(base_field):
raise ValueError, "Base field (=%s) must be a field" % base_field
base_field = base_field.fraction_field()
if names == None:
names = F.parent().variable_names()
pol_ring = PolynomialRing(base_field, 3, names)
if F.parent().ngens() == 2:
(x,y,z) = pol_ring.gens()
F = pol_ring(F(x/z,y/z)*z**2)
if F == 0:
raise ValueError, "F must be nonzero over base field %s" % base_field
if F.total_degree() != 2:
raise TypeError, "F (=%s) must have degree 2 over base field %s" % \
(F, base_field)
if F.parent().ngens() == 3:
P2 = ProjectiveSpace(2, base_field, names)
if is_PrimeFiniteField(base_field):
return ProjectiveConic_prime_finite_field(P2, F)
if is_FiniteField(base_field):
return ProjectiveConic_finite_field(P2, F)
if is_RationalField(base_field):
return ProjectiveConic_rational_field(P2, F)
if is_NumberField(base_field):
return ProjectiveConic_number_field(P2, F)
return ProjectiveConic_field(P2, F)
raise TypeError, "Number of variables of F (=%s) must be 2 or 3" % F
class HarmonicCocycles(AmbientHeckeModule):
Element=HarmonicCocycleElement
r"""
This object represents a space of Gamma invariant harmonic cocycles valued in
a cofficient module.
INPUT:
- ``X`` - A BTQuotient object
- ``k`` - integer - The weight.
- ``prec`` - integer (Default: None). If specified, the precision for the coefficient module
- ``basis_matrix`` - integer (Default: None)
- ``base_field`` - (Default: None)
EXAMPLES:
::
AUTHORS:
- Cameron Franc (2012-02-20)
- Marc Masdeu
"""
def __init__(self,X,k,prec=None,basis_matrix=None,base_field=None):
self._k=k
self._X=X
self._E=self._X.get_edge_list()
self._V=self._X.get_vertex_list()
if prec is None:
self._prec=None
if base_field is None:
try:
self._R= X.get_splitting_field()
except AttributeError:
raise ValueError, "It looks like you are not using Magma as backend...and still we don't know how to compute splittings in that case!"
else:
pol=X.get_splitting_field().defining_polynomial().factor()[0][0]
self._R=base_field.extension(pol,pol.variable_name()).absolute_field(name='r')
self._U=OCVn(self._k-2,self._R)
else:
self._prec=prec
if base_field is None:
self._R=Qp(self._X._p,prec=prec)
else:
self._R=base_field
self._U=OCVn(self._k-2,self._R,self._k-1)
self.__rank = self._X.dimension_harmonic_cocycles(self._k)
if basis_matrix is not None:
self.__matrix=basis_matrix
self.__matrix.set_immutable()
assert self.__rank == self.__matrix.nrows()
AmbientHeckeModule.__init__(self, self._R, self.__rank, self._X.prime()*self._X.Nplus()*self._X.Nminus(), weight=self._k)
self._populate_coercion_lists_()
def base_extend(self,base_ring):
r"""
This function extends the base ring of the coefficient module.
INPUT:
- ``base_ring`` - a ring that has a coerce map from the current base ring
EXAMPLES:
::
"""
if not base_ring.has_coerce_map_from(self.base_ring()):
raise ValueError, "No coercion defined"
else:
return self.change_ring(base_ring)
def change_ring(self, new_base_ring):
r"""
This function changes the base ring of the coefficient module.
INPUT:
- ``new_base_ring'' - a ring that has a coerce map from the current base ring
EXAMPLES:
::
"""
if not new_base_ring.has_coerce_map_from(self.base_ring()):
raise ValueError, "No coercion defined"
else:
return self.__class__(self._X,self._k,prec=self._prec,basis_matrix=self.basis_matrix().change_ring(base_ring),base_field=new_base_ring)
def rank(self):
r"""
The rank (dimension) of ``self``.
EXAMPLES:
::
"""
return self.__rank
def submodule(self,v,check=False):
r"""
Return the submodule of ``self`` spanned by ``v``.
EXAMPLES:
"""
return HarmonicCocyclesSubmodule(self,v,dual=None,check=check)
def is_simple(self):
r"""
Whether ``self`` is irreducible.
EXAMPLES:
::
"""
return self.rank()==1
def _repr_(self):
r"""
This returns the representation of self as a string.
"""
return 'Space of harmonic cocycles of weight %s on %s'%(self._k,self._X)
def _latex_(self):
r"""
A LaTeX representation of ``self``.
EXAMPLES:
::
"""
s='\\text{Space of harmonic cocycles of weight }'+latex(self._k)+'\\text{ on }'+latex(self._X)
return s
def _an_element_(self):
r"""
"""
return self.basis()[0]
def _coerce_map_from_(self, S):
r"""
Can coerce from other HarmonicCocycles or from pAutomorphicForms
"""
if isinstance(S,(HarmonicCocycles,pAutomorphicForms)):
if(S._k!=self._k):
return False
if(S._X!=self._X):
return False
return True
return False
def __cmp__(self,other):
r"""
"""
try:
res=(self.base_ring()==other.base_ring() and self._X==other._X and self._k==other._k)
return res
except:
return False
def _element_constructor_(self,x):
r"""
"""
#Code how to coherce x into the space
#Admissible values of x?
if isinstance(x,HarmonicCocycleElement):
return HarmonicCocycleElement(self,x)
elif isinstance(x,pAutomorphicForm):
tmp=[self._U.element_class(_parent._U,x._F[ii]).l_act_by(self._E[ii].rep) for ii in range(self._nE)]
return HarmonicCocycleElement(self,tmp,from_values=True)
else:
return HarmonicCocycleElement(self,x)
def free_module(self):
r"""
This function returns the underlying free module
EXAMPLES:
::
"""
try: return self.__free_module
except AttributeError: pass
V = self.base_ring()**self.dimension()
self.__free_module = V
return V
def character(self):
r"""
Only implemented the trivial character so far.
EXAMPLES:
"""
return lambda x:x
def embed_quaternion(self,g):
r"""
Embed the quaternion element ``g`` into the matrix algebra.
EXAMPLES:
::
"""
return self._X.embed_quaternion(g,exact = self._R.is_exact(), prec = self._prec)
def basis_matrix(self):
r"""
Returns a basis of ``self`` in matrix form.
If the coefficient module `M` is of finite rank then the space of Gamma invariant
`M` valued harmonic cocycles can be represented as a subspace of the finite rank
space of all functions from the finitely many edges in the corresponding
BTQuotient into `M`. This function computes this representation of the space of
cocycles.
OUTPUT:
A basis matrix describing the cocycles in the spaced of all `M` valued Gamma
invariant functions on the tree.
EXAMPLES:
::
sage: X = BTQuotient(3,19)
sage: C = HarmonicCocycles(X,4,prec = 5)
sage: B = C.basis()
Traceback (most recent call last):
...
RuntimeError: The computed dimension does not agree with the expectation. Consider increasing precision!
We try increasing the precision:
::
sage: C = HarmonicCocycles(X,4,prec = 20)
sage: B = C.basis()
sage: len(B) == X.dimension_harmonic_cocycles(4)
True
AUTHORS:
- Cameron Franc (2012-02-20)
- Marc Masdeu (2012-02-20)
"""
try: return self.__matrix
except AttributeError: pass
nV=len(self._V)
nE=len(self._E)
stab_conds=[]
S=self._X.get_edge_stabs()
p=self._X._p
d=self._k-1
for e in self._E:
try:
g=filter(lambda g:g[2],S[e.label])[0]
C=self._U.l_matrix_representation(self.embed_quaternion(g[0]))
C-=self._U.l_matrix_representation(Matrix(QQ,2,2,p**g[1]))
stab_conds.append([e.label,C])
except IndexError: pass
n_stab_conds=len(stab_conds)
self._M=Matrix(self._R,(nV+n_stab_conds)*d,nE*d,0,sparse=True)
for v in self._V:
for e in filter(lambda e:e.parity==0,v.leaving_edges):
C=sum([self._U.l_matrix_representation(self.embed_quaternion(x[0])) for x in e.links],Matrix(self._R,d,d,0))
self._M.set_block(v.label*d,e.label*d,C)
for e in filter(lambda e:e.parity==0,v.entering_edges):
C=sum([self._U.l_matrix_representation(self.embed_quaternion(x[0])) for x in e.opposite.links],Matrix(self._R,d,d,0))
self._M.set_block(v.label*d,e.opposite.label*d,C)
for kk in range(n_stab_conds):
v=stab_conds[kk]
self._M.set_block((nV+kk)*d,v[0]*d,v[1])
x1=self._M.right_kernel().matrix()
if x1.nrows() != self.rank():
raise RuntimeError, 'The computed dimension does not agree with the expectation. Consider increasing precision!'
K=[c for c in x1.rows()]
if not self._R.is_exact():
for ii in range(len(K)):
s=min([t.valuation() for t in K[ii]])
for jj in range(len(K[ii])):
K[ii][jj]=(p**(-s))*K[ii][jj]
self.__matrix=Matrix(self._R,len(K),nE*d,K)
self.__matrix.set_immutable()
return self.__matrix
def __apply_atkin_lehner(self,q,f):
r"""
This function applies an Atkin-Lehner involution to a harmonic cocycle
INPUT:
- ``q`` - an integer dividing the full level p*Nminus*Nplus
- ``f`` - a harmonic cocycle
OUTPUT:
The harmonic cocycle obtained by hitting f with the Atkin-Lehner at q
EXAMPLES:
::
"""
R=self._R
Data=self._X._get_atkin_lehner_data(q)
p=self._X._p
tmp=[self._U.element_class(self._U,zero_matrix(self._R,self._k-1,1),quick=True) for jj in range(len(self._E))]
d1=Data[1]
mga=self.embed_quaternion(Data[0])
for jj in range(len(self._E)):
t=d1[jj]
tmp[jj]+=(t.sign()*f._F[t.label]).l_act_by(p**(-t.power)*mga*t.igamma(self.embed_quaternion))
return HarmonicCocycleElement(self,tmp,from_values=True)
def __apply_hecke_operator(self,l,f):
r"""
This function applies a Hecke operator to a harmonic cocycle.
INPUT:
- ``l`` - an integer
- ``f`` - a harmonic cocycle
OUTPUT:
A harmonic cocycle which is the result of applying the lth Hecke operator
to f
EXAMPLES:
::
"""
R=self._R
HeckeData,alpha=self._X._get_hecke_data(l)
if(self.level()%l==0):
factor=QQ(l**(Integer((self._k-2)/2))/(l+1))
else:
factor=QQ(l**(Integer((self._k-2)/2)))
p=self._X._p
alphamat=self.embed_quaternion(alpha)
tmp=[self._U.element_class(self._U,zero_matrix(self._R,self._k-1,1),quick=True) for jj in range(len(self._E))]
for ii in range(len(HeckeData)):
d1=HeckeData[ii][1]
mga=self.embed_quaternion(HeckeData[ii][0])*alphamat
for jj in range(len(self._E)):
t=d1[jj]
tmp[jj]+=(t.sign()*f._F[t.label]).l_act_by(p**(-t.power)*mga*t.igamma(self.embed_quaternion))
return HarmonicCocycleElement(self,[factor*x for x in tmp],from_values=True)
def _compute_atkin_lehner_matrix(self,d):
r"""
When the underlying coefficient module is finite, this function computes the
matrix of an Atkin-Lehner involution in the basis provided by the function
basis_matrix
INPUT:
- ``d`` - an integer dividing p*Nminus*Nplus
OUTPUT:
The matrix of the AL-involution at d in the basis given by self.basis_matrix
EXAMPLES:
::
"""
res=self.__compute_operator_matrix(lambda f:self.__apply_atkin_lehner(d,f))
return res
def _compute_hecke_matrix_prime(self,l):
r"""
When the underlying coefficient module is finite, this function computes the
matrix of a (prime) Hecke operator in the basis provided by the function
basis_matrix
INPUT:
- ``l`` - an integer prime
OUTPUT:
The matrix of T_l acting on the cocycles in the basis given by
self.basis_matrix
EXAMPLES:
::
"""
res=self.__compute_operator_matrix(lambda f:self.__apply_hecke_operator(l,f))
return res
def __compute_operator_matrix(self,T):
r"""
Compute the matrix of the operator ``T``.
EXAMPLES:
::
"""
R=self._R
A=self.basis_matrix().transpose()
basis=self.basis()
B=zero_matrix(R,len(self._E)*(self._k-1),self.dimension())
for rr in range(len(basis)):
g=T(basis[rr])
B.set_block(0,rr,Matrix(R,len(self._E)*(self._k-1),1,[g._F[e]._val[ii,0] for e in range(len(self._E)) for ii in range(self._k-1) ]))
try:
res=(A.solve_right(B)).transpose()
res.set_immutable()
return res
except ValueError:
print A
print B
raise ValueError
def run_tests(num_to_check=10, smaller_num_to_check = 10):
import taut
veering_isosigs = parse_data_file("Data/veering_census.txt")
print("testing is_taut")
for sig in random.sample(veering_isosigs, num_to_check):
tri, angle = taut.isosig_to_tri_angle(sig)
assert taut.is_taut(tri, angle), sig
print("testing isosig round trip")
for sig in random.sample(veering_isosigs, num_to_check):
tri, angle = taut.isosig_to_tri_angle(sig)
recovered_sig = taut.isosig_from_tri_angle(tri, angle)
assert sig == recovered_sig, sig
# we only test this round trip - the other round trip does not
# make sense because tri->isosig is many to one.
import transverse_taut
print("testing is_transverse_taut")
for sig in random.sample(veering_isosigs, num_to_check):
tri, angle = taut.isosig_to_tri_angle(sig)
assert transverse_taut.is_transverse_taut(tri, angle), sig
non_transverse_taut_isosigs = parse_data_file("Data/veering_non_transverse_taut_examples.txt")
print("testing not is_transverse_taut")
for sig in non_transverse_taut_isosigs:
tri, angle = taut.isosig_to_tri_angle(sig)
assert not transverse_taut.is_transverse_taut(tri, angle), sig
import veering
print("testing is_veering")
for sig in random.sample(veering_isosigs, num_to_check):
tri, angle = taut.isosig_to_tri_angle(sig)
assert veering.is_veering(tri, angle), sig
# tri, angle = taut.isosig_to_tri_angle("cPcbbbdxm_10")
# explore_mobius_surgery_graph(tri, angle, max_tetrahedra = 12)
# # tests to see that it makes only veering triangulations as it goes
import veering_dehn_surgery
print("testing veering_dehn_surgery")
for sig in random.sample(veering_isosigs, num_to_check):
tri, angle = taut.isosig_to_tri_angle(sig)
for face_num in veering_dehn_surgery.get_mobius_strip_indices(tri):
(tri_s, angle_s, face_num_s) = veering_dehn_surgery.veering_mobius_dehn_surgery(tri, angle, face_num)
assert veering.is_veering(tri_s, angle_s), sig
import veering_fan_excision
print("testing veering_fan_excision")
m003, _ = taut.isosig_to_tri_angle('cPcbbbdxm_10')
m004, _ = taut.isosig_to_tri_angle('cPcbbbiht_12')
for sig in random.sample(veering_isosigs, num_to_check):
tri, angle = taut.isosig_to_tri_angle(sig)
tet_types = veering.is_veering(tri, angle, return_type = "tet_types")
if tet_types.count("toggle") == 2:
excised_tri, _ = veering_fan_excision.excise_fans(tri, angle)
assert ( excised_tri.isIsomorphicTo(m003) != None or
excised_tri.isIsomorphicTo(m004) != None ), sig
import pachner
print("testing pachner with taut structure")
for sig in random.sample(veering_isosigs, num_to_check):
tri, angle = taut.isosig_to_tri_angle(sig)
face_num = random.randrange(tri.countTriangles())
result = pachner.twoThreeMove(tri, face_num, angle = angle, return_edge = True)
if result != False:
tri2, angle2, edge_num = result
tri3, angle3 = pachner.threeTwoMove(tri2, edge_num, angle = angle2)
assert taut.isosig_from_tri_angle(tri, angle) == taut.isosig_from_tri_angle(tri3, angle3), sig
import branched_surface
import regina
print("testing branched_surface and pachner with branched surface")
for sig in random.sample(veering_isosigs, num_to_check):
tri, angle = taut.isosig_to_tri_angle(sig)
tri_original = regina.Triangulation3(tri) #copy
branch = branched_surface.upper_branched_surface(tri, angle, return_lower = random.choice([True, False]))
### test branch isosig round trip
sig_with_branch = branched_surface.isosig_from_tri_angle_branch(tri, angle, branch)
tri2, angle2, branch2 = branched_surface.isosig_to_tri_angle_branch(sig_with_branch)
assert (branch == branch2) and (angle == angle2), sig
branch_original = branch[:] #copy
face_num = random.randrange(tri.countTriangles())
out = pachner.twoThreeMove(tri, face_num, branch = branch, return_edge = True)
if out != False:
tri, possible_branches, edge_num = out
tri, branch = pachner.threeTwoMove(tri, edge_num, branch = possible_branches[0])
all_isoms = tri.findAllIsomorphisms(tri_original)
all_branches = [branched_surface.apply_isom_to_branched_surface(branch, isom) for isom in all_isoms]
assert branch_original in all_branches, sig
import flow_cycles
import drill
print("testing taut and branched drill + semiflows on drillings")
for sig in random.sample(veering_isosigs, smaller_num_to_check):
tri, angle = taut.isosig_to_tri_angle(sig)
branch = branched_surface.upper_branched_surface(tri, angle) ### also checks for veering and transverse taut
found_loops = flow_cycles.find_flow_cycles(tri, branch)
for loop in random.sample(found_loops, min(len(found_loops), 5)): ## drill along at most 5 loops
tri, angle = taut.isosig_to_tri_angle(sig)
branch = branched_surface.upper_branched_surface(tri, angle)
tri_loop = flow_cycles.flow_cycle_to_triangle_loop(tri, branch, loop)
if tri_loop != False:
if not flow_cycles.tri_loop_is_boundary_parallel(tri_loop, tri):
drill.drill(tri, tri_loop, angle = angle, branch = branch, sig = sig)
assert branched_surface.has_non_sing_semiflow(tri, branch), sig
print("all basic tests passed")
try:
import snappy
import snappy_util
snappy_working = True
except:
print("failed to import from snappy?")
snappy_working = False
if snappy_working:
print("testing algebraic intersection")
census = snappy.OrientableCuspedCensus() # not a set or list, so can't use random.sample
for i in range(10):
M = random.choice(census)
n = M.num_cusps()
peripheral_curves = M.gluing_equations()[-2*n:]
for i in range(2*n):
for j in range(i, 2*n):
alg_int = snappy_util.algebraic_intersection(peripheral_curves[i], peripheral_curves[j])
if i % 2 == 0 and j == i + 1:
assert alg_int == 1, M.name()
else:
assert alg_int == 0, M.name()
if snappy_working:
import veering_drill_midsurface_bdy
print("testing veering drilling and filling")
for sig in random.sample(veering_isosigs[:3000], num_to_check):
T, per = veering_drill_midsurface_bdy.drill_midsurface_bdy(sig)
M = snappy.Manifold(T.snapPea())
M.set_peripheral_curves("shortest")
L = snappy_util.get_slopes_from_peripherals(M, per)
M.dehn_fill(L)
N = snappy.Manifold(sig.split("_")[0])
assert M.is_isometric_to(N), sig
if snappy_working:
print("all tests depending on snappy passed")
# try:
# from hashlib import md5
# from os import remove
# import pyx
# from boundary_triangulation import draw_triangulation_boundary_from_veering_isosig
# pyx_working = True
# except:
# print("failed to import from pyx?")
# pyx_working = False
# ladders_style_sigs = {
# "cPcbbbiht_12": "f34c1fdf65db9d02994752814803ae01",
# "gLLAQbecdfffhhnkqnc_120012": "091c85b4f4877276bfd8a955b769b496",
# "kLALPPzkcbbegfhgijjhhrwaaxnxxn_1221100101": "a0f15a8454f715f492c74ce1073a13a4",
# }
# geometric_style_sigs = {
# "cPcbbbiht_12": "1e74d0b68160c4922e85a5adb20a0f1d",
# "gLLAQbecdfffhhnkqnc_120012": "856a1fce74eb64f519bcda083303bd8f",
# "kLALPPzkcbbegfhgijjhhrwaaxnxxn_1221100101": "33bd23b34c5d977a103fa50ffe63120a",
# }
# args = {
# "draw_boundary_triangulation":True,
# "draw_triangles_near_poles": False,
# "ct_depth":-1,
# "ct_epsilon":0.03,
# "global_drawing_scale": 4,
# "delta": 0.2,
# "ladder_width": 10.0,
# "ladder_height": 20.0,
# "draw_labels": True,
# }
# shapes_data = read_from_pickle("Data/veering_shapes_up_to_ten_tetrahedra.pkl")
# if pyx_working:
# for sig in ladders_style_sigs:
# print("testing boundary triangulation pictures, ladder style", sig)
# args["tet_shapes"] = shapes_data[sig]
# args["style"] = "ladders"
# file_name = draw_triangulation_boundary_from_veering_isosig(sig, args = args)
# f = open(file_name, "rb")
# file_hash = md5(f.read())
# assert file_hash.hexdigest() == ladders_style_sigs[sig]
# f.close()
# remove(file_name)
# if pyx_working:
# for sig in geometric_style_sigs:
# print("testing boundary triangulation pictures, ladder style", sig)
# args["tet_shapes"] = shapes_data[sig]
# args["style"] = "geometric"
# file_name = draw_triangulation_boundary_from_veering_isosig(sig, args = args)
# f = open(file_name, "rb")
# file_hash = md5(f.read())
# assert file_hash.hexdigest() == geometric_style_sigs[sig]
# f.close()
# remove(file_name)
# if pyx_working:
# print("all tests depending on pyx passed")
veering_polys = {
"cPcbbbiht_12": [-4, -1, 1, 4],
"eLMkbcddddedde_2100": [-2, -2, -2, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 2, 2],
"gLLAQbecdfffhhnkqnc_120012": [-1, -1, -1, -1, 1, 1, 1, 1],
"gLLPQcdfefefuoaaauo_022110": [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1],
}
# veering_polys = { ### old
# "cPcbbbiht_12": "a^3 - 4*a^2 + 4*a - 1",
# "eLMkbcddddedde_2100": "a^6*b - a^6 - 2*a^5*b - a^4*b^2 + a^5 + 2*a^4*b + a^3*b^2 - 2*a^3*b + a^3 + 2*a^2*b + a*b^2 - a^2 - 2*a*b - b^2 + b",
# "gLLAQbecdfffhhnkqnc_120012": "a^7 + a^6 + a^5 + a^4 - a^3 - a^2 - a - 1",
# "gLLPQcdfefefuoaaauo_022110": "a^12*b^3 - a^11*b^2 - a^10*b^3 - a^10*b^2 - a^7*b^3 - a^7*b^2 - a^6*b^3 + a^7*b + a^5*b^2 - a^6 - a^5*b - a^5 - a^2*b - a^2 - a*b + 1",
# }
taut_polys = {
"cPcbbbiht_12": [-3, 1, 1],
"eLMkbcddddedde_2100": [-1, -1, -1, 1, 1],
"iLLAwQcccedfghhhlnhcqeesr_12001122": [],
}
# taut_polys = { ### old
# "cPcbbbiht_12": "a^2 - 3*a + 1",
# "eLMkbcddddedde_2100": "a^2*b - a^2 - a*b - b^2 + b",
# "iLLAwQcccedfghhhlnhcqeesr_12001122": "0",
# }
torus_bundles = [
"cPcbbbiht_12",
"eLMkbcdddhhqqa_1220",
"gLMzQbcdefffhhqqqdl_122002",
]
measured = [
"gLLAQbecdfffhhnkqnc_120012",
"iLLALQcccedhgghhlnxkxrkaa_12001112",
"iLLAwQcccedfghhhlnhcqeesr_12001122",
]
empties = [
"fLAMcaccdeejsnaxk_20010",
"gLALQbcbeeffhhwsras_211220",
"hLALAkbcbeefgghhwsraqj_2112202",
]
try:
from sage.rings.integer_ring import ZZ
sage_working = True
except:
print("failed to import from sage?")
sage_working = False
if sage_working:
import taut_polytope
print("testing is_layered")
for sig in veering_isosigs[:17]:
assert taut_polytope.is_layered(sig), sig
for sig in veering_isosigs[17:21]:
assert not taut_polytope.is_layered(sig), sig
if sage_working:
import fibered
print("testing is_fibered")
mflds = parse_data_file("Data/mflds_which_fiber.txt")
mflds = [line.split("\t")[0:2] for line in mflds]
for (name, kind) in random.sample(mflds, num_to_check):
assert fibered.is_fibered(name) == (kind == "fibered"), name
if sage_working:
import veering_polynomial
import taut_polynomial
print("testing veering poly")
for sig in veering_polys:
p = veering_polynomial.veering_polynomial(sig)
assert check_polynomial_coefficients(p, veering_polys[sig]), sig
### Nov 2021: sage 9.4 changed how smith normal form works, which changed our polynomials
### to equivalent but not equal polynomials. To avoid this kind of change breaking things
### in the future, we changed to comparing the list of coefficients.
# assert p.__repr__() == veering_polys[sig]
print("testing taut poly")
for sig in taut_polys:
p = taut_polynomial.taut_polynomial_via_tree(sig)
assert check_polynomial_coefficients(p, taut_polys[sig]), sig
# assert p.__repr__() == taut_polys[sig]
print("testing divide")
for sig in random.sample(veering_isosigs[:3000], num_to_check):
p = veering_polynomial.veering_polynomial(sig)
q = taut_polynomial.taut_polynomial_via_tree(sig)
if q == 0:
assert p == 0, sig
else:
assert q.divides(p), sig
if sage_working:
print("testing alex")
for sig in random.sample(veering_isosigs[:3000], num_to_check):
snap_sig = sig.split("_")[0]
M = snappy.Manifold(snap_sig)
if M.homology().betti_number() == 1:
assert taut_polynomial.taut_polynomial_via_tree(sig, mode = "alexander") == M.alexander_polynomial(), sig
if sage_working:
# would be nice to automate this - need to fetch the angle
# structure say via z_charge.py...
print("testing is_torus_bundle")
for sig in torus_bundles:
assert taut_polytope.is_torus_bundle(sig), sig
if sage_working:
# ditto
print("testing is_layered")
for sig in torus_bundles:
assert taut_polytope.is_layered(sig), sig
print("testing measured")
for sig in measured:
assert taut_polytope.LMN_tri_angle(sig) == "M", sig
print("testing empty")
for sig in empties:
assert taut_polytope.LMN_tri_angle(sig) == "N", sig
if sage_working: # warning - this takes random amounts of time!
print("testing hom dim")
for sig in random.sample(veering_isosigs[:3000], 3): # magic number
# dimension = zero if and only if nothing is carried.
assert (taut_polytope.taut_cone_homological_dim(sig) == 0) == (taut_polytope.LMN_tri_angle(sig) == "N"), sig
if sage_working:
boundary_cycles = {
("eLMkbcddddedde_2100",(2,5,5,1,3,4,7,1)): "((-7, -7, 0, 0, 4, -3, 7, 0), (7, 7, 0, 0, -4, 3, -7, 0))",
("iLLLQPcbeegefhhhhhhahahha_01110221",(0,1,0,0,0,1,0,0,0,0,0,0,1,0,1,0)): "((0, 0, -1, 1, 1, 0, 1, 1, -1, 0, 0, 0, 0, 1, 0, 1), (0, 0, 1, -1, -1, 0, -1, -1, 1, 0, 0, 0, 0, -1, 0, -1))",
("ivvPQQcfhghgfghfaaaaaaaaa_01122000",(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1)): "((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2), (1, 1, 0, 2, -1, 0, -3, 1, 2, -1, -2, 0, 3, -2, -1, 0), (-2, 0, -3, 1, 2, -1, 0, 2, -1, 0, 3, 1, -2, 1, 0, -1), (0, -2, 1, -3, 0, -1, 2, 0, -1, 2, -1, 1, 0, 1, -2, 3))",
}
taut_polys_with_cycles = {
("eLMkbcddddedde_2100", ((7, 7, 0, 0, -4, 3, -7, 0),)): [-1, -1, -1, 1, 1],
("iLLLQPcbeegefhhhhhhahahha_01110221", ((0, 0, 1, -1, -1, 0, -1, -1, 1, 0, 0, 0, 0, -1, 0, -1),)): [1, 1, 2],
("ivvPQQcfhghgfghfaaaaaaaaa_01122000", ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2), (1, 1, 0, 2, -1, 0, -3, 1, 2, -1, -2, 0, 3, -2, -1, 0))): [-4, -1, -1, 1, 1],
}
# taut_polys_with_cycles = {
# ("eLMkbcddddedde_2100", ((7, 7, 0, 0, -4, 3, -7, 0),)): "a^14 - a^8 - a^7 - a^6 + 1",
# ("iLLLQPcbeegefhhhhhhahahha_01110221", ((0, 0, 1, -1, -1, 0, -1, -1, 1, 0, 0, 0, 0, -1, 0, -1),)): "a^2 + 2*a + 1",
# ("ivvPQQcfhghgfghfaaaaaaaaa_01122000", ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2), (1, 1, 0, 2, -1, 0, -3, 1, 2, -1, -2, 0, 3, -2, -1, 0))): "a*b^2 - a^2 - 4*a*b - b^2 + a",
# }
taut_polys_image = {
('eLMkbcddddedde_2100', ((7, 8, -1, 0, -4, 4, -8, 0),)):[-1, -1, -1, 1, 1],
('ivvPQQcfhghgfghfaaaaaaaaa_01122000', ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2),)):[-2, -2, -1, -1, 1, 1],
('ivvPQQcfhghgfghfaaaaaaaaa_01122000', ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2), (1, 1, 0, 2, -1, 0, -3, 1, 2, -1, -2, 0, 3, -2, -1, 0))):[-4, -1, -1, 1, 1]
}
# taut_polys_image = {
# ('eLMkbcddddedde_2100', ((7, 8, -1, 0, -4, 4, -8, 0),)):"a^16 - a^9 - a^8 - a^7 + 1",
# ('ivvPQQcfhghgfghfaaaaaaaaa_01122000', ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2),)):"a*b^2*c - 2*a*b*c - b^2*c - a^2 - 2*a*b + a",
# ('ivvPQQcfhghgfghfaaaaaaaaa_01122000', ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2), (1, 1, 0, 2, -1, 0, -3, 1, 2, -1, -2, 0, 3, -2, -1, 0))):"a*b^2 - a^2 - 4*a*b - b^2 + a"
# }
alex_polys_with_cycles = {
("eLMkbcddddedde_2100",((7, 7, 0, 0, -4, 3, -7, 0),)): [-2, -1, -1, -1, 1, 1, 1, 2],
("iLLLQPcbeegefhhhhhhahahha_01110221", ((0, 0, 1, -1, -1, 0, -1, -1, 1, 0, 0, 0, 0, -1, 0, -1),)): [-3, -1, 1, 3],
("ivvPQQcfhghgfghfaaaaaaaaa_01122000", ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2), (1, 1, 0, 2, -1, 0, -3, 1, 2, -1, -2, 0, 3, -2, -1, 0))): [-1, -1, 1, 1],
}
# alex_polys_with_cycles = {
# ("eLMkbcddddedde_2100",((7, 7, 0, 0, -4, 3, -7, 0),)): "a^15 - a^14 + a^9 - 2*a^8 + 2*a^7 - a^6 + a - 1",
# ("iLLLQPcbeegefhhhhhhahahha_01110221", ((0, 0, 1, -1, -1, 0, -1, -1, 1, 0, 0, 0, 0, -1, 0, -1),)): "3*a^3 - a^2 + a - 3",
# ("ivvPQQcfhghgfghfaaaaaaaaa_01122000", ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2), (1, 1, 0, 2, -1, 0, -3, 1, 2, -1, -2, 0, 3, -2, -1, 0))): "a*b^2 - a^2 - b^2 + a",
# }
if sage_working:
import taut_carried
print("testing boundary cycles")
for sig, surface in boundary_cycles:
surface_list = list(surface)
cycles = taut_carried.boundary_cycles_from_surface(sig, surface_list)
cycles = tuple(tuple(cycle) for cycle in cycles)
assert cycles.__repr__() == boundary_cycles[(sig, surface)], sig
if sage_working:
print("testing taut with cycles")
for sig, cycles in taut_polys_with_cycles:
cycles_in = [list(cycle) for cycle in cycles]
p = taut_polynomial.taut_polynomial_via_tree(sig, cycles_in)
assert check_polynomial_coefficients(p, taut_polys_with_cycles[(sig, cycles)]), sig
# assert p.__repr__() == taut_polys_with_cycles[(sig, cycles)]
if sage_working:
print("testing taut with images")
for sig, cycles in taut_polys_image:
cycles_in = [list(cycle) for cycle in cycles]
p = taut_polynomial.taut_polynomial_image(sig, cycles_in)
assert check_polynomial_coefficients(p, taut_polys_image[(sig, cycles)]), sig
# assert p.__repr__() == taut_polys_image[(sig, cycles)]
if sage_working:
print("testing alex with cycles")
for sig, cycles in alex_polys_with_cycles:
cycles_in = [list(cycle) for cycle in cycles]
p = taut_polynomial.taut_polynomial_via_tree(sig, cycles_in, mode = "alexander")
assert check_polynomial_coefficients(p, alex_polys_with_cycles[(sig, cycles)]), sig
# assert p.__repr__() == alex_polys_with_cycles[(sig, cycles)]
if sage_working:
import edge_orientability
import taut_euler_class
print("testing euler and edge orientability")
for sig in random.sample(veering_isosigs[:3000], 3):
# Theorem: If (tri, angle) is edge orientable then e = 0.
assert not ( edge_orientability.is_edge_orientable(sig) and
(taut_euler_class.order_of_euler_class_wrapper(sig) == 2) ), sig
if sage_working:
# Theorem: If (tri, angle) is edge orientable then taut poly = alex poly.
# taut_polynomial.taut_polynomial_via_tree(sig, mode = "alexander") ==
# taut_polynomial.taut_polynomial_via_tree(sig, mode = "taut")
pass
if sage_working:
print("testing exotics")
for sig in random.sample(veering_isosigs[:3000], 3):
tri, angle = taut.isosig_to_tri_angle(sig)
T = veering.veering_triangulation(tri, angle)
is_eo = T.is_edge_orientable()
for angle in T.exotic_angles():
assert taut_polytope.taut_cone_homological_dim(tri, angle) == 0, sig
assert is_eo == transverse_taut.is_transverse_taut(tri, angle), sig
### test for drill_midsurface_bdy: drill then fill, check you get the same manifold
if sage_working:
from sage.combinat.words.word_generators import words
from sage.modules.free_module_integer import IntegerLattice
from sage.modules.free_module import VectorSpace
from sage.matrix.constructor import Matrix
import z_charge
import z2_taut
import regina
ZZ2 = ZZ.quotient(ZZ(2))
sig_starts = ["b+-LR", "b++LR"]
print("testing lattice for punc torus bundle")
for i in range(3):
for sig_start in sig_starts:
sig = sig_start + str(words.RandomWord(8, 2, "LR")) # 8 is a magic number
M = snappy.Manifold(sig)
tri = regina.Triangulation3(M)
t, A = z_charge.sol_and_kernel(M)
B = z_charge.leading_trailing_deformations(M)
C = z2_taut.cohomology_loops(tri)
AA = IntegerLattice(A)
BB = IntegerLattice(B)
assert AA == BB.saturation(), sig
dim = 3*M.num_tetrahedra()
V = VectorSpace(ZZ2, dim)
AA = V.subspace(A)
BB = V.subspace(B)
CM = Matrix(ZZ2, C)
CC = CM.right_kernel()
assert AA.intersection(CC) == BB , sig
## so l-t defms are the part of the kernel that doesn't flip over
if sage_working:
print("testing charges for punc torus bundle")
for i in range(3):
for sig_start in sig_starts:
sig = sig_start + str(words.RandomWord(8, 2, "LR")) # 8 is a magic number
M = snappy.Manifold(sig)
assert z_charge.can_deal_with_reduced_angles(M), sig
if sage_working:
import carried_surface
import mutation
print("testing building carried surfaces and mutations")
sigs_weights = [
['iLLLPQccdgefhhghqrqqssvof_02221000', (0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0)],
['jLLAvQQcedehihiihiinasmkutn_011220000', (2, 0, 1, 0, 0, 0, 1, 2, 0, 2, 0, 2, 1, 0, 0, 0, 1, 0)],
['jLLAvQQcedehihiihiinasmkutn_011220000', (0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0)],
['jLLLMPQcdgfhfhiiihshassspiq_122201101', (0, 0, 4, 0, 4, 1, 0, 2, 2, 0, 1, 0, 0, 4, 0, 4, 0, 0)]
]
strata = [
((1, 2), [2, 2]),
((2, 4), [5, 5, 1, 1]),
((0, 3), [2, 0, 0]),
((6, 1), [22])
]
orders_of_veering_symmetry_groups = [4, 2, 2, 2]
for i in range(len(sigs_weights)):
tri, angle = taut.isosig_to_tri_angle(sigs_weights[i][0])
weights = sigs_weights[i][1]
surface, edge_colours = carried_surface.build_surface(tri, angle, weights, return_edge_colours = True)
assert strata[i] == carried_surface.stratum_from_weights_surface(weights, surface)
veering_isoms = carried_surface.veering_symmetry_group(surface, edge_colours)
assert len(veering_isoms) == orders_of_veering_symmetry_groups[i]
isom = veering_isoms[1]
mutation.mutate(tri, angle, weights, isom, quiet = True)
if i == 0:
assert tri.isoSig() == 'ivLLQQccfhfeghghwadiwadrv'
#print('svof to wadrv passed')
elif i == 1:
assert tri.isoSig() == 'jvLLAQQdfghhfgiiijttmtltrcr'
#print('smkutn to tltrcr passed')
elif i == 2:
assert tri.isoSig() == 'jLLMvQQcedehhiiihiikiwnmtxk'
#print('smkutn to mtxk passed')
elif i == 3:
assert tri.isoSig() == 'jLLALMQcecdhggiiihqrwqwrafo'
#print('spiq to rafo passed')
if sage_working:
print("all tests depending on sage passed")
