Field $\mathbf{Q}$ of Rational Numbers

The class RationalField represents the field $\mathbf{Q}$ 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

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()
3.1
sage: QQ(RealField(9).pi())
22/7
sage: QQ(RealField().pi())
245850922/78256779
sage: QQ(35)
35
sage: QQ('12/347')
12/347
sage: QQ(exp(pi*I))
-1
sage: x = polygen(ZZ)
sage: QQ((3*x)/(4*x))
3/4

AUTHORS:

• Niles Johnson (2010-08): trac ticket #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

Bases: Singleton, NumberField

The class RationalField represents the field $\mathbf{Q}$ 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))
39029384023840928309482842098430284398243982394
sage: 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
0

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

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

Here’s a nice example involving elliptic curves:

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

absolute_degree()

Return the absolute degree of $\mathbf{Q}$ which is 1.

EXAMPLES:

sage: QQ.absolute_degree()
1

absolute_discriminant()

Return the absolute discriminant, which is 1.

EXAMPLES:

sage: QQ.absolute_discriminant()
1

absolute_polynomial()

Return a defining polynomial of $\mathbf{Q}$, as for other number fields.

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

EXAMPLES:

sage: QQ.polynomial()
x

algebraic_closure()

Return the algebraic closure of self (which is $\bar{\mathbf{Q}}$).

EXAMPLES:

sage: QQ.algebraic_closure()
Algebraic Field

automorphisms()

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
]

characteristic()

Return 0 since the rational field has characteristic 0.

EXAMPLES:

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

class_number()

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

EXAMPLES:

sage: QQ.class_number()
1

completion(p, prec, extras={})

Return the completion of $\mathbf{Q}$ at $p$.

EXAMPLES:

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

complex_embedding(prec=53)

Return embedding of the rational numbers into the complex numbers.

EXAMPLES:

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

construction()

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

This is the construction of $\mathbf{Q}$ as the fraction field of $\mathbf{Z}$.

EXAMPLES:

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

defining_polynomial()

Return a defining polynomial of $\mathbf{Q}$, as for other number fields.

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

EXAMPLES:

sage: QQ.polynomial()
x

degree()

Return the degree of $\mathbf{Q}$ which is 1.

EXAMPLES:

sage: QQ.degree()
1

discriminant()

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

EXAMPLES:

sage: QQ.discriminant()
1

embeddings(K)

Return list of the one embedding of $\mathbf{Q}$ into $K$, if it exists.

EXAMPLES:

sage: QQ.embeddings(QQ)
[Identity endomorphism of Rational Field]
sage: QQ.embeddings(CyclotomicField(5))
[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.

extension(poly, names, **kwds)

Create a field extension of $\mathbf{Q}$.

EXAMPLES:

We make a single absolute extension:

sage: K.<a> = QQ.extension(x^3 + 5); K
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
Number Field in a with defining polynomial x^3 + 5 over its base field
sage: b^2
-3
sage: a^3
-5

gen(n=0)

Return the n-th generator of $\mathbf{Q}$.

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

EXAMPLES:

sage: QQ.gen()
1

gens()

Return a tuple of generators of $\mathbf{Q}$ which is only (1,).

EXAMPLES:

sage: QQ.gens()
(1,)

hilbert_symbol_negative_at_S(S, b, check=True)

Returns 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 $\mathbf{Q}$ or as -1

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

• check – bool (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)
-9867
sage: QQ.hilbert_symbol_negative_at_S([3, 5, QQ.places()[0], 11], -15)
-33
sage: QQ.hilbert_symbol_negative_at_S([3, 5], 2)
15

AUTHORS:

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

is_absolute()

$\mathbf{Q}$ is an absolute extension of $\mathbf{Q}$.

EXAMPLES:

sage: QQ.is_absolute()
True

is_prime_field()

Return True since $\mathbf{Q}$ is a prime field.

EXAMPLES:

sage: QQ.is_prime_field()
True

maximal_order()

Return the maximal order of the rational numbers, i.e., the ring $\mathbf{Z}$ of integers.

EXAMPLES:

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

ngens()

Return the number of generators of $\mathbf{Q}$ which is 1.

EXAMPLES:

sage: QQ.ngens()
1

number_field()

Return the number field associated to $\mathbf{Q}$. Since $\mathbf{Q}$ is a number field, this just returns $\mathbf{Q}$ again.

EXAMPLES:

sage: QQ.number_field() is QQ
True

order()

Return the order of $\mathbf{Q}$ which is $\mathrm{\infty }$.

EXAMPLES:

sage: QQ.order()
+Infinity

places(all_complex=False, prec=None)

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

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()
[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)
[Ring morphism:
  From: Rational Field
  To:   Complex Field with 200 bits of precision
  Defn: 1 |--> 1.0000000000000000000000000000000000000000000000000000000000]

polynomial()

Return a defining polynomial of $\mathbf{Q}$, as for other number fields.

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

EXAMPLES:

sage: QQ.polynomial()
x

power_basis()

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]

primes_of_bounded_norm_iter(B)

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)
[2, 3, 5, 7]
sage: list(QQ.primes_of_bounded_norm_iter(1))
[]

quadratic_defect(a, p, check=True)

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
sage: QQ.quadratic_defect(5, 7)
0
sage: QQ.quadratic_defect(5, 2)
2
sage: QQ.quadratic_defect(5, 5)
1

random_element(num_bound=None, den_bound=None, *args, **kwds)

Return an random element of $\mathbf{Q}$.

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

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

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

range_by_height(start, end=None)

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, see 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]

All rational numbers with height 2:

sage: list(QQ.range_by_height(2, 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))
[]

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

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

relative_discriminant()

Return the relative discriminant, which is 1.

EXAMPLES:

sage: QQ.relative_discriminant()
1

residue_field(p, check=True)

Return the residue field of $\mathbf{Q}$ 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))
Residue field of Integers modulo 1000000007

selmer_generators(S, m, proof=True, orders=False)

Return generators of the group $\mathbf{Q}(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 $\mathbf{Q}(S,m)$ (and, optionally, their orders in ${\mathbf{Q}}^{\times }/({\mathbf{Q}}^{\times }{)}^m$). This is the subgroup of ${\mathbf{Q}}^{\times }/({\mathbf{Q}}^{\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 $\mathbf{Q}(S,m)$ contains the subgroup of those $a$ such that $\mathbf{Q}(\sqrt[m]{a})/\mathbf{Q}$ is unramified at all primes of $\mathbf{Q}$ outside of $S$, but may contain it properly when not all primes dividing $m$ are in $S$.

See also

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 $\mathbf{Q}(S,p)$ and maps implementing the isomorphism between this space and $\mathbf{Q}(S,p)$ as a subgroup of ${\mathbf{Q}}^{\ast }/({\mathbf{Q}}^{\ast }{)}^p$.

EXAMPLES:

sage: QQ.selmer_generators((), 2)
[-1]
sage: QQ.selmer_generators((3,), 2)
[-1, 3]
sage: QQ.selmer_generators((5,), 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])

selmer_group(*args, **kwds)

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

selmer_group_iterator(S, m, proof=True)

Return an iterator through elements of the finite group $\mathbf{Q}(S,m)$.

INPUT:

• S – a set of primes

• m – a positive integer

• proof – ignored

OUTPUT:

An iterator yielding the distinct elements of $\mathbf{Q}(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]

selmer_space(S, p, proof=None)

Compute the group $\mathbf{Q}(S,p)$ as a vector space with maps to and from ${\mathbf{Q}}^{\ast }$.

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 $\mathbf{Q}(S,p)$;

• QSp_gens is a list of elements of ${\mathbf{Q}}^{\ast }$ generating $\mathbf{Q}(S,p)$;

• from_QSp is a function from QSp to ${\mathbf{Q}}^{\ast }$ implementing the isomorphism from the abstract $\mathbf{Q}(S,p)$ to $\mathbf{Q}(S,p)$ as a subgroup of ${\mathbf{Q}}^{\ast }/({\mathbf{Q}}^{\ast }{)}^p$;

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

The group $\mathbf{Q}(S,p)$ is the finite subgroup of ${\mathbf{Q}}^{\ast }/({\mathbf{Q}}^{\ast }{)}^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 {\mathbf{Q}}^{\ast }$ such that $\mathbf{Q}(\sqrt[p]{a})/\mathbf{Q}$ is unramified at all primes of $\mathbf{Q}$ outside of $S$, but may contain it properly when $p$ is not in $S$.

EXAMPLES:

When $S$ is empty, $\mathbf{Q}(S,p)$ is only nontrivial for $p=2$:

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

sage: all(QQ.selmer_space([], p)[0].dimension() == 0 for p in primes(3,10))
True

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

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

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

sage: toQS2(-5/7)
(1, 1, 1)
sage: fromQS2((1,1,1))
-35
sage: ((-5/7)/(-35)).is_square()
True

The map toQS2 is not defined on all of ${\mathbf{Q}}^{\ast }$, only on those numbers which are squares away from $5$ and $7$:

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

signature()

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)

some_elements()

Return some elements of $\mathbf{Q}$.

See TestSuite() for a typical use case.

OUTPUT:

An iterator over 100 elements of $\mathbf{Q}$.

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,
 ...)

valuation(p)

Return the discrete valuation with uniformizer p.

EXAMPLES:

sage: v = QQ.valuation(3); v
3-adic valuation
sage: v(1/3)
-1

See also

NumberField_generic.valuation(), IntegerRing_class.valuation()

zeta(n=2)

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

sage.rings.rational_field.frac(n, d)

Return the fraction n/d.

EXAMPLES:

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

sage.rings.rational_field.is_RationalField(x)

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)
True
sage: is_RF(ZZ)
False