def __init__(self, coordinate_patch = None):
"""
Construct the algebra of differential forms on a given coordinate patch.
See ``DifferentialForms`` for details.
INPUT::
- ``coordinate_patch`` -- Coordinate patch where the algebra lives.
If no coordinate patch is given, a default coordinate patch with
coordinates (x, y, z) is used.
EXAMPLES::
sage: p, q = var('p, q')
sage: U = CoordinatePatch((p, q)); U
Open subset of R^2 with coordinates p, q
sage: F = DifferentialForms(U); F
Algebra of differential forms in the variables p, q
"""
from sage.categories.graded_algebras_with_basis \
import GradedAlgebrasWithBasis
from sage.structure.parent_gens import ParentWithGens
if not coordinate_patch:
x, y, z = var('x, y, z')
coordinate_patch = CoordinatePatch((x, y, z))
if not isinstance(coordinate_patch, CoordinatePatch):
raise TypeError("%s not a valid Coordinate Patch" % coordinate_patch)
self._patch = coordinate_patch
ParentWithGens.__init__(self, SR, \
category = GradedAlgebrasWithBasis(SR))
def weight_integrand(self, simplify_factor=True):
"""
Weight integrand as a rational function.
The Jacobian determinant of some coordinate transformation.
"""
def arg(x, y):
return arctan(y / x) # up to a constant, but it doesn't matter
def phi(x, y, a, b):
z = (a + I * b - x - I * y) * (a - I * b - x - I * y)
w = z.real()
q = z.imag()
return arg(w, q).full_simplify()
n = len(self.internal_vertices())
coordinates = lambda v: SR.var(chr(97+2*(v-1)) + ',' + chr(97+2*(v-1)+1)) \
if v in self.internal_vertices() else \
[(0,0), (1,0)][self.ground_vertices().index(v)]
internal_coordinates = sum(
(list(coordinates(v)) for v in sorted(self.internal_vertices())),
[])
U = CoordinatePatch(internal_coordinates)
F = DifferentialForms(U)
psi = 0
two_forms = []
for v in self.internal_vertices():
x, y = coordinates(v)
outgoing_edges = self.outgoing_edges([v])
left_target = filter(lambda (x, y, z): z == 'L',
outgoing_edges)[0][1]
right_target = filter(lambda (x, y, z): z == 'R',
outgoing_edges)[0][1]
one_forms = []
for target in [left_target, right_target]:
a, b = coordinates(target)
one_form = DifferentialForm(F, 1)
for v in internal_coordinates:
index = internal_coordinates.index(v)
one_form[index] = phi(x, y, a, b).diff(v)
if simplify_factor:
one_form[index] = SR(one_form[index]).full_simplify()
one_forms.append(one_form)
two_form = one_forms[0] * one_forms[1]
two_forms.append(two_form)
import operator
two_n_form = reduce(operator.mul, two_forms, 1)
return two_n_form[range(0, 2 * n)]
def __init__(self, coordinate_patch=None):
"""
Construct the algebra of differential forms on a given coordinate patch.
See ``DifferentialForms`` for details.
INPUT:
- ``coordinate_patch`` -- Coordinate patch where the algebra lives.
If no coordinate patch is given, a default coordinate patch with
coordinates (x, y, z) is used.
EXAMPLES::
sage: p, q = var('p, q')
sage: U = CoordinatePatch((p, q)); U
doctest:...: DeprecationWarning: Use Manifold instead.
See http://trac.sagemath.org/24444 for details.
Open subset of R^2 with coordinates p, q
sage: F = DifferentialForms(U); F
doctest:...: DeprecationWarning: For the set of differential forms of
degree p, use U.diff_form_module(p), where U is the base manifold
(type U.diff_form_module? for details).
See http://trac.sagemath.org/24444 for details.
Algebra of differential forms in the variables p, q
"""
from sage.categories.graded_algebras_with_basis \
import GradedAlgebrasWithBasis
from sage.structure.parent_gens import ParentWithGens
from sage.misc.superseded import deprecation
deprecation(
24444, 'For the set of differential forms of degree p, ' +
'use U.diff_form_module(p), where U is the base ' +
'manifold (type U.diff_form_module? for details).')
if not coordinate_patch:
x, y, z = var('x, y, z')
coordinate_patch = CoordinatePatch((x, y, z))
if not isinstance(coordinate_patch, CoordinatePatch):
raise TypeError("%s not a valid Coordinate Patch" %
coordinate_patch)
self._patch = coordinate_patch
ParentWithGens.__init__(self, SR, \
category = GradedAlgebrasWithBasis(SR))