def rational_points(self, F=None):
"""
Return the list of ``F``-rational points on the affine space self,
where ``F`` is a given finite field, or the base ring of self.
EXAMPLES::
sage: A = AffineSpace(1, GF(3))
sage: A.rational_points()
[(0), (1), (2)]
sage: A.rational_points(GF(3^2, 'b'))
[(0), (b), (b + 1), (2*b + 1), (2), (2*b), (2*b + 2), (b + 2), (1)]
sage: AffineSpace(2, ZZ).rational_points(GF(2))
[(0, 0), (1, 0), (0, 1), (1, 1)]
TESTS::
sage: AffineSpace(2, QQ).rational_points()
Traceback (most recent call last):
...
TypeError: base ring (= Rational Field) must be a finite field
sage: AffineSpace(1, GF(3)).rational_points(ZZ)
Traceback (most recent call last):
...
TypeError: second argument (= Integer Ring) must be a finite field
"""
if F is None:
if not is_FiniteField(self.base_ring()):
raise TypeError("base ring (= %s) must be a finite field"%self.base_ring())
return [ P for P in self ]
elif not is_FiniteField(F):
raise TypeError("second argument (= %s) must be a finite field"%F)
return [ P for P in self.base_extend(F) ]
def rational_points(self, F=None):
"""
Return the list of ``F``-rational points on the affine space self,
where ``F`` is a given finite field, or the base ring of self.
EXAMPLES::
sage: A = AffineSpace(1, GF(3))
sage: A.rational_points()
[(0), (1), (2)]
sage: A.rational_points(GF(3^2, 'b'))
[(0), (b), (b + 1), (2*b + 1), (2), (2*b), (2*b + 2), (b + 2), (1)]
sage: AffineSpace(2, ZZ).rational_points(GF(2))
[(0, 0), (1, 0), (0, 1), (1, 1)]
TESTS::
sage: AffineSpace(2, QQ).rational_points()
Traceback (most recent call last):
...
TypeError: base ring (= Rational Field) must be a finite field
sage: AffineSpace(1, GF(3)).rational_points(ZZ)
Traceback (most recent call last):
...
TypeError: second argument (= Integer Ring) must be a finite field
"""
if F is None:
if not is_FiniteField(self.base_ring()):
raise TypeError("base ring (= %s) must be a finite field"%self.base_ring())
return [ P for P in self ]
elif not is_FiniteField(F):
raise TypeError("second argument (= %s) must be a finite field"%F)
return [ P for P in self.base_extend(F) ]
def __init__(self, degree, base_ring, category=None):
"""
Base class for matrix groups over generic base rings
You should not use this class directly. Instead, use one of
the more specialized derived classes.
INPUT:
- ``degree`` -- integer. The degree (matrix size) of the
matrix group.
- ``base_ring`` -- ring. The base ring of the matrices.
TESTS::
sage: G = GL(2, QQ)
sage: from sage.groups.matrix_gps.matrix_group import MatrixGroup_generic
sage: isinstance(G, MatrixGroup_generic)
True
"""
assert is_Ring(base_ring)
assert is_Integer(degree)
self._deg = degree
if self._deg <= 0:
raise ValueError('the degree must be at least 1')
if (category is None) and is_FiniteField(base_ring):
from sage.categories.finite_groups import FiniteGroups
category = FiniteGroups()
super(MatrixGroup_generic, self).__init__(base=base_ring,
category=category)
def __init__(self, degree, base_ring, category=None):
"""
Base class for matrix groups over generic base rings
You should not use this class directly. Instead, use one of
the more specialized derived classes.
INPUT:
- ``degree`` -- integer. The degree (matrix size) of the
matrix group.
- ``base_ring`` -- ring. The base ring of the matrices.
TESTS::
sage: G = GL(2, QQ)
sage: from sage.groups.matrix_gps.matrix_group import MatrixGroup_generic
sage: isinstance(G, MatrixGroup_generic)
True
"""
assert is_Ring(base_ring)
assert is_Integer(degree)
self._deg = degree
if self._deg <= 0:
raise ValueError('the degree must be at least 1')
if (category is None) and is_FiniteField(base_ring):
from sage.categories.finite_groups import FiniteGroups
category = FiniteGroups()
super(MatrixGroup_generic, self).__init__(base=base_ring, category=category)
def rational_points(self, F=None):
r"""
Return the list of `F`-rational points on this product of projective spaces,
where `F` is a given finite field, or the base ring of this space.
EXAMPLES::
sage: P = ProductProjectiveSpaces([1, 1], GF(5))
sage: P.rational_points()
[(0 : 1 , 0 : 1), (1 : 1 , 0 : 1), (2 : 1 , 0 : 1), (3 : 1 , 0 : 1), (4 : 1 , 0 : 1), (1 : 0 , 0 : 1),
(0 : 1 , 1 : 1), (1 : 1 , 1 : 1), (2 : 1 , 1 : 1), (3 : 1 , 1 : 1), (4 : 1 , 1 : 1), (1 : 0 , 1 : 1),
(0 : 1 , 2 : 1), (1 : 1 , 2 : 1), (2 : 1 , 2 : 1), (3 : 1 , 2 : 1), (4 : 1 , 2 : 1), (1 : 0 , 2 : 1),
(0 : 1 , 3 : 1), (1 : 1 , 3 : 1), (2 : 1 , 3 : 1), (3 : 1 , 3 : 1), (4 : 1 , 3 : 1), (1 : 0 , 3 : 1),
(0 : 1 , 4 : 1), (1 : 1 , 4 : 1), (2 : 1 , 4 : 1), (3 : 1 , 4 : 1), (4 : 1 , 4 : 1), (1 : 0 , 4 : 1),
(0 : 1 , 1 : 0), (1 : 1 , 1 : 0), (2 : 1 , 1 : 0), (3 : 1 , 1 : 0), (4 : 1 , 1 : 0), (1 : 0 , 1 : 0)]
::
sage: P = ProductProjectiveSpaces([1, 1], GF(2))
sage: P.rational_points(GF(2^2,'a'))
[(0 : 1 , 0 : 1), (a : 1 , 0 : 1), (a + 1 : 1 , 0 : 1), (1 : 1 , 0 : 1), (1 : 0 , 0 : 1), (0 : 1 , a : 1),
(a : 1 , a : 1), (a + 1 : 1 , a : 1), (1 : 1 , a : 1), (1 : 0 , a : 1), (0 : 1 , a + 1 : 1), (a : 1 , a + 1 : 1),
(a + 1 : 1 , a + 1 : 1), (1 : 1 , a + 1 : 1), (1 : 0 , a + 1 : 1), (0 : 1 , 1 : 1), (a : 1 , 1 : 1),
(a + 1 : 1 , 1 : 1), (1 : 1 , 1 : 1), (1 : 0 , 1 : 1), (0 : 1 , 1 : 0), (a : 1 , 1 : 0), (a + 1 : 1 , 1 : 0),
(1 : 1 , 1 : 0), (1 : 0 , 1 : 0)]
"""
if F is None:
return list(self)
elif not is_FiniteField(F):
raise TypeError("second argument (= %s) must be a finite field" %
F)
return list(self.base_extend(F))
def rational_points(self, F=None):
r"""
Return the list of `F`-rational points on this product of projective spaces,
where `F` is a given finite field, or the base ring of this space.
EXAMPLES::
sage: P = ProductProjectiveSpaces([1, 1], GF(5))
sage: P.rational_points()
[(0 : 1 , 0 : 1), (1 : 1 , 0 : 1), (2 : 1 , 0 : 1), (3 : 1 , 0 : 1), (4 : 1 , 0 : 1), (1 : 0 , 0 : 1),
(0 : 1 , 1 : 1), (1 : 1 , 1 : 1), (2 : 1 , 1 : 1), (3 : 1 , 1 : 1), (4 : 1 , 1 : 1), (1 : 0 , 1 : 1),
(0 : 1 , 2 : 1), (1 : 1 , 2 : 1), (2 : 1 , 2 : 1), (3 : 1 , 2 : 1), (4 : 1 , 2 : 1), (1 : 0 , 2 : 1),
(0 : 1 , 3 : 1), (1 : 1 , 3 : 1), (2 : 1 , 3 : 1), (3 : 1 , 3 : 1), (4 : 1 , 3 : 1), (1 : 0 , 3 : 1),
(0 : 1 , 4 : 1), (1 : 1 , 4 : 1), (2 : 1 , 4 : 1), (3 : 1 , 4 : 1), (4 : 1 , 4 : 1), (1 : 0 , 4 : 1),
(0 : 1 , 1 : 0), (1 : 1 , 1 : 0), (2 : 1 , 1 : 0), (3 : 1 , 1 : 0), (4 : 1 , 1 : 0), (1 : 0 , 1 : 0)]
::
sage: P = ProductProjectiveSpaces([1, 1], GF(2))
sage: P.rational_points(GF(2^2,'a'))
[(0 : 1 , 0 : 1), (a : 1 , 0 : 1), (a + 1 : 1 , 0 : 1), (1 : 1 , 0 : 1), (1 : 0 , 0 : 1), (0 : 1 , a : 1),
(a : 1 , a : 1), (a + 1 : 1 , a : 1), (1 : 1 , a : 1), (1 : 0 , a : 1), (0 : 1 , a + 1 : 1), (a : 1 , a + 1 : 1),
(a + 1 : 1 , a + 1 : 1), (1 : 1 , a + 1 : 1), (1 : 0 , a + 1 : 1), (0 : 1 , 1 : 1), (a : 1 , 1 : 1),
(a + 1 : 1 , 1 : 1), (1 : 1 , 1 : 1), (1 : 0 , 1 : 1), (0 : 1 , 1 : 0), (a : 1 , 1 : 0), (a + 1 : 1 , 1 : 0),
(1 : 1 , 1 : 0), (1 : 0 , 1 : 0)]
"""
if F is None:
return list(self)
elif not is_FiniteField(F):
raise TypeError("second argument (= %s) must be a finite field"%F)
return list(self.base_extend(F))
def lfsr_sequence(key, fill, n):
r"""
Create an LFSR sequence.
INPUT:
- ``key`` -- a list of finite field elements, `[c_0, c_1,\dots, c_k]`
- ``fill`` -- the list of the initial terms of the LFSR sequence, `[x_0,x_1,\dots,x_k]`
- ``n`` -- number of terms of the sequence that the function returns
OUTPUT:
The LFSR sequence defined by `x_{n+1} = c_kx_n+...+c_0x_{n-k}` for `n \geq k`.
EXAMPLES::
sage: F = GF(2); l = F(1); o = F(0)
sage: F = GF(2); S = LaurentSeriesRing(F,'x'); x = S.gen()
sage: fill = [l,l,o,l]; key = [1,o,o,l]; n = 20
sage: L = lfsr_sequence(key,fill,20); L
[1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0]
sage: from sage.matrix.berlekamp_massey import berlekamp_massey
sage: g = berlekamp_massey(L); g
x^4 + x^3 + 1
sage: (1)/(g.reverse()+O(x^20))
1 + x + x^2 + x^3 + x^5 + x^7 + x^8 + x^11 + x^15 + x^16 + x^17 + x^18 + O(x^20)
sage: (1+x^2)/(g.reverse()+O(x^20))
1 + x + x^4 + x^8 + x^9 + x^10 + x^11 + x^13 + x^15 + x^16 + x^19 + O(x^20)
sage: (1+x^2+x^3)/(g.reverse()+O(x^20))
1 + x + x^3 + x^5 + x^6 + x^9 + x^13 + x^14 + x^15 + x^16 + x^18 + O(x^20)
sage: fill = [l,l,o,l]; key = [l,o,o,o]; n = 20
sage: L = lfsr_sequence(key,fill,20); L
[1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1]
sage: g = berlekamp_massey(L); g
x^4 + 1
sage: (1+x)/(g.reverse()+O(x^20))
1 + x + x^4 + x^5 + x^8 + x^9 + x^12 + x^13 + x^16 + x^17 + O(x^20)
sage: (1+x+x^3)/(g.reverse()+O(x^20))
1 + x + x^3 + x^4 + x^5 + x^7 + x^8 + x^9 + x^11 + x^12 + x^13 + x^15 + x^16 + x^17 + x^19 + O(x^20)
"""
if not isinstance(key, list):
raise TypeError("key must be a list")
key = Sequence(key)
F = key.universe()
if not is_FiniteField(F):
raise TypeError("universe of sequence must be a finite field")
s = fill
k = len(fill)
L = []
for i in range(n):
s0 = copy.copy(s)
L.append(s[0])
s = s[1:k]
s.append(sum([key[i] * s0[i] for i in range(k)]))
return L
def lfsr_sequence(key, fill, n):
r"""
This function creates an LFSR sequence.
INPUT:
- ``key`` -- a list of finite field elements, [c_0,c_1,...,c_k]
- ``fill`` -- the list of the initial terms of the LFSR sequence, [x_0,x_1,...,x_k]
- ``n`` -- number of terms of the sequence that the function returns
OUTPUT: The LFSR sequence defined by `x_{n+1} = c_kx_n+...+c_0x_{n-k}` for `n \leq k`.
EXAMPLES::
sage: F = GF(2); l = F(1); o = F(0)
sage: F = GF(2); S = LaurentSeriesRing(F,'x'); x = S.gen()
sage: fill = [l,l,o,l]; key = [1,o,o,l]; n = 20
sage: L = lfsr_sequence(key,fill,20); L
[1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0]
sage: from sage.matrix.berlekamp_massey import berlekamp_massey
sage: g = berlekamp_massey(L); g
x^4 + x^3 + 1
sage: (1)/(g.reverse()+O(x^20))
1 + x + x^2 + x^3 + x^5 + x^7 + x^8 + x^11 + x^15 + x^16 + x^17 + x^18 + O(x^20)
sage: (1+x^2)/(g.reverse()+O(x^20))
1 + x + x^4 + x^8 + x^9 + x^10 + x^11 + x^13 + x^15 + x^16 + x^19 + O(x^20)
sage: (1+x^2+x^3)/(g.reverse()+O(x^20))
1 + x + x^3 + x^5 + x^6 + x^9 + x^13 + x^14 + x^15 + x^16 + x^18 + O(x^20)
sage: fill = [l,l,o,l]; key = [l,o,o,o]; n = 20
sage: L = lfsr_sequence(key,fill,20); L
[1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1]
sage: g = berlekamp_massey(L); g
x^4 + 1
sage: (1+x)/(g.reverse()+O(x^20))
1 + x + x^4 + x^5 + x^8 + x^9 + x^12 + x^13 + x^16 + x^17 + O(x^20)
sage: (1+x+x^3)/(g.reverse()+O(x^20))
1 + x + x^3 + x^4 + x^5 + x^7 + x^8 + x^9 + x^11 + x^12 + x^13 + x^15 + x^16 + x^17 + x^19 + O(x^20)
"""
if not isinstance(key, list):
raise TypeError("key must be a list")
key = Sequence(key)
F = key.universe()
if not is_FiniteField(F):
raise TypeError("universe of sequence must be a finite field")
s = fill
k = len(fill)
L = []
for i in range(n):
s0 = copy.copy(s)
L.append(s[0])
s = s[1:k]
s.append(sum([key[i]*s0[i] for i in range(k)]))
return L
def AffineSpace(n, R=None, names='x'):
r"""
Return affine space of dimension ``n`` over the ring ``R``.
EXAMPLES:
The dimension and ring can be given in either order::
sage: AffineSpace(3, QQ, 'x')
Affine Space of dimension 3 over Rational Field
sage: AffineSpace(5, QQ, 'x')
Affine Space of dimension 5 over Rational Field
sage: A = AffineSpace(2, QQ, names='XY'); A
Affine Space of dimension 2 over Rational Field
sage: A.coordinate_ring()
Multivariate Polynomial Ring in X, Y over Rational Field
Use the divide operator for base extension::
sage: AffineSpace(5, names='x')/GF(17)
Affine Space of dimension 5 over Finite Field of size 17
The default base ring is `\ZZ`::
sage: AffineSpace(5, names='x')
Affine Space of dimension 5 over Integer Ring
There is also an affine space associated to each polynomial ring::
sage: R = GF(7)['x, y, z']
sage: A = AffineSpace(R); A
Affine Space of dimension 3 over Finite Field of size 7
sage: A.coordinate_ring() is R
True
"""
if is_MPolynomialRing(n) and R is None:
R = n
A = AffineSpace(R.ngens(), R.base_ring(), R.variable_names())
A._coordinate_ring = R
return A
if isinstance(R, integer_types + (Integer, )):
n, R = R, n
if R is None:
R = ZZ # default is the integers
if names is None:
if n == 0:
names = ''
else:
raise TypeError(
"you must specify the variables names of the coordinate ring")
names = normalize_names(n, names)
if R in _Fields:
if is_FiniteField(R):
return AffineSpace_finite_field(n, R, names)
else:
return AffineSpace_field(n, R, names)
return AffineSpace_generic(n, R, names)
def AffineSpace(n, R=None, names='x'):
r"""
Return affine space of dimension ``n`` over the ring ``R``.
EXAMPLES:
The dimension and ring can be given in either order::
sage: AffineSpace(3, QQ, 'x')
Affine Space of dimension 3 over Rational Field
sage: AffineSpace(5, QQ, 'x')
Affine Space of dimension 5 over Rational Field
sage: A = AffineSpace(2, QQ, names='XY'); A
Affine Space of dimension 2 over Rational Field
sage: A.coordinate_ring()
Multivariate Polynomial Ring in X, Y over Rational Field
Use the divide operator for base extension::
sage: AffineSpace(5, names='x')/GF(17)
Affine Space of dimension 5 over Finite Field of size 17
The default base ring is `\ZZ`::
sage: AffineSpace(5, names='x')
Affine Space of dimension 5 over Integer Ring
There is also an affine space associated to each polynomial ring::
sage: R = GF(7)['x, y, z']
sage: A = AffineSpace(R); A
Affine Space of dimension 3 over Finite Field of size 7
sage: A.coordinate_ring() is R
True
"""
if (is_MPolynomialRing(n) or is_PolynomialRing(n)) and R is None:
R = n
A = AffineSpace(R.ngens(), R.base_ring(), R.variable_names())
A._coordinate_ring = R
return A
if isinstance(R, integer_types + (Integer,)):
n, R = R, n
if R is None:
R = ZZ # default is the integers
if names is None:
if n == 0:
names = ''
else:
raise TypeError("you must specify the variables names of the coordinate ring")
names = normalize_names(n, names)
if R in _Fields:
if is_FiniteField(R):
return AffineSpace_finite_field(n, R, names)
else:
return AffineSpace_field(n, R, names)
return AffineSpace_generic(n, R, names)
def _single_variate(base_ring, name, sparse, implementation):
import sage.rings.polynomial.polynomial_ring as m
name = normalize_names(1, name)
key = (base_ring, name, sparse, implementation if not sparse else None)
R = _get_from_cache(key)
if not R is None:
return R
if isinstance(base_ring, ring.CommutativeRing):
if is_IntegerModRing(base_ring) and not sparse:
n = base_ring.order()
if n.is_prime():
R = m.PolynomialRing_dense_mod_p(base_ring, name, implementation=implementation)
elif n > 1:
R = m.PolynomialRing_dense_mod_n(base_ring, name, implementation=implementation)
else: # n == 1!
R = m.PolynomialRing_integral_domain(base_ring, name) # specialized code breaks in this case.
elif is_FiniteField(base_ring) and not sparse:
R = m.PolynomialRing_dense_finite_field(base_ring, name, implementation=implementation)
elif isinstance(base_ring, padic_base_leaves.pAdicFieldCappedRelative):
R = m.PolynomialRing_dense_padic_field_capped_relative(base_ring, name)
elif isinstance(base_ring, padic_base_leaves.pAdicRingCappedRelative):
R = m.PolynomialRing_dense_padic_ring_capped_relative(base_ring, name)
elif isinstance(base_ring, padic_base_leaves.pAdicRingCappedAbsolute):
R = m.PolynomialRing_dense_padic_ring_capped_absolute(base_ring, name)
elif isinstance(base_ring, padic_base_leaves.pAdicRingFixedMod):
R = m.PolynomialRing_dense_padic_ring_fixed_mod(base_ring, name)
elif base_ring in _CompleteDiscreteValuationRings:
R = m.PolynomialRing_cdvr(base_ring, name, sparse)
elif base_ring in _CompleteDiscreteValuationFields:
R = m.PolynomialRing_cdvf(base_ring, name, sparse)
elif base_ring.is_field(proof = False):
R = m.PolynomialRing_field(base_ring, name, sparse)
elif base_ring.is_integral_domain(proof = False):
R = m.PolynomialRing_integral_domain(base_ring, name, sparse, implementation)
else:
R = m.PolynomialRing_commutative(base_ring, name, sparse)
else:
R = m.PolynomialRing_general(base_ring, name, sparse)
if hasattr(R, '_implementation_names'):
for name in R._implementation_names:
real_key = key[0:3] + (name,)
_save_in_cache(real_key, R)
else:
_save_in_cache(key, R)
return R
def as_dynamical_system(self):
"""
Return this endomorphism as a :class:`DynamicalSystem_affine`.
OUTPUT:
- :class:`DynamicalSystem_affine`
EXAMPLES::
sage: A.<x,y,z> = AffineSpace(ZZ, 3)
sage: H = End(A)
sage: f = H([x^2, y^2, z^2])
sage: type(f.as_dynamical_system())
<class 'sage.dynamics.arithmetic_dynamics.affine_ds.DynamicalSystem_affine'>
::
sage: A.<x,y> = AffineSpace(ZZ, 2)
sage: H = End(A)
sage: f = H([x^2-y^2, y^2])
sage: type(f.as_dynamical_system())
<class 'sage.dynamics.arithmetic_dynamics.affine_ds.DynamicalSystem_affine'>
::
sage: A.<x> = AffineSpace(GF(5), 1)
sage: H = End(A)
sage: f = H([x^2])
sage: type(f.as_dynamical_system())
<class 'sage.dynamics.arithmetic_dynamics.affine_ds.DynamicalSystem_affine_finite_field'>
::
sage: P.<x,y> = AffineSpace(RR, 2)
sage: f = DynamicalSystem([x^2 + y^2, y^2], P)
sage: g = f.as_dynamical_system()
sage: g is f
True
"""
from sage.dynamics.arithmetic_dynamics.generic_ds import DynamicalSystem
if isinstance(self, DynamicalSystem):
return self
if not self.domain() == self.codomain():
raise TypeError("must be an endomorphism")
from sage.dynamics.arithmetic_dynamics.affine_ds import DynamicalSystem_affine
from sage.dynamics.arithmetic_dynamics.affine_ds import DynamicalSystem_affine_field
from sage.dynamics.arithmetic_dynamics.affine_ds import DynamicalSystem_affine_finite_field
R = self.base_ring()
if R not in _Fields:
return DynamicalSystem_affine(list(self), self.domain())
if is_FiniteField(R):
return DynamicalSystem_affine_finite_field(list(self),
self.domain())
return DynamicalSystem_affine_field(list(self), self.domain())
def _single_variate(base_ring, name, sparse, implementation):
import sage.rings.polynomial.polynomial_ring as m
name = normalize_names(1, name)
key = (base_ring, name, sparse, implementation if not sparse else None)
R = _get_from_cache(key)
if not R is None:
return R
if isinstance(base_ring, ring.CommutativeRing):
if is_IntegerModRing(base_ring) and not sparse:
n = base_ring.order()
if n.is_prime():
R = m.PolynomialRing_dense_mod_p(base_ring, name, implementation=implementation)
elif n > 1:
R = m.PolynomialRing_dense_mod_n(base_ring, name, implementation=implementation)
else: # n == 1!
R = m.PolynomialRing_integral_domain(base_ring, name) # specialized code breaks in this case.
elif is_FiniteField(base_ring) and not sparse:
R = m.PolynomialRing_dense_finite_field(base_ring, name, implementation=implementation)
elif isinstance(base_ring, padic_base_leaves.pAdicFieldCappedRelative):
R = m.PolynomialRing_dense_padic_field_capped_relative(base_ring, name)
elif isinstance(base_ring, padic_base_leaves.pAdicRingCappedRelative):
R = m.PolynomialRing_dense_padic_ring_capped_relative(base_ring, name)
elif isinstance(base_ring, padic_base_leaves.pAdicRingCappedAbsolute):
R = m.PolynomialRing_dense_padic_ring_capped_absolute(base_ring, name)
elif isinstance(base_ring, padic_base_leaves.pAdicRingFixedMod):
R = m.PolynomialRing_dense_padic_ring_fixed_mod(base_ring, name)
elif base_ring.is_field(proof = False):
R = m.PolynomialRing_field(base_ring, name, sparse)
elif base_ring.is_integral_domain(proof = False):
R = m.PolynomialRing_integral_domain(base_ring, name, sparse, implementation)
else:
R = m.PolynomialRing_commutative(base_ring, name, sparse)
else:
R = m.PolynomialRing_general(base_ring, name, sparse)
if hasattr(R, '_implementation_names'):
for name in R._implementation_names:
real_key = key[0:3] + (name,)
_save_in_cache(real_key, R)
else:
_save_in_cache(key, R)
return R
def rational_points(self, F=None):
"""
Return the list of ``F``-rational points on this projective space,
where ``F`` is a given finite field, or the base ring of this space.
EXAMPLES::
sage: P = ProjectiveSpace(1, GF(3))
sage: P.rational_points()
[(0 : 1), (1 : 1), (2 : 1), (1 : 0)]
sage: P.rational_points(GF(3^2, 'b'))
[(0 : 1), (b : 1), (b + 1 : 1), (2*b + 1 : 1), (2 : 1), (2*b : 1), (2*b + 2 : 1), (b + 2 : 1), (1 : 1), (1 : 0)]
"""
if F is None:
return [P for P in self]
elif not is_FiniteField(F):
raise TypeError("second argument (= %s) must be a finite field" % F)
return [P for P in self.base_extend(F)]
def rational_points(self, F=None):
"""
Return the list of ``F``-rational points on this projective space,
where ``F`` is a given finite field, or the base ring of this space.
EXAMPLES::
sage: P = ProjectiveSpace(1, GF(3))
sage: P.rational_points()
[(0 : 1), (1 : 1), (2 : 1), (1 : 0)]
sage: P.rational_points(GF(3^2, 'b'))
[(0 : 1), (b : 1), (b + 1 : 1), (2*b + 1 : 1), (2 : 1), (2*b : 1), (2*b + 2 : 1), (b + 2 : 1), (1 : 1), (1 : 0)]
"""
if F is None:
return [ P for P in self ]
elif not is_FiniteField(F):
raise TypeError("second argument (= %s) must be a finite field"%F)
return [ P for P in self.base_extend(F) ]
def as_dynamical_system(self):
"""
Return this endomorphism as a :class:`DynamicalSystem_affine`.
OUTPUT:
- :class:`DynamicalSystem_affine`
EXAMPLES::
sage: A.<x,y,z> = AffineSpace(ZZ, 3)
sage: H = End(A)
sage: f = H([x^2, y^2, z^2])
sage: type(f.as_dynamical_system())
<class 'sage.dynamics.arithmetic_dynamics.affine_ds.DynamicalSystem_affine'>
::
sage: A.<x,y> = AffineSpace(ZZ, 2)
sage: H = End(A)
sage: f = H([x^2-y^2, y^2])
sage: type(f.as_dynamical_system())
<class 'sage.dynamics.arithmetic_dynamics.affine_ds.DynamicalSystem_affine'>
::
sage: A.<x> = AffineSpace(GF(5), 1)
sage: H = End(A)
sage: f = H([x^2])
sage: type(f.as_dynamical_system())
<class 'sage.dynamics.arithmetic_dynamics.affine_ds.DynamicalSystem_affine_finite_field'>
"""
if not self.domain() == self.codomain():
raise TypeError("must be an endomorphism")
from sage.dynamics.arithmetic_dynamics.affine_ds import DynamicalSystem_affine
from sage.dynamics.arithmetic_dynamics.affine_ds import DynamicalSystem_affine_field
from sage.dynamics.arithmetic_dynamics.affine_ds import DynamicalSystem_affine_finite_field
R = self.base_ring()
if R not in _Fields:
return DynamicalSystem_affine(list(self), self.domain())
if is_FiniteField(R):
return DynamicalSystem_affine_finite_field(list(self), self.domain())
return DynamicalSystem_affine_field(list(self), self.domain())
def create_object(self, version, key, **kwds):
"""
Create an object from a ``UniqueFactory`` key.
EXAMPLES::
sage: E = EllipticCurve.create_object(0, (GF(3), (1, 2, 0, 1, 2)))
sage: type(E)
<class 'sage.schemes.elliptic_curves.ell_finite_field.EllipticCurve_finite_field_with_category'>
.. NOTE::
Keyword arguments are currently only passed to the
constructor for elliptic curves over `\\QQ`; elliptic
curves over other fields do not support them.
"""
R, x = key
if R is rings.QQ:
from .ell_rational_field import EllipticCurve_rational_field
return EllipticCurve_rational_field(x, **kwds)
elif is_NumberField(R):
from .ell_number_field import EllipticCurve_number_field
return EllipticCurve_number_field(R, x)
elif rings.is_pAdicField(R):
from .ell_padic_field import EllipticCurve_padic_field
return EllipticCurve_padic_field(R, x)
elif is_FiniteField(R) or (is_IntegerModRing(R)
and R.characteristic().is_prime()):
from .ell_finite_field import EllipticCurve_finite_field
return EllipticCurve_finite_field(R, x)
elif R in _Fields:
from .ell_field import EllipticCurve_field
return EllipticCurve_field(R, x)
from .ell_generic import EllipticCurve_generic
return EllipticCurve_generic(R, x)
def create_object(self, version, key, **kwds):
"""
Create an object from a ``UniqueFactory`` key.
EXAMPLES::
sage: E = EllipticCurve.create_object(0, (GF(3), (1, 2, 0, 1, 2)))
sage: type(E)
<class 'sage.schemes.elliptic_curves.ell_finite_field.EllipticCurve_finite_field_with_category'>
.. NOTE::
Keyword arguments are currently only passed to the
constructor for elliptic curves over `\\QQ`; elliptic
curves over other fields do not support them.
"""
R, x = key
if R is rings.QQ:
from ell_rational_field import EllipticCurve_rational_field
return EllipticCurve_rational_field(x, **kwds)
elif is_NumberField(R):
from ell_number_field import EllipticCurve_number_field
return EllipticCurve_number_field(R, x)
elif rings.is_pAdicField(R):
from ell_padic_field import EllipticCurve_padic_field
return EllipticCurve_padic_field(R, x)
elif is_FiniteField(R) or (is_IntegerModRing(R) and R.characteristic().is_prime()):
from ell_finite_field import EllipticCurve_finite_field
return EllipticCurve_finite_field(R, x)
elif R in _Fields:
from ell_field import EllipticCurve_field
return EllipticCurve_field(R, x)
from ell_generic import EllipticCurve_generic
return EllipticCurve_generic(R, x)
def field_of_definition_critical(self, return_embedding=False, simplify_all=False, names='a'):
r"""
Return smallest extension of the base field which contains the critical points
Ambient space of dynamical system must be either the affine line or projective
line over a number field or finite field.
INPUT:
- ``return_embedding`` -- (default: ``False``) boolean; If ``True``, return an
embedding of base field of dynamical system into the returned number field or
finite field. Note that computing this embedding might be expensive.
- ``simplify_all`` -- (default: ``False``) boolean; If ``True``, simplify
intermediate fields and also the resulting number field. Note that this
is not implemented for finite fields and has no effect
- ``names`` -- (optional) string to be used as generator for returned number field
or finite field
OUTPUT:
If ``return_embedding`` is ``False``, the field of definition as an absolute number
field or finite field. If ``return_embedding`` is ``True``, a tuple
``(K, phi)`` where ``phi`` is an embedding of the base field in ``K``.
EXAMPLES:
Note that the number of critical points is 2d-2, but (1:0) has multiplicity 2 in this case::
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([1/3*x^3 + x*y^2, y^3], domain=P)
sage: f.critical_points()
[(1 : 0)]
sage: N.<a> = f.field_of_definition_critical(); N
Number Field in a with defining polynomial x^2 + 1
sage: g = f.change_ring(N)
sage: g.critical_points()
[(-a : 1), (a : 1), (1 : 0)]
::
sage: A.<z> = AffineSpace(QQ, 1)
sage: f = DynamicalSystem([z^4 + 2*z^2 + 2], domain=A)
sage: K.<a> = f.field_of_definition_critical(); K
Number Field in a with defining polynomial z^2 + 1
::
sage: G.<a> = GF(9)
sage: R.<z> = G[]
sage: R.irreducible_element(3, algorithm='first_lexicographic')
z^3 + (a + 1)*z + a
sage: A.<x> = AffineSpace(G,1)
sage: f = DynamicalSystem([x^4 + (2*a+2)*x^2 + a*x], domain=A)
sage: f[0].derivative(x).univariate_polynomial().is_irreducible()
True
sage: f.field_of_definition_critical(return_embedding=True, names='b')
(Finite Field in b of size 3^6, Ring morphism:
From: Finite Field in a of size 3^2
To: Finite Field in b of size 3^6
Defn: a |--> 2*b^5 + 2*b^3 + b^2 + 2*b + 2)
"""
ds = copy(self)
space = ds.domain().ambient_space()
if space.dimension() != 1:
raise ValueError('Ambient space of dynamical system must be either the affine line or projective line')
if space.is_projective():
ds = ds.dehomogenize(1)
f,g = ds[0].numerator(), ds[0].denominator()
CR = space.coordinate_ring()
if CR.is_field():
#want the polynomial ring not the fraction field
CR = CR.ring()
x = CR.gen(0)
poly = (g*CR(f).derivative(x) - f*CR(g).derivative(x)).univariate_polynomial()
if is_FiniteField(ds.base_ring()):
return poly.splitting_field(names, map=return_embedding)
else:
K = poly.splitting_field(names, map=return_embedding, simplify_all=simplify_all)
if return_embedding:
N = K[0]
else:
N = K
if N.absolute_degree() == 1:
if return_embedding:
return (QQ,ds.base_ring().embeddings(QQ)[0])
else:
return QQ
else:
return K
def points(self, B=0, prec=53):
"""
Return some or all rational points of a projective scheme.
INPUT:
- ``B`` - integer (optional, default=0). The bound for the
coordinates.
- ``prec`` - he precision to use to compute the elements of bounded height for number fields.
OUTPUT:
A list of points. Over a finite field, all points are
returned. Over an infinite field, all points satisfying the
bound are returned.
.. WARNING::
In the current implementation, the output of the [Doyle-Krumm] algorithm
cannot be guaranteed to be correct due to the necessity of floating point
computations. In some cases, the default 53-bit precision is
considerably lower than would be required for the algorithm to
generate correct output.
EXAMPLES::
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: P(QQ).points(4)
[(-4 : 1), (-3 : 1), (-2 : 1), (-3/2 : 1), (-4/3 : 1), (-1 : 1),
(-3/4 : 1), (-2/3 : 1), (-1/2 : 1), (-1/3 : 1), (-1/4 : 1), (0 : 1),
(1/4 : 1), (1/3 : 1), (1/2 : 1), (2/3 : 1), (3/4 : 1), (1 : 0), (1 : 1),
(4/3 : 1), (3/2 : 1), (2 : 1), (3 : 1), (4 : 1)]
::
sage: u = QQ['u'].0
sage: K.<v> = NumberField(u^2 + 3)
sage: P.<x,y,z> = ProjectiveSpace(K,2)
sage: len(P(K).points(1.8))
381
::
sage: P1 = ProjectiveSpace(GF(2),1)
sage: F.<a> = GF(4,'a')
sage: P1(F).points()
[(0 : 1), (1 : 0), (1 : 1), (a : 1), (a + 1 : 1)]
::
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: E = P.subscheme([(y^3-y*z^2) - (x^3-x*z^2),(y^3-y*z^2) + (x^3-x*z^2)])
sage: E(P.base_ring()).points()
[(-1 : -1 : 1), (-1 : 0 : 1), (-1 : 1 : 1), (0 : -1 : 1), (0 : 0 : 1), (0 : 1 : 1),
(1 : -1 : 1), (1 : 0 : 1), (1 : 1 : 1)]
"""
X = self.codomain()
from sage.schemes.projective.projective_space import is_ProjectiveSpace
if not is_ProjectiveSpace(X) and X.base_ring() in Fields():
#Then it must be a subscheme
dim_ideal = X.defining_ideal().dimension()
if dim_ideal < 1: # no points
return []
if dim_ideal == 1: # if X zero-dimensional
rat_points = set()
PS = X.ambient_space()
N = PS.dimension_relative()
BR = X.base_ring()
#need a lexicographic ordering for elimination
R = PolynomialRing(BR, N + 1, PS.variable_names(), order='lex')
I = R.ideal(X.defining_polynomials())
I0 = R.ideal(0)
#Determine the points through elimination
#This is much faster than using the I.variety() function on each affine chart.
for k in range(N + 1):
#create the elimination ideal for the kth affine patch
G = I.substitute({R.gen(k): 1}).groebner_basis()
if G != [1]:
P = {}
#keep track that we know the kth coordinate is 1
P.update({R.gen(k): 1})
points = [P]
#work backwards from solving each equation for the possible
#values of the next coordinate
for i in range(len(G) - 1, -1, -1):
new_points = []
good = 0
for P in points:
#substitute in our dictionary entry that has the values
#of coordinates known so far. This results in a single
#variable polynomial (by elimination)
L = G[i].substitute(P)
if L != 0:
L = L.factor()
#the linear factors give the possible rational values of
#this coordinate
for pol, pow in L:
if pol.degree() == 1 and len(
pol.variables()) == 1:
good = 1
r = pol.variables()[0]
varindex = R.gens().index(r)
#add this coordinates information to
#each dictionary entry
P.update({
R.gen(varindex):
-pol.constant_coefficient() /
pol.monomial_coefficient(r)
})
new_points.append(copy(P))
else:
new_points.append(P)
good = 1
if good:
points = new_points
#the dictionary entries now have values for all coordinates
#they are the rational solutions to the equations
#make them into projective points
for i in range(len(points)):
if len(points[i]) == N + 1 and I.subs(
points[i]) == I0:
S = X([
points[i][R.gen(j)] for j in range(N + 1)
])
S.normalize_coordinates()
rat_points.add(S)
rat_points = sorted(rat_points)
return rat_points
R = self.value_ring()
if is_RationalField(R):
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified" %
B)
from sage.schemes.projective.projective_rational_point import enum_projective_rational_field
return enum_projective_rational_field(self, B)
elif R in NumberFields():
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified" %
B)
from sage.schemes.projective.projective_rational_point import enum_projective_number_field
return enum_projective_number_field(self, B, prec=prec)
elif is_FiniteField(R):
from sage.schemes.projective.projective_rational_point import enum_projective_finite_field
return enum_projective_finite_field(self.extended_codomain())
else:
raise TypeError("unable to enumerate points over %s" % R)
def field_of_definition_periodic(self,
n,
formal=False,
return_embedding=False,
simplify_all=False,
names='a'):
r"""
Return smallest extension of the base field which contains all fixed points
of the ``n``-th iterate
Ambient space of dynamical system must be either the affine line
or projective line over a number field or finite field.
INPUT:
- ``n`` -- a positive integer
- ``formal`` -- (default: ``False``) boolean; ``True`` signals to return number
field or finite field over which the formal periodic points are defined, where a
formal periodic point is a root of the ``n``-th dynatomic polynomial.
``False`` specifies to find number field or finite field over which all periodic
points of the ``n``-th iterate are defined
- ``return_embedding`` -- (default: ``False``) boolean; If ``True``, return
an embedding of base field of dynamical system into the returned number
field or finite field. Note that computing this embedding might be expensive.
- ``simplify_all`` -- (default: ``False``) boolean; If ``True``, simplify
intermediate fields and also the resulting number field. Note that this
is not implemented for finite fields and has no effect
- ``names`` -- (optional) string to be used as generator for returned number
field or finite field
OUTPUT:
If ``return_embedding`` is ``False``, the field of definition as an absolute
number field or finite field. If ``return_embedding`` is ``True``, a tuple
``(K, phi)`` where ``phi`` is an embedding of the base field in ``K``.
EXAMPLES::
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([x^2, y^2], domain=P)
sage: f.periodic_points(3, minimal=False)
[(0 : 1), (1 : 0), (1 : 1)]
sage: N.<a> = f.field_of_definition_periodic(3); N
Number Field in a with defining polynomial x^6 + x^5 + x^4 + x^3 + x^2 + x + 1
sage: sorted(f.periodic_points(3,minimal=False, R=N), key=str)
[(-a^5 - a^4 - a^3 - a^2 - a - 1 : 1),
(0 : 1),
(1 : 0),
(1 : 1),
(a : 1),
(a^2 : 1),
(a^3 : 1),
(a^4 : 1),
(a^5 : 1)]
::
sage: A.<z> = AffineSpace(QQ, 1)
sage: f = DynamicalSystem([(z^2 + 1)/(2*z + 1)], domain=A)
sage: K.<a> = f.field_of_definition_periodic(2); K
Number Field in a with defining polynomial z^4 + 12*z^3 + 39*z^2 + 18*z + 171
sage: F.<b> = f.field_of_definition_periodic(2, formal=True); F
Number Field in b with defining polynomial z^2 + 3*z + 6
::
sage: G.<a> = GF(4)
sage: A.<x> = AffineSpace(G, 1)
sage: f = DynamicalSystem([x^2 + (a+1)*x + 1], domain=A)
sage: g = f.nth_iterate_map(2)[0]
sage: (g-x).univariate_polynomial().factor()
(x + 1) * (x + a + 1) * (x^2 + a*x + 1)
sage: f.field_of_definition_periodic(2, return_embedding=True, names='b')
(Finite Field in b of size 2^4, Ring morphism:
From: Finite Field in a of size 2^2
To: Finite Field in b of size 2^4
Defn: a |--> b^2 + b)
"""
ds = copy(self)
n = int(n)
K = ds.base_ring()
if n < 1:
raise ValueError('`n` must be >= 1')
space = ds.domain().ambient_space()
if space.dimension() != 1:
raise NotImplementedError(
"not implemented for affine or projective spaces of dimension >1"
)
if isinstance(
K,
(AlgebraicClosureFiniteField_generic, AlgebraicField_common)):
if return_embedding:
return (K, K.hom(K))
else:
return K
if space.is_projective():
ds = ds.dehomogenize(1)
CR = space.coordinate_ring()
if CR.is_field():
#want the polynomial ring not the fraction field
CR = CR.ring()
x = CR.gen(0)
if formal:
poly = ds.dynatomic_polynomial(n)
poly = CR(poly).univariate_polynomial()
else:
fn = ds.nth_iterate_map(n)
f, g = fn[0].numerator(), fn[0].denominator()
poly = (f - g * x).univariate_polynomial()
if is_FiniteField(ds.base_ring()):
return poly.splitting_field(names, map=return_embedding)
else:
K = poly.splitting_field(names,
map=return_embedding,
simplify_all=simplify_all)
if return_embedding:
N = K[0]
else:
N = K
if N.absolute_degree() == 1:
if return_embedding:
return (QQ, ds.base_ring().embeddings(QQ)[0])
else:
return QQ
else:
return K
def points(self, B=0, prec=53):
r"""
Return some or all rational points of a projective scheme.
Over a finite field, all points are returned. Over an infinite field, all points satisfying the bound
are returned. For a zero-dimensional subscheme, all points are returned regardless of whether the base
ring is a field or not.
INPUT:
- `B` -- integer (optional, default=0). The bound for the
coordinates.
- ``prec`` - the precision to use to compute the elements of bounded height for number fields.
OUTPUT:
- a list of rational points of a projective scheme.
.. WARNING::
In the current implementation, the output of the [Doyle-Krumm]_ algorithm
cannot be guaranteed to be correct due to the necessity of floating point
computations. In some cases, the default 53-bit precision is
considerably lower than would be required for the algorithm to
generate correct output.
EXAMPLES::
sage: P.<x,y,z,w> = ProductProjectiveSpaces([1, 1], QQ)
sage: X = P.subscheme([x - y, z^2 - 2*w^2])
sage: X(P.base_ring()).points()
[]
::
sage: u = QQ['u'].0
sage: P.<x,y,z,w> = ProductProjectiveSpaces([1,1], NumberField(u^2 - 2, 'v'))
sage: X = P.subscheme([x^2 - y^2, z^2 - 2*w^2])
sage: X(P.base_ring()).points()
[(-1 : 1 , -v : 1), (1 : 1 , v : 1), (1 : 1 , -v : 1), (-1 : 1 , v : 1)]
::
sage: u = QQ['u'].0
sage: K = NumberField(u^2 + 1, 'v')
sage: P.<x,y,z,w> = ProductProjectiveSpaces([1, 1], K)
sage: P(K).points(1)
[(0 : 1 , 0 : 1), (0 : 1 , v : 1), (0 : 1 , -1 : 1), (0 : 1 , -v : 1), (0 : 1 , 1 : 1),
(0 : 1 , 1 : 0), (v : 1 , 0 : 1), (v : 1 , v : 1), (v : 1 , -1 : 1), (v : 1 , -v : 1),
(v : 1 , 1 : 1), (v : 1 , 1 : 0), (-1 : 1 , 0 : 1), (-1 : 1 , v : 1), (-1 : 1 , -1 : 1),
(-1 : 1 , -v : 1), (-1 : 1 , 1 : 1), (-1 : 1 , 1 : 0), (-v : 1 , 0 : 1), (-v : 1 , v : 1),
(-v : 1 , -1 : 1), (-v : 1 , -v : 1), (-v : 1 , 1 : 1), (-v : 1 , 1 : 0), (1 : 1 , 0 : 1),
(1 : 1 , v : 1), (1 : 1 , -1 : 1), (1 : 1 , -v : 1), (1 : 1 , 1 : 1), (1 : 1 , 1 : 0),
(1 : 0 , 0 : 1), (1 : 0 , v : 1), (1 : 0 , -1 : 1), (1 : 0 , -v : 1), (1 : 0 , 1 : 1),
(1 : 0 , 1 : 0)]
::
sage: P.<x,y,z,u,v> = ProductProjectiveSpaces([2, 1], GF(3))
sage: P(P.base_ring()).points()
[(0 : 0 : 1 , 0 : 1), (1 : 0 : 1 , 0 : 1), (2 : 0 : 1 , 0 : 1), (0 : 1 : 1 , 0 : 1), (1 : 1 : 1 , 0 : 1),
(2 : 1 : 1 , 0 : 1), (0 : 2 : 1 , 0 : 1), (1 : 2 : 1 , 0 : 1), (2 : 2 : 1 , 0 : 1), (0 : 1 : 0 , 0 : 1),
(1 : 1 : 0 , 0 : 1), (2 : 1 : 0 , 0 : 1), (1 : 0 : 0 , 0 : 1), (0 : 0 : 1 , 1 : 1), (1 : 0 : 1 , 1 : 1),
(2 : 0 : 1 , 1 : 1), (0 : 1 : 1 , 1 : 1), (1 : 1 : 1 , 1 : 1), (2 : 1 : 1 , 1 : 1), (0 : 2 : 1 , 1 : 1),
(1 : 2 : 1 , 1 : 1), (2 : 2 : 1 , 1 : 1), (0 : 1 : 0 , 1 : 1), (1 : 1 : 0 , 1 : 1), (2 : 1 : 0 , 1 : 1),
(1 : 0 : 0 , 1 : 1), (0 : 0 : 1 , 2 : 1), (1 : 0 : 1 , 2 : 1), (2 : 0 : 1 , 2 : 1), (0 : 1 : 1 , 2 : 1),
(1 : 1 : 1 , 2 : 1), (2 : 1 : 1 , 2 : 1), (0 : 2 : 1 , 2 : 1), (1 : 2 : 1 , 2 : 1), (2 : 2 : 1 , 2 : 1),
(0 : 1 : 0 , 2 : 1), (1 : 1 : 0 , 2 : 1), (2 : 1 : 0 , 2 : 1), (1 : 0 : 0 , 2 : 1), (0 : 0 : 1 , 1 : 0),
(1 : 0 : 1 , 1 : 0), (2 : 0 : 1 , 1 : 0), (0 : 1 : 1 , 1 : 0), (1 : 1 : 1 , 1 : 0), (2 : 1 : 1 , 1 : 0),
(0 : 2 : 1 , 1 : 0), (1 : 2 : 1 , 1 : 0), (2 : 2 : 1 , 1 : 0), (0 : 1 : 0 , 1 : 0), (1 : 1 : 0 , 1 : 0),
(2 : 1 : 0 , 1 : 0), (1 : 0 : 0 , 1 : 0)]
"""
X = self.codomain()
from sage.schemes.product_projective.space import is_ProductProjectiveSpaces
if not is_ProductProjectiveSpaces(X) and X.base_ring() in Fields():
# no points
if X.dimension() == -1:
return []
# if X is zero-dimensional
if X.dimension() == 0:
points = set()
# find points from all possible affine patches
for I in xmrange([n + 1 for n in X.ambient_space().dimension_relative_components()]):
[Y,phi] = X.affine_patch(I, True)
aff_points = Y.rational_points()
for PP in aff_points:
points.add(phi(PP))
return list(points)
R = self.value_ring()
points = []
if R in NumberFields():
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified"%B)
for P in X.ambient_space().points_of_bounded_height(B, prec):
try:
points.append(X(P))
except TypeError:
pass
return points
if is_FiniteField(R):
for P in X.ambient_space().rational_points():
try:
points.append(X(P))
except TypeError:
pass
return points
else:
raise TypeError("unable to enumerate points over %s"%R)
def field_of_definition_preimage(self, point, n, return_embedding=False, simplify_all=False, names='a'):
r"""
Return smallest extension of the base field which contains the
``n``-th preimages of ``point``
Ambient space of dynamical system must be either the affine line or
projective line over a number field or finite field.
INPUT:
- ``point`` -- a point in this map's domain
- ``n`` -- a positive integer
- ``return_embedding`` -- (default: ``False``) boolean; If ``True``, return
an embedding of base field of dynamical system into the returned number
field or finite field. Note that computing this embedding might be expensive.
- ``simplify_all`` -- (default: ``False``) boolean; If ``True``, simplify
intermediate fields and also the resulting number field. Note that this
is not implemented for finite fields and has no effect
- ``names`` -- (optional) string to be used as generator for returned
number field or finite field
OUTPUT:
If ``return_embedding`` is ``False``, the field of definition as an absolute
number field or finite field. If ``return_embedding`` is ``True``, a tuple
``(K, phi)`` where ``phi`` is an embedding of the base field in ``K``.
EXAMPLES::
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([1/3*x^2 + 2/3*x*y, x^2 - 2*y^2], domain=P)
sage: N.<a> = f.field_of_definition_preimage(P(1,1), 2, simplify_all=True); N
Number Field in a with defining polynomial x^8 - 4*x^7 - 128*x^6 + 398*x^5 + 3913*x^4 - 8494*x^3 - 26250*x^2 + 30564*x - 2916
::
sage: A.<z> = AffineSpace(QQ, 1)
sage: f = DynamicalSystem([z^2], domain=A)
sage: K.<a> = f.field_of_definition_preimage(A(1), 3); K
Number Field in a with defining polynomial z^4 + 1
::
sage: G = GF(5)
sage: P.<x,y> = ProjectiveSpace(G, 1)
sage: f = DynamicalSystem([x^2 + 2*y^2, y^2], domain=P)
sage: f.field_of_definition_preimage(P(2,1), 2, return_embedding=True, names='a')
(Finite Field in a of size 5^2, Ring morphism:
From: Finite Field of size 5
To: Finite Field in a of size 5^2
Defn: 1 |--> 1)
"""
ds = copy(self)
n = int(n)
if n < 1:
raise ValueError('`n` must be >= 1')
space = ds.domain().ambient_space()
if space.dimension() != 1:
raise NotImplementedError("not implemented for affine or projective spaces of dimension >1")
try:
point = space(point)
except TypeError:
raise TypeError('`point` must be in {}'.format(ds.domain()))
if space.is_projective():
ds = ds.dehomogenize(1)
else:
point = (point[0],1)
fn = ds.nth_iterate_map(n)
f, g = fn[0].numerator(), fn[0].denominator()
CR = space.coordinate_ring()
if CR.is_field():
#want the polynomial ring not the fraction field
CR = CR.ring()
poly = (f*point[1] - g*CR(point[0])).univariate_polynomial()
if is_FiniteField(ds.base_ring()):
return poly.splitting_field(names, map=return_embedding)
else:
K = poly.splitting_field(names, map=return_embedding, simplify_all=simplify_all)
if return_embedding:
N = K[0]
else:
N = K
if N.absolute_degree() == 1:
if return_embedding:
return (QQ,ds.base_ring().embeddings(QQ)[0])
else:
return QQ
else:
return K
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 (base_field is None or isinstance(base_field, IntegralDomain)):
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 is 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 isinstance(P, IntegralDomain):
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 is 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 is None:
base_field = F.base_ring()
if not isinstance(base_field, IntegralDomain):
raise ValueError("Base field (=%s) must be a field" % base_field)
base_field = base_field.fraction_field()
if names is 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)
if is_FractionField(base_field) and (is_PolynomialRing(
base_field.ring()) or is_MPolynomialRing(base_field.ring())):
return ProjectiveConic_rational_function_field(P2, F)
return ProjectiveConic_field(P2, F)
raise TypeError("Number of variables of F (=%s) must be 2 or 3" % F)
def __classcall_private__(cls, morphism_or_polys, domain=None):
r"""
Return the appropriate dynamical system on an affine scheme.
TESTS::
sage: A.<x> = AffineSpace(ZZ,1)
sage: A1.<z> = AffineSpace(CC,1)
sage: H = End(A1)
sage: f2 = H([z^2+1])
sage: f = DynamicalSystem_affine(f2, A)
sage: f.domain() is A
False
::
sage: P1.<x,y> = ProjectiveSpace(QQ,1)
sage: DynamicalSystem_affine([y, 2*x], domain=P1)
Traceback (most recent call last):
...
ValueError: "domain" must be an affine scheme
sage: H = End(P1)
sage: DynamicalSystem_affine(H([y, 2*x]))
Traceback (most recent call last):
...
ValueError: "domain" must be an affine scheme
::
sage: R.<x,y,z> = QQ[]
sage: f = DynamicalSystem_affine([x+y+z, y*z])
Traceback (most recent call last):
...
ValueError: Number of polys does not match dimension of Affine Space of dimension 3 over Rational Field
::
sage: A.<x,y> = AffineSpace(QQ,2)
sage: f = DynamicalSystem_affine([CC.0*x^2, y^2], domain=A)
Traceback (most recent call last):
...
TypeError: coefficients of polynomial not in Rational Field
"""
if isinstance(morphism_or_polys, SchemeMorphism_polynomial):
morphism = morphism_or_polys
R = morphism.base_ring()
polys = list(morphism)
domain = morphism.domain()
if not is_AffineSpace(domain) and not isinstance(domain, AlgebraicScheme_subscheme_affine):
raise ValueError('"domain" must be an affine scheme')
if domain != morphism_or_polys.codomain():
raise ValueError('domain and codomain do not agree')
if R not in Fields():
return typecall(cls, polys, domain)
if is_FiniteField(R):
return DynamicalSystem_affine_finite_field(polys, domain)
return DynamicalSystem_affine_field(polys, domain)
elif isinstance(morphism_or_polys,(list, tuple)):
polys = list(morphism_or_polys)
else:
polys = [morphism_or_polys]
PR = get_coercion_model().common_parent(*polys)
fraction_field = any(is_FractionField(poly.parent()) for poly in polys)
if fraction_field:
K = PR.base_ring().fraction_field()
# Replace base ring with its fraction field
PR = PR.ring().change_ring(K).fraction_field()
polys = [PR(poly) for poly in polys]
else:
quotient_ring = any(is_QuotientRing(poly.parent()) for poly in polys)
# If any of the list entries lies in a quotient ring, we try
# to lift all entries to a common polynomial ring.
if quotient_ring:
polys = [PR(poly).lift() for poly in polys]
else:
polys = [PR(poly) for poly in polys]
if domain is None:
if PR is SR:
raise TypeError("Symbolic Ring cannot be the base ring")
if fraction_field:
PR = PR.ring()
domain = AffineSpace(PR)
else:
# Check if we can coerce the given polynomials over the given domain
PR = domain.ambient_space().coordinate_ring()
try:
if fraction_field:
PR = PR.fraction_field()
polys = [PR(poly) for poly in polys]
except TypeError:
raise TypeError('coefficients of polynomial not in {}'.format(domain.base_ring()))
if len(polys) != domain.ambient_space().coordinate_ring().ngens():
raise ValueError('Number of polys does not match dimension of {}'.format(domain))
R = domain.base_ring()
if R is SR:
raise TypeError("Symbolic Ring cannot be the base ring")
if not is_AffineSpace(domain) and not isinstance(domain, AlgebraicScheme_subscheme_affine):
raise ValueError('"domain" must be an affine scheme')
if R not in Fields():
return typecall(cls, polys, domain)
if is_FiniteField(R):
return DynamicalSystem_affine_finite_field(polys, domain)
return DynamicalSystem_affine_field(polys, domain)
def ProjectiveSpace(n, R=None, names='x'):
r"""
Return projective space of dimension ``n`` over the ring ``R``.
EXAMPLES: The dimension and ring can be given in either order.
::
sage: ProjectiveSpace(3, QQ)
Projective Space of dimension 3 over Rational Field
sage: ProjectiveSpace(5, QQ)
Projective Space of dimension 5 over Rational Field
sage: P = ProjectiveSpace(2, QQ, names='XYZ'); P
Projective Space of dimension 2 over Rational Field
sage: P.coordinate_ring()
Multivariate Polynomial Ring in X, Y, Z over Rational Field
The divide operator does base extension.
::
sage: ProjectiveSpace(5)/GF(17)
Projective Space of dimension 5 over Finite Field of size 17
The default base ring is `\ZZ`.
::
sage: ProjectiveSpace(5)
Projective Space of dimension 5 over Integer Ring
There is also an projective space associated each polynomial ring.
::
sage: R = GF(7)['x,y,z']
sage: P = ProjectiveSpace(R); P
Projective Space of dimension 2 over Finite Field of size 7
sage: P.coordinate_ring()
Multivariate Polynomial Ring in x, y, z over Finite Field of size 7
sage: P.coordinate_ring() is R
True
::
sage: ProjectiveSpace(3, Zp(5), 'y')
Projective Space of dimension 3 over 5-adic Ring with capped relative precision 20
::
sage: ProjectiveSpace(2,QQ,'x,y,z')
Projective Space of dimension 2 over Rational Field
::
sage: PS.<x,y>=ProjectiveSpace(1,CC)
sage: PS
Projective Space of dimension 1 over Complex Field with 53 bits of precision
Projective spaces are not cached, i.e., there can be several with
the same base ring and dimension (to facilitate gluing
constructions).
"""
if is_MPolynomialRing(n) and R is None:
A = ProjectiveSpace(n.ngens() - 1, n.base_ring())
A._coordinate_ring = n
return A
if isinstance(R, (int, long, Integer)):
n, R = R, n
if R is None:
R = ZZ # default is the integers
if R in _Fields:
if is_FiniteField(R):
return ProjectiveSpace_finite_field(n, R, names)
if is_RationalField(R):
return ProjectiveSpace_rational_field(n, R, names)
else:
return ProjectiveSpace_field(n, R, names)
elif isinstance(R, CommutativeRing):
return ProjectiveSpace_ring(n, R, names)
else:
raise TypeError("R (=%s) must be a commutative ring" % R)
def points(self, B=0):
r"""
Return some or all rational points of an affine scheme.
INPUT:
- ``B`` -- integer (optional, default: 0). The bound for the
height of the coordinates.
OUTPUT:
- If the base ring is a finite field: all points of the scheme,
given by coordinate tuples.
- If the base ring is `\QQ` or `\ZZ`: the subset of points whose
coordinates have height ``B`` or less.
EXAMPLES: The bug reported at #11526 is fixed::
sage: A2 = AffineSpace(ZZ, 2)
sage: F = GF(3)
sage: A2(F).points()
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
sage: R = ZZ
sage: A.<x,y> = R[]
sage: I = A.ideal(x^2-y^2-1)
sage: V = AffineSpace(R, 2)
sage: X = V.subscheme(I)
sage: M = X(R)
sage: M.points(1)
[(-1, 0), (1, 0)]
::
sage: u = QQ['u'].0
sage: K.<v> = NumberField(u^2 + 3)
sage: A.<x,y> = AffineSpace(K, 2)
sage: len(A(K).points(9))
361
::
sage: A.<x,y> = AffineSpace(QQ, 2)
sage: E = A.subscheme([x^2 + y^2 - 1, y^2 - x^3 + x^2 + x - 1])
sage: E(A.base_ring()).points()
[(-1, 0), (0, -1), (0, 1), (1, 0)]
"""
X = self.codomain()
from sage.schemes.affine.affine_space import is_AffineSpace
if not is_AffineSpace(X) and X.base_ring() in Fields():
# Then X must be a subscheme
dim_ideal = X.defining_ideal().dimension()
if dim_ideal < 0: # no points
return []
if dim_ideal == 0: # if X zero-dimensional
N = len(X.ambient_space().gens())
S = X.defining_polynomials()[0].parent()
R = PolynomialRing(S.base_ring(), 's', N, order='lex')
phi = S.hom(R.gens(),R)
J = R.ideal([phi(t) for t in X.defining_polynomials()])
D = J.variety()
points = []
for d in D:
P = [d[t] for t in R.gens()]
points.append(X(P))
points.sort()
return points
R = self.value_ring()
if is_RationalField(R) or R == ZZ:
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified"%B)
from sage.schemes.affine.affine_rational_point import enum_affine_rational_field
return enum_affine_rational_field(self,B)
if R in NumberFields():
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified"%B)
from sage.schemes.affine.affine_rational_point import enum_affine_number_field
return enum_affine_number_field(self,B)
elif is_FiniteField(R):
from sage.schemes.affine.affine_rational_point import enum_affine_finite_field
return enum_affine_finite_field(self)
else:
raise TypeError("unable to enumerate points over %s"%R)
def __classcall_private__(cls, morphism_or_polys, domain=None):
r"""
Return the appropriate dynamical system on an affine scheme.
TESTS::
sage: A.<x> = AffineSpace(ZZ,1)
sage: A1.<z> = AffineSpace(CC,1)
sage: H = End(A1)
sage: f2 = H([z^2+1])
sage: f = DynamicalSystem_affine(f2, A)
sage: f.domain() is A
False
::
sage: P1.<x,y> = ProjectiveSpace(QQ,1)
sage: DynamicalSystem_affine([y, 2*x], domain=P1)
Traceback (most recent call last):
...
ValueError: "domain" must be an affine scheme
sage: H = End(P1)
sage: DynamicalSystem_affine(H([y, 2*x]))
Traceback (most recent call last):
...
ValueError: "domain" must be an affine scheme
"""
if isinstance(morphism_or_polys, SchemeMorphism_polynomial):
morphism = morphism_or_polys
R = morphism.base_ring()
polys = list(morphism)
domain = morphism.domain()
if not is_AffineSpace(domain) and not isinstance(
domain, AlgebraicScheme_subscheme_affine):
raise ValueError('"domain" must be an affine scheme')
if domain != morphism_or_polys.codomain():
raise ValueError('domain and codomain do not agree')
if R not in Fields():
return typecall(cls, polys, domain)
if is_FiniteField(R):
return DynamicalSystem_affine_finite_field(polys, domain)
return DynamicalSystem_affine_field(polys, domain)
elif isinstance(morphism_or_polys, (list, tuple)):
polys = list(morphism_or_polys)
else:
polys = [morphism_or_polys]
# We now arrange for all of our list entries to lie in the same ring
# Fraction field case first
fraction_field = False
for poly in polys:
P = poly.parent()
if is_FractionField(P):
fraction_field = True
break
if fraction_field:
K = P.base_ring().fraction_field()
# Replace base ring with its fraction field
P = P.ring().change_ring(K).fraction_field()
polys = [P(poly) for poly in polys]
else:
# If any of the list entries lies in a quotient ring, we try
# to lift all entries to a common polynomial ring.
quotient_ring = False
for poly in polys:
P = poly.parent()
if is_QuotientRing(P):
quotient_ring = True
break
if quotient_ring:
polys = [P(poly).lift() for poly in polys]
else:
poly_ring = False
for poly in polys:
P = poly.parent()
if is_PolynomialRing(P) or is_MPolynomialRing(P):
poly_ring = True
break
if poly_ring:
polys = [P(poly) for poly in polys]
if domain is None:
f = polys[0]
CR = f.parent()
if CR is SR:
raise TypeError("Symbolic Ring cannot be the base ring")
if fraction_field:
CR = CR.ring()
domain = AffineSpace(CR)
R = domain.base_ring()
if R is SR:
raise TypeError("Symbolic Ring cannot be the base ring")
if not is_AffineSpace(domain) and not isinstance(
domain, AlgebraicScheme_subscheme_affine):
raise ValueError('"domain" must be an affine scheme')
if R not in Fields():
return typecall(cls, polys, domain)
if is_FiniteField(R):
return DynamicalSystem_affine_finite_field(polys, domain)
return DynamicalSystem_affine_field(polys, domain)
def points(self, **kwds):
r"""
Return some or all rational points of an affine scheme.
Over a finite field, all points are returned. Over an infinite field, all points satisfying the bound
are returned. For a zero-dimensional subscheme, all points are returned regardless of whether the field
is infinite or not.
For number fields, this uses the
Doyle-Krumm algorithm 4 (algorithm 5 for imaginary quadratic) for
computing algebraic numbers up to a given height [Doyle-Krumm]_.
The algorithm requires floating point arithmetic, so the user is
allowed to specify the precision for such calculations.
Additionally, due to floating point issues, points
slightly larger than the bound may be returned. This can be controlled
by lowering the tolerance.
INPUT:
- ``bound`` - a real number
- ``tolerance`` - a rational number in (0,1] used in doyle-krumm algorithm-4
- ``precision`` - the precision to use for computing the elements of bounded height of number fields.
OUTPUT:
- a list of rational points of a affine scheme
EXAMPLES: The bug reported at #11526 is fixed::
sage: A2 = AffineSpace(ZZ, 2)
sage: F = GF(3)
sage: A2(F).points()
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
sage: R = ZZ
sage: A.<x,y> = R[]
sage: I = A.ideal(x^2-y^2-1)
sage: V = AffineSpace(R, 2)
sage: X = V.subscheme(I)
sage: M = X(R)
sage: M.points(bound=1)
[(-1, 0), (1, 0)]
::
sage: u = QQ['u'].0
sage: K.<v> = NumberField(u^2 + 3)
sage: A.<x,y> = AffineSpace(K, 2)
sage: len(A(K).points(bound=2))
1849
::
sage: A.<x,y> = AffineSpace(QQ, 2)
sage: E = A.subscheme([x^2 + y^2 - 1, y^2 - x^3 + x^2 + x - 1])
sage: E(A.base_ring()).points()
[(-1, 0), (0, -1), (0, 1), (1, 0)]
"""
B = kwds.pop('bound', 0)
tol = kwds.pop('tolerance', 1e-2)
prec = kwds.pop('precision', 53)
X = self.codomain()
from sage.schemes.affine.affine_space import is_AffineSpace
if not is_AffineSpace(X) and X.base_ring() in Fields():
# Then X must be a subscheme
dim_ideal = X.defining_ideal().dimension()
if dim_ideal < 0: # no points
return []
if dim_ideal == 0: # if X zero-dimensional
N = len(X.ambient_space().gens())
S = X.defining_polynomials()[0].parent()
R = PolynomialRing(S.base_ring(), 's', N, order='lex')
phi = S.hom(R.gens(), R)
J = R.ideal([phi(t) for t in X.defining_polynomials()])
D = J.variety()
points = []
for d in D:
P = [d[t] for t in R.gens()]
points.append(X(P))
points.sort()
return points
R = self.value_ring()
if is_RationalField(R) or R == ZZ:
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified" %
B)
from sage.schemes.affine.affine_rational_point import enum_affine_rational_field
return enum_affine_rational_field(self, B)
if R in NumberFields():
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified" %
B)
from sage.schemes.affine.affine_rational_point import enum_affine_number_field
return enum_affine_number_field(self,
bound=B,
tolerance=tol,
precision=prec)
elif is_FiniteField(R):
from sage.schemes.affine.affine_rational_point import enum_affine_finite_field
return enum_affine_finite_field(self)
else:
raise TypeError("unable to enumerate points over %s" % R)
def points(self, **kwds):
r"""
Return some or all rational points of an affine scheme.
For dimension 0 subschemes points are determined through a groebner
basis calculation. For schemes or subschemes with dimension greater than 1
points are determined through enumeration up to the specified bound.
Over a finite field, all points are returned. Over an infinite field, all points satisfying the bound
are returned. For a zero-dimensional subscheme, all points are returned regardless of whether the field
is infinite or not.
For number fields, this uses the
Doyle-Krumm algorithm 4 (algorithm 5 for imaginary quadratic) for
computing algebraic numbers up to a given height [Doyle-Krumm]_.
The algorithm requires floating point arithmetic, so the user is
allowed to specify the precision for such calculations.
Additionally, due to floating point issues, points
slightly larger than the bound may be returned. This can be controlled
by lowering the tolerance.
INPUT:
kwds:
- ``bound`` - real number (optional, default: 0). The bound for the
height of the coordinates. Only used for subschemes with
dimension at least 1.
- ``zero_tolerance`` - positive real number (optional, default=10^(-10)).
For numerically inexact fields, points are on the subscheme if they
satisfy the equations to within tolerance.
- ``tolerance`` - a rational number in (0,1] used in doyle-krumm algorithm-4
for enumeration over number fields.
- ``precision`` - the precision to use for computing the elements of
bounded height of number fields.
OUTPUT:
- a list of rational points of a affine scheme
.. WARNING::
For numerically inexact fields such as ComplexField or RealField the
list of points returned is very likely to be incomplete. It may also
contain repeated points due to tolerance.
EXAMPLES: The bug reported at #11526 is fixed::
sage: A2 = AffineSpace(ZZ, 2)
sage: F = GF(3)
sage: A2(F).points()
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
::
sage: A.<x,y> = ZZ[]
sage: I = A.ideal(x^2-y^2-1)
sage: V = AffineSpace(ZZ, 2)
sage: X = V.subscheme(I)
sage: M = X(ZZ)
sage: M.points(bound=1)
[(-1, 0), (1, 0)]
::
sage: u = QQ['u'].0
sage: K.<v> = NumberField(u^2 + 3)
sage: A.<x,y> = AffineSpace(K, 2)
sage: len(A(K).points(bound=2))
1849
::
sage: A.<x,y> = AffineSpace(QQ, 2)
sage: E = A.subscheme([x^2 + y^2 - 1, y^2 - x^3 + x^2 + x - 1])
sage: E(A.base_ring()).points()
[(-1, 0), (0, -1), (0, 1), (1, 0)]
::
sage: A.<x,y> = AffineSpace(CC, 2)
sage: E = A.subscheme([y^3 - x^3 - x^2, x*y])
sage: E(A.base_ring()).points()
verbose 0 (124: affine_homset.py, points) Warning: computations in the numerical fields are inexact;points may be computed partially or incorrectly.
[(-1.00000000000000, 0.000000000000000),
(0.000000000000000, 0.000000000000000)]
::
sage: A.<x1,x2> = AffineSpace(CDF, 2)
sage: E = A.subscheme([x1^2 + x2^2 + x1*x2, x1 + x2])
sage: E(A.base_ring()).points()
verbose 0 (124: affine_homset.py, points) Warning: computations in the numerical fields are inexact;points may be computed partially or incorrectly.
[(0.0, 0.0)]
"""
from sage.schemes.affine.affine_space import is_AffineSpace
X = self.codomain()
if not is_AffineSpace(X) and X.base_ring() in Fields():
if hasattr(X.base_ring(), 'precision'):
numerical = True
verbose("Warning: computations in the numerical fields are inexact;points may be computed partially or incorrectly.", level=0)
zero_tol = RR(kwds.pop('zero_tolerance', 10**(-10)))
if zero_tol <= 0:
raise ValueError("tolerance must be positive")
else:
numerical = False
# Then X must be a subscheme
dim_ideal = X.defining_ideal().dimension()
if dim_ideal < 0: # no points
return []
if dim_ideal == 0: # if X zero-dimensional
rat_points = []
AS = X.ambient_space()
N = AS.dimension_relative()
BR = X.base_ring()
#need a lexicographic ordering for elimination
R = PolynomialRing(BR, N, AS.gens(), order='lex')
I = R.ideal(X.defining_polynomials())
I0 = R.ideal(0)
#Determine the points through elimination
#This is much faster than using the I.variety() function on each affine chart.
G = I.groebner_basis()
if G != [1]:
P = {}
points = [P]
#work backwards from solving each equation for the possible
#values of the next coordinate
for i in range(len(G) - 1, -1, -1):
new_points = []
good = 0
for P in points:
#substitute in our dictionary entry that has the values
#of coordinates known so far. This results in a single
#variable polynomial (by elimination)
L = G[i].substitute(P)
if R(L).degree() > 0:
if numerical:
for pol in L.univariate_polynomial().roots(multiplicities=False):
r = L.variables()[0]
varindex = R.gens().index(r)
P.update({R.gen(varindex):pol})
new_points.append(copy(P))
good = 1
else:
L = L.factor()
#the linear factors give the possible rational values of
#this coordinate
for pol, pow in L:
if pol.degree() == 1 and len(pol.variables()) == 1:
good = 1
r = pol.variables()[0]
varindex = R.gens().index(r)
#add this coordinates information to
#each dictionary entry
P.update({R.gen(varindex):-pol.constant_coefficient() /
pol.monomial_coefficient(r)})
new_points.append(copy(P))
else:
new_points.append(P)
good = 1
if good:
points = new_points
#the dictionary entries now have values for all coordinates
#they are the rational solutions to the equations
#make them into affine points
for i in range(len(points)):
if numerical:
if len(points[i]) == N:
S = AS([points[i][R.gen(j)] for j in range(N)])
if all([g(list(S)) < zero_tol for g in X.defining_polynomials()]):
rat_points.append(S)
else:
if len(points[i]) == N and I.subs(points[i]) == I0:
S = X([points[i][R.gen(j)] for j in range(N)])
rat_points.append(S)
rat_points = sorted(rat_points)
return rat_points
R = self.value_ring()
B = kwds.pop('bound', 0)
tol = kwds.pop('tolerance', 1e-2)
prec = kwds.pop('precision', 53)
if is_RationalField(R) or R == ZZ:
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified"%B)
from sage.schemes.affine.affine_rational_point import enum_affine_rational_field
return enum_affine_rational_field(self,B)
if R in NumberFields():
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified"%B)
from sage.schemes.affine.affine_rational_point import enum_affine_number_field
return enum_affine_number_field(self, bound=B, tolerance=tol, precision=prec)
elif is_FiniteField(R):
from sage.schemes.affine.affine_rational_point import enum_affine_finite_field
return enum_affine_finite_field(self)
else:
raise TypeError("unable to enumerate points over %s"%R)
def Curve(F, A=None):
"""
Return the plane or space curve defined by ``F``, where
``F`` can be either a multivariate polynomial, a list or
tuple of polynomials, or an algebraic scheme.
If no ambient space is passed in for ``A``, and if ``F`` is not
an algebraic scheme, a new ambient space is constructed.
Also not specifying an ambient space will cause the curve to be defined
in either affine or projective space based on properties of ``F``. In
particular, if ``F`` contains a nonhomogenous polynomial, the curve is
affine, and if ``F`` consists of homogenous polynomials, then the curve
is projective.
INPUT:
- ``F`` -- a multivariate polynomial, or a list or tuple of polynomials, or an algebraic scheme.
- ``A`` -- (default: None) an ambient space in which to create the curve.
EXAMPLE: A projective plane curve
::
sage: x,y,z = QQ['x,y,z'].gens()
sage: C = Curve(x^3 + y^3 + z^3); C
Projective Plane Curve over Rational Field defined by x^3 + y^3 + z^3
sage: C.genus()
1
EXAMPLE: Affine plane curves
::
sage: x,y = GF(7)['x,y'].gens()
sage: C = Curve(y^2 + x^3 + x^10); C
Affine Plane Curve over Finite Field of size 7 defined by x^10 + x^3 + y^2
sage: C.genus()
0
sage: x, y = QQ['x,y'].gens()
sage: Curve(x^3 + y^3 + 1)
Affine Plane Curve over Rational Field defined by x^3 + y^3 + 1
EXAMPLE: A projective space curve
::
sage: x,y,z,w = QQ['x,y,z,w'].gens()
sage: C = Curve([x^3 + y^3 - z^3 - w^3, x^5 - y*z^4]); C
Projective Curve over Rational Field defined by x^3 + y^3 - z^3 - w^3, x^5 - y*z^4
sage: C.genus()
13
EXAMPLE: An affine space curve
::
sage: x,y,z = QQ['x,y,z'].gens()
sage: C = Curve([y^2 + x^3 + x^10 + z^7, x^2 + y^2]); C
Affine Curve over Rational Field defined by x^10 + z^7 + x^3 + y^2, x^2 + y^2
sage: C.genus()
47
EXAMPLE: We can also make non-reduced non-irreducible curves.
::
sage: x,y,z = QQ['x,y,z'].gens()
sage: Curve((x-y)*(x+y))
Projective Conic Curve over Rational Field defined by x^2 - y^2
sage: Curve((x-y)^2*(x+y)^2)
Projective Plane Curve over Rational Field defined by x^4 - 2*x^2*y^2 + y^4
EXAMPLE: A union of curves is a curve.
::
sage: x,y,z = QQ['x,y,z'].gens()
sage: C = Curve(x^3 + y^3 + z^3)
sage: D = Curve(x^4 + y^4 + z^4)
sage: C.union(D)
Projective Plane Curve over Rational Field defined by
x^7 + x^4*y^3 + x^3*y^4 + y^7 + x^4*z^3 + y^4*z^3 + x^3*z^4 + y^3*z^4 + z^7
The intersection is not a curve, though it is a scheme.
::
sage: X = C.intersection(D); X
Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:
x^3 + y^3 + z^3,
x^4 + y^4 + z^4
Note that the intersection has dimension `0`.
::
sage: X.dimension()
0
sage: I = X.defining_ideal(); I
Ideal (x^3 + y^3 + z^3, x^4 + y^4 + z^4) of Multivariate Polynomial Ring in x, y, z over Rational Field
EXAMPLE: In three variables, the defining equation must be
homogeneous.
If the parent polynomial ring is in three variables, then the
defining ideal must be homogeneous.
::
sage: x,y,z = QQ['x,y,z'].gens()
sage: Curve(x^2+y^2)
Projective Conic Curve over Rational Field defined by x^2 + y^2
sage: Curve(x^2+y^2+z)
Traceback (most recent call last):
...
TypeError: x^2 + y^2 + z is not a homogeneous polynomial
The defining polynomial must always be nonzero::
sage: P1.<x,y> = ProjectiveSpace(1,GF(5))
sage: Curve(0*x)
Traceback (most recent call last):
...
ValueError: defining polynomial of curve must be nonzero
::
sage: A.<x,y,z> = AffineSpace(QQ, 3)
sage: C = Curve([y - x^2, z - x^3], A)
sage: A == C.ambient_space()
True
"""
if not A is None:
if not isinstance(F, (list, tuple)):
return Curve([F], A)
if not is_AmbientSpace(A):
raise TypeError(
"A (=%s) must be either an affine or projective space" % A)
if not all([f.parent() == A.coordinate_ring() for f in F]):
raise TypeError("F (=%s) must be a list or tuple of polynomials of the coordinate ring of " \
"A (=%s)"%(F, A))
n = A.dimension_relative()
if n < 2:
raise TypeError(
"A (=%s) must be either an affine or projective space of dimension > 1"
% A)
# there is no dimension check when initializing a plane curve, so check here that F consists
# of a single nonconstant polynomial
if n == 2:
if len(F) != 1 or F[0] == 0 or not is_MPolynomial(F[0]):
raise TypeError(
"F (=%s) must consist of a single nonconstant polynomial to define a plane curve"
% (F, ))
if is_AffineSpace(A):
if n > 2:
return AffineCurve(A, F)
k = A.base_ring()
if is_FiniteField(k):
if k.is_prime_field():
return AffinePlaneCurve_prime_finite_field(A, F[0])
return AffinePlaneCurve_finite_field(A, F[0])
return AffinePlaneCurve(A, F[0])
elif is_ProjectiveSpace(A):
if not all([f.is_homogeneous() for f in F]):
raise TypeError(
"polynomials defining a curve in a projective space must be homogeneous"
)
if n > 2:
return ProjectiveCurve(A, F)
k = A.base_ring()
if is_FiniteField(k):
if k.is_prime_field():
return ProjectivePlaneCurve_prime_finite_field(A, F[0])
return ProjectivePlaneCurve_finite_field(A, F[0])
return ProjectivePlaneCurve(A, F[0])
if is_AlgebraicScheme(F):
return Curve(F.defining_polynomials(), F.ambient_space())
if isinstance(F, (list, tuple)):
if len(F) == 1:
return Curve(F[0])
F = Sequence(F)
P = F.universe()
if not is_MPolynomialRing(P):
raise TypeError(
"universe of F must be a multivariate polynomial ring")
for f in F:
if not f.is_homogeneous():
A = AffineSpace(P.ngens(), P.base_ring())
A._coordinate_ring = P
return AffineCurve(A, F)
A = ProjectiveSpace(P.ngens() - 1, P.base_ring())
A._coordinate_ring = P
return ProjectiveCurve(A, F)
if not is_MPolynomial(F):
raise TypeError("F (=%s) must be a multivariate polynomial" % F)
P = F.parent()
k = F.base_ring()
if F.parent().ngens() == 2:
if F == 0:
raise ValueError("defining polynomial of curve must be nonzero")
A2 = AffineSpace(2, P.base_ring())
A2._coordinate_ring = P
if is_FiniteField(k):
if k.is_prime_field():
return AffinePlaneCurve_prime_finite_field(A2, F)
else:
return AffinePlaneCurve_finite_field(A2, F)
else:
return AffinePlaneCurve(A2, F)
elif F.parent().ngens() == 3:
if F == 0:
raise ValueError("defining polynomial of curve must be nonzero")
P2 = ProjectiveSpace(2, P.base_ring())
P2._coordinate_ring = P
if F.total_degree() == 2 and k.is_field():
return Conic(F)
if is_FiniteField(k):
if k.is_prime_field():
return ProjectivePlaneCurve_prime_finite_field(P2, F)
else:
return ProjectivePlaneCurve_finite_field(P2, F)
else:
return ProjectivePlaneCurve(P2, F)
else:
raise TypeError("Number of variables of F (=%s) must be 2 or 3" % F)
def HyperellipticCurve(f, h=0, names=None, PP=None, check_squarefree=True):
r"""
Returns the hyperelliptic curve `y^2 + h y = f`, for
univariate polynomials `h` and `f`. If `h`
is not given, then it defaults to 0.
INPUT:
- ``f`` - univariate polynomial
- ``h`` - optional univariate polynomial
- ``names`` (default: ``["x","y"]``) - names for the
coordinate functions
- ``check_squarefree`` (default: ``True``) - test if
the input defines a hyperelliptic curve when f is
homogenized to degree `2g+2` and h to degree
`g+1` for some g.
.. WARNING::
When setting ``check_squarefree=False`` or using a base ring that is
not a field, the output curves are not to be trusted. For example, the
output of ``is_singular`` is always ``False``, without this being
properly tested in that case.
.. NOTE::
The words "hyperelliptic curve" are normally only used for curves of
genus at least two, but this class allows more general smooth double
covers of the projective line (conics and elliptic curves), even though
the class is not meant for those and some outputs may be incorrect.
EXAMPLES:
Basic examples::
sage: R.<x> = QQ[]
sage: HyperellipticCurve(x^5 + x + 1)
Hyperelliptic Curve over Rational Field defined by y^2 = x^5 + x + 1
sage: HyperellipticCurve(x^19 + x + 1, x-2)
Hyperelliptic Curve over Rational Field defined by y^2 + (x - 2)*y = x^19 + x + 1
sage: k.<a> = GF(9); R.<x> = k[]
sage: HyperellipticCurve(x^3 + x - 1, x+a)
Hyperelliptic Curve over Finite Field in a of size 3^2 defined by y^2 + (x + a)*y = x^3 + x + 2
Characteristic two::
sage: P.<x> = GF(8,'a')[]
sage: HyperellipticCurve(x^7+1, x)
Hyperelliptic Curve over Finite Field in a of size 2^3 defined by y^2 + x*y = x^7 + 1
sage: HyperellipticCurve(x^8+x^7+1, x^4+1)
Hyperelliptic Curve over Finite Field in a of size 2^3 defined by y^2 + (x^4 + 1)*y = x^8 + x^7 + 1
sage: HyperellipticCurve(x^8+1, x)
Traceback (most recent call last):
...
ValueError: Not a hyperelliptic curve: highly singular at infinity.
sage: HyperellipticCurve(x^8+x^7+1, x^4)
Traceback (most recent call last):
...
ValueError: Not a hyperelliptic curve: singularity in the provided affine patch.
sage: F.<t> = PowerSeriesRing(FiniteField(2))
sage: P.<x> = PolynomialRing(FractionField(F))
sage: HyperellipticCurve(x^5+t, x)
Hyperelliptic Curve over Laurent Series Ring in t over Finite Field of size 2 defined by y^2 + x*y = x^5 + t
We can change the names of the variables in the output::
sage: k.<a> = GF(9); R.<x> = k[]
sage: HyperellipticCurve(x^3 + x - 1, x+a, names=['X','Y'])
Hyperelliptic Curve over Finite Field in a of size 3^2 defined by Y^2 + (X + a)*Y = X^3 + X + 2
This class also allows curves of genus zero or one, which are strictly
speaking not hyperelliptic::
sage: P.<x> = QQ[]
sage: HyperellipticCurve(x^2+1)
Hyperelliptic Curve over Rational Field defined by y^2 = x^2 + 1
sage: HyperellipticCurve(x^4-1)
Hyperelliptic Curve over Rational Field defined by y^2 = x^4 - 1
sage: HyperellipticCurve(x^3+2*x+2)
Hyperelliptic Curve over Rational Field defined by y^2 = x^3 + 2*x + 2
Double roots::
sage: P.<x> = GF(7)[]
sage: HyperellipticCurve((x^3-x+2)^2*(x^6-1))
Traceback (most recent call last):
...
ValueError: Not a hyperelliptic curve: singularity in the provided affine patch.
sage: HyperellipticCurve((x^3-x+2)^2*(x^6-1), check_squarefree=False)
Hyperelliptic Curve over Finite Field of size 7 defined by y^2 = x^12 + 5*x^10 + 4*x^9 + x^8 + 3*x^7 + 3*x^6 + 2*x^4 + 3*x^3 + 6*x^2 + 4*x + 3
The input for a (smooth) hyperelliptic curve of genus `g` should not
contain polynomials of degree greater than `2g+2`. In the following
example, the hyperelliptic curve has genus 2 and there exists a model
`y^2 = F` of degree 6, so the model `y^2 + yh = f` of degree 200 is not
allowed.::
sage: P.<x> = QQ[]
sage: h = x^100
sage: F = x^6+1
sage: f = F-h^2/4
sage: HyperellipticCurve(f, h)
Traceback (most recent call last):
...
ValueError: Not a hyperelliptic curve: highly singular at infinity.
sage: HyperellipticCurve(F)
Hyperelliptic Curve over Rational Field defined by y^2 = x^6 + 1
An example with a singularity over an inseparable extension of the
base field::
sage: F.<t> = GF(5)[]
sage: P.<x> = F[]
sage: HyperellipticCurve(x^5+t)
Traceback (most recent call last):
...
ValueError: Not a hyperelliptic curve: singularity in the provided affine patch.
Input with integer coefficients creates objects with the integers
as base ring, but only checks smoothness over `\QQ`, not over Spec(`\ZZ`).
In other words, it is checked that the discriminant is non-zero, but it is
not checked whether the discriminant is a unit in `\ZZ^*`.::
sage: P.<x> = ZZ[]
sage: HyperellipticCurve(3*x^7+6*x+6)
Hyperelliptic Curve over Integer Ring defined by y^2 = 3*x^7 + 6*x + 6
TESTS:
Check that `f` can be a constant (see :trac:`15516`)::
sage: R.<u> = PolynomialRing(Rationals())
sage: HyperellipticCurve(-12, u^4 + 7)
Hyperelliptic Curve over Rational Field defined by y^2 + (x^4 + 7)*y = -12
"""
# F is the discriminant; use this for the type check
# rather than f and h, one of which might be constant.
F = h**2 + 4 * f
if not is_Polynomial(F):
raise TypeError("Arguments f (= %s) and h (= %s) must be polynomials" %
(f, h))
P = F.parent()
f = P(f)
h = P(h)
df = f.degree()
dh_2 = 2 * h.degree()
if dh_2 < df:
g = (df - 1) // 2
else:
g = (dh_2 - 1) // 2
if check_squarefree:
# Assuming we are working over a field, this checks that after
# resolving the singularity at infinity, we get a smooth double cover
# of P^1.
if P(2) == 0:
# characteristic 2
if h == 0:
raise ValueError(
"In characteristic 2, argument h (= %s) must be non-zero."
% h)
if h[g + 1] == 0 and f[2 * g + 1]**2 == f[2 * g + 2] * h[g]**2:
raise ValueError("Not a hyperelliptic curve: " \
"highly singular at infinity.")
should_be_coprime = [h, f * h.derivative()**2 + f.derivative()**2]
else:
# characteristic not 2
if not F.degree() in [2 * g + 1, 2 * g + 2]:
raise ValueError("Not a hyperelliptic curve: " \
"highly singular at infinity.")
should_be_coprime = [F, F.derivative()]
try:
smooth = should_be_coprime[0].gcd(
should_be_coprime[1]).degree() == 0
except (AttributeError, NotImplementedError, TypeError):
try:
smooth = should_be_coprime[0].resultant(
should_be_coprime[1]) != 0
except (AttributeError, NotImplementedError, TypeError):
raise NotImplementedError("Cannot determine whether " \
"polynomials %s have a common root. Use " \
"check_squarefree=False to skip this check." % \
should_be_coprime)
if not smooth:
raise ValueError("Not a hyperelliptic curve: " \
"singularity in the provided affine patch.")
R = P.base_ring()
PP = ProjectiveSpace(2, R)
if names is None:
names = ["x", "y"]
if is_FiniteField(R):
if g == 2:
return HyperellipticCurve_g2_finite_field(PP,
f,
h,
names=names,
genus=g)
else:
return HyperellipticCurve_finite_field(PP,
f,
h,
names=names,
genus=g)
elif is_RationalField(R):
if g == 2:
return HyperellipticCurve_g2_rational_field(PP,
f,
h,
names=names,
genus=g)
else:
return HyperellipticCurve_rational_field(PP,
f,
h,
names=names,
genus=g)
elif is_pAdicField(R):
if g == 2:
return HyperellipticCurve_g2_padic_field(PP,
f,
h,
names=names,
genus=g)
else:
return HyperellipticCurve_padic_field(PP,
f,
h,
names=names,
genus=g)
else:
if g == 2:
return HyperellipticCurve_g2_generic(PP,
f,
h,
names=names,
genus=g)
else:
return HyperellipticCurve_generic(PP, f, h, names=names, genus=g)
def HyperellipticCurve(f, h=0, names=None, PP=None, check_squarefree=True):
r"""
Returns the hyperelliptic curve `y^2 + h y = f`, for
univariate polynomials `h` and `f`. If `h`
is not given, then it defaults to 0.
INPUT:
- ``f`` - univariate polynomial
- ``h`` - optional univariate polynomial
- ``names`` (default: ``["x","y"]``) - names for the
coordinate functions
- ``check_squarefree`` (default: ``True``) - test if
the input defines a hyperelliptic curve when f is
homogenized to degree `2g+2` and h to degree
`g+1` for some g.
.. WARNING::
When setting ``check_squarefree=False`` or using a base ring that is
not a field, the output curves are not to be trusted. For example, the
output of ``is_singular`` is always ``False``, without this being
properly tested in that case.
.. NOTE::
The words "hyperelliptic curve" are normally only used for curves of
genus at least two, but this class allows more general smooth double
covers of the projective line (conics and elliptic curves), even though
the class is not meant for those and some outputs may be incorrect.
EXAMPLES:
Basic examples::
sage: R.<x> = QQ[]
sage: HyperellipticCurve(x^5 + x + 1)
Hyperelliptic Curve over Rational Field defined by y^2 = x^5 + x + 1
sage: HyperellipticCurve(x^19 + x + 1, x-2)
Hyperelliptic Curve over Rational Field defined by y^2 + (x - 2)*y = x^19 + x + 1
sage: k.<a> = GF(9); R.<x> = k[]
sage: HyperellipticCurve(x^3 + x - 1, x+a)
Hyperelliptic Curve over Finite Field in a of size 3^2 defined by y^2 + (x + a)*y = x^3 + x + 2
Characteristic two::
sage: P.<x> = GF(8,'a')[]
sage: HyperellipticCurve(x^7+1, x)
Hyperelliptic Curve over Finite Field in a of size 2^3 defined by y^2 + x*y = x^7 + 1
sage: HyperellipticCurve(x^8+x^7+1, x^4+1)
Hyperelliptic Curve over Finite Field in a of size 2^3 defined by y^2 + (x^4 + 1)*y = x^8 + x^7 + 1
sage: HyperellipticCurve(x^8+1, x)
Traceback (most recent call last):
...
ValueError: Not a hyperelliptic curve: highly singular at infinity.
sage: HyperellipticCurve(x^8+x^7+1, x^4)
Traceback (most recent call last):
...
ValueError: Not a hyperelliptic curve: singularity in the provided affine patch.
sage: F.<t> = PowerSeriesRing(FiniteField(2))
sage: P.<x> = PolynomialRing(FractionField(F))
sage: HyperellipticCurve(x^5+t, x)
Hyperelliptic Curve over Laurent Series Ring in t over Finite Field of size 2 defined by y^2 + x*y = x^5 + t
We can change the names of the variables in the output::
sage: k.<a> = GF(9); R.<x> = k[]
sage: HyperellipticCurve(x^3 + x - 1, x+a, names=['X','Y'])
Hyperelliptic Curve over Finite Field in a of size 3^2 defined by Y^2 + (X + a)*Y = X^3 + X + 2
This class also allows curves of genus zero or one, which are strictly
speaking not hyperelliptic::
sage: P.<x> = QQ[]
sage: HyperellipticCurve(x^2+1)
Hyperelliptic Curve over Rational Field defined by y^2 = x^2 + 1
sage: HyperellipticCurve(x^4-1)
Hyperelliptic Curve over Rational Field defined by y^2 = x^4 - 1
sage: HyperellipticCurve(x^3+2*x+2)
Hyperelliptic Curve over Rational Field defined by y^2 = x^3 + 2*x + 2
Double roots::
sage: P.<x> = GF(7)[]
sage: HyperellipticCurve((x^3-x+2)^2*(x^6-1))
Traceback (most recent call last):
...
ValueError: Not a hyperelliptic curve: singularity in the provided affine patch.
sage: HyperellipticCurve((x^3-x+2)^2*(x^6-1), check_squarefree=False)
Hyperelliptic Curve over Finite Field of size 7 defined by y^2 = x^12 + 5*x^10 + 4*x^9 + x^8 + 3*x^7 + 3*x^6 + 2*x^4 + 3*x^3 + 6*x^2 + 4*x + 3
The input for a (smooth) hyperelliptic curve of genus `g` should not
contain polynomials of degree greater than `2g+2`. In the following
example, the hyperelliptic curve has genus 2 and there exists a model
`y^2 = F` of degree 6, so the model `y^2 + yh = f` of degree 200 is not
allowed.::
sage: P.<x> = QQ[]
sage: h = x^100
sage: F = x^6+1
sage: f = F-h^2/4
sage: HyperellipticCurve(f, h)
Traceback (most recent call last):
...
ValueError: Not a hyperelliptic curve: highly singular at infinity.
sage: HyperellipticCurve(F)
Hyperelliptic Curve over Rational Field defined by y^2 = x^6 + 1
An example with a singularity over an inseparable extension of the
base field::
sage: F.<t> = GF(5)[]
sage: P.<x> = F[]
sage: HyperellipticCurve(x^5+t)
Traceback (most recent call last):
...
ValueError: Not a hyperelliptic curve: singularity in the provided affine patch.
Input with integer coefficients creates objects with the integers
as base ring, but only checks smoothness over `\QQ`, not over Spec(`\ZZ`).
In other words, it is checked that the discriminant is non-zero, but it is
not checked whether the discriminant is a unit in `\ZZ^*`.::
sage: P.<x> = ZZ[]
sage: HyperellipticCurve(3*x^7+6*x+6)
Hyperelliptic Curve over Integer Ring defined by y^2 = 3*x^7 + 6*x + 6
TESTS:
Check that `f` can be a constant (see :trac:`15516`)::
sage: R.<u> = PolynomialRing(Rationals())
sage: HyperellipticCurve(-12, u^4 + 7)
Hyperelliptic Curve over Rational Field defined by y^2 + (x^4 + 7)*y = -12
"""
# F is the discriminant; use this for the type check
# rather than f and h, one of which might be constant.
F = h**2 + 4*f
if not is_Polynomial(F):
raise TypeError("Arguments f (= %s) and h (= %s) must be polynomials" % (f, h))
P = F.parent()
f = P(f)
h = P(h)
df = f.degree()
dh_2 = 2*h.degree()
if dh_2 < df:
g = (df-1)//2
else:
g = (dh_2-1)//2
if check_squarefree:
# Assuming we are working over a field, this checks that after
# resolving the singularity at infinity, we get a smooth double cover
# of P^1.
if P(2) == 0:
# characteristic 2
if h == 0:
raise ValueError("In characteristic 2, argument h (= %s) must be non-zero."%h)
if h[g+1] == 0 and f[2*g+1]**2 == f[2*g+2]*h[g]**2:
raise ValueError("Not a hyperelliptic curve: " \
"highly singular at infinity.")
should_be_coprime = [h, f*h.derivative()**2+f.derivative()**2]
else:
# characteristic not 2
if not F.degree() in [2*g+1, 2*g+2]:
raise ValueError("Not a hyperelliptic curve: " \
"highly singular at infinity.")
should_be_coprime = [F, F.derivative()]
try:
smooth = should_be_coprime[0].gcd(should_be_coprime[1]).degree()==0
except (AttributeError, NotImplementedError, TypeError):
try:
smooth = should_be_coprime[0].resultant(should_be_coprime[1])!=0
except (AttributeError, NotImplementedError, TypeError):
raise NotImplementedError("Cannot determine whether " \
"polynomials %s have a common root. Use " \
"check_squarefree=False to skip this check." % \
should_be_coprime)
if not smooth:
raise ValueError("Not a hyperelliptic curve: " \
"singularity in the provided affine patch.")
R = P.base_ring()
PP = ProjectiveSpace(2, R)
if names is None:
names = ["x","y"]
if is_FiniteField(R):
if g == 2:
return HyperellipticCurve_g2_finite_field(PP, f, h, names=names, genus=g)
else:
return HyperellipticCurve_finite_field(PP, f, h, names=names, genus=g)
elif is_RationalField(R):
if g == 2:
return HyperellipticCurve_g2_rational_field(PP, f, h, names=names, genus=g)
else:
return HyperellipticCurve_rational_field(PP, f, h, names=names, genus=g)
elif is_pAdicField(R):
if g == 2:
return HyperellipticCurve_g2_padic_field(PP, f, h, names=names, genus=g)
else:
return HyperellipticCurve_padic_field(PP, f, h, names=names, genus=g)
else:
if g == 2:
return HyperellipticCurve_g2_generic(PP, f, h, names=names, genus=g)
else:
return HyperellipticCurve_generic(PP, f, h, names=names, genus=g)
def Curve(F, A=None):
"""
Return the plane or space curve defined by ``F``, where
``F`` can be either a multivariate polynomial, a list or
tuple of polynomials, or an algebraic scheme.
If no ambient space is passed in for ``A``, and if ``F`` is not
an algebraic scheme, a new ambient space is constructed.
Also not specifying an ambient space will cause the curve to be defined
in either affine or projective space based on properties of ``F``. In
particular, if ``F`` contains a nonhomogenous polynomial, the curve is
affine, and if ``F`` consists of homogenous polynomials, then the curve
is projective.
INPUT:
- ``F`` -- a multivariate polynomial, or a list or tuple of polynomials, or an algebraic scheme.
- ``A`` -- (default: None) an ambient space in which to create the curve.
EXAMPLES: A projective plane curve
::
sage: x,y,z = QQ['x,y,z'].gens()
sage: C = Curve(x^3 + y^3 + z^3); C
Projective Plane Curve over Rational Field defined by x^3 + y^3 + z^3
sage: C.genus()
1
EXAMPLES: Affine plane curves
::
sage: x,y = GF(7)['x,y'].gens()
sage: C = Curve(y^2 + x^3 + x^10); C
Affine Plane Curve over Finite Field of size 7 defined by x^10 + x^3 + y^2
sage: C.genus()
0
sage: x, y = QQ['x,y'].gens()
sage: Curve(x^3 + y^3 + 1)
Affine Plane Curve over Rational Field defined by x^3 + y^3 + 1
EXAMPLES: A projective space curve
::
sage: x,y,z,w = QQ['x,y,z,w'].gens()
sage: C = Curve([x^3 + y^3 - z^3 - w^3, x^5 - y*z^4]); C
Projective Curve over Rational Field defined by x^3 + y^3 - z^3 - w^3, x^5 - y*z^4
sage: C.genus()
13
EXAMPLES: An affine space curve
::
sage: x,y,z = QQ['x,y,z'].gens()
sage: C = Curve([y^2 + x^3 + x^10 + z^7, x^2 + y^2]); C
Affine Curve over Rational Field defined by x^10 + z^7 + x^3 + y^2, x^2 + y^2
sage: C.genus()
47
EXAMPLES: We can also make non-reduced non-irreducible curves.
::
sage: x,y,z = QQ['x,y,z'].gens()
sage: Curve((x-y)*(x+y))
Projective Conic Curve over Rational Field defined by x^2 - y^2
sage: Curve((x-y)^2*(x+y)^2)
Projective Plane Curve over Rational Field defined by x^4 - 2*x^2*y^2 + y^4
EXAMPLES: A union of curves is a curve.
::
sage: x,y,z = QQ['x,y,z'].gens()
sage: C = Curve(x^3 + y^3 + z^3)
sage: D = Curve(x^4 + y^4 + z^4)
sage: C.union(D)
Projective Plane Curve over Rational Field defined by
x^7 + x^4*y^3 + x^3*y^4 + y^7 + x^4*z^3 + y^4*z^3 + x^3*z^4 + y^3*z^4 + z^7
The intersection is not a curve, though it is a scheme.
::
sage: X = C.intersection(D); X
Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:
x^3 + y^3 + z^3,
x^4 + y^4 + z^4
Note that the intersection has dimension `0`.
::
sage: X.dimension()
0
sage: I = X.defining_ideal(); I
Ideal (x^3 + y^3 + z^3, x^4 + y^4 + z^4) of Multivariate Polynomial Ring in x, y, z over Rational Field
EXAMPLES: In three variables, the defining equation must be
homogeneous.
If the parent polynomial ring is in three variables, then the
defining ideal must be homogeneous.
::
sage: x,y,z = QQ['x,y,z'].gens()
sage: Curve(x^2+y^2)
Projective Conic Curve over Rational Field defined by x^2 + y^2
sage: Curve(x^2+y^2+z)
Traceback (most recent call last):
...
TypeError: x^2 + y^2 + z is not a homogeneous polynomial
The defining polynomial must always be nonzero::
sage: P1.<x,y> = ProjectiveSpace(1,GF(5))
sage: Curve(0*x)
Traceback (most recent call last):
...
ValueError: defining polynomial of curve must be nonzero
::
sage: A.<x,y,z> = AffineSpace(QQ, 3)
sage: C = Curve([y - x^2, z - x^3], A)
sage: A == C.ambient_space()
True
"""
if not A is None:
if not isinstance(F, (list, tuple)):
return Curve([F], A)
if not is_AmbientSpace(A):
raise TypeError("A (=%s) must be either an affine or projective space"%A)
if not all([f.parent() == A.coordinate_ring() for f in F]):
raise TypeError("F (=%s) must be a list or tuple of polynomials of the coordinate ring of " \
"A (=%s)"%(F, A))
n = A.dimension_relative()
if n < 2:
raise TypeError("A (=%s) must be either an affine or projective space of dimension > 1"%A)
# there is no dimension check when initializing a plane curve, so check here that F consists
# of a single nonconstant polynomial
if n == 2:
if len(F) != 1 or F[0] == 0 or not is_MPolynomial(F[0]):
raise TypeError("F (=%s) must consist of a single nonconstant polynomial to define a plane curve"%(F,))
if is_AffineSpace(A):
if n > 2:
return AffineCurve(A, F)
k = A.base_ring()
if is_FiniteField(k):
if k.is_prime_field():
return AffinePlaneCurve_prime_finite_field(A, F[0])
return AffinePlaneCurve_finite_field(A, F[0])
return AffinePlaneCurve(A, F[0])
elif is_ProjectiveSpace(A):
if not all([f.is_homogeneous() for f in F]):
raise TypeError("polynomials defining a curve in a projective space must be homogeneous")
if n > 2:
return ProjectiveCurve(A, F)
k = A.base_ring()
if is_FiniteField(k):
if k.is_prime_field():
return ProjectivePlaneCurve_prime_finite_field(A, F[0])
return ProjectivePlaneCurve_finite_field(A, F[0])
return ProjectivePlaneCurve(A, F[0])
if is_AlgebraicScheme(F):
return Curve(F.defining_polynomials(), F.ambient_space())
if isinstance(F, (list, tuple)):
if len(F) == 1:
return Curve(F[0])
F = Sequence(F)
P = F.universe()
if not is_MPolynomialRing(P):
raise TypeError("universe of F must be a multivariate polynomial ring")
for f in F:
if not f.is_homogeneous():
A = AffineSpace(P.ngens(), P.base_ring())
A._coordinate_ring = P
return AffineCurve(A, F)
A = ProjectiveSpace(P.ngens()-1, P.base_ring())
A._coordinate_ring = P
return ProjectiveCurve(A, F)
if not is_MPolynomial(F):
raise TypeError("F (=%s) must be a multivariate polynomial"%F)
P = F.parent()
k = F.base_ring()
if F.parent().ngens() == 2:
if F == 0:
raise ValueError("defining polynomial of curve must be nonzero")
A2 = AffineSpace(2, P.base_ring())
A2._coordinate_ring = P
if is_FiniteField(k):
if k.is_prime_field():
return AffinePlaneCurve_prime_finite_field(A2, F)
else:
return AffinePlaneCurve_finite_field(A2, F)
else:
return AffinePlaneCurve(A2, F)
elif F.parent().ngens() == 3:
if F == 0:
raise ValueError("defining polynomial of curve must be nonzero")
P2 = ProjectiveSpace(2, P.base_ring())
P2._coordinate_ring = P
if F.total_degree() == 2 and k.is_field():
return Conic(F)
if is_FiniteField(k):
if k.is_prime_field():
return ProjectivePlaneCurve_prime_finite_field(P2, F)
else:
return ProjectivePlaneCurve_finite_field(P2, F)
else:
return ProjectivePlaneCurve(P2, F)
else:
raise TypeError("Number of variables of F (=%s) must be 2 or 3"%F)
def ProductProjectiveSpaces(n, R=None, names='x'):
r"""
Returns the Cartesian product of projective spaces.
Can input either a list of projective space over the same base \
ring or the list of dimensions, the base ring, and the variable names.
INPUT:
- ``n`` -- a list of integers or a list of projective spaces.
- ``R`` -- a ring.
- ``names`` -- a string or list of strings.
EXAMPLES::
sage: P1 = ProjectiveSpace(QQ, 2, 'x')
sage: P2 = ProjectiveSpace(QQ, 3, 'y')
sage: ProductProjectiveSpaces([P1, P2])
Product of projective spaces P^2 x P^3 over Rational Field
::
sage: ProductProjectiveSpaces([2, 2],GF(7), 'y')
Product of projective spaces P^2 x P^2 over Finite Field of size 7
::
sage: P1 = ProjectiveSpace(ZZ, 2, 'x')
sage: P2 = ProjectiveSpace(QQ, 3, 'y')
sage: ProductProjectiveSpaces([P1, P2])
Traceback (most recent call last):
...
AttributeError: components must be over the same base ring
"""
if isinstance(R, (list, tuple)):
n, R = R, n
if not isinstance(n, (tuple, list)):
raise TypeError("must be a list of dimensions")
if R is None:
R = QQ # default is the rationals
if isinstance(n[0], ProjectiveSpace_ring):
#this should be a list of projective spaces
names = []
N = []
R = None
for PS in n:
if not isinstance(PS,ProjectiveSpace_ring):
raise TypeError("must be a list of projective spaces or (dimensions, base ring, names)")
if R is None:
R = PS.base_ring()
elif R != PS.base_ring():
raise AttributeError("components must be over the same base ring")
N.append(PS.dimension_relative())
names += PS.variable_names()
if is_FiniteField(R):
X = ProductProjectiveSpaces_finite_field(N, R, names)
elif R in Fields():
X = ProductProjectiveSpaces_field(N, R, names)
else:
X = ProductProjectiveSpaces_ring(N, R, names)
X._components = n
else:
if not isinstance(n,(list,tuple)):
raise ValueError("need list or tuple of dimensions")
if not isinstance(R, CommutativeRing):
raise ValueError("must be a commutative ring")
from sage.structure.category_object import normalize_names
n_vars = sum(d+1 for d in n)
if isinstance(names, six.string_types):
names = normalize_names(n_vars, names)
else:
name_list = list(names)
if len(name_list) == len(n):
names = []
for name, dim in zip(name_list, n):
names += normalize_names(dim+1, name)
else:
n_vars = sum(1+d for d in n)
names = normalize_names(n_vars, name_list)
if is_FiniteField(R):
X = ProductProjectiveSpaces_finite_field(n, R, names)
elif R in Fields():
X = ProductProjectiveSpaces_field(n, R, names)
else:
X = ProductProjectiveSpaces_ring(n, R, names)
return(X)
def ProductProjectiveSpaces(n, R=None, names='x'):
r"""
Returns the Cartesian product of projective spaces.
Can input either a list of projective space over the same base \
ring or the list of dimensions, the base ring, and the variable names.
INPUT:
- ``n`` -- a list of integers or a list of projective spaces.
- ``R`` -- a ring.
- ``names`` -- a string or list of strings.
EXAMPLES::
sage: P1 = ProjectiveSpace(QQ, 2, 'x')
sage: P2 = ProjectiveSpace(QQ, 3, 'y')
sage: ProductProjectiveSpaces([P1, P2])
Product of projective spaces P^2 x P^3 over Rational Field
::
sage: ProductProjectiveSpaces([2, 2],GF(7), 'y')
Product of projective spaces P^2 x P^2 over Finite Field of size 7
::
sage: P1 = ProjectiveSpace(ZZ, 2, 'x')
sage: P2 = ProjectiveSpace(QQ, 3, 'y')
sage: ProductProjectiveSpaces([P1, P2])
Traceback (most recent call last):
...
AttributeError: components must be over the same base ring
"""
if isinstance(R, (list, tuple)):
n, R = R, n
if not isinstance(n, (tuple, list)):
raise TypeError("must be a list of dimensions")
if R is None:
R = QQ # default is the rationals
if isinstance(n[0], ProjectiveSpace_ring):
#this should be a list of projective spaces
names = []
N = []
R = None
for PS in n:
if not isinstance(PS, ProjectiveSpace_ring):
raise TypeError(
"must be a list of projective spaces or (dimensions, base ring, names)"
)
if R is None:
R = PS.base_ring()
elif R != PS.base_ring():
raise AttributeError(
"components must be over the same base ring")
N.append(PS.dimension_relative())
names += PS.variable_names()
if is_FiniteField(R):
X = ProductProjectiveSpaces_finite_field(N, R, names)
elif R in Fields():
X = ProductProjectiveSpaces_field(N, R, names)
else:
X = ProductProjectiveSpaces_ring(N, R, names)
X._components = n
else:
if not isinstance(n, (list, tuple)):
raise ValueError("need list or tuple of dimensions")
if not isinstance(R, CommutativeRing):
raise ValueError("must be a commutative ring")
from sage.structure.category_object import normalize_names
n_vars = sum(d + 1 for d in n)
if isinstance(names, six.string_types):
names = normalize_names(n_vars, names)
else:
name_list = list(names)
if len(name_list) == len(n):
names = []
for name, dim in zip(name_list, n):
names += normalize_names(dim + 1, name)
else:
n_vars = sum(1 + d for d in n)
names = normalize_names(n_vars, name_list)
if is_FiniteField(R):
X = ProductProjectiveSpaces_finite_field(n, R, names)
elif R in Fields():
X = ProductProjectiveSpaces_field(n, R, names)
else:
X = ProductProjectiveSpaces_ring(n, R, names)
return X
def lfsr_sequence(key, fill, n):
r"""
This function creates an lfsr sequence.
INPUT:
- ``key`` - a list of finite field elements,
[c_0,c_1,...,c_k].
- ``fill`` - the list of the initial terms of the lfsr
sequence, [x_0,x_1,...,x_k].
- ``n`` - number of terms of the sequence that the
function returns.
OUTPUT: The lfsr sequence defined by
`x_{n+1} = c_kx_n+...+c_0x_{n-k}`, for
`n \leq k`.
EXAMPLES::
sage: F = GF(2); l = F(1); o = F(0)
sage: F = GF(2); S = LaurentSeriesRing(F,'x'); x = S.gen()
sage: fill = [l,l,o,l]; key = [1,o,o,l]; n = 20
sage: L = lfsr_sequence(key,fill,20); L
[1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0]
sage: g = berlekamp_massey(L); g
x^4 + x^3 + 1
sage: (1)/(g.reverse()+O(x^20))
1 + x + x^2 + x^3 + x^5 + x^7 + x^8 + x^11 + x^15 + x^16 + x^17 + x^18 + O(x^20)
sage: (1+x^2)/(g.reverse()+O(x^20))
1 + x + x^4 + x^8 + x^9 + x^10 + x^11 + x^13 + x^15 + x^16 + x^19 + O(x^20)
sage: (1+x^2+x^3)/(g.reverse()+O(x^20))
1 + x + x^3 + x^5 + x^6 + x^9 + x^13 + x^14 + x^15 + x^16 + x^18 + O(x^20)
sage: fill = [l,l,o,l]; key = [l,o,o,o]; n = 20
sage: L = lfsr_sequence(key,fill,20); L
[1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1]
sage: g = berlekamp_massey(L); g
x^4 + 1
sage: (1+x)/(g.reverse()+O(x^20))
1 + x + x^4 + x^5 + x^8 + x^9 + x^12 + x^13 + x^16 + x^17 + O(x^20)
sage: (1+x+x^3)/(g.reverse()+O(x^20))
1 + x + x^3 + x^4 + x^5 + x^7 + x^8 + x^9 + x^11 + x^12 + x^13 + x^15 + x^16 + x^17 + x^19 + O(x^20)
AUTHORS:
- Timothy Brock (2005-11): with code modified from Python
Cookbook, http://aspn.activestate.com/ASPN/Python/Cookbook/
"""
if not isinstance(key, list):
raise TypeError("key must be a list")
key = Sequence(key)
F = key.universe()
if not is_FiniteField(F):
raise TypeError("universe of sequence must be a finite field")
s = fill
k = len(fill)
L = []
for i in range(n):
s0 = copy.copy(s)
L.append(s[0])
s = s[1:k]
s.append(sum([key[i] * s0[i] for i in range(k)]))
return L
def points(self, **kwds):
"""
Return some or all rational points of a projective scheme.
For dimension 0 subschemes points are determined through a groebner
basis calculation. For schemes or subschemes with dimension greater than 1
points are determined through enumeration up to the specified bound.
INPUT:
kwds:
- ``bound`` - real number (optional, default=0). The bound for the coordinates for
subschemes with dimension at least 1.
- ``precision`` - integer (optional, default=53). The precision to use to
compute the elements of bounded height for number fields.
- ``point_tolerance`` - positive real number (optional, default=10^(-10)).
For numerically inexact fields, two points are considered the same
if their coordinates are within tolerance.
- ``zero_tolerance`` - positive real number (optional, default=10^(-10)).
For numerically inexact fields, points are on the subscheme if they
satisfy the equations to within tolerance.
- ``tolerance`` - a rational number in (0,1] used in doyle-krumm algorithm-4
for enumeration over number fields.
OUTPUT:
- a list of rational points of a projective scheme
.. WARNING::
For numerically inexact fields such as ComplexField or RealField the
list of points returned is very likely to be incomplete. It may also
contain repeated points due to tolerances.
EXAMPLES::
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: P(QQ).points(bound=4)
[(-4 : 1), (-3 : 1), (-2 : 1), (-3/2 : 1), (-4/3 : 1), (-1 : 1),
(-3/4 : 1), (-2/3 : 1), (-1/2 : 1), (-1/3 : 1), (-1/4 : 1), (0 : 1),
(1/4 : 1), (1/3 : 1), (1/2 : 1), (2/3 : 1), (3/4 : 1), (1 : 0), (1 : 1),
(4/3 : 1), (3/2 : 1), (2 : 1), (3 : 1), (4 : 1)]
::
sage: u = QQ['u'].0
sage: K.<v> = NumberField(u^2 + 3)
sage: P.<x,y,z> = ProjectiveSpace(K,2)
sage: len(P(K).points(bound=1.8))
381
::
sage: P1 = ProjectiveSpace(GF(2),1)
sage: F.<a> = GF(4,'a')
sage: P1(F).points()
[(0 : 1), (1 : 0), (1 : 1), (a : 1), (a + 1 : 1)]
::
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: E = P.subscheme([(y^3-y*z^2) - (x^3-x*z^2),(y^3-y*z^2) + (x^3-x*z^2)])
sage: E(P.base_ring()).points()
[(-1 : -1 : 1), (-1 : 0 : 1), (-1 : 1 : 1), (0 : -1 : 1), (0 : 0 : 1), (0 : 1 : 1),
(1 : -1 : 1), (1 : 0 : 1), (1 : 1 : 1)]
::
sage: P.<x,y,z> = ProjectiveSpace(CC, 2)
sage: E = P.subscheme([y^3 - x^3 - x*z^2, x*y*z])
sage: L=E(P.base_ring()).points(); sorted(L, key=str)
verbose 0 (71: projective_homset.py, points) Warning: computations in the numerical fields are inexact;points may be computed partially or incorrectly.
[(-0.500000000000000 + 0.866025403784439*I : 1.00000000000000 : 0.000000000000000),
(-0.500000000000000 - 0.866025403784439*I : 1.00000000000000 : 0.000000000000000),
(-1.00000000000000*I : 0.000000000000000 : 1.00000000000000),
(0.000000000000000 : 0.000000000000000 : 1.00000000000000),
(1.00000000000000 : 1.00000000000000 : 0.000000000000000),
(1.00000000000000*I : 0.000000000000000 : 1.00000000000000)]
sage: L[0].codomain()
Projective Space of dimension 2 over Complex Field with 53 bits of precision
::
sage: P.<x,y,z> = ProjectiveSpace(CDF, 2)
sage: E = P.subscheme([y^2 + x^2 + z^2, x*y*z])
sage: len(E(P.base_ring()).points())
verbose 0 (71: projective_homset.py, points) Warning: computations in the numerical fields are inexact;points may be computed partially or incorrectly.
6
"""
from sage.schemes.projective.projective_space import is_ProjectiveSpace
X = self.codomain()
if not is_ProjectiveSpace(X) and X.base_ring() in Fields():
if hasattr(X.base_ring(), 'precision'):
numerical = True
verbose(
"Warning: computations in the numerical fields are inexact;points may be computed partially or incorrectly.",
level=0)
pt_tol = RR(kwds.pop('point_tolerance', 10**(-10)))
zero_tol = RR(kwds.pop('zero_tolerance', 10**(-10)))
if pt_tol <= 0 or zero_tol <= 0:
raise ValueError("tolerance must be positive")
else:
numerical = False
#Then it must be a subscheme
dim_ideal = X.defining_ideal().dimension()
if dim_ideal < 1: # no points
return []
if dim_ideal == 1: # if X zero-dimensional
rat_points = set()
PS = X.ambient_space()
N = PS.dimension_relative()
BR = X.base_ring()
#need a lexicographic ordering for elimination
R = PolynomialRing(BR, N + 1, PS.variable_names(), order='lex')
I = R.ideal(X.defining_polynomials())
I0 = R.ideal(0)
#Determine the points through elimination
#This is much faster than using the I.variety() function on each affine chart.
for k in range(N + 1):
#create the elimination ideal for the kth affine patch
G = I.substitute({R.gen(k): 1}).groebner_basis()
if G != [1]:
P = {}
#keep track that we know the kth coordinate is 1
P.update({R.gen(k): 1})
points = [P]
#work backwards from solving each equation for the possible
#values of the next coordinate
for i in range(len(G) - 1, -1, -1):
new_points = []
good = 0
for P in points:
#substitute in our dictionary entry that has the values
#of coordinates known so far. This results in a single
#variable polynomial (by elimination)
L = G[i].substitute(P)
if R(L).degree() > 0:
if numerical:
for pol in L.univariate_polynomial(
).roots(multiplicities=False):
good = 1
r = L.variables()[0]
varindex = R.gens().index(r)
P.update({R.gen(varindex): pol})
new_points.append(copy(P))
else:
L = L.factor()
#the linear factors give the possible rational values of
#this coordinate
for pol, pow in L:
if pol.degree() == 1 and len(
pol.variables()) == 1:
good = 1
r = pol.variables()[0]
varindex = R.gens().index(r)
#add this coordinates information to
#each dictionary entry
P.update({
R.gen(varindex):
-pol.constant_coefficient(
) /
pol.monomial_coefficient(r)
})
new_points.append(copy(P))
else:
new_points.append(P)
good = 1
if good:
points = new_points
#the dictionary entries now have values for all coordinates
#they are the rational solutions to the equations
#make them into projective points
for i in range(len(points)):
if numerical:
if len(points[i]) == N + 1:
S = PS([
points[i][R.gen(j)]
for j in range(N + 1)
])
S.normalize_coordinates()
if all(
g(list(S)) < zero_tol
for g in X.defining_polynomials()):
rat_points.add(S)
else:
if len(points[i]) == N + 1 and I.subs(
points[i]) == I0:
S = X([
points[i][R.gen(j)]
for j in range(N + 1)
])
S.normalize_coordinates()
rat_points.add(S)
# remove duplicate element using tolerance
if numerical:
dupl_points = list(rat_points)
for i in range(len(dupl_points)):
u = dupl_points[i]
for j in range(i + 1, len(dupl_points)):
v = dupl_points[j]
if all((u[k] - v[k]).abs() < pt_tol
for k in range(len(u))):
rat_points.remove(u)
break
rat_points = sorted(rat_points)
return rat_points
R = self.value_ring()
B = kwds.pop('bound', 0)
tol = kwds.pop('tolerance', 1e-2)
prec = kwds.pop('precision', 53)
if is_RationalField(R):
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified" %
B)
if isinstance(X, AlgebraicScheme_subscheme
): # sieve should only be called for subschemes
from sage.schemes.projective.projective_rational_point import sieve
return sieve(X, B)
else:
from sage.schemes.projective.projective_rational_point import enum_projective_rational_field
return enum_projective_rational_field(self, B)
elif R in NumberFields():
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified" %
B)
from sage.schemes.projective.projective_rational_point import enum_projective_number_field
return enum_projective_number_field(self,
bound=B,
tolerance=tol,
precision=prec)
elif is_FiniteField(R):
from sage.schemes.projective.projective_rational_point import enum_projective_finite_field
return enum_projective_finite_field(self.extended_codomain())
else:
raise TypeError("unable to enumerate points over %s" % R)
def dual(self):
r"""
Return the projective dual of the given subscheme of projective space.
INPUT:
- ``X`` -- A subscheme of projective space. At present, ``X`` is
required to be an irreducible and reduced hypersurface defined
over `\QQ` or a finite field.
OUTPUT:
- The dual of ``X`` as a subscheme of the dual projective space.
EXAMPLES:
The dual of a smooth conic in the plane is also a smooth conic::
sage: R.<x, y, z> = QQ[]
sage: P.<x, y, z> = ProjectiveSpace(2, QQ)
sage: I = R.ideal(x^2 + y^2 + z^2)
sage: X = P.subscheme(I)
sage: X.dual()
Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:
y0^2 + y1^2 + y2^2
The dual of the twisted cubic curve in projective 3-space is a singular
quartic surface. In the following example, we compute the dual of this
surface, which by double duality is equal to the twisted cubic itself.
The output is the twisted cubic as an intersection of three quadrics::
sage: R.<x, y, z, w> = QQ[]
sage: P.<x, y, z, w> = ProjectiveSpace(3, QQ)
sage: I = R.ideal(y^2*z^2 - 4*x*z^3 - 4*y^3*w + 18*x*y*z*w - 27*x^2*w^2)
sage: X = P.subscheme(I)
sage: X.dual()
Closed subscheme of Projective Space of dimension 3 over
Rational Field defined by:
y2^2 - y1*y3,
y1*y2 - y0*y3,
y1^2 - y0*y2
The singular locus of the quartic surface in the last example
is itself supported on a twisted cubic::
sage: X.Jacobian().radical()
Ideal (z^2 - 3*y*w, y*z - 9*x*w, y^2 - 3*x*z) of Multivariate
Polynomial Ring in x, y, z, w over Rational Field
An example over a finite field::
sage: R = PolynomialRing(GF(61), 'a,b,c')
sage: P.<a, b, c> = ProjectiveSpace(2, R.base_ring())
sage: X = P.subscheme(R.ideal(a*a+2*b*b+3*c*c))
sage: X.dual()
Closed subscheme of Projective Space of dimension 2 over
Finite Field of size 61 defined by:
y0^2 - 30*y1^2 - 20*y2^2
TESTS::
sage: R = PolynomialRing(Qp(3), 'a,b,c')
sage: P.<a, b, c> = ProjectiveSpace(2, R.base_ring())
sage: X = P.subscheme(R.ideal(a*a+2*b*b+3*c*c))
sage: X.dual()
Traceback (most recent call last):
...
NotImplementedError: base ring must be QQ or a finite field
"""
from sage.libs.singular.function_factory import ff
K = self.base_ring()
if not(is_RationalField(K) or is_FiniteField(K)):
raise NotImplementedError("base ring must be QQ or a finite field")
I = self.defining_ideal()
m = I.ngens()
n = I.ring().ngens() - 1
if (m != 1 or (n < 1) or I.is_zero()
or I.is_trivial() or not I.is_prime()):
raise NotImplementedError("At the present, the method is only"
" implemented for irreducible and"
" reduced hypersurfaces and the given"
" list of generators for the ideal must"
" have exactly one element.")
R = PolynomialRing(K, 'x', n + 1)
from sage.schemes.projective.projective_space import ProjectiveSpace
Pd = ProjectiveSpace(n, K, 'y')
Rd = Pd.coordinate_ring()
x = R.variable_names()
y = Rd.variable_names()
S = PolynomialRing(K, x + y + ('t',))
if S.has_coerce_map_from(I.ring()):
T = PolynomialRing(K, 'w', n + 1)
I_S = (I.change_ring(T)).change_ring(S)
else:
I_S = I.change_ring(S)
f_S = I_S.gens()[0]
z = S.gens()
J = I_S
for i in range(n + 1):
J = J + S.ideal(z[-1] * f_S.derivative(z[i]) - z[i + n + 1])
sat = ff.elim__lib.sat
max_ideal = S.ideal(z[n + 1: 2 * n + 2])
J_sat_gens = sat(J, max_ideal)[0]
J_sat = S.ideal(J_sat_gens)
L = J_sat.elimination_ideal(z[0: n + 1] + (z[-1],))
return Pd.subscheme(L.change_ring(Rd))
def field_of_definition_critical(self,
return_embedding=False,
simplify_all=False,
names='a'):
r"""
Return smallest extension of the base field which contains the critical points
Ambient space of dynamical system must be either the affine line or projective
line over a number field or finite field.
INPUT:
- ``return_embedding`` -- (default: ``False``) boolean; If ``True``, return an
embedding of base field of dynamical system into the returned number field or
finite field. Note that computing this embedding might be expensive.
- ``simplify_all`` -- (default: ``False``) boolean; If ``True``, simplify
intermediate fields and also the resulting number field. Note that this
is not implemented for finite fields and has no effect
- ``names`` -- (optional) string to be used as generator for returned number field
or finite field
OUTPUT:
If ``return_embedding`` is ``False``, the field of definition as an absolute number
field or finite field. If ``return_embedding`` is ``True``, a tuple
``(K, phi)`` where ``phi`` is an embedding of the base field in ``K``.
EXAMPLES:
Note that the number of critical points is 2d-2, but (1:0) has multiplicity 2 in this case::
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([1/3*x^3 + x*y^2, y^3], domain=P)
sage: f.critical_points()
[(1 : 0)]
sage: N.<a> = f.field_of_definition_critical(); N
Number Field in a with defining polynomial x^2 + 1
sage: g = f.change_ring(N)
sage: g.critical_points()
[(-a : 1), (a : 1), (1 : 0)]
::
sage: A.<z> = AffineSpace(QQ, 1)
sage: f = DynamicalSystem([z^4 + 2*z^2 + 2], domain=A)
sage: K.<a> = f.field_of_definition_critical(); K
Number Field in a with defining polynomial z^2 + 1
::
sage: G.<a> = GF(9)
sage: R.<z> = G[]
sage: R.irreducible_element(3, algorithm='first_lexicographic')
z^3 + (a + 1)*z + a
sage: A.<x> = AffineSpace(G,1)
sage: f = DynamicalSystem([x^4 + (2*a+2)*x^2 + a*x], domain=A)
sage: f[0].derivative(x).univariate_polynomial().is_irreducible()
True
sage: f.field_of_definition_critical(return_embedding=True, names='b')
(Finite Field in b of size 3^6, Ring morphism:
From: Finite Field in a of size 3^2
To: Finite Field in b of size 3^6
Defn: a |--> 2*b^5 + 2*b^3 + b^2 + 2*b + 2)
"""
ds = copy(self)
space = ds.domain().ambient_space()
K = ds.base_ring()
if space.dimension() != 1:
raise ValueError(
'Ambient space of dynamical system must be either the affine line or projective line'
)
if isinstance(
K,
(AlgebraicClosureFiniteField_generic, AlgebraicField_common)):
if return_embedding:
return (K, K.hom(K))
else:
return K
if space.is_projective():
ds = ds.dehomogenize(1)
f, g = ds[0].numerator(), ds[0].denominator()
CR = space.coordinate_ring()
if CR.is_field():
#want the polynomial ring not the fraction field
CR = CR.ring()
x = CR.gen(0)
poly = (g * CR(f).derivative(x) -
f * CR(g).derivative(x)).univariate_polynomial()
if is_FiniteField(ds.base_ring()):
return poly.splitting_field(names, map=return_embedding)
else:
K = poly.splitting_field(names,
map=return_embedding,
simplify_all=simplify_all)
if return_embedding:
N = K[0]
else:
N = K
if N.absolute_degree() == 1:
if return_embedding:
return (QQ, ds.base_ring().embeddings(QQ)[0])
else:
return QQ
else:
return K
def __classcall_private__(cls, morphism_or_polys, domain=None):
r"""
Return the appropriate dynamical system on an affine scheme.
TESTS::
sage: A.<x> = AffineSpace(ZZ,1)
sage: A1.<z> = AffineSpace(CC,1)
sage: H = End(A1)
sage: f2 = H([z^2+1])
sage: f = DynamicalSystem_affine(f2, A)
sage: f.domain() is A
False
::
sage: P1.<x,y> = ProjectiveSpace(QQ,1)
sage: DynamicalSystem_affine([y, 2*x], domain=P1)
Traceback (most recent call last):
...
ValueError: "domain" must be an affine scheme
sage: H = End(P1)
sage: DynamicalSystem_affine(H([y, 2*x]))
Traceback (most recent call last):
...
ValueError: "domain" must be an affine scheme
::
sage: R.<x,y,z> = QQ[]
sage: f = DynamicalSystem_affine([x+y+z, y*z])
Traceback (most recent call last):
...
ValueError: Number of polys does not match dimension of Affine Space of dimension 3 over Rational Field
::
sage: A.<x,y> = AffineSpace(QQ,2)
sage: f = DynamicalSystem_affine([CC.0*x^2, y^2], domain=A)
Traceback (most recent call last):
...
TypeError: coefficients of polynomial not in Rational Field
"""
if isinstance(morphism_or_polys, SchemeMorphism_polynomial):
morphism = morphism_or_polys
R = morphism.base_ring()
polys = list(morphism)
domain = morphism.domain()
if not is_AffineSpace(domain) and not isinstance(
domain, AlgebraicScheme_subscheme_affine):
raise ValueError('"domain" must be an affine scheme')
if domain != morphism_or_polys.codomain():
raise ValueError('domain and codomain do not agree')
if R not in Fields():
return typecall(cls, polys, domain)
if is_FiniteField(R):
return DynamicalSystem_affine_finite_field(polys, domain)
return DynamicalSystem_affine_field(polys, domain)
elif isinstance(morphism_or_polys, (list, tuple)):
polys = list(morphism_or_polys)
else:
polys = [morphism_or_polys]
PR = get_coercion_model().common_parent(*polys)
fraction_field = any(is_FractionField(poly.parent()) for poly in polys)
if fraction_field:
K = PR.base_ring().fraction_field()
# Replace base ring with its fraction field
PR = PR.ring().change_ring(K).fraction_field()
polys = [PR(poly) for poly in polys]
else:
quotient_ring = any(
is_QuotientRing(poly.parent()) for poly in polys)
# If any of the list entries lies in a quotient ring, we try
# to lift all entries to a common polynomial ring.
if quotient_ring:
polys = [PR(poly).lift() for poly in polys]
else:
polys = [PR(poly) for poly in polys]
if domain is None:
if PR is SR:
raise TypeError("Symbolic Ring cannot be the base ring")
if fraction_field:
PR = PR.ring()
domain = AffineSpace(PR)
else:
# Check if we can coerce the given polynomials over the given domain
PR = domain.ambient_space().coordinate_ring()
try:
if fraction_field:
PR = PR.fraction_field()
polys = [PR(poly) for poly in polys]
except TypeError:
raise TypeError('coefficients of polynomial not in {}'.format(
domain.base_ring()))
if len(polys) != domain.ambient_space().coordinate_ring().ngens():
raise ValueError(
'Number of polys does not match dimension of {}'.format(
domain))
R = domain.base_ring()
if R is SR:
raise TypeError("Symbolic Ring cannot be the base ring")
if not is_AffineSpace(domain) and not isinstance(
domain, AlgebraicScheme_subscheme_affine):
raise ValueError('"domain" must be an affine scheme')
if R not in Fields():
return typecall(cls, polys, domain)
if is_FiniteField(R):
return DynamicalSystem_affine_finite_field(polys, domain)
return DynamicalSystem_affine_field(polys, domain)
def field_of_definition_preimage(self,
point,
n,
return_embedding=False,
simplify_all=False,
names='a'):
r"""
Return smallest extension of the base field which contains the
``n``-th preimages of ``point``
Ambient space of dynamical system must be either the affine line or
projective line over a number field or finite field.
INPUT:
- ``point`` -- a point in this map's domain
- ``n`` -- a positive integer
- ``return_embedding`` -- (default: ``False``) boolean; If ``True``, return
an embedding of base field of dynamical system into the returned number
field or finite field. Note that computing this embedding might be expensive.
- ``simplify_all`` -- (default: ``False``) boolean; If ``True``, simplify
intermediate fields and also the resulting number field. Note that this
is not implemented for finite fields and has no effect
- ``names`` -- (optional) string to be used as generator for returned
number field or finite field
OUTPUT:
If ``return_embedding`` is ``False``, the field of definition as an absolute
number field or finite field. If ``return_embedding`` is ``True``, a tuple
``(K, phi)`` where ``phi`` is an embedding of the base field in ``K``.
EXAMPLES::
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([1/3*x^2 + 2/3*x*y, x^2 - 2*y^2], domain=P)
sage: N.<a> = f.field_of_definition_preimage(P(1,1), 2, simplify_all=True); N
Number Field in a with defining polynomial x^8 - 4*x^7 - 128*x^6 + 398*x^5 + 3913*x^4 - 8494*x^3 - 26250*x^2 + 30564*x - 2916
::
sage: A.<z> = AffineSpace(QQ, 1)
sage: f = DynamicalSystem([z^2], domain=A)
sage: K.<a> = f.field_of_definition_preimage(A(1), 3); K
Number Field in a with defining polynomial z^4 + 1
::
sage: G = GF(5)
sage: P.<x,y> = ProjectiveSpace(G, 1)
sage: f = DynamicalSystem([x^2 + 2*y^2, y^2], domain=P)
sage: f.field_of_definition_preimage(P(2,1), 2, return_embedding=True, names='a')
(Finite Field in a of size 5^2, Ring morphism:
From: Finite Field of size 5
To: Finite Field in a of size 5^2
Defn: 1 |--> 1)
"""
ds = copy(self)
n = int(n)
if n < 1:
raise ValueError('`n` must be >= 1')
space = ds.domain().ambient_space()
if space.dimension() != 1:
raise NotImplementedError(
"not implemented for affine or projective spaces of dimension >1"
)
try:
point = space(point)
except TypeError:
raise TypeError('`point` must be in {}'.format(ds.domain()))
if space.is_projective():
ds = ds.dehomogenize(1)
else:
point = (point[0], 1)
fn = ds.nth_iterate_map(n)
f, g = fn[0].numerator(), fn[0].denominator()
CR = space.coordinate_ring()
if CR.is_field():
#want the polynomial ring not the fraction field
CR = CR.ring()
poly = (f * point[1] - g * CR(point[0])).univariate_polynomial()
if is_FiniteField(ds.base_ring()):
return poly.splitting_field(names, map=return_embedding)
else:
K = poly.splitting_field(names,
map=return_embedding,
simplify_all=simplify_all)
if return_embedding:
N = K[0]
else:
N = K
if N.absolute_degree() == 1:
if return_embedding:
return (QQ, ds.base_ring().embeddings(QQ)[0])
else:
return QQ
else:
return K
def ProjectiveSpace(n, R=None, names="x"):
r"""
Return projective space of dimension ``n`` over the ring ``R``.
EXAMPLES: The dimension and ring can be given in either order.
::
sage: ProjectiveSpace(3, QQ)
Projective Space of dimension 3 over Rational Field
sage: ProjectiveSpace(5, QQ)
Projective Space of dimension 5 over Rational Field
sage: P = ProjectiveSpace(2, QQ, names='XYZ'); P
Projective Space of dimension 2 over Rational Field
sage: P.coordinate_ring()
Multivariate Polynomial Ring in X, Y, Z over Rational Field
The divide operator does base extension.
::
sage: ProjectiveSpace(5)/GF(17)
Projective Space of dimension 5 over Finite Field of size 17
The default base ring is `\ZZ`.
::
sage: ProjectiveSpace(5)
Projective Space of dimension 5 over Integer Ring
There is also an projective space associated each polynomial ring.
::
sage: R = GF(7)['x,y,z']
sage: P = ProjectiveSpace(R); P
Projective Space of dimension 2 over Finite Field of size 7
sage: P.coordinate_ring()
Multivariate Polynomial Ring in x, y, z over Finite Field of size 7
sage: P.coordinate_ring() is R
True
::
sage: ProjectiveSpace(3, Zp(5), 'y')
Projective Space of dimension 3 over 5-adic Ring with capped relative precision 20
::
sage: ProjectiveSpace(2,QQ,'x,y,z')
Projective Space of dimension 2 over Rational Field
::
sage: PS.<x,y>=ProjectiveSpace(1,CC)
sage: PS
Projective Space of dimension 1 over Complex Field with 53 bits of precision
Projective spaces are not cached, i.e., there can be several with
the same base ring and dimension (to facilitate gluing
constructions).
"""
if is_MPolynomialRing(n) and R is None:
A = ProjectiveSpace(n.ngens() - 1, n.base_ring())
A._coordinate_ring = n
return A
if isinstance(R, (int, long, Integer)):
n, R = R, n
if R is None:
R = ZZ # default is the integers
if R in _Fields:
if is_FiniteField(R):
return ProjectiveSpace_finite_field(n, R, names)
if is_RationalField(R):
return ProjectiveSpace_rational_field(n, R, names)
else:
return ProjectiveSpace_field(n, R, names)
elif isinstance(R, CommutativeRing):
return ProjectiveSpace_ring(n, R, names)
else:
raise TypeError("R (=%s) must be a commutative ring" % R)
def field_of_definition_periodic(self, n, formal=False, return_embedding=False, simplify_all=False, names='a'):
r"""
Return smallest extension of the base field which contains all fixed points
of the ``n``-th iterate
Ambient space of dynamical system must be either the affine line
or projective line over a number field or finite field.
INPUT:
- ``n`` -- a positive integer
- ``formal`` -- (default: ``False``) boolean; ``True`` signals to return number
field or finite field over which the formal periodic points are defined, where a
formal periodic point is a root of the ``n``-th dynatomic polynomial.
``False`` specifies to find number field or finite field over which all periodic
points of the ``n``-th iterate are defined
- ``return_embedding`` -- (default: ``False``) boolean; If ``True``, return
an embedding of base field of dynamical system into the returned number
field or finite field. Note that computing this embedding might be expensive.
- ``simplify_all`` -- (default: ``False``) boolean; If ``True``, simplify
intermediate fields and also the resulting number field. Note that this
is not implemented for finite fields and has no effect
- ``names`` -- (optional) string to be used as generator for returned number
field or finite field
OUTPUT:
If ``return_embedding`` is ``False``, the field of definition as an absolute
number field or finite field. If ``return_embedding`` is ``True``, a tuple
``(K, phi)`` where ``phi`` is an embedding of the base field in ``K``.
EXAMPLES::
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([x^2, y^2], domain=P)
sage: f.periodic_points(3, minimal=False)
[(0 : 1), (1 : 0), (1 : 1)]
sage: N.<a> = f.field_of_definition_periodic(3); N
Number Field in a with defining polynomial x^6 + x^5 + x^4 + x^3 + x^2 + x + 1
sage: f.periodic_points(3,minimal=False, R=N)
[(0 : 1),
(a : 1),
(a^5 : 1),
(a^2 : 1),
(-a^5 - a^4 - a^3 - a^2 - a - 1 : 1),
(a^4 : 1),
(1 : 0),
(a^3 : 1),
(1 : 1)]
::
sage: A.<z> = AffineSpace(QQ, 1)
sage: f = DynamicalSystem([(z^2 + 1)/(2*z + 1)], domain=A)
sage: K.<a> = f.field_of_definition_periodic(2); K
Number Field in a with defining polynomial z^4 + 12*z^3 + 39*z^2 + 18*z + 171
sage: F.<b> = f.field_of_definition_periodic(2, formal=True); F
Number Field in b with defining polynomial z^2 + 3*z + 6
::
sage: G.<a> = GF(4)
sage: A.<x> = AffineSpace(G, 1)
sage: f = DynamicalSystem([x^2 + (a+1)*x + 1], domain=A)
sage: g = f.nth_iterate_map(2)[0]
sage: (g-x).univariate_polynomial().factor()
(x + 1) * (x + a + 1) * (x^2 + a*x + 1)
sage: f.field_of_definition_periodic(2, return_embedding=True, names='b')
(Finite Field in b of size 2^4, Ring morphism:
From: Finite Field in a of size 2^2
To: Finite Field in b of size 2^4
Defn: a |--> b^2 + b)
"""
ds = copy(self)
n = int(n)
if n < 1:
raise ValueError('`n` must be >= 1')
space = ds.domain().ambient_space()
if space.dimension() != 1:
raise NotImplementedError("not implemented for affine or projective spaces of dimension >1")
if space.is_projective():
ds = ds.dehomogenize(1)
CR = space.coordinate_ring()
if CR.is_field():
#want the polynomial ring not the fraction field
CR = CR.ring()
x = CR.gen(0)
if formal:
poly = ds.dynatomic_polynomial(n)
poly = CR(poly).univariate_polynomial()
else:
fn = ds.nth_iterate_map(n)
f,g = fn[0].numerator(), fn[0].denominator()
poly = (f - g*x).univariate_polynomial()
if is_FiniteField(ds.base_ring()):
return poly.splitting_field(names, map=return_embedding)
else:
K = poly.splitting_field(names, map=return_embedding, simplify_all=simplify_all)
if return_embedding:
N = K[0]
else:
N = K
if N.absolute_degree() == 1:
if return_embedding:
return (QQ,ds.base_ring().embeddings(QQ)[0])
else:
return QQ
else:
return K
def dual(self):
r"""
Return the projective dual of the given subscheme of projective space.
INPUT:
- ``X`` -- A subscheme of projective space. At present, ``X`` is
required to be an irreducible and reduced hypersurface defined
over `\QQ` or a finite field.
OUTPUT:
- The dual of ``X`` as a subscheme of the dual projective space.
EXAMPLES:
The dual of a smooth conic in the plane is also a smooth conic::
sage: R.<x, y, z> = QQ[]
sage: P.<x, y, z> = ProjectiveSpace(2, QQ)
sage: I = R.ideal(x^2 + y^2 + z^2)
sage: X = P.subscheme(I)
sage: X.dual()
Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:
y0^2 + y1^2 + y2^2
The dual of the twisted cubic curve in projective 3-space is a singular
quartic surface. In the following example, we compute the dual of this
surface, which by double duality is equal to the twisted cubic itself.
The output is the twisted cubic as an intersection of three quadrics::
sage: R.<x, y, z, w> = QQ[]
sage: P.<x, y, z, w> = ProjectiveSpace(3, QQ)
sage: I = R.ideal(y^2*z^2 - 4*x*z^3 - 4*y^3*w + 18*x*y*z*w - 27*x^2*w^2)
sage: X = P.subscheme(I)
sage: X.dual()
Closed subscheme of Projective Space of dimension 3 over
Rational Field defined by:
y2^2 - y1*y3,
y1*y2 - y0*y3,
y1^2 - y0*y2
The singular locus of the quartic surface in the last example
is itself supported on a twisted cubic::
sage: X.Jacobian().radical()
Ideal (z^2 - 3*y*w, y*z - 9*x*w, y^2 - 3*x*z) of Multivariate
Polynomial Ring in x, y, z, w over Rational Field
An example over a finite field::
sage: R = PolynomialRing(GF(61), 'a,b,c')
sage: P.<a, b, c> = ProjectiveSpace(2, R.base_ring())
sage: X = P.subscheme(R.ideal(a*a+2*b*b+3*c*c))
sage: X.dual()
Closed subscheme of Projective Space of dimension 2 over
Finite Field of size 61 defined by:
y0^2 - 30*y1^2 - 20*y2^2
TESTS::
sage: R = PolynomialRing(Qp(3), 'a,b,c')
sage: P.<a, b, c> = ProjectiveSpace(2, R.base_ring())
sage: X = P.subscheme(R.ideal(a*a+2*b*b+3*c*c))
sage: X.dual()
Traceback (most recent call last):
...
NotImplementedError: base ring must be QQ or a finite field
"""
from sage.libs.singular.function_factory import ff
K = self.base_ring()
if not (is_RationalField(K) or is_FiniteField(K)):
raise NotImplementedError("base ring must be QQ or a finite field")
I = self.defining_ideal()
m = I.ngens()
n = I.ring().ngens() - 1
if (m != 1 or (n < 1) or I.is_zero() or I.is_trivial()
or not I.is_prime()):
raise NotImplementedError("At the present, the method is only"
" implemented for irreducible and"
" reduced hypersurfaces and the given"
" list of generators for the ideal must"
" have exactly one element.")
R = PolynomialRing(K, 'x', n + 1)
from sage.schemes.projective.projective_space import ProjectiveSpace
Pd = ProjectiveSpace(n, K, 'y')
Rd = Pd.coordinate_ring()
x = R.variable_names()
y = Rd.variable_names()
S = PolynomialRing(K, x + y + ('t', ))
if S.has_coerce_map_from(I.ring()):
T = PolynomialRing(K, 'w', n + 1)
I_S = (I.change_ring(T)).change_ring(S)
else:
I_S = I.change_ring(S)
f_S = I_S.gens()[0]
z = S.gens()
J = I_S
for i in range(n + 1):
J = J + S.ideal(z[-1] * f_S.derivative(z[i]) - z[i + n + 1])
sat = ff.elim__lib.sat
max_ideal = S.ideal(z[n + 1:2 * n + 2])
J_sat_gens = sat(J, max_ideal)[0]
J_sat = S.ideal(J_sat_gens)
L = J_sat.elimination_ideal(z[0:n + 1] + (z[-1], ))
return Pd.subscheme(L.change_ring(Rd))
def points(self, **kwds):
r"""
Return some or all rational points of a projective scheme.
Over a finite field, all points are returned. Over an infinite field, all points satisfying the bound
are returned. For a zero-dimensional subscheme, all points are returned regardless of whether the base
ring is a field or not.
For number fields, this uses the
Doyle-Krumm algorithm 4 (algorithm 5 for imaginary quadratic) for
computing algebraic numbers up to a given height [DK2013]_ or
uses the chinese remainder theorem and points modulo primes
for larger bounds.
The algorithm requires floating point arithmetic, so the user is
allowed to specify the precision for such calculations.
Additionally, due to floating point issues, points
slightly larger than the bound may be returned. This can be controlled
by lowering the tolerance.
INPUT:
- ``bound`` - a real number
- ``tolerance`` - a rational number in (0,1] used in doyle-krumm algorithm-4
- ``precision`` - the precision to use for computing the elements of bounded height of number fields.
- ``algorithm`` - either 'sieve' or 'enumerate' algorithms can be used over `QQ`. If
not specified, enumerate is used only for small height bounds.
OUTPUT:
- a list of rational points of a projective scheme
EXAMPLES::
sage: P.<x,y,z,w> = ProductProjectiveSpaces([1, 1], QQ)
sage: X = P.subscheme([x - y, z^2 - 2*w^2])
sage: X(P.base_ring()).points()
[]
::
sage: u = QQ['u'].0
sage: P.<x,y,z,w> = ProductProjectiveSpaces([1,1], NumberField(u^2 - 2, 'v'))
sage: X = P.subscheme([x^2 - y^2, z^2 - 2*w^2])
sage: sorted(X(P.base_ring()).points())
[(-1 : 1 , -v : 1), (-1 : 1 , v : 1), (1 : 1 , -v : 1), (1 : 1 , v : 1)]
::
sage: u = QQ['u'].0
sage: K = NumberField(u^2 + 1, 'v')
sage: P.<x,y,z,w> = ProductProjectiveSpaces([1, 1], K)
sage: P(K).points(bound=1)
[(-1 : 1 , -1 : 1), (-1 : 1 , -v : 1), (-1 : 1 , 0 : 1), (-1 : 1 , v : 1),
(-1 : 1 , 1 : 0), (-1 : 1 , 1 : 1), (-v : 1 , -1 : 1), (-v : 1 , -v : 1),
(-v : 1 , 0 : 1), (-v : 1 , v : 1), (-v : 1 , 1 : 0), (-v : 1 , 1 : 1),
(0 : 1 , -1 : 1), (0 : 1 , -v : 1), (0 : 1 , 0 : 1), (0 : 1 , v : 1),
(0 : 1 , 1 : 0), (0 : 1 , 1 : 1), (v : 1 , -1 : 1), (v : 1 , -v : 1),
(v : 1 , 0 : 1), (v : 1 , v : 1), (v : 1 , 1 : 0), (v : 1 , 1 : 1),
(1 : 0 , -1 : 1), (1 : 0 , -v : 1), (1 : 0 , 0 : 1), (1 : 0 , v : 1),
(1 : 0 , 1 : 0), (1 : 0 , 1 : 1), (1 : 1 , -1 : 1), (1 : 1 , -v : 1),
(1 : 1 , 0 : 1), (1 : 1 , v : 1), (1 : 1 , 1 : 0), (1 : 1 , 1 : 1)]
::
sage: P.<x,y,z,u,v> = ProductProjectiveSpaces([2, 1], GF(3))
sage: P(P.base_ring()).points()
[(0 : 0 : 1 , 0 : 1), (0 : 0 : 1 , 1 : 0), (0 : 0 : 1 , 1 : 1), (0 : 0 : 1 , 2 : 1),
(0 : 1 : 0 , 0 : 1), (0 : 1 : 0 , 1 : 0), (0 : 1 : 0 , 1 : 1), (0 : 1 : 0 , 2 : 1),
(0 : 1 : 1 , 0 : 1), (0 : 1 : 1 , 1 : 0), (0 : 1 : 1 , 1 : 1), (0 : 1 : 1 , 2 : 1),
(0 : 2 : 1 , 0 : 1), (0 : 2 : 1 , 1 : 0), (0 : 2 : 1 , 1 : 1), (0 : 2 : 1 , 2 : 1),
(1 : 0 : 0 , 0 : 1), (1 : 0 : 0 , 1 : 0), (1 : 0 : 0 , 1 : 1), (1 : 0 : 0 , 2 : 1),
(1 : 0 : 1 , 0 : 1), (1 : 0 : 1 , 1 : 0), (1 : 0 : 1 , 1 : 1), (1 : 0 : 1 , 2 : 1),
(1 : 1 : 0 , 0 : 1), (1 : 1 : 0 , 1 : 0), (1 : 1 : 0 , 1 : 1), (1 : 1 : 0 , 2 : 1),
(1 : 1 : 1 , 0 : 1), (1 : 1 : 1 , 1 : 0), (1 : 1 : 1 , 1 : 1), (1 : 1 : 1 , 2 : 1),
(1 : 2 : 1 , 0 : 1), (1 : 2 : 1 , 1 : 0), (1 : 2 : 1 , 1 : 1), (1 : 2 : 1 , 2 : 1),
(2 : 0 : 1 , 0 : 1), (2 : 0 : 1 , 1 : 0), (2 : 0 : 1 , 1 : 1), (2 : 0 : 1 , 2 : 1),
(2 : 1 : 0 , 0 : 1), (2 : 1 : 0 , 1 : 0), (2 : 1 : 0 , 1 : 1), (2 : 1 : 0 , 2 : 1),
(2 : 1 : 1 , 0 : 1), (2 : 1 : 1 , 1 : 0), (2 : 1 : 1 , 1 : 1), (2 : 1 : 1 , 2 : 1),
(2 : 2 : 1 , 0 : 1), (2 : 2 : 1 , 1 : 0), (2 : 2 : 1 , 1 : 1), (2 : 2 : 1 , 2 : 1)]
::
sage: PP.<x,y,z,u,v> = ProductProjectiveSpaces([2,1], QQ)
sage: X = PP.subscheme([x + y, u*u-v*u])
sage: X.rational_points(bound=2)
[(-2 : 2 : 1 , 0 : 1),
(-2 : 2 : 1 , 1 : 1),
(-1 : 1 : 0 , 0 : 1),
(-1 : 1 : 0 , 1 : 1),
(-1 : 1 : 1 , 0 : 1),
(-1 : 1 : 1 , 1 : 1),
(-1/2 : 1/2 : 1 , 0 : 1),
(-1/2 : 1/2 : 1 , 1 : 1),
(0 : 0 : 1 , 0 : 1),
(0 : 0 : 1 , 1 : 1),
(1/2 : -1/2 : 1 , 0 : 1),
(1/2 : -1/2 : 1 , 1 : 1),
(1 : -1 : 1 , 0 : 1),
(1 : -1 : 1 , 1 : 1),
(2 : -2 : 1 , 0 : 1),
(2 : -2 : 1 , 1 : 1)]
better to enumerate with low codimension::
sage: PP.<x,y,z,u,v,a,b,c> = ProductProjectiveSpaces([2,1,2], QQ)
sage: X = PP.subscheme([x*u^2*a, b*z*u*v,z*v^2*c ])
sage: len(X.rational_points(bound=1, algorithm='enumerate'))
232
"""
B = kwds.pop('bound', 0)
X = self.codomain()
from sage.schemes.product_projective.space import is_ProductProjectiveSpaces
if not is_ProductProjectiveSpaces(X) and X.base_ring() in Fields():
# no points
if X.dimension() == -1:
return []
# if X is zero-dimensional
if X.dimension() == 0:
points = set()
# find points from all possible affine patches
for I in xmrange([n + 1 for n in X.ambient_space().dimension_relative_components()]):
[Y,phi] = X.affine_patch(I, True)
aff_points = Y.rational_points()
for PP in aff_points:
points.add(phi(PP))
return list(points)
R = self.value_ring()
points = []
if is_RationalField(R):
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified"%B)
alg = kwds.pop('algorithm', None)
if alg is None:
# sieve should only be called for subschemes and if the bound is not very small
N = prod([k+1 for k in X.ambient_space().dimension_relative_components()])
if isinstance(X, AlgebraicScheme_subscheme) and B**N > 5000:
from sage.schemes.product_projective.rational_point import sieve
return sieve(X, B)
else:
from sage.schemes.product_projective.rational_point import enum_product_projective_rational_field
return enum_product_projective_rational_field(self, B)
elif alg == 'sieve':
from sage.schemes.product_projective.rational_point import sieve
return sieve(X, B)
elif alg == 'enumerate':
from sage.schemes.product_projective.rational_point import enum_product_projective_rational_field
return enum_product_projective_rational_field(self, B)
else:
raise ValueError("algorithm must be 'sieve' or 'enumerate'")
elif R in NumberFields():
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified"%B)
from sage.schemes.product_projective.rational_point import enum_product_projective_number_field
return enum_product_projective_number_field(self, bound=B)
elif is_FiniteField(R):
from sage.schemes.product_projective.rational_point import enum_product_projective_finite_field
return enum_product_projective_finite_field(self)
else:
raise TypeError("unable to enumerate points over %s" % R)
def __classcall_private__(cls, morphism_or_polys, domain=None):
r"""
Return the appropriate dynamical system on an affine scheme.
TESTS::
sage: A.<x> = AffineSpace(ZZ,1)
sage: A1.<z> = AffineSpace(CC,1)
sage: H = End(A1)
sage: f2 = H([z^2+1])
sage: f = DynamicalSystem_affine(f2, A)
sage: f.domain() is A
False
::
sage: P1.<x,y> = ProjectiveSpace(QQ,1)
sage: DynamicalSystem_affine([y, 2*x], domain=P1)
Traceback (most recent call last):
...
ValueError: "domain" must be an affine scheme
sage: H = End(P1)
sage: DynamicalSystem_affine(H([y, 2*x]))
Traceback (most recent call last):
...
ValueError: "domain" must be an affine scheme
"""
if isinstance(morphism_or_polys, SchemeMorphism_polynomial):
morphism = morphism_or_polys
R = morphism.base_ring()
polys = list(morphism)
domain = morphism.domain()
if not is_AffineSpace(domain) and not isinstance(domain, AlgebraicScheme_subscheme_affine):
raise ValueError('"domain" must be an affine scheme')
if domain != morphism_or_polys.codomain():
raise ValueError('domain and codomain do not agree')
if R not in Fields():
return typecall(cls, polys, domain)
if is_FiniteField(R):
return DynamicalSystem_affine_finite_field(polys, domain)
return DynamicalSystem_affine_field(polys, domain)
elif isinstance(morphism_or_polys,(list, tuple)):
polys = list(morphism_or_polys)
else:
polys = [morphism_or_polys]
# We now arrange for all of our list entries to lie in the same ring
# Fraction field case first
fraction_field = False
for poly in polys:
P = poly.parent()
if is_FractionField(P):
fraction_field = True
break
if fraction_field:
K = P.base_ring().fraction_field()
# Replace base ring with its fraction field
P = P.ring().change_ring(K).fraction_field()
polys = [P(poly) for poly in polys]
else:
# If any of the list entries lies in a quotient ring, we try
# to lift all entries to a common polynomial ring.
quotient_ring = False
for poly in polys:
P = poly.parent()
if is_QuotientRing(P):
quotient_ring = True
break
if quotient_ring:
polys = [P(poly).lift() for poly in polys]
else:
poly_ring = False
for poly in polys:
P = poly.parent()
if is_PolynomialRing(P) or is_MPolynomialRing(P):
poly_ring = True
break
if poly_ring:
polys = [P(poly) for poly in polys]
if domain is None:
f = polys[0]
CR = f.parent()
if CR is SR:
raise TypeError("Symbolic Ring cannot be the base ring")
if fraction_field:
CR = CR.ring()
domain = AffineSpace(CR)
R = domain.base_ring()
if R is SR:
raise TypeError("Symbolic Ring cannot be the base ring")
if not is_AffineSpace(domain) and not isinstance(domain, AlgebraicScheme_subscheme_affine):
raise ValueError('"domain" must be an affine scheme')
if R not in Fields():
return typecall(cls, polys, domain)
if is_FiniteField(R):
return DynamicalSystem_affine_finite_field(polys, domain)
return DynamicalSystem_affine_field(polys, domain)
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 (base_field is None or isinstance(base_field, IntegralDomain)):
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 is 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 isinstance(P, IntegralDomain):
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 is 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 is None:
base_field = F.base_ring()
if not isinstance(base_field, IntegralDomain):
raise ValueError("Base field (=%s) must be a field" % base_field)
base_field = base_field.fraction_field()
if names is 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)
if is_FractionField(base_field) and (is_PolynomialRing(base_field.ring()) or is_MPolynomialRing(base_field.ring())):
return ProjectiveConic_rational_function_field(P2, F)
return ProjectiveConic_field(P2, F)
raise TypeError("Number of variables of F (=%s) must be 2 or 3" % F)
def Curve(F, A=None):
"""
Return the plane or space curve defined by ``F``, where ``F`` can be either
a multivariate polynomial, a list or tuple of polynomials, or an algebraic
scheme.
If no ambient space is passed in for ``A``, and if ``F`` is not an
algebraic scheme, a new ambient space is constructed.
Also not specifying an ambient space will cause the curve to be defined in
either affine or projective space based on properties of ``F``. In
particular, if ``F`` contains a nonhomogenous polynomial, the curve is
affine, and if ``F`` consists of homogenous polynomials, then the curve is
projective.
INPUT:
- ``F`` -- a multivariate polynomial, or a list or tuple of polynomials, or an algebraic scheme.
- ``A`` -- (default: None) an ambient space in which to create the curve.
EXAMPLES: A projective plane curve. ::
sage: x,y,z = QQ['x,y,z'].gens()
sage: C = Curve(x^3 + y^3 + z^3); C
Projective Plane Curve over Rational Field defined by x^3 + y^3 + z^3
sage: C.genus()
1
Affine plane curves. ::
sage: x,y = GF(7)['x,y'].gens()
sage: C = Curve(y^2 + x^3 + x^10); C
Affine Plane Curve over Finite Field of size 7 defined by x^10 + x^3 + y^2
sage: C.genus()
0
sage: x, y = QQ['x,y'].gens()
sage: Curve(x^3 + y^3 + 1)
Affine Plane Curve over Rational Field defined by x^3 + y^3 + 1
A projective space curve. ::
sage: x,y,z,w = QQ['x,y,z,w'].gens()
sage: C = Curve([x^3 + y^3 - z^3 - w^3, x^5 - y*z^4]); C
Projective Curve over Rational Field defined by x^3 + y^3 - z^3 - w^3, x^5 - y*z^4
sage: C.genus()
13
An affine space curve. ::
sage: x,y,z = QQ['x,y,z'].gens()
sage: C = Curve([y^2 + x^3 + x^10 + z^7, x^2 + y^2]); C
Affine Curve over Rational Field defined by x^10 + z^7 + x^3 + y^2, x^2 + y^2
sage: C.genus()
47
We can also make non-reduced non-irreducible curves. ::
sage: x,y,z = QQ['x,y,z'].gens()
sage: Curve((x-y)*(x+y))
Projective Conic Curve over Rational Field defined by x^2 - y^2
sage: Curve((x-y)^2*(x+y)^2)
Projective Plane Curve over Rational Field defined by x^4 - 2*x^2*y^2 + y^4
A union of curves is a curve. ::
sage: x,y,z = QQ['x,y,z'].gens()
sage: C = Curve(x^3 + y^3 + z^3)
sage: D = Curve(x^4 + y^4 + z^4)
sage: C.union(D)
Projective Plane Curve over Rational Field defined by
x^7 + x^4*y^3 + x^3*y^4 + y^7 + x^4*z^3 + y^4*z^3 + x^3*z^4 + y^3*z^4 + z^7
The intersection is not a curve, though it is a scheme. ::
sage: X = C.intersection(D); X
Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:
x^3 + y^3 + z^3,
x^4 + y^4 + z^4
Note that the intersection has dimension 0. ::
sage: X.dimension()
0
sage: I = X.defining_ideal(); I
Ideal (x^3 + y^3 + z^3, x^4 + y^4 + z^4) of Multivariate Polynomial Ring in x, y, z over Rational Field
If only a polynomial in three variables is given, then it must be
homogeneous such that a projective curve is constructed. ::
sage: x,y,z = QQ['x,y,z'].gens()
sage: Curve(x^2+y^2)
Projective Conic Curve over Rational Field defined by x^2 + y^2
sage: Curve(x^2+y^2+z)
Traceback (most recent call last):
...
TypeError: x^2 + y^2 + z is not a homogeneous polynomial
An ambient space can be specified to construct a space curve in an affine
or a projective space. ::
sage: A.<x,y,z> = AffineSpace(QQ, 3)
sage: C = Curve([y - x^2, z - x^3], A)
sage: C
Affine Curve over Rational Field defined by -x^2 + y, -x^3 + z
sage: A == C.ambient_space()
True
The defining polynomial must be nonzero unless the ambient space itself is
of dimension 1. ::
sage: P1.<x,y> = ProjectiveSpace(1,GF(5))
sage: S = P1.coordinate_ring()
sage: Curve(S(0), P1)
Projective Line over Finite Field of size 5
sage: Curve(P1)
Projective Line over Finite Field of size 5
::
sage: A1.<x> = AffineSpace(1, QQ)
sage: R = A1.coordinate_ring()
sage: Curve(R(0), A1)
Affine Line over Rational Field
sage: Curve(A1)
Affine Line over Rational Field
"""
if A is None:
if is_AmbientSpace(F) and F.dimension() == 1:
return Curve(F.coordinate_ring().zero(), F)
if is_AlgebraicScheme(F):
return Curve(F.defining_polynomials(), F.ambient_space())
if isinstance(F, (list, tuple)):
P = Sequence(F).universe()
if not is_MPolynomialRing(P):
raise TypeError("universe of F must be a multivariate polynomial ring")
for f in F:
if not f.is_homogeneous():
A = AffineSpace(P.ngens(), P.base_ring(), names=P.variable_names())
A._coordinate_ring = P
break
else:
A = ProjectiveSpace(P.ngens()-1, P.base_ring(), names=P.variable_names())
A._coordinate_ring = P
elif is_MPolynomial(F): # define a plane curve
P = F.parent()
k = F.base_ring()
if not k.is_field():
if k.is_integral_domain(): # upgrade to a field
P = P.change_ring(k.fraction_field())
F = P(F)
k = F.base_ring()
else:
raise TypeError("not a multivariate polynomial over a field or an integral domain")
if F.parent().ngens() == 2:
if F == 0:
raise ValueError("defining polynomial of curve must be nonzero")
A = AffineSpace(2, P.base_ring(), names=P.variable_names())
A._coordinate_ring = P
elif F.parent().ngens() == 3:
if F == 0:
raise ValueError("defining polynomial of curve must be nonzero")
# special case: construct a conic curve
if F.total_degree() == 2 and k.is_field():
return Conic(k, F)
A = ProjectiveSpace(2, P.base_ring(), names=P.variable_names())
A._coordinate_ring = P
elif F.parent().ngens() == 1:
if not F.is_zero():
raise ValueError("defining polynomial of curve must be zero "
"if the ambient space is of dimension 1")
A = AffineSpace(1, P.base_ring(), names=P.variable_names())
A._coordinate_ring = P
else:
raise TypeError("number of variables of F (={}) must be 2 or 3".format(F))
F = [F]
else:
raise TypeError("F (={}) must be a multivariate polynomial".format(F))
else:
if not is_AmbientSpace(A):
raise TypeError("ambient space must be either an affine or projective space")
if not isinstance(F, (list, tuple)):
F = [F]
if not all(f.parent() == A.coordinate_ring() for f in F):
raise TypeError("need a list of polynomials of the coordinate ring of {}".format(A))
n = A.dimension_relative()
if n < 1:
raise TypeError("ambient space should be an affine or projective space of positive dimension")
k = A.base_ring()
if is_AffineSpace(A):
if n != 2:
if is_FiniteField(k):
if A.coordinate_ring().ideal(F).is_prime():
return IntegralAffineCurve_finite_field(A, F)
if k in Fields():
if k == QQ and A.coordinate_ring().ideal(F).is_prime():
return IntegralAffineCurve(A, F)
return AffineCurve_field(A, F)
return AffineCurve(A, F)
if not (len(F) == 1 and F[0] != 0 and F[0].degree() > 0):
raise TypeError("need a single nonconstant polynomial to define a plane curve")
F = F[0]
if is_FiniteField(k):
if _is_irreducible_and_reduced(F):
return IntegralAffinePlaneCurve_finite_field(A, F)
return AffinePlaneCurve_finite_field(A, F)
if k in Fields():
if k == QQ and _is_irreducible_and_reduced(F):
return IntegralAffinePlaneCurve(A, F)
return AffinePlaneCurve_field(A, F)
return AffinePlaneCurve(A, F)
elif is_ProjectiveSpace(A):
if n != 2:
if not all(f.is_homogeneous() for f in F):
raise TypeError("polynomials defining a curve in a projective space must be homogeneous")
if is_FiniteField(k):
if A.coordinate_ring().ideal(F).is_prime():
return IntegralProjectiveCurve_finite_field(A, F)
if k in Fields():
if k == QQ and A.coordinate_ring().ideal(F).is_prime():
return IntegralProjectiveCurve(A, F)
return ProjectiveCurve_field(A, F)
return ProjectiveCurve(A, F)
# There is no dimension check when initializing a plane curve, so check
# here that F consists of a single nonconstant polynomial.
if not (len(F) == 1 and F[0] != 0 and F[0].degree() > 0):
raise TypeError("need a single nonconstant polynomial to define a plane curve")
F = F[0]
if not F.is_homogeneous():
raise TypeError("{} is not a homogeneous polynomial".format(F))
if is_FiniteField(k):
if _is_irreducible_and_reduced(F):
return IntegralProjectivePlaneCurve_finite_field(A, F)
return ProjectivePlaneCurve_finite_field(A, F)
if k in Fields():
if k == QQ and _is_irreducible_and_reduced(F):
return IntegralProjectivePlaneCurve(A, F)
return ProjectivePlaneCurve_field(A, F)
return ProjectivePlaneCurve(A, F)
else:
raise TypeError('ambient space neither affine nor projective')
def points(self, B=0, prec=53):
"""
Return some or all rational points of a projective scheme.
INPUT:
- ``B`` - integer (optional, default=0). The bound for the
coordinates.
- ``prec`` - he precision to use to compute the elements of bounded height for number fields.
OUTPUT:
A list of points. Over a finite field, all points are
returned. Over an infinite field, all points satisfying the
bound are returned.
.. WARNING::
In the current implementation, the output of the [Doyle-Krumm] algorithm
cannot be guaranteed to be correct due to the necessity of floating point
computations. In some cases, the default 53-bit precision is
considerably lower than would be required for the algorithm to
generate correct output.
EXAMPLES::
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: P(QQ).points(4)
[(-4 : 1), (-3 : 1), (-2 : 1), (-3/2 : 1), (-4/3 : 1), (-1 : 1),
(-3/4 : 1), (-2/3 : 1), (-1/2 : 1), (-1/3 : 1), (-1/4 : 1), (0 : 1),
(1/4 : 1), (1/3 : 1), (1/2 : 1), (2/3 : 1), (3/4 : 1), (1 : 0), (1 : 1),
(4/3 : 1), (3/2 : 1), (2 : 1), (3 : 1), (4 : 1)]
::
sage: u = QQ['u'].0
sage: K.<v> = NumberField(u^2 + 3)
sage: P.<x,y,z> = ProjectiveSpace(K,2)
sage: len(P(K).points(1.8))
381
::
sage: P1 = ProjectiveSpace(GF(2),1)
sage: F.<a> = GF(4,'a')
sage: P1(F).points()
[(0 : 1), (1 : 0), (1 : 1), (a : 1), (a + 1 : 1)]
::
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: E = P.subscheme([(y^3-y*z^2) - (x^3-x*z^2),(y^3-y*z^2) + (x^3-x*z^2)])
sage: E(P.base_ring()).points()
[(-1 : -1 : 1), (-1 : 0 : 1), (-1 : 1 : 1), (0 : -1 : 1), (0 : 0 : 1), (0 : 1 : 1),
(1 : -1 : 1), (1 : 0 : 1), (1 : 1 : 1)]
"""
X = self.codomain()
from sage.schemes.projective.projective_space import is_ProjectiveSpace
if not is_ProjectiveSpace(X) and X.base_ring() in Fields():
#Then it must be a subscheme
dim_ideal = X.defining_ideal().dimension()
if dim_ideal < 1: # no points
return []
if dim_ideal == 1: # if X zero-dimensional
rat_points = set()
PS = X.ambient_space()
N = PS.dimension_relative()
BR = X.base_ring()
#need a lexicographic ordering for elimination
R = PolynomialRing(BR, N + 1, PS.gens(), order='lex')
I = R.ideal(X.defining_polynomials())
I0 = R.ideal(0)
#Determine the points through elimination
#This is much faster than using the I.variety() function on each affine chart.
for k in range(N + 1):
#create the elimination ideal for the kth affine patch
G = I.substitute({R.gen(k):1}).groebner_basis()
if G != [1]:
P = {}
#keep track that we know the kth coordinate is 1
P.update({R.gen(k):1})
points = [P]
#work backwards from solving each equation for the possible
#values of the next coordinate
for i in range(len(G) - 1, -1, -1):
new_points = []
good = 0
for P in points:
#substitute in our dictionary entry that has the values
#of coordinates known so far. This results in a single
#variable polynomial (by elimination)
L = G[i].substitute(P)
if L != 0:
L = L.factor()
#the linear factors give the possible rational values of
#this coordinate
for pol, pow in L:
if pol.degree() == 1 and len(pol.variables()) == 1:
good = 1
r = pol.variables()[0]
varindex = R.gens().index(r)
#add this coordinates information to
#each dictionary entry
P.update({R.gen(varindex):-pol.constant_coefficient() / pol.monomial_coefficient(r)})
new_points.append(copy(P))
else:
new_points.append(P)
good = 1
if good:
points = new_points
#the dictionary entries now have values for all coordinates
#they are the rational solutions to the equations
#make them into projective points
for i in range(len(points)):
if len(points[i]) == N + 1 and I.subs(points[i]) == I0:
S = X([points[i][R.gen(j)] for j in range(N + 1)])
S.normalize_coordinates()
rat_points.add(S)
rat_points = sorted(rat_points)
return rat_points
R = self.value_ring()
if is_RationalField(R):
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified"%B)
from sage.schemes.projective.projective_rational_point import enum_projective_rational_field
return enum_projective_rational_field(self,B)
elif R in NumberFields():
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified"%B)
from sage.schemes.projective.projective_rational_point import enum_projective_number_field
return enum_projective_number_field(self,B, prec=prec)
elif is_FiniteField(R):
from sage.schemes.projective.projective_rational_point import enum_projective_finite_field
return enum_projective_finite_field(self.extended_codomain())
else:
raise TypeError("unable to enumerate points over %s"%R)
def _single_variate(base_ring,
name,
sparse=None,
implementation=None,
order=None):
# The "order" argument is unused, but we allow it (and ignore it)
# for consistency with the multi-variate case.
sparse = bool(sparse)
if sparse:
implementation = None
key = (base_ring, name, sparse, implementation)
R = _get_from_cache(key)
if R is not None:
return R
import sage.rings.polynomial.polynomial_ring as m
if isinstance(base_ring, ring.CommutativeRing):
if is_IntegerModRing(base_ring) and not sparse:
n = base_ring.order()
if n.is_prime():
R = m.PolynomialRing_dense_mod_p(base_ring,
name,
implementation=implementation)
elif n > 1:
R = m.PolynomialRing_dense_mod_n(base_ring,
name,
implementation=implementation)
else: # n == 1!
R = m.PolynomialRing_integral_domain(
base_ring, name) # specialized code breaks in this case.
elif is_FiniteField(base_ring) and not sparse:
R = m.PolynomialRing_dense_finite_field(
base_ring, name, implementation=implementation)
elif isinstance(base_ring, padic_base_leaves.pAdicFieldCappedRelative):
R = m.PolynomialRing_dense_padic_field_capped_relative(
base_ring, name)
elif isinstance(base_ring, padic_base_leaves.pAdicRingCappedRelative):
R = m.PolynomialRing_dense_padic_ring_capped_relative(
base_ring, name)
elif isinstance(base_ring, padic_base_leaves.pAdicRingCappedAbsolute):
R = m.PolynomialRing_dense_padic_ring_capped_absolute(
base_ring, name)
elif isinstance(base_ring, padic_base_leaves.pAdicRingFixedMod):
R = m.PolynomialRing_dense_padic_ring_fixed_mod(base_ring, name)
elif base_ring in _CompleteDiscreteValuationRings:
R = m.PolynomialRing_cdvr(base_ring, name, sparse)
elif base_ring in _CompleteDiscreteValuationFields:
R = m.PolynomialRing_cdvf(base_ring, name, sparse)
elif base_ring.is_field(proof=False):
R = m.PolynomialRing_field(base_ring, name, sparse)
elif base_ring.is_integral_domain(proof=False):
R = m.PolynomialRing_integral_domain(base_ring, name, sparse,
implementation)
else:
R = m.PolynomialRing_commutative(base_ring, name, sparse)
else:
R = m.PolynomialRing_general(base_ring, name, sparse)
if hasattr(R, '_implementation_names'):
for name in R._implementation_names:
real_key = key[0:3] + (name, )
_save_in_cache(real_key, R)
else:
_save_in_cache(key, R)
return R
def points(self, B=0, prec=53):
"""
Return some or all rational points of a projective scheme.
INPUT:
- ``B`` - integer (optional, default=0). The bound for the
coordinates.
- ``prec`` - he precision to use to compute the elements of bounded height for number fields.
OUTPUT:
A list of points. Over a finite field, all points are
returned. Over an infinite field, all points satisfying the
bound are returned.
.. WARNING::
In the current implementation, the output of the [Doyle-Krumm] algorithm
cannot be guaranteed to be correct due to the necessity of floating point
computations. In some cases, the default 53-bit precision is
considerably lower than would be required for the algorithm to
generate correct output.
EXAMPLES::
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: P(QQ).points(4)
[(-4 : 1), (-3 : 1), (-2 : 1), (-3/2 : 1), (-4/3 : 1), (-1 : 1),
(-3/4 : 1), (-2/3 : 1), (-1/2 : 1), (-1/3 : 1), (-1/4 : 1), (0 : 1),
(1/4 : 1), (1/3 : 1), (1/2 : 1), (2/3 : 1), (3/4 : 1), (1 : 0), (1 : 1),
(4/3 : 1), (3/2 : 1), (2 : 1), (3 : 1), (4 : 1)]
::
sage: u = QQ['u'].0
sage: K.<v> = NumberField(u^2 + 3)
sage: P.<x,y,z> = ProjectiveSpace(K,2)
sage: len(P(K).points(1.8))
381
::
sage: P1 = ProjectiveSpace(GF(2),1)
sage: F.<a> = GF(4,'a')
sage: P1(F).points()
[(0 : 1), (1 : 0), (1 : 1), (a : 1), (a + 1 : 1)]
::
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: E = P.subscheme([(y^3-y*z^2) - (x^3-x*z^2),(y^3-y*z^2) + (x^3-x*z^2)])
sage: E(P.base_ring()).points()
[(-1 : -1 : 1), (-1 : 0 : 1), (-1 : 1 : 1), (0 : -1 : 1), (0 : 0 : 1), (0 : 1 : 1),
(1 : -1 : 1), (1 : 0 : 1), (1 : 1 : 1)]
"""
X = self.codomain()
from sage.schemes.projective.projective_space import is_ProjectiveSpace
if not is_ProjectiveSpace(X) and X.base_ring() in Fields():
#Then it must be a subscheme
dim_ideal = X.defining_ideal().dimension()
if dim_ideal < 1: # no points
return []
if dim_ideal == 1: # if X zero-dimensional
points = set()
for i in range(X.ambient_space().dimension_relative() + 1):
Y = X.affine_patch(i)
phi = Y.projective_embedding()
aff_points = Y.rational_points()
for PP in aff_points:
points.add(X.ambient_space()(list(phi(PP))))
points = sorted(points)
return points
R = self.value_ring()
if is_RationalField(R):
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified"%B)
from sage.schemes.projective.projective_rational_point import enum_projective_rational_field
return enum_projective_rational_field(self,B)
elif R in NumberFields():
if not B > 0:
raise TypeError("a positive bound B (= %s) must be specified"%B)
from sage.schemes.projective.projective_rational_point import enum_projective_number_field
return enum_projective_number_field(self,B, prec=prec)
elif is_FiniteField(R):
from sage.schemes.projective.projective_rational_point import enum_projective_finite_field
return enum_projective_finite_field(self.extended_codomain())
else:
raise TypeError("unable to enumerate points over %s"%R)
def _single_variate(base_ring,
name,
sparse=None,
implementation=None,
order=None):
# The "order" argument is unused, but we allow it (and ignore it)
# for consistency with the multi-variate case.
sparse = bool(sparse)
# "implementation" must be last
key = [base_ring, name, sparse, implementation]
R = _get_from_cache(key)
if R is not None:
return R
from . import polynomial_ring
# Find the right constructor and **kwds for our polynomial ring
constructor = None
kwds = {}
if sparse:
kwds["sparse"] = True
# Specialized implementations
specialized = None
if is_IntegerModRing(base_ring):
n = base_ring.order()
if n.is_prime():
specialized = polynomial_ring.PolynomialRing_dense_mod_p
elif n > 1: # Specialized code breaks for n == 1
specialized = polynomial_ring.PolynomialRing_dense_mod_n
elif is_FiniteField(base_ring):
specialized = polynomial_ring.PolynomialRing_dense_finite_field
elif isinstance(base_ring, padic_base_leaves.pAdicFieldCappedRelative):
specialized = polynomial_ring.PolynomialRing_dense_padic_field_capped_relative
elif isinstance(base_ring, padic_base_leaves.pAdicRingCappedRelative):
specialized = polynomial_ring.PolynomialRing_dense_padic_ring_capped_relative
elif isinstance(base_ring, padic_base_leaves.pAdicRingCappedAbsolute):
specialized = polynomial_ring.PolynomialRing_dense_padic_ring_capped_absolute
elif isinstance(base_ring, padic_base_leaves.pAdicRingFixedMod):
specialized = polynomial_ring.PolynomialRing_dense_padic_ring_fixed_mod
# If the implementation is supported, then we are done
if specialized is not None:
implementation_names = specialized._implementation_names_impl(
implementation, base_ring, sparse)
if implementation_names is not NotImplemented:
implementation = implementation_names[0]
constructor = specialized
# Generic implementations
if constructor is None:
if not isinstance(base_ring, ring.CommutativeRing):
constructor = polynomial_ring.PolynomialRing_general
elif base_ring in _CompleteDiscreteValuationRings:
constructor = polynomial_ring.PolynomialRing_cdvr
elif base_ring in _CompleteDiscreteValuationFields:
constructor = polynomial_ring.PolynomialRing_cdvf
elif base_ring.is_field(proof=False):
constructor = polynomial_ring.PolynomialRing_field
elif base_ring.is_integral_domain(proof=False):
constructor = polynomial_ring.PolynomialRing_integral_domain
else:
constructor = polynomial_ring.PolynomialRing_commutative
implementation_names = constructor._implementation_names(
implementation, base_ring, sparse)
implementation = implementation_names[0]
# Only use names which are not supported by the specialized class.
if specialized is not None:
implementation_names = [
n for n in implementation_names
if specialized._implementation_names_impl(
n, base_ring, sparse) is NotImplemented
]
if implementation is not None:
kwds["implementation"] = implementation
R = constructor(base_ring, name, **kwds)
for impl in implementation_names:
key[-1] = impl
_save_in_cache(key, R)
return R
