Complex embedding

We describe functionality for complex embeddings of arbitrary number fields. Note that a complex embeddding of a number field $L$ is a morphism $\iota \colon L \to \mathbf{C}$. Such an embedding is called real if $\operatorname{im}(\iota) \subseteq \mathbf{R}$ and imaginary otherwise.

Construction of complex embeddings

complex_embeddings — Method

complex_embeddings(K::NumField; conjugates::Bool = true) -> Vector{NumFieldEmb}

Return the complex embeddings of $K$. If conjugates is false, only one imaginary embedding per conjugated pairs is returned.

Examples

julia> K, a = quadratic_field(-3);

julia> complex_embeddings(K)
2-element Vector{AbsSimpleNumFieldEmbedding}:
 Complex embedding corresponding to 0.00 + 1.73 * i of imaginary quadratic field
 Complex embedding corresponding to 0.00 - 1.73 * i of imaginary quadratic field

julia> complex_embeddings(K, conjugates = false)
1-element Vector{AbsSimpleNumFieldEmbedding}:
 Complex embedding corresponding to 0.00 + 1.73 * i of imaginary quadratic field

real_embeddings — Method

real_embeddings(K::NumField) -> Vector{NumFieldEmb}

Return the real embeddings of $K$.

Examples

julia> K, a = quadratic_field(3);

julia> real_embeddings(K)
2-element Vector{AbsSimpleNumFieldEmbedding}:
 Embedding corresponding to ≈ -1.73
 Embedding corresponding to ≈ 1.73

Properties

number_field — Method

number_field(f::NumFieldEmb) -> NumField

Return the corresponding number field of the embedding $f$.

Examples

julia> K, a = quadratic_field(-3); e = complex_embeddings(K)[1];

julia> number_field(e)
Imaginary quadratic field defined by x^2 + 3

is_real — Method

is_real(f::NumFieldEmb) -> Bool

Return true if the embedding is real.

Examples

julia> K, a = quadratic_field(3); e = complex_embeddings(K)[1];

julia> is_real(e)
true

is_imaginary — Method

is_imaginary(f::NumFieldEmb) -> Bool

Returns true if the embedding is imaginary, that is, not real.

Examples

julia> K, a = quadratic_field(-3); e = complex_embeddings(K)[1];

julia> is_imaginary(e)
true

Conjugated embedding

conj — Method

conj(f::NumFieldEmb) -> NumFieldEmb

Returns the conjugate embedding of f.

Examples

julia> K, a = quadratic_field(-3); e = complex_embeddings(K);

julia> conj(e[1]) == e[2]
true

Evaluating elements at complex embeddings

Given an embedding $f \colon K \to \mathbf{C}$ and an element $x$ of $K$, the image $f(x)$ of $x$ under $f$ can be constructed as follows.

    (f::NumFieldEmb)(x::NumFieldElem, prec::Int = 32) -> AcbFieldElem

Note that the return type will be a complex ball of type AcbFieldElem. The radius r of the ball is guaranteed to satisfy r < 2^(-prec).
If the embedding is real, then the value c will satisfy is_real(c) == true.

For convenience, we also provide the following function to quickly create a corresponding anonymous function:

evaluation_function — Method

evaluation_function(e::NumFieldEmb, prec::Int) -> Function

Return the anonymous function x -> e(x, prec).

Examples

julia> K, a = quadratic_field(-3);

julia> e = complex_embeddings(K)[1];

julia> fn = evaluation_function(e, 64);

julia> fn(a)
[+/- 3.99e-77] + [1.73205080756887729353 +/- 5.41e-21]*im

Logarithmic embedding

Given an object e representing an embedding $\iota \colon L \to \mathbf{C}$, the corresponding logarithmic embedding $L \to \mathbf{R}, \ x \mapsto \log(\lvert \iota(x) \rvert)$ can be constructed as log(abs(e)).

julia> K, a = quadratic_field(2);

julia> e = complex_embedding(K, 1.41)
Embedding of
Real quadratic field defined by x^2 - 2
corresponding to ≈ 1.41

julia> log(abs(e))(a, 128)
[0.346573590279972654708616060729088284037750067180127627 +/- 4.62e-55]

julia> log(abs(e(a)))
[0.346573590 +/- 2.99e-10]

Restriction

Given a subfield $\iota \colon k \to K$, any embedding $f \colon K \to \mathbf{C}$ naturally restricts to a complex embedding of $K$. Computing this restriction is supported in case $k$ appears as a base field of (a base field) of $K$ or $\iota$ is provided:

restrict — Method

restrict(f::NumFieldEmb, K::NumField)

Given an embedding $f$ of a number field $L$ and a number field $K$ appearing as a base field of $L$, return the restriction of $f$ to $K$.

Examples

julia> K, a = quadratic_field(3);

julia> L, b = number_field(polynomial(K, [1, 0, 1]), "b");

julia> e = complex_embeddings(L);

julia> restrict(e[1], K)
Complex embedding corresponding to -1.73
  of real quadratic field defined by x^2 - 3

restrict — Method

restrict(f::NumFieldEmb, g::NumFieldHom)

Given an embedding $f$ of a number field $L$ and a morphism $g \colon K \to L$, return the embedding $g \circ f$ of $K$.

This is the same as g * f.

Examples

julia> K, a = cyclotomic_field(5, "a");

julia> k, ktoK = Hecke.subfield(K, [a + inv(a)]);

julia> e = complex_embeddings(K);

julia> restrict(e[1], ktoK)
Complex embedding corresponding to 0.62
  of number field with defining polynomial x^2 + x - 1
    over rational field

Extension

Given a complex embedding $f \colon k \to \mathbf{C}$ and a morphism $\iota \colon k \to K$, an embedding $g \colon K \to \mathbf{C}$ is extension of $f$, if $g$ restricts to $f$. Given an embedding and a morphism, all extensions can be computed as follows:

extend — Method

extend(e::NumFieldEmb, f::NumFieldHom)

Given an embedding $e$ of $k$ and a morphism $f \colon k \to K$, determine all embedings of $K$ which restrict to $e$ along $f$.

Example

julia> K, a = cyclotomic_field(5, "a");

julia> k, ktoK = Hecke.subfield(K, [a + inv(a)]);

julia> e = complex_embeddings(k)[1];

julia> extend(e, ktoK)
2-element Vector{AbsSimpleNumFieldEmbedding}:
 Complex embedding corresponding to -0.81 + 0.59 * i of cyclotomic field of order 5
 Complex embedding corresponding to -0.81 - 0.59 * i of cyclotomic field of order 5

Positivity & Signs

sign — Method

sign(x::NumFieldElem, e::NumFieldEmb) -> Int

Given a number field element x and a complex embedding e, return 1, -1 or 0 depending on whether e(x) is positive, negative, or zero.

Examples

julia> K, a = quadratic_field(3);

julia> e = complex_embedding(K, 1.7);

julia> sign(a, e)
1

signs — Method

signs(a::NumFieldElem, [embs::Vector{NumFieldEmb} = real_embeddings(K)])
                                                   -> Dict{NumFieldEmb, Int}

Return the signs of a at the real embeddings in embs as a dictionary, which are by default all real embeddings of the number field.

Examples

julia> K, a = quadratic_field(3);

julia> signs(a)
Dict{AbsSimpleNumFieldEmbedding, Int64} with 2 entries:
  Complex embedding corresponding to -1.73 of real quadratic field define… => -1
  Complex embedding corresponding to 1.73 of real quadratic field defined… => 1

is_positive — Method

is_positive(a::NumFieldElem, e::NumFieldEmb)   -> Bool

Given a number field element a and a real embedding e, return whether a is positive at e.

Examples

julia> K, a  = quadratic_field(5);

julia> e = complex_embedding(K, 2.1);

julia> is_positive(a, e)
true

is_positive — Method

is_positive(a::NumFieldElem, embs::Vector{NumFieldEmb}) -> Bool

Return whether the element $a$ is positive at all embeddings of embs. All embeddings in embs must be real.

julia> K, a  = quadratic_field(5);

julia> e = complex_embedding(K, 2.1);

julia> e(a)
[2.236067977 +/- 5.02e-10]

julia> is_positive(a, [e])
true

is_totally_positive — Method

is_totally_positive(a::NumFieldElem) -> Bool

Return whether the element $a$ is totally positive, that is, whether it is positive at all real embeddings of the ambient number field.

is_negative — Method

is_negative(a::NumFieldElem, e::NumFieldEmb)   -> Bool

Given a number field element a and a real embedding e, return whether a is positive at e.

Examples

julia> K, a  = quadratic_field(5);

julia> e = complex_embedding(K, 2.1);

julia> is_negative(a, e)
false

is_negative — Method

is_negative(a::NumFieldElem, embs::Vector{NumFieldEmb}) -> Bool

Return whether the element $a$ is positive at all embeddings of embs. All embeddings in embs must be real.

Examples

julia> K, a  = quadratic_field(5);

julia> e = complex_embedding(K, -2.1);

julia> e(a)
[-2.236067977 +/- 5.02e-10]

julia> is_negative(a, [e])
true

Example

As mentioned, this functionality works for all types of number fields. Here is an example of an absolute non-simple number field.

julia> Qx, x = QQ["x"];

julia> K, a = number_field([x^2 + 1, x^3 + 2], "a");

julia> emb = complex_embeddings(K)
6-element Vector{AbsNonSimpleNumFieldEmbedding}:
 Complex embedding corresponding to [1.00 * i, -1.26] of non-simple number field
 Complex embedding corresponding to [1.00 * i, 0.63 + 1.09 * i] of non-simple number field
 Complex embedding corresponding to [-1.00 * i, 0.63 + 1.09 * i] of non-simple number field
 Complex embedding corresponding to [-1.00 * i, -1.26] of non-simple number field
 Complex embedding corresponding to [-1.00 * i, 0.63 - 1.09 * i] of non-simple number field
 Complex embedding corresponding to [1.00 * i, 0.63 - 1.09 * i] of non-simple number field

julia> k, b = quadratic_field(-1);

julia> i = hom(k, K, a[1]);

julia> restrict(emb[1], i)
Complex embedding corresponding to 1.00 * i
  of imaginary quadratic field defined by x^2 + 1

julia> restrict(emb[3], i)
Complex embedding corresponding to -1.00 * i
  of imaginary quadratic field defined by x^2 + 1