def __init__(self, fmodule, degree, name=None, latex_name=None): r""" TESTS:: sage: from sage.tensor.modules.ext_pow_free_module import ExtPowerFreeModule sage: M = FiniteRankFreeModule(ZZ, 3, name='M') sage: e = M.basis('e') sage: A = ExtPowerFreeModule(M, 2) ; A 2nd exterior power of the Rank-3 free module M over the Integer Ring sage: TestSuite(A).run() """ from sage.functions.other import binomial self._fmodule = fmodule self._degree = degree rank = binomial(fmodule._rank, degree) if name is None and fmodule._name is not None: name = r'/\^{}('.format(degree) + fmodule._name + ')' if latex_name is None and fmodule._latex_name is not None: latex_name = r'\Lambda^{' + str(degree) + r'}\left(' + \ fmodule._latex_name + r'\right)' FiniteRankFreeModule.__init__(self, fmodule._ring, rank, name=name, latex_name=latex_name, start_index=fmodule._sindex, output_formatter=fmodule._output_formatter) # Unique representation: if self._degree == 1 or \ self._degree in self._fmodule._exterior_powers: raise ValueError("the {}th exterior power of ".format(degree) + "{}".format(self._fmodule) + " has already been created") else: self._fmodule._exterior_powers[self._degree] = self
def __init__(self, fmodule, tensor_type, name=None, latex_name=None): r""" TESTS:: sage: M = FiniteRankFreeModule(ZZ, 3, name='M') sage: T = M.tensor_module(2, 3) sage: TestSuite(T).run() """ self._fmodule = fmodule self._tensor_type = tuple(tensor_type) rank = pow(fmodule._rank, tensor_type[0] + tensor_type[1]) if self._tensor_type == (0, 1): # case of the dual if name is None and fmodule._name is not None: name = fmodule._name + '*' if latex_name is None and fmodule._latex_name is not None: latex_name = fmodule._latex_name + r'^*' else: if name is None and fmodule._name is not None: name = 'T^' + str(self._tensor_type) + '(' + fmodule._name + \ ')' if latex_name is None and fmodule._latex_name is not None: latex_name = r'T^{' + str(self._tensor_type) + r'}\left(' + \ fmodule._latex_name + r'\right)' FiniteRankFreeModule.__init__( self, fmodule._ring, rank, name=name, latex_name=latex_name, start_index=fmodule._sindex, output_formatter=fmodule._output_formatter) fmodule._all_modules.add(self)
def __init__(self, fmodule, degree, name=None, latex_name=None): r""" TESTS:: sage: from sage.tensor.modules.ext_pow_free_module import ExtPowerFreeModule sage: M = FiniteRankFreeModule(ZZ, 3, name='M') sage: e = M.basis('e') sage: A = ExtPowerFreeModule(M, 2) ; A 2nd exterior power of the Rank-3 free module M over the Integer Ring sage: TestSuite(A).run() """ from sage.functions.other import binomial self._fmodule = fmodule self._degree = ZZ(degree) rank = binomial(fmodule._rank, degree) if name is None and fmodule._name is not None: name = r'/\^{}('.format(degree) + fmodule._name + ')' if latex_name is None and fmodule._latex_name is not None: latex_name = r'\Lambda^{' + str(degree) + r'}\left(' + \ fmodule._latex_name + r'\right)' FiniteRankFreeModule.__init__( self, fmodule._ring, rank, name=name, latex_name=latex_name, start_index=fmodule._sindex, output_formatter=fmodule._output_formatter) fmodule._all_modules.add(self)
def __init__(self, vbundle, domain): r""" Construct the free module of sections over a trivial part of a vector bundle. TESTS:: sage: M = Manifold(3, 'M', structure='top') sage: X.<x,y,z> = M.chart() sage: E = M.vector_bundle(2, 'E') sage: from sage.manifolds.section_module import SectionFreeModule sage: C0 = SectionFreeModule(E, M); C0 Free module C^0(M;E) of sections on the 3-dimensional topological manifold M with values in the real vector bundle E of rank 2 sage: C0 is E.section_module(force_free=True) True sage: TestSuite(C0).run() """ from .scalarfield import ScalarField self._domain = domain name = "C^0({};{})".format(domain._name, vbundle._name) latex_name = r'C^0({};{})'.format(domain._latex_name, vbundle._latex_name) base_space = vbundle.base_space() self._base_space = base_space self._vbundle = vbundle cat = Modules(domain.scalar_field_algebra()).FiniteDimensional() FiniteRankFreeModule.__init__(self, domain.scalar_field_algebra(), vbundle.rank(), name=name, latex_name=latex_name, start_index=base_space._sindex, output_formatter=ScalarField.coord_function, category=cat)
def __init__(self, fmodule, degree, name=None, latex_name=None): r""" TESTS:: sage: from sage.tensor.modules.ext_pow_free_module import ExtPowerDualFreeModule sage: M = FiniteRankFreeModule(ZZ, 3, name='M') sage: e = M.basis('e') sage: A = ExtPowerDualFreeModule(M, 2) ; A 2nd exterior power of the dual of the Rank-3 free module M over the Integer Ring sage: TestSuite(A).run() """ from sage.functions.other import binomial self._fmodule = fmodule self._degree = degree rank = binomial(fmodule._rank, degree) self._zero_element = 0 # provisory (to avoid infinite recursion in what # follows) if degree == 1: # case of the dual if name is None and fmodule._name is not None: name = fmodule._name + '*' if latex_name is None and fmodule._latex_name is not None: latex_name = fmodule._latex_name + r'^*' else: if name is None and fmodule._name is not None: name = r'/\^{}('.format(degree) + fmodule._name + '*)' if latex_name is None and fmodule._latex_name is not None: latex_name = r'\Lambda^{' + str(degree) + r'}\left(' + \ fmodule._latex_name + r'^*\right)' FiniteRankFreeModule.__init__( self, fmodule._ring, rank, name=name, latex_name=latex_name, start_index=fmodule._sindex, output_formatter=fmodule._output_formatter) # Unique representation: if self._degree in self._fmodule._dual_exterior_powers: raise ValueError("the {}th exterior power of ".format(degree) + "the dual of {}".format(self._fmodule) + " has already been created") else: self._fmodule._dual_exterior_powers[self._degree] = self # Zero element self._zero_element = self._element_constructor_(name='zero', latex_name='0') for basis in self._fmodule._known_bases: self._zero_element._components[basis] = \ self._zero_element._new_comp(basis)
def stalk(self, point): """ Return the stalk of ``self`` at the point ``point``. INPUT: - ``point`` -- A point in the domain poset of ``self``. OUTPUT: The stalk of ``self`` at ``point`` """ stalk = FiniteRankFreeModule(self._base_ring, self._stalk_dict[point], name="Stalk of {} at {}".format(self, point)) stalk.basis('e') return stalk
def __init__(self, fmodule, tensor_type, name=None, latex_name=None): r""" TEST:: sage: from sage.tensor.modules.tensor_free_module import TensorFreeModule sage: M = FiniteRankFreeModule(ZZ, 3, name='M') sage: T = TensorFreeModule(M, (2,3), name='T23', latex_name=r'T^2_3') sage: TestSuite(T).run() """ self._fmodule = fmodule self._tensor_type = tuple(tensor_type) rank = pow(fmodule._rank, tensor_type[0] + tensor_type[1]) self._zero_element = 0 # provisory (to avoid infinite recursion in what # follows) if self._tensor_type == (0, 1): # case of the dual if name is None and fmodule._name is not None: name = fmodule._name + '*' if latex_name is None and fmodule._latex_name is not None: latex_name = fmodule._latex_name + r'^*' else: if name is None and fmodule._name is not None: name = 'T^' + str(self._tensor_type) + '(' + fmodule._name + \ ')' if latex_name is None and fmodule._latex_name is not None: latex_name = r'T^{' + str(self._tensor_type) + r'}\left(' + \ fmodule._latex_name + r'\right)' FiniteRankFreeModule.__init__( self, fmodule._ring, rank, name=name, latex_name=latex_name, start_index=fmodule._sindex, output_formatter=fmodule._output_formatter) # Unique representation: if self._tensor_type in self._fmodule._tensor_modules: raise ValueError( "the module of tensors of type {}".format(self._tensor_type) + " has already been created") else: self._fmodule._tensor_modules[self._tensor_type] = self # Zero element self._zero_element = self._element_constructor_(name='zero', latex_name='0') for basis in self._fmodule._known_bases: self._zero_element._components[basis] = \ self._zero_element._new_comp(basis)
def __init__(self, fmodule, degree, name=None, latex_name=None): r""" TESTS:: sage: from sage.tensor.modules.ext_pow_free_module import ExtPowerDualFreeModule sage: M = FiniteRankFreeModule(ZZ, 3, name='M') sage: e = M.basis('e') sage: A = ExtPowerDualFreeModule(M, 2) ; A 2nd exterior power of the dual of the Rank-3 free module M over the Integer Ring sage: TestSuite(A).run() """ from sage.functions.other import binomial self._fmodule = fmodule self._degree = degree rank = binomial(fmodule._rank, degree) self._zero_element = 0 # provisory (to avoid infinite recursion in what # follows) if degree == 1: # case of the dual if name is None and fmodule._name is not None: name = fmodule._name + '*' if latex_name is None and fmodule._latex_name is not None: latex_name = fmodule._latex_name + r'^*' else: if name is None and fmodule._name is not None: name = '/\^{}('.format(degree) + fmodule._name + '*)' if latex_name is None and fmodule._latex_name is not None: latex_name = r'\Lambda^{' + str(degree) + r'}\left(' + \ fmodule._latex_name + r'^*\right)' FiniteRankFreeModule.__init__(self, fmodule._ring, rank, name=name, latex_name=latex_name, start_index=fmodule._sindex, output_formatter=fmodule._output_formatter) # Unique representation: if self._degree in self._fmodule._dual_exterior_powers: raise ValueError("the {}th exterior power of ".format(degree) + "the dual of {}".format(self._fmodule) + " has already been created") else: self._fmodule._dual_exterior_powers[self._degree] = self # Zero element self._zero_element = self._element_constructor_(name='zero', latex_name='0') for basis in self._fmodule._known_bases: self._zero_element._components[basis] = \ self._zero_element._new_comp(basis)
def __init__(self, fmodule, tensor_type, name=None, latex_name=None): r""" TEST:: sage: from sage.tensor.modules.tensor_free_module import TensorFreeModule sage: M = FiniteRankFreeModule(ZZ, 3, name='M') sage: T = TensorFreeModule(M, (2,3), name='T23', latex_name=r'T^2_3') sage: TestSuite(T).run() """ self._fmodule = fmodule self._tensor_type = tuple(tensor_type) rank = pow(fmodule._rank, tensor_type[0] + tensor_type[1]) self._zero_element = 0 # provisory (to avoid infinite recursion in what # follows) if self._tensor_type == (0,1): # case of the dual if name is None and fmodule._name is not None: name = fmodule._name + '*' if latex_name is None and fmodule._latex_name is not None: latex_name = fmodule._latex_name + r'^*' else: if name is None and fmodule._name is not None: name = 'T^' + str(self._tensor_type) + '(' + fmodule._name + \ ')' if latex_name is None and fmodule._latex_name is not None: latex_name = r'T^{' + str(self._tensor_type) + r'}\left(' + \ fmodule._latex_name + r'\right)' FiniteRankFreeModule.__init__(self, fmodule._ring, rank, name=name, latex_name=latex_name, start_index=fmodule._sindex, output_formatter=fmodule._output_formatter) # Unique representation: if self._tensor_type in self._fmodule._tensor_modules: raise ValueError("the module of tensors of type {}".format( self._tensor_type) + " has already been created") else: self._fmodule._tensor_modules[self._tensor_type] = self # Zero element self._zero_element = self._element_constructor_(name='zero', latex_name='0') for basis in self._fmodule._known_bases: self._zero_element._components[basis] = \ self._zero_element._new_comp(basis)
def __init__(self, fmodule, tensor_type, name=None, latex_name=None): r""" TESTS:: sage: from sage.tensor.modules.tensor_free_module import TensorFreeModule sage: M = FiniteRankFreeModule(ZZ, 3, name='M') sage: T = TensorFreeModule(M, (2,3), name='T23', latex_name=r'T^2_3') sage: TestSuite(T).run() """ self._fmodule = fmodule self._tensor_type = tuple(tensor_type) rank = pow(fmodule._rank, tensor_type[0] + tensor_type[1]) if self._tensor_type == (0, 1): # case of the dual if name is None and fmodule._name is not None: name = fmodule._name + '*' if latex_name is None and fmodule._latex_name is not None: latex_name = fmodule._latex_name + r'^*' else: if name is None and fmodule._name is not None: name = 'T^' + str(self._tensor_type) + '(' + fmodule._name + \ ')' if latex_name is None and fmodule._latex_name is not None: latex_name = r'T^{' + str(self._tensor_type) + r'}\left(' + \ fmodule._latex_name + r'\right)' FiniteRankFreeModule.__init__( self, fmodule._ring, rank, name=name, latex_name=latex_name, start_index=fmodule._sindex, output_formatter=fmodule._output_formatter) # Unique representation: if self._tensor_type in self._fmodule._tensor_modules: raise ValueError( "the module of tensors of type {}".format(self._tensor_type) + " has already been created") else: self._fmodule._tensor_modules[self._tensor_type] = self
def __init__(self, fmodule, degree, name=None, latex_name=None): r""" TESTS:: sage: from sage.tensor.modules.ext_pow_free_module import ExtPowerDualFreeModule sage: M = FiniteRankFreeModule(ZZ, 3, name='M') sage: e = M.basis('e') sage: A = ExtPowerDualFreeModule(M, 2) ; A 2nd exterior power of the dual of the Rank-3 free module M over the Integer Ring sage: TestSuite(A).run() """ from sage.arith.all import binomial from sage.typeset.unicode_characters import unicode_bigwedge self._fmodule = fmodule self._degree = ZZ(degree) rank = binomial(fmodule._rank, degree) if degree == 1: # case of the dual if name is None and fmodule._name is not None: name = fmodule._name + '*' if latex_name is None and fmodule._latex_name is not None: latex_name = fmodule._latex_name + r'^*' else: if name is None and fmodule._name is not None: name = unicode_bigwedge + r'^{}('.format(degree) \ + fmodule._name + '*)' if latex_name is None and fmodule._latex_name is not None: latex_name = r'\Lambda^{' + str(degree) + r'}\left(' \ + fmodule._latex_name + r'^*\right)' FiniteRankFreeModule.__init__( self, fmodule._ring, rank, name=name, latex_name=latex_name, start_index=fmodule._sindex, output_formatter=fmodule._output_formatter) fmodule._all_modules.add(self)
def __init__(self, point): r""" Construct the tangent space at a given point. TESTS:: sage: from sage.geometry.manifolds.tangentspace import TangentSpace sage: M = Manifold(2, 'M') sage: X.<x,y> = M.chart() sage: p = M.point((1,-2), name='p') sage: Tp = TangentSpace(p) ; Tp tangent space at point 'p' on 2-dimensional manifold 'M' sage: TestSuite(Tp).run() """ manif = point._manifold name = "T_" + str(point._name) + " " + str(manif._name) latex_name = r"T_{" + str(point._latex_name) + "}\," + \ str(manif._latex_name) self._point = point self._manif = manif FiniteRankFreeModule.__init__(self, SR, manif._dim, name=name, latex_name=latex_name, start_index=manif._sindex) # Initialization of bases of the tangent space from existing vector # frames around the point: self._frame_bases = {} # dictionary of bases of the tangent vector # derived from vector frames (keys: vector # frames) for frame in point._subset._top_frames: if point in frame._domain: basis = self.basis(symbol=frame._symbol, latex_symbol=frame._latex_symbol) # Names of basis vectors set to those of the frame vector # fields: n = manif._dim for i in range(n): basis._vec[i]._name = frame._vec[i]._name basis._vec[i]._latex_name = frame._vec[i]._latex_name basis._name = "(" + \ ",".join([basis._vec[i]._name for i in range(n)]) + ")" basis._latex_name = r"\left(" + \ ",".join([basis._vec[i]._latex_name for i in range(n)])+ \ r"\right)" basis._symbol = basis._name basis._latex_symbol = basis._latex_name # Names of cobasis linear forms set to those of the coframe # 1-forms: coframe = frame.coframe() cobasis = basis.dual_basis() for i in range(n): cobasis._form[i]._name = coframe._form[i]._name cobasis._form[i]._latex_name = coframe._form[i]._latex_name cobasis._name = "(" + \ ",".join([cobasis._form[i]._name for i in range(n)]) + ")" cobasis._latex_name = r"\left(" + \ ",".join([cobasis._form[i]._latex_name for i in range(n)])+ \ r"\right)" self._frame_bases[frame] = basis # The basis induced by the default frame of the manifold subset # in which the point has been created is declared the default # basis of self: def_frame = point._subset._def_frame if def_frame in self._frame_bases: self._def_basis = self._frame_bases[def_frame] # Initialization of the changes of bases from the existing changes of # frames around the point: for frame_pair, automorph in point._subset._frame_changes.iteritems(): frame1 = frame_pair[0] frame2 = frame_pair[1] fr1, fr2 = None, None for frame in self._frame_bases: if frame1 in frame._subframes: fr1 = frame break for frame in self._frame_bases: if frame2 in frame._subframes: fr2 = frame break if fr1 is not None and fr2 is not None: basis1 = self._frame_bases[fr1] basis2 = self._frame_bases[fr2] auto = self.automorphism() for frame, comp in automorph._components.iteritems(): basis = None if frame is frame1: basis = basis1 if frame is frame2: basis = basis2 if basis is not None: cauto = auto.add_comp(basis) for ind, val in comp._comp.iteritems(): cauto._comp[ind] = val(point) self._basis_changes[(basis1, basis2)] = auto
def __init__(self, point): r""" Construct the tangent space at a given point. TESTS:: sage: from sage.manifolds.differentiable.tangent_space import TangentSpace sage: M = Manifold(2, 'M') sage: X.<x,y> = M.chart() sage: p = M.point((1,-2), name='p') sage: Tp = TangentSpace(p) ; Tp Tangent space at Point p on the 2-dimensional differentiable manifold M sage: TestSuite(Tp).run() """ manif = point._manifold name = "T_{} {}".format(point._name, manif._name) latex_name = r"T_{%s}\,%s"%(point._latex_name, manif._latex_name) self._point = point self._manif = manif FiniteRankFreeModule.__init__(self, SR, manif._dim, name=name, latex_name=latex_name, start_index=manif._sindex) # Initialization of bases of the tangent space from existing vector # frames around the point: # dictionary of bases of the tangent space derived from vector # frames around the point (keys: vector frames) self._frame_bases = {} for frame in point.parent()._top_frames: # the frame is used to construct a basis of the tangent space # only if it is a frame on the current manifold: if frame.destination_map().is_identity(): if point in frame._domain: coframe = frame.coframe() basis = self.basis(frame._symbol, latex_symbol=frame._latex_symbol, indices=frame._indices, latex_indices=frame._latex_indices, symbol_dual=coframe._symbol, latex_symbol_dual=coframe._latex_symbol) self._frame_bases[frame] = basis # The basis induced by the default frame of the manifold subset # in which the point has been created is declared the default # basis of self: def_frame = point.parent()._def_frame if def_frame in self._frame_bases: self._def_basis = self._frame_bases[def_frame] # Initialization of the changes of bases from the existing changes of # frames around the point: for frame_pair, automorph in point.parent()._frame_changes.items(): if point in automorph.domain(): frame1, frame2 = frame_pair[0], frame_pair[1] fr1, fr2 = None, None for frame in self._frame_bases: if frame1 in frame._subframes: fr1 = frame break for frame in self._frame_bases: if frame2 in frame._subframes: fr2 = frame break if fr1 is not None and fr2 is not None: basis1 = self._frame_bases[fr1] basis2 = self._frame_bases[fr2] auto = self.automorphism() for frame, comp in automorph._components.items(): try: basis = None if frame is frame1: basis = basis1 if frame is frame2: basis = basis2 if basis is not None: cauto = auto.add_comp(basis=basis) for ind, val in comp._comp.items(): cauto._comp[ind] = val(point) except ValueError: pass self._basis_changes[(basis1, basis2)] = auto
def global_sections(self): """ Return the global sections of ``self``. """ c = self.cohomology(0) return FiniteRankFreeModule(self._base_ring, c.ngens(), name="Global Sections of {}".format(self))
def __init__(self, vector_bundle, point): r""" Construct a fiber of a vector bundle. TESTS:: sage: M = Manifold(3, 'M', structure='top') sage: X.<x,y,z> = M.chart() sage: p = M((0,0,0), name='p') sage: E = M.vector_bundle(2, 'E') sage: e = E.local_frame('e') sage: Ep = E.fiber(p) sage: TestSuite(Ep).run() """ if point._manifold is not vector_bundle._base_space: raise ValueError("Point must be an element " "of {}".format(vector_bundle._manifold)) name = "{}_{}".format(vector_bundle._name, point._name) latex_name = r'{}_{{{}}}'.format(vector_bundle._latex_name, point._latex_name) self._rank = vector_bundle._rank self._vbundle = vector_bundle self._point = point self._base_space = point._manifold FiniteRankFreeModule.__init__(self, SR, self._rank, name=name, latex_name=latex_name, start_index=self._base_space._sindex) ### # Construct basis self._frame_bases = { } # dictionary of bases of the vector bundle fiber # derived from local frames around the point # (keys: local frames) self._def_basis = None for frame in vector_bundle._frames: # the frame is used to construct a basis of the vector bundle fiber # only if it is a frame for the given point: if point in frame.domain(): coframe = frame.coframe() basis = self.basis(frame._symbol, latex_symbol=frame._latex_symbol, indices=frame._indices, latex_indices=frame._latex_indices, symbol_dual=coframe._symbol, latex_symbol_dual=coframe._latex_symbol) self._frame_bases[frame] = basis if self._def_basis is None: self._def_basis = basis # Declare the first basis as default # Initialization of the changes of bases from the existing changes of # frames around the point: for frame_pair, automorph in self._vbundle._frame_changes.items(): if point in automorph._fmodule.domain(): frame1, frame2 = frame_pair[0], frame_pair[1] fr1, fr2 = None, None for frame in self._frame_bases: if frame1 in frame._subframes: fr1 = frame break for frame in self._frame_bases: if frame2 in frame._subframes: fr2 = frame break if fr1 is not None and fr2 is not None: basis1 = self._frame_bases[fr1] basis2 = self._frame_bases[fr2] auto = self.automorphism() for frame, comp in automorph._components.items(): try: basis = None if frame is frame1: basis = basis1 if frame is frame2: basis = basis2 if basis is not None: cauto = auto.add_comp(basis) for ind, val in comp._comp.items(): cauto._comp[ind] = val(point) except ValueError: pass self._basis_changes[(basis1, basis2)] = auto
def __init__(self, point): r""" Construct the tangent space at a given point. TESTS:: sage: from sage.manifolds.differentiable.tangent_space import TangentSpace sage: M = Manifold(2, 'M') sage: X.<x,y> = M.chart() sage: p = M.point((1,-2), name='p') sage: Tp = TangentSpace(p) ; Tp Tangent space at Point p on the 2-dimensional differentiable manifold M sage: TestSuite(Tp).run() """ manif = point._manifold name = "T_{} {}".format(point._name, manif._name) latex_name = r"T_{%s}\,%s"%(point._latex_name, manif._latex_name) self._point = point self._manif = manif FiniteRankFreeModule.__init__(self, SR, manif._dim, name=name, latex_name=latex_name, start_index=manif._sindex) # Initialization of bases of the tangent space from existing vector # frames around the point: # dictionary of bases of the tangent space derived from vector # frames around the point (keys: vector frames) self._frame_bases = {} for frame in point.parent()._top_frames: # the frame is used to construct a basis of the tangent space # only if it is a frame on the current manifold: if frame.destination_map().is_identity(): if point in frame._domain: basis = self.basis(symbol=frame._symbol, latex_symbol=frame._latex_symbol) # Names of basis vectors set to those of the frame vector # fields: for i,v in enumerate(frame._vec): basis._vec[i]._name = v._name basis._vec[i]._latex_name = v._latex_name basis._name = "({})".format( ",".join(v._name for v in basis._vec)) basis._latex_name = r"\left({}\right)".format( ",".join(v._latex_name for v in basis._vec)) basis._symbol = basis._name basis._latex_symbol = basis._latex_name # Names of cobasis linear forms set to those of the coframe # 1-forms: coframe = frame.coframe() cobasis = basis.dual_basis() for i,f in enumerate(coframe._form): cobasis._form[i]._name = f._name cobasis._form[i]._latex_name = f._latex_name cobasis._name = "({})".format( ",".join(f._name for f in cobasis._form)) cobasis._latex_name = r"\left({}\right)".format( ",".join(f._latex_name for f in cobasis._form)) self._frame_bases[frame] = basis # The basis induced by the default frame of the manifold subset # in which the point has been created is declared the default # basis of self: def_frame = point.parent()._def_frame if def_frame in self._frame_bases: self._def_basis = self._frame_bases[def_frame] # Initialization of the changes of bases from the existing changes of # frames around the point: for frame_pair, automorph in point.parent()._frame_changes.items(): if point in automorph.domain(): frame1, frame2 = frame_pair[0], frame_pair[1] fr1, fr2 = None, None for frame in self._frame_bases: if frame1 in frame._subframes: fr1 = frame break for frame in self._frame_bases: if frame2 in frame._subframes: fr2 = frame break if fr1 is not None and fr2 is not None: basis1 = self._frame_bases[fr1] basis2 = self._frame_bases[fr2] auto = self.automorphism() for frame, comp in automorph._components.items(): try: basis = None if frame is frame1: basis = basis1 if frame is frame2: basis = basis2 if basis is not None: cauto = auto.add_comp(basis) for ind, val in comp._comp.items(): cauto._comp[ind] = val(point) except ValueError: pass self._basis_changes[(basis1, basis2)] = auto