# Field $$\QQ$$ of Rational Numbers#

The class RationalField represents the field $$\QQ$$ of (arbitrary precision) rational numbers. Each rational number is an instance of the class Rational.

Interactively, an instance of RationalField is available as QQ:

sage: QQ
Rational Field

>>> from sage.all import *
>>> QQ
Rational Field


Values of various types can be converted to rational numbers by using the __call__() method of RationalField (that is, by treating QQ as a function).

sage: RealField(9).pi()                                                             # needs sage.rings.real_mpfr
3.1
sage: QQ(RealField(9).pi())                                                         # needs sage.rings.real_interval_field sage.rings.real_mpfr
22/7
sage: QQ(RealField().pi())                                                          # needs sage.rings.real_interval_field sage.rings.real_mpfr
245850922/78256779
sage: QQ(35)
35
sage: QQ('12/347')
12/347
sage: QQ(exp(pi*I))                                                                 # needs sage.symbolic
-1
sage: x = polygen(ZZ)
sage: QQ((3*x)/(4*x))
3/4

>>> from sage.all import *
>>> RealField(Integer(9)).pi()                                                             # needs sage.rings.real_mpfr
3.1
>>> QQ(RealField(Integer(9)).pi())                                                         # needs sage.rings.real_interval_field sage.rings.real_mpfr
22/7
>>> QQ(RealField().pi())                                                          # needs sage.rings.real_interval_field sage.rings.real_mpfr
245850922/78256779
>>> QQ(Integer(35))
35
>>> QQ('12/347')
12/347
>>> QQ(exp(pi*I))                                                                 # needs sage.symbolic
-1
>>> x = polygen(ZZ)
>>> QQ((Integer(3)*x)/(Integer(4)*x))
3/4


AUTHORS:

• Niles Johnson (2010-08): Issue #3893: random_element() should pass on *args and **kwds.

• Travis Scrimshaw (2012-10-18): Added additional docstrings for full coverage. Removed duplicates of discriminant() and signature().

• Anna Haensch (2018-03): Added function quadratic_defect()

class sage.rings.rational_field.RationalField[source]#

The class RationalField represents the field $$\QQ$$ of rational numbers.

EXAMPLES:

sage: a = 901824309821093821093812093810928309183091832091
sage: b = QQ(a); b
901824309821093821093812093810928309183091832091
sage: QQ(b)
901824309821093821093812093810928309183091832091
sage: QQ(int(93820984323))
93820984323
sage: QQ(ZZ(901824309821093821093812093810928309183091832091))
901824309821093821093812093810928309183091832091
sage: QQ('-930482/9320842317')
-930482/9320842317
sage: QQ((-930482, 9320842317))
-930482/9320842317
sage: QQ([9320842317])
9320842317
sage: QQ(pari(39029384023840928309482842098430284398243982394))                 # needs sage.libs.pari
39029384023840928309482842098430284398243982394
sage: QQ('sage')
Traceback (most recent call last):
...
TypeError: unable to convert 'sage' to a rational

>>> from sage.all import *
>>> a = Integer(901824309821093821093812093810928309183091832091)
>>> b = QQ(a); b
901824309821093821093812093810928309183091832091
>>> QQ(b)
901824309821093821093812093810928309183091832091
>>> QQ(int(Integer(93820984323)))
93820984323
>>> QQ(ZZ(Integer(901824309821093821093812093810928309183091832091)))
901824309821093821093812093810928309183091832091
>>> QQ('-930482/9320842317')
-930482/9320842317
>>> QQ((-Integer(930482), Integer(9320842317)))
-930482/9320842317
>>> QQ([Integer(9320842317)])
9320842317
>>> QQ(pari(Integer(39029384023840928309482842098430284398243982394)))                 # needs sage.libs.pari
39029384023840928309482842098430284398243982394
>>> QQ('sage')
Traceback (most recent call last):
...
TypeError: unable to convert 'sage' to a rational


Conversion from the reals to the rationals is done by default using continued fractions.

sage: QQ(RR(3929329/32))
3929329/32
sage: QQ(-RR(3929329/32))
-3929329/32
sage: QQ(RR(1/7)) - 1/7                                                         # needs sage.rings.real_mpfr
0

>>> from sage.all import *
>>> QQ(RR(Integer(3929329)/Integer(32)))
3929329/32
>>> QQ(-RR(Integer(3929329)/Integer(32)))
-3929329/32
>>> QQ(RR(Integer(1)/Integer(7))) - Integer(1)/Integer(7)                                                         # needs sage.rings.real_mpfr
0


If you specify the optional second argument base, then the string representation of the float is used.

sage: # needs sage.rings.real_mpfr
sage: QQ(23.2, 2)
6530219459687219/281474976710656
sage: 6530219459687219.0/281474976710656
23.20000000000000
sage: a = 23.2; a
23.2000000000000
sage: QQ(a, 10)
116/5

>>> from sage.all import *
>>> # needs sage.rings.real_mpfr
>>> QQ(RealNumber('23.2'), Integer(2))
6530219459687219/281474976710656
>>> RealNumber('6530219459687219.0')/Integer(281474976710656)
23.20000000000000
>>> a = RealNumber('23.2'); a
23.2000000000000
>>> QQ(a, Integer(10))
116/5


Here’s a nice example involving elliptic curves:

sage: # needs sage.rings.real_mpfr sage.schemes
sage: E = EllipticCurve('11a')
sage: L = E.lseries().at1(300)[0]; L
0.2538418608559106843377589233...
sage: O = E.period_lattice().omega(); O
1.26920930427955
sage: t = L/O; t
0.200000000000000
sage: QQ(RealField(45)(t))
1/5

>>> from sage.all import *
>>> # needs sage.rings.real_mpfr sage.schemes
>>> E = EllipticCurve('11a')
>>> L = E.lseries().at1(Integer(300))[Integer(0)]; L
0.2538418608559106843377589233...
>>> O = E.period_lattice().omega(); O
1.26920930427955
>>> t = L/O; t
0.200000000000000
>>> QQ(RealField(Integer(45))(t))
1/5

absolute_degree()[source]#

Return the absolute degree of $$\QQ$$, which is 1.

EXAMPLES:

sage: QQ.absolute_degree()
1

>>> from sage.all import *
>>> QQ.absolute_degree()
1

absolute_discriminant()[source]#

Return the absolute discriminant, which is 1.

EXAMPLES:

sage: QQ.absolute_discriminant()
1

>>> from sage.all import *
>>> QQ.absolute_discriminant()
1

absolute_polynomial()[source]#

Return a defining polynomial of $$\QQ$$, as for other number fields.

This is also aliased to defining_polynomial() and absolute_polynomial().

EXAMPLES:

sage: QQ.polynomial()
x

>>> from sage.all import *
>>> QQ.polynomial()
x

algebraic_closure()[source]#

Return the algebraic closure of self (which is $$\QQbar$$).

EXAMPLES:

sage: QQ.algebraic_closure()                                                # needs sage.rings.number_field
Algebraic Field

>>> from sage.all import *
>>> QQ.algebraic_closure()                                                # needs sage.rings.number_field
Algebraic Field

automorphisms()[source]#

Return all Galois automorphisms of self.

OUTPUT: a sequence containing just the identity morphism

EXAMPLES:

sage: QQ.automorphisms()
[
Ring endomorphism of Rational Field
Defn: 1 |--> 1
]

>>> from sage.all import *
>>> QQ.automorphisms()
[
Ring endomorphism of Rational Field
Defn: 1 |--> 1
]

characteristic()[source]#

Return 0 since the rational field has characteristic 0.

EXAMPLES:

sage: c = QQ.characteristic(); c
0
sage: parent(c)
Integer Ring

>>> from sage.all import *
>>> c = QQ.characteristic(); c
0
>>> parent(c)
Integer Ring

class_number()[source]#

Return the class number of the field of rational numbers, which is 1.

EXAMPLES:

sage: QQ.class_number()
1

>>> from sage.all import *
>>> QQ.class_number()
1

completion(p, prec, extras={})[source]#

Return the completion of $$\QQ$$ at $$p$$.

EXAMPLES:

sage: QQ.completion(infinity, 53)                                           # needs sage.rings.real_mpfr
Real Field with 53 bits of precision
sage: QQ.completion(5, 15, {'print_mode': 'bars'})                          # needs sage.rings.padics
5-adic Field with capped relative precision 15

>>> from sage.all import *
>>> QQ.completion(infinity, Integer(53))                                           # needs sage.rings.real_mpfr
Real Field with 53 bits of precision
>>> QQ.completion(Integer(5), Integer(15), {'print_mode': 'bars'})                          # needs sage.rings.padics
5-adic Field with capped relative precision 15

complex_embedding(prec=53)[source]#

Return embedding of the rational numbers into the complex numbers.

EXAMPLES:

sage: QQ.complex_embedding()                                                # needs sage.rings.real_mpfr
Ring morphism:
From: Rational Field
To:   Complex Field with 53 bits of precision
Defn: 1 |--> 1.00000000000000
sage: QQ.complex_embedding(20)                                              # needs sage.rings.real_mpfr
Ring morphism:
From: Rational Field
To:   Complex Field with 20 bits of precision
Defn: 1 |--> 1.0000

>>> from sage.all import *
>>> QQ.complex_embedding()                                                # needs sage.rings.real_mpfr
Ring morphism:
From: Rational Field
To:   Complex Field with 53 bits of precision
Defn: 1 |--> 1.00000000000000
>>> QQ.complex_embedding(Integer(20))                                              # needs sage.rings.real_mpfr
Ring morphism:
From: Rational Field
To:   Complex Field with 20 bits of precision
Defn: 1 |--> 1.0000

construction()[source]#

Return a pair (functor, parent) such that functor(parent) returns self.

This is the construction of $$\QQ$$ as the fraction field of $$\ZZ$$.

EXAMPLES:

sage: QQ.construction()
(FractionField, Integer Ring)

>>> from sage.all import *
>>> QQ.construction()
(FractionField, Integer Ring)

defining_polynomial()[source]#

Return a defining polynomial of $$\QQ$$, as for other number fields.

This is also aliased to defining_polynomial() and absolute_polynomial().

EXAMPLES:

sage: QQ.polynomial()
x

>>> from sage.all import *
>>> QQ.polynomial()
x

degree()[source]#

Return the degree of $$\QQ$$, which is 1.

EXAMPLES:

sage: QQ.degree()
1

>>> from sage.all import *
>>> QQ.degree()
1

discriminant()[source]#

Return the discriminant of the field of rational numbers, which is 1.

EXAMPLES:

sage: QQ.discriminant()
1

>>> from sage.all import *
>>> QQ.discriminant()
1

embeddings(K)[source]#

Return list of the one embedding of $$\QQ$$ into $$K$$, if it exists.

EXAMPLES:

sage: QQ.embeddings(QQ)
[Identity endomorphism of Rational Field]
sage: QQ.embeddings(CyclotomicField(5))                                     # needs sage.rings.number_field
[Coercion map:
From: Rational Field
To:   Cyclotomic Field of order 5 and degree 4]

>>> from sage.all import *
>>> QQ.embeddings(QQ)
[Identity endomorphism of Rational Field]
>>> QQ.embeddings(CyclotomicField(Integer(5)))                                     # needs sage.rings.number_field
[Coercion map:
From: Rational Field
To:   Cyclotomic Field of order 5 and degree 4]


$$K$$ must have characteristic 0:

sage: QQ.embeddings(GF(3))
Traceback (most recent call last):
...
ValueError: no embeddings of the rational field into K.

>>> from sage.all import *
>>> QQ.embeddings(GF(Integer(3)))
Traceback (most recent call last):
...
ValueError: no embeddings of the rational field into K.

extension(poly, names, **kwds)[source]#

Create a field extension of $$\QQ$$.

EXAMPLES:

We make a single absolute extension:

sage: x = polygen(QQ, 'x')
sage: K.<a> = QQ.extension(x^3 + 5); K                                      # needs sage.rings.number_field
Number Field in a with defining polynomial x^3 + 5

>>> from sage.all import *
>>> x = polygen(QQ, 'x')
>>> K = QQ.extension(x**Integer(3) + Integer(5), names=('a',)); (a,) = K._first_ngens(1); K                                      # needs sage.rings.number_field
Number Field in a with defining polynomial x^3 + 5


We make an extension generated by roots of two polynomials:

sage: K.<a,b> = QQ.extension([x^3 + 5, x^2 + 3]); K                         # needs sage.rings.number_field
Number Field in a with defining polynomial x^3 + 5 over its base field
sage: b^2                                                                   # needs sage.rings.number_field
-3
sage: a^3                                                                   # needs sage.rings.number_field
-5

>>> from sage.all import *
>>> K = QQ.extension([x**Integer(3) + Integer(5), x**Integer(2) + Integer(3)], names=('a', 'b',)); (a, b,) = K._first_ngens(2); K                         # needs sage.rings.number_field
Number Field in a with defining polynomial x^3 + 5 over its base field
>>> b**Integer(2)                                                                   # needs sage.rings.number_field
-3
>>> a**Integer(3)                                                                   # needs sage.rings.number_field
-5

gen(n=0)[source]#

Return the n-th generator of $$\QQ$$.

There is only the 0-th generator, which is 1.

EXAMPLES:

sage: QQ.gen()
1

>>> from sage.all import *
>>> QQ.gen()
1

gens()[source]#

Return a tuple of generators of $$\QQ$$, which is only (1,).

EXAMPLES:

sage: QQ.gens()
(1,)

>>> from sage.all import *
>>> QQ.gens()
(1,)

hilbert_symbol_negative_at_S(S, b, check=True)[source]#

Return an integer that has a negative Hilbert symbol with respect to a given rational number and a given set of primes (or places).

The function is algorithm 3.4.1 in [Kir2016]. It finds an integer $$a$$ that has negative Hilbert symbol with respect to a given rational number exactly at a given set of primes (or places).

INPUT:

• S – a list of rational primes, the infinite place as real embedding of $$\QQ$$ or as $$-1$$

• b – a non-zero rational number which is a non-square locally at every prime in S.

• checkbool (default: True) perform additional checks on input and confirm the output.

OUTPUT:

• An integer $$a$$ that has negative Hilbert symbol $$(a,b)_p$$ for every place $$p$$ in $$S$$ and no other place.

EXAMPLES:

sage: QQ.hilbert_symbol_negative_at_S([-1,5,3,2,7,11,13,23], -10/7)         # needs sage.rings.padics
-9867
sage: QQ.hilbert_symbol_negative_at_S([3, 5, QQ.places()[0], 11], -15)      # needs sage.rings.padics
-33
sage: QQ.hilbert_symbol_negative_at_S([3, 5], 2)                            # needs sage.rings.padics
15

>>> from sage.all import *
>>> QQ.hilbert_symbol_negative_at_S([-Integer(1),Integer(5),Integer(3),Integer(2),Integer(7),Integer(11),Integer(13),Integer(23)], -Integer(10)/Integer(7))         # needs sage.rings.padics
-9867
>>> QQ.hilbert_symbol_negative_at_S([Integer(3), Integer(5), QQ.places()[Integer(0)], Integer(11)], -Integer(15))      # needs sage.rings.padics
-33
>>> QQ.hilbert_symbol_negative_at_S([Integer(3), Integer(5)], Integer(2))                            # needs sage.rings.padics
15


AUTHORS:

• Simon Brandhorst, Juanita Duque, Anna Haensch, Manami Roy, Sandi Rudzinski (10-24-2017)

is_absolute()[source]#

$$\QQ$$ is an absolute extension of $$\QQ$$.

EXAMPLES:

sage: QQ.is_absolute()
True

>>> from sage.all import *
>>> QQ.is_absolute()
True

is_prime_field()[source]#

Return True since $$\QQ$$ is a prime field.

EXAMPLES:

sage: QQ.is_prime_field()
True

>>> from sage.all import *
>>> QQ.is_prime_field()
True

maximal_order()[source]#

Return the maximal order of the rational numbers, i.e., the ring $$\ZZ$$ of integers.

EXAMPLES:

sage: QQ.maximal_order()
Integer Ring
sage: QQ.ring_of_integers ()
Integer Ring

>>> from sage.all import *
>>> QQ.maximal_order()
Integer Ring
>>> QQ.ring_of_integers ()
Integer Ring

ngens()[source]#

Return the number of generators of $$\QQ$$, which is 1.

EXAMPLES:

sage: QQ.ngens()
1

>>> from sage.all import *
>>> QQ.ngens()
1

number_field()[source]#

Return the number field associated to $$\QQ$$. Since $$\QQ$$ is a number field, this just returns $$\QQ$$ again.

EXAMPLES:

sage: QQ.number_field() is QQ
True

>>> from sage.all import *
>>> QQ.number_field() is QQ
True

order()[source]#

Return the order of $$\QQ$$, which is $$\infty$$.

EXAMPLES:

sage: QQ.order()
+Infinity

>>> from sage.all import *
>>> QQ.order()
+Infinity

places(all_complex=False, prec=None)[source]#

Return the collection of all infinite places of self, which in this case is just the embedding of self into $$\RR$$.

By default, this returns homomorphisms into RR. If prec is not None, we simply return homomorphisms into RealField(prec) (or RDF if prec=53).

There is an optional flag all_complex, which defaults to False. If all_complex is True, then the real embeddings are returned as embeddings into the corresponding complex field.

For consistency with non-trivial number fields.

EXAMPLES:

sage: QQ.places()                                                           # needs sage.rings.real_mpfr
[Ring morphism:
From: Rational Field
To:   Real Field with 53 bits of precision
Defn: 1 |--> 1.00000000000000]
sage: QQ.places(prec=53)
[Ring morphism:
From: Rational Field
To:   Real Double Field
Defn: 1 |--> 1.0]
sage: QQ.places(prec=200, all_complex=True)                                 # needs sage.rings.real_mpfr
[Ring morphism:
From: Rational Field
To:   Complex Field with 200 bits of precision
Defn: 1 |--> 1.0000000000000000000000000000000000000000000000000000000000]

>>> from sage.all import *
>>> QQ.places()                                                           # needs sage.rings.real_mpfr
[Ring morphism:
From: Rational Field
To:   Real Field with 53 bits of precision
Defn: 1 |--> 1.00000000000000]
>>> QQ.places(prec=Integer(53))
[Ring morphism:
From: Rational Field
To:   Real Double Field
Defn: 1 |--> 1.0]
>>> QQ.places(prec=Integer(200), all_complex=True)                                 # needs sage.rings.real_mpfr
[Ring morphism:
From: Rational Field
To:   Complex Field with 200 bits of precision
Defn: 1 |--> 1.0000000000000000000000000000000000000000000000000000000000]

polynomial()[source]#

Return a defining polynomial of $$\QQ$$, as for other number fields.

This is also aliased to defining_polynomial() and absolute_polynomial().

EXAMPLES:

sage: QQ.polynomial()
x

>>> from sage.all import *
>>> QQ.polynomial()
x

power_basis()[source]#

Return a power basis for this number field over its base field.

The power basis is always [1] for the rational field. This method is defined to make the rational field behave more like a number field.

EXAMPLES:

sage: QQ.power_basis()
[1]

>>> from sage.all import *
>>> QQ.power_basis()
[1]

primes_of_bounded_norm_iter(B)[source]#

Iterator yielding all primes less than or equal to $$B$$.

INPUT:

• B – a positive integer; upper bound on the primes generated.

OUTPUT:

An iterator over all integer primes less than or equal to $$B$$.

Note

This function exists for compatibility with the related number field method, though it returns prime integers, not ideals.

EXAMPLES:

sage: it = QQ.primes_of_bounded_norm_iter(10)
sage: list(it)                                                              # needs sage.libs.pari
[2, 3, 5, 7]
sage: list(QQ.primes_of_bounded_norm_iter(1))
[]

>>> from sage.all import *
>>> it = QQ.primes_of_bounded_norm_iter(Integer(10))
>>> list(it)                                                              # needs sage.libs.pari
[2, 3, 5, 7]
>>> list(QQ.primes_of_bounded_norm_iter(Integer(1)))
[]


Return the valuation of the quadratic defect of $$a$$ at $$p$$.

INPUT:

• a – an element of self

• p – a prime ideal or a prime number

• check – (default: True); check if $$p$$ is prime

REFERENCE:

[Kir2016]

EXAMPLES:

sage: QQ.quadratic_defect(0, 7)
+Infinity
0
2
1

>>> from sage.all import *
+Infinity
0
2
1

random_element(num_bound=None, den_bound=None, *args, **kwds)[source]#

Return a random element of $$\QQ$$.

Elements are constructed by randomly choosing integers for the numerator and denominator, not necessarily coprime.

INPUT:

• num_bound – a positive integer, specifying a bound on the absolute value of the numerator. If absent, no bound is enforced.

• den_bound – a positive integer, specifying a bound on the value of the denominator. If absent, the bound for the numerator will be reused.

Any extra positional or keyword arguments are passed through to sage.rings.integer_ring.IntegerRing_class.random_element().

EXAMPLES:

sage: QQ.random_element().parent() is QQ
True
sage: while QQ.random_element() != 0:
....:     pass
sage: while QQ.random_element() != -1/2:
....:     pass

>>> from sage.all import *
>>> QQ.random_element().parent() is QQ
True
>>> while QQ.random_element() != Integer(0):
...     pass
>>> while QQ.random_element() != -Integer(1)/Integer(2):
...     pass


In the following example, the resulting numbers range from -5/1 to 5/1 (both inclusive), while the smallest possible positive value is 1/10:

sage: q = QQ.random_element(5, 10)
sage: -5/1 <= q <= 5/1
True
sage: q.denominator() <= 10
True
sage: q.numerator() <= 5
True

>>> from sage.all import *
>>> q = QQ.random_element(Integer(5), Integer(10))
>>> -Integer(5)/Integer(1) <= q <= Integer(5)/Integer(1)
True
>>> q.denominator() <= Integer(10)
True
>>> q.numerator() <= Integer(5)
True


Extra positional or keyword arguments are passed through:

sage: QQ.random_element(distribution='1/n').parent() is QQ
True
sage: QQ.random_element(distribution='1/n').parent() is QQ
True

>>> from sage.all import *
>>> QQ.random_element(distribution='1/n').parent() is QQ
True
>>> QQ.random_element(distribution='1/n').parent() is QQ
True

range_by_height(start, end=None)[source]#

Range function for rational numbers, ordered by height.

Returns a Python generator for the list of rational numbers with heights in range(start, end). Follows the same convention as Python range(), type range? for details.

See also __iter__().

EXAMPLES:

All rational numbers with height strictly less than 4:

sage: list(QQ.range_by_height(4))
[0, 1, -1, 1/2, -1/2, 2, -2, 1/3, -1/3, 3, -3, 2/3, -2/3, 3/2, -3/2]
sage: [a.height() for a in QQ.range_by_height(4)]
[1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3]

>>> from sage.all import *
>>> list(QQ.range_by_height(Integer(4)))
[0, 1, -1, 1/2, -1/2, 2, -2, 1/3, -1/3, 3, -3, 2/3, -2/3, 3/2, -3/2]
>>> [a.height() for a in QQ.range_by_height(Integer(4))]
[1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3]


All rational numbers with height 2:

sage: list(QQ.range_by_height(2, 3))
[1/2, -1/2, 2, -2]

>>> from sage.all import *
>>> list(QQ.range_by_height(Integer(2), Integer(3)))
[1/2, -1/2, 2, -2]


Nonsensical integer arguments will return an empty generator:

sage: list(QQ.range_by_height(3, 3))
[]
sage: list(QQ.range_by_height(10, 1))
[]

>>> from sage.all import *
>>> list(QQ.range_by_height(Integer(3), Integer(3)))
[]
>>> list(QQ.range_by_height(Integer(10), Integer(1)))
[]


There are no rational numbers with height $$\leq 0$$:

sage: list(QQ.range_by_height(-10, 1))
[]

>>> from sage.all import *
>>> list(QQ.range_by_height(-Integer(10), Integer(1)))
[]

relative_discriminant()[source]#

Return the relative discriminant, which is 1.

EXAMPLES:

sage: QQ.relative_discriminant()
1

>>> from sage.all import *
>>> QQ.relative_discriminant()
1

residue_field(p, check=True)[source]#

Return the residue field of $$\QQ$$ at the prime $$p$$, for consistency with other number fields.

INPUT:

• p – a prime integer.

• check (default True) – if True, check the primality of $$p$$, else do not.

OUTPUT: The residue field at this prime.

EXAMPLES:

sage: QQ.residue_field(5)
Residue field of Integers modulo 5
sage: QQ.residue_field(next_prime(10^9))                                    # needs sage.rings.finite_rings
Residue field of Integers modulo 1000000007

>>> from sage.all import *
>>> QQ.residue_field(Integer(5))
Residue field of Integers modulo 5
>>> QQ.residue_field(next_prime(Integer(10)**Integer(9)))                                    # needs sage.rings.finite_rings
Residue field of Integers modulo 1000000007

selmer_generators(S, m, proof=True, orders=False)[source]#

Return generators of the group $$\QQ(S,m)$$.

INPUT:

• S – a set of primes

• m – a positive integer

• proof – ignored

• orders (default False) – if True, output two lists, the generators and their orders

OUTPUT:

A list of generators of $$\QQ(S,m)$$ (and, optionally, their orders in $$\QQ^\times/(\QQ^\times)^m$$). This is the subgroup of $$\QQ^\times/(\QQ^\times)^m$$ consisting of elements $$a$$ such that the valuation of $$a$$ is divisible by $$m$$ at all primes not in $$S$$. It is equal to the group of $$S$$-units modulo $$m$$-th powers. The group $$\QQ(S,m)$$ contains the subgroup of those $$a$$ such that $$\QQ(\sqrt[m]{a})/\QQ$$ is unramified at all primes of $$\QQ$$ outside of $$S$$, but may contain it properly when not all primes dividing $$m$$ are in $$S$$.

RationalField.selmer_space(), which gives additional output when $$m=p$$ is prime: as well as generators, it gives an abstract vector space over $$\GF{p}$$ isomorphic to $$\QQ(S,p)$$ and maps implementing the isomorphism between this space and $$\QQ(S,p)$$ as a subgroup of $$\QQ^*/(\QQ^*)^p$$.

EXAMPLES:

sage: QQ.selmer_generators((), 2)
[-1]
sage: QQ.selmer_generators((3,), 2)
[-1, 3]
sage: QQ.selmer_generators((5,), 2)
[-1, 5]

>>> from sage.all import *
>>> QQ.selmer_generators((), Integer(2))
[-1]
>>> QQ.selmer_generators((Integer(3),), Integer(2))
[-1, 3]
>>> QQ.selmer_generators((Integer(5),), Integer(2))
[-1, 5]


The previous examples show that the group generated by the output may be strictly larger than the ‘true’ Selmer group of elements giving extensions unramified outside $$S$$.

When $$m$$ is even, $$-1$$ is a generator of order $$2$$:

sage: QQ.selmer_generators((2,3,5,7,), 2, orders=True)
([-1, 2, 3, 5, 7], [2, 2, 2, 2, 2])
sage: QQ.selmer_generators((2,3,5,7,), 3, orders=True)
([2, 3, 5, 7], [3, 3, 3, 3])

>>> from sage.all import *
>>> QQ.selmer_generators((Integer(2),Integer(3),Integer(5),Integer(7),), Integer(2), orders=True)
([-1, 2, 3, 5, 7], [2, 2, 2, 2, 2])
>>> QQ.selmer_generators((Integer(2),Integer(3),Integer(5),Integer(7),), Integer(3), orders=True)
([2, 3, 5, 7], [3, 3, 3, 3])

selmer_group(*args, **kwds)[source]#

Deprecated: Use selmer_generators() instead. See Issue #31345 for details.

selmer_group_iterator(S, m, proof=True)[source]#

Return an iterator through elements of the finite group $$\QQ(S,m)$$.

INPUT:

• S – a set of primes

• m – a positive integer

• proof – ignored

OUTPUT:

An iterator yielding the distinct elements of $$\QQ(S,m)$$. See the docstring for selmer_generators() for more information.

EXAMPLES:

sage: list(QQ.selmer_group_iterator((), 2))
[1, -1]
sage: list(QQ.selmer_group_iterator((2,), 2))
[1, 2, -1, -2]
sage: list(QQ.selmer_group_iterator((2,3), 2))
[1, 3, 2, 6, -1, -3, -2, -6]
sage: list(QQ.selmer_group_iterator((5,), 2))
[1, 5, -1, -5]

>>> from sage.all import *
>>> list(QQ.selmer_group_iterator((), Integer(2)))
[1, -1]
>>> list(QQ.selmer_group_iterator((Integer(2),), Integer(2)))
[1, 2, -1, -2]
>>> list(QQ.selmer_group_iterator((Integer(2),Integer(3)), Integer(2)))
[1, 3, 2, 6, -1, -3, -2, -6]
>>> list(QQ.selmer_group_iterator((Integer(5),), Integer(2)))
[1, 5, -1, -5]

selmer_space(S, p, proof=None)[source]#

Compute the group $$\QQ(S,p)$$ as a vector space with maps to and from $$\QQ^*$$.

INPUT:

• S – a list of prime numbers

• p – a prime number

OUTPUT:

(tuple) QSp, QSp_gens, from_QSp, to_QSp where

• QSp is an abstract vector space over $$\GF{p}$$ isomorphic to $$\QQ(S,p)$$;

• QSp_gens is a list of elements of $$\QQ^*$$ generating $$\QQ(S,p)$$;

• from_QSp is a function from QSp to $$\QQ^*$$ implementing the isomorphism from the abstract $$\QQ(S,p)$$ to $$\QQ(S,p)$$ as a subgroup of $$\QQ^*/(\QQ^*)^p$$;

• to_QSP is a partial function from $$\QQ^*$$ to QSp, defined on elements $$a$$ whose image in $$\QQ^*/(\QQ^*)^p$$ lies in $$\QQ(S,p)$$, mapping them via the inverse isomorphism to the abstract vector space QSp.

The group $$\QQ(S,p)$$ is the finite subgroup of $$\QQ^*/(\QQ^*)^p$$ consisting of elements whose valuation at all primes not in $$S$$ is a multiple of $$p$$. It contains the subgroup of those $$a\in \QQ^*$$ such that $$\QQ(\sqrt[p]{a})/\QQ$$ is unramified at all primes of $$\QQ$$ outside of $$S$$, but may contain it properly when $$p$$ is not in $$S$$.

EXAMPLES:

When $$S$$ is empty, $$\QQ(S,p)$$ is only nontrivial for $$p=2$$:

sage: QS2, QS2gens, fromQS2, toQS2 = QQ.selmer_space([], 2)                 # needs sage.rings.number_field
sage: QS2                                                                   # needs sage.rings.number_field
Vector space of dimension 1 over Finite Field of size 2
sage: QS2gens                                                               # needs sage.rings.number_field
[-1]

sage: all(QQ.selmer_space([], p)[0].dimension() == 0                        # needs sage.libs.pari sage.rings.number_field
....:     for p in primes(3, 10))
True

>>> from sage.all import *
>>> QS2, QS2gens, fromQS2, toQS2 = QQ.selmer_space([], Integer(2))                 # needs sage.rings.number_field
>>> QS2                                                                   # needs sage.rings.number_field
Vector space of dimension 1 over Finite Field of size 2
>>> QS2gens                                                               # needs sage.rings.number_field
[-1]

>>> all(QQ.selmer_space([], p)[Integer(0)].dimension() == Integer(0)                        # needs sage.libs.pari sage.rings.number_field
...     for p in primes(Integer(3), Integer(10)))
True


In general there is one generator for each $$p\in S$$, and an additional generator of $$-1$$ when $$p=2$$:

sage: # needs sage.modules sage.rings.number_field
sage: QS2, QS2gens, fromQS2, toQS2 = QQ.selmer_space([5,7], 2)
sage: QS2
Vector space of dimension 3 over Finite Field of size 2
sage: QS2gens
[5, 7, -1]
sage: toQS2(-7)
(0, 1, 1)
sage: fromQS2((0,1,1))
-7

>>> from sage.all import *
>>> # needs sage.modules sage.rings.number_field
>>> QS2, QS2gens, fromQS2, toQS2 = QQ.selmer_space([Integer(5),Integer(7)], Integer(2))
>>> QS2
Vector space of dimension 3 over Finite Field of size 2
>>> QS2gens
[5, 7, -1]
>>> toQS2(-Integer(7))
(0, 1, 1)
>>> fromQS2((Integer(0),Integer(1),Integer(1)))
-7


The map fromQS2 is only well-defined modulo $$p$$’th powers (in this case, modulo squares):

sage: toQS2(-5/7)                                                           # needs sage.modules sage.rings.number_field
(1, 1, 1)
sage: fromQS2((1,1,1))                                                      # needs sage.modules sage.rings.number_field
-35
sage: ((-5/7)/(-35)).is_square()
True

>>> from sage.all import *
>>> toQS2(-Integer(5)/Integer(7))                                                           # needs sage.modules sage.rings.number_field
(1, 1, 1)
>>> fromQS2((Integer(1),Integer(1),Integer(1)))                                                      # needs sage.modules sage.rings.number_field
-35
>>> ((-Integer(5)/Integer(7))/(-Integer(35))).is_square()
True


The map toQS2 is not defined on all of $$\QQ^*$$, only on those numbers which are squares away from $$5$$ and $$7$$:

sage: toQS2(210)                                                            # needs sage.modules sage.rings.number_field
Traceback (most recent call last):
...
ValueError: argument 210 should have valuations divisible by 2
at all primes in [5, 7]

>>> from sage.all import *
>>> toQS2(Integer(210))                                                            # needs sage.modules sage.rings.number_field
Traceback (most recent call last):
...
ValueError: argument 210 should have valuations divisible by 2
at all primes in [5, 7]

signature()[source]#

Return the signature of the rational field, which is $$(1,0)$$, since there are 1 real and no complex embeddings.

EXAMPLES:

sage: QQ.signature()
(1, 0)

>>> from sage.all import *
>>> QQ.signature()
(1, 0)

some_elements()[source]#

Return some elements of $$\QQ$$.

See TestSuite() for a typical use case.

OUTPUT: An iterator over 100 elements of $$\QQ$$.

EXAMPLES:

sage: tuple(QQ.some_elements())
(1/2, -1/2, 2, -2,
0, 1, -1, 42,
2/3, -2/3, 3/2, -3/2,
4/5, -4/5, 5/4, -5/4,
6/7, -6/7, 7/6, -7/6,
8/9, -8/9, 9/8, -9/8,
10/11, -10/11, 11/10, -11/10,
12/13, -12/13, 13/12, -13/12,
14/15, -14/15, 15/14, -15/14,
16/17, -16/17, 17/16, -17/16,
18/19, -18/19, 19/18, -19/18,
20/441, -20/441, 441/20, -441/20,
22/529, -22/529, 529/22, -529/22,
24/625, -24/625, 625/24, -625/24,
...)

>>> from sage.all import *
>>> tuple(QQ.some_elements())
(1/2, -1/2, 2, -2,
0, 1, -1, 42,
2/3, -2/3, 3/2, -3/2,
4/5, -4/5, 5/4, -5/4,
6/7, -6/7, 7/6, -7/6,
8/9, -8/9, 9/8, -9/8,
10/11, -10/11, 11/10, -11/10,
12/13, -12/13, 13/12, -13/12,
14/15, -14/15, 15/14, -15/14,
16/17, -16/17, 17/16, -17/16,
18/19, -18/19, 19/18, -19/18,
20/441, -20/441, 441/20, -441/20,
22/529, -22/529, 529/22, -529/22,
24/625, -24/625, 625/24, -625/24,
...)

valuation(p)[source]#

Return the discrete valuation with uniformizer p.

EXAMPLES:

sage: v = QQ.valuation(3); v                                                # needs sage.rings.padics
-1

>>> from sage.all import *
>>> v = QQ.valuation(Integer(3)); v                                                # needs sage.rings.padics
-1

zeta(n=2)[source]#

Return a root of unity in self.

INPUT:

• n – integer (default: 2) order of the root of unity

EXAMPLES:

sage: QQ.zeta()
-1
sage: QQ.zeta(2)
-1
sage: QQ.zeta(1)
1
sage: QQ.zeta(3)
Traceback (most recent call last):
...
ValueError: no n-th root of unity in rational field

>>> from sage.all import *
>>> QQ.zeta()
-1
>>> QQ.zeta(Integer(2))
-1
>>> QQ.zeta(Integer(1))
1
>>> QQ.zeta(Integer(3))
Traceback (most recent call last):
...
ValueError: no n-th root of unity in rational field

sage.rings.rational_field.frac(n, d)[source]#

Return the fraction n/d.

EXAMPLES:

sage: from sage.rings.rational_field import frac
sage: frac(1,2)
1/2

>>> from sage.all import *
>>> from sage.rings.rational_field import frac
>>> frac(Integer(1),Integer(2))
1/2

sage.rings.rational_field.is_RationalField(x)[source]#

Check to see if x is the rational field.

EXAMPLES:

sage: from sage.rings.rational_field import is_RationalField as is_RF
sage: is_RF(QQ)
doctest:warning...
DeprecationWarning: The function is_RationalField is deprecated;
See https://github.com/sagemath/sage/issues/38128 for details.
True
sage: is_RF(ZZ)
False

>>> from sage.all import *
>>> from sage.rings.rational_field import is_RationalField as is_RF
>>> is_RF(QQ)
doctest:warning...
DeprecationWarning: The function is_RationalField is deprecated;