File: Mathlib/NumberTheory/NumberField/Embeddings.lean

full_name: NumberField.Embeddings.instFintypeRingHom
code: /-- There are finitely many embeddings of a number field. -/
noncomputable instance : Fintype (K →+* A) 
goal: Fintype (K →+* A)

full_name: NumberField.Embeddings.card
code: /-- The number of embeddings of a number field is equal to its finrank. -/
theorem card : Fintype.card (K →+* A) = finrank ℚ K 
goal: Fintype.card (K →+* A) = FiniteDimensional.finrank ℚ K

full_name: NumberField.Embeddings.instNonemptyRingHom
code: instance : Nonempty (K →+* A) 
goal: Nonempty (K →+* A)

full_name: NumberField.Embeddings.range_eval_eq_rootSet_minpoly
code: /-- Let `A` be an algebraically closed field and let `x ∈ K`, with `K` a number field.
The images of `x` by the embeddings of `K` in `A` are exactly the roots in `A` of
the minimal polynomial of `x` over `ℚ`. -/
theorem range_eval_eq_rootSet_minpoly :
    (range fun φ : K →+* A => φ x) = (minpoly ℚ x).rootSet A 
goal: (Set.range fun φ => φ x) = (minpoly ℚ x).rootSet A

full_name: NumberField.Embeddings.coeff_bdd_of_norm_le
code: theorem coeff_bdd_of_norm_le {B : ℝ} {x : K} (h : ∀ φ : K →+* A, ‖φ x‖ ≤ B) (i : ℕ) :
    ‖(minpoly ℚ x).coeff i‖ ≤ max B 1 ^ finrank ℚ K * (finrank ℚ K).choose (finrank ℚ K / 2) 
goal: ‖(minpoly ℚ x).coeff i‖ ≤
  max B 1 ^ FiniteDimensional.finrank ℚ K *
    ↑((FiniteDimensional.finrank ℚ K).choose (FiniteDimensional.finrank ℚ K / 2))

full_name: NumberField.Embeddings.finite_of_norm_le
code: /-- Let `B` be a real number. The set of algebraic integers in `K` whose conjugates are all
smaller in norm than `B` is finite. -/
theorem finite_of_norm_le (B : ℝ) : {x : K | IsIntegral ℤ x ∧ ∀ φ : K →+* A, ‖φ x‖ ≤ B}.Finite 
goal: {x | IsIntegral ℤ x ∧ ∀ (φ : K →+* A), ‖φ x‖ ≤ B}.Finite

full_name: NumberField.Embeddings.pow_eq_one_of_norm_eq_one
code: /-- An algebraic integer whose conjugates are all of norm one is a root of unity. -/
theorem pow_eq_one_of_norm_eq_one {x : K} (hxi : IsIntegral ℤ x) (hx : ∀ φ : K →+* A, ‖φ x‖ = 1) :
    ∃ (n : ℕ) (_ : 0 < n), x ^ n = 1 
goal: ∃ n, ∃ (_ : 0 < n), x ^ n = 1

full_name: NumberField.place
code: /-- An embedding into a normed division ring defines a place of `K` -/
def NumberField.place : AbsoluteValue K ℝ 
goal: AbsoluteValue K ℝ

full_name: NumberField.place_apply
code: @[simp]
theorem NumberField.place_apply (x : K) : (NumberField.place φ) x = norm (φ x) 
goal: (NumberField.place φ) x = ‖φ x‖

full_name: NumberField.ComplexEmbedding.conjugate
code: /-- The conjugate of a complex embedding as a complex embedding. -/
abbrev conjugate (φ : K →+* ℂ) : K →+* ℂ 
goal: K →+* ℂ

full_name: NumberField.ComplexEmbedding.conjugate_coe_eq
code: @[simp]
theorem conjugate_coe_eq (φ : K →+* ℂ) (x : K) : (conjugate φ) x = conj (φ x) 
goal: (NumberField.ComplexEmbedding.conjugate φ) x = (starRingEnd ℂ) (φ x)

full_name: NumberField.ComplexEmbedding.place_conjugate
code: theorem place_conjugate (φ : K →+* ℂ) : place (conjugate φ) = place φ 
goal: NumberField.place (NumberField.ComplexEmbedding.conjugate φ) = NumberField.place φ

full_name: NumberField.ComplexEmbedding.IsReal
code: /-- An embedding into `ℂ` is real if it is fixed by complex conjugation. -/
abbrev IsReal (φ : K →+* ℂ) : Prop 
goal: Prop

full_name: NumberField.ComplexEmbedding.isReal_iff
code: theorem isReal_iff {φ : K →+* ℂ} : IsReal φ ↔ conjugate φ = φ 
goal: NumberField.ComplexEmbedding.IsReal φ ↔ NumberField.ComplexEmbedding.conjugate φ = φ

full_name: NumberField.ComplexEmbedding.isReal_conjugate_iff
code: theorem isReal_conjugate_iff {φ : K →+* ℂ} : IsReal (conjugate φ) ↔ IsReal φ 
goal: NumberField.ComplexEmbedding.IsReal (NumberField.ComplexEmbedding.conjugate φ) ↔ NumberField.ComplexEmbedding.IsReal φ

full_name: NumberField.ComplexEmbedding.IsReal.embedding
code: /-- A real embedding as a ring homomorphism from `K` to `ℝ` . -/
def IsReal.embedding {φ : K →+* ℂ} (hφ : IsReal φ) : K →+* ℝ 
goal: K →+* ℝ

full_name: NumberField.ComplexEmbedding.IsReal.coe_embedding_apply
code: @[simp]
theorem IsReal.coe_embedding_apply {φ : K →+* ℂ} (hφ : IsReal φ) (x : K) :
    (hφ.embedding x : ℂ) = φ x 
goal: ↑(hφ.embedding x) = φ x

full_name: NumberField.ComplexEmbedding.IsReal.comp
code: lemma IsReal.comp (f : k →+* K) {φ : K →+* ℂ} (hφ : IsReal φ) :
    IsReal (φ.comp f) 
goal: NumberField.ComplexEmbedding.IsReal (φ.comp f)

full_name: NumberField.ComplexEmbedding.isReal_comp_iff
code: lemma isReal_comp_iff {f : k ≃+* K} {φ : K →+* ℂ} :
    IsReal (φ.comp (f : k →+* K)) ↔ IsReal φ 
goal: NumberField.ComplexEmbedding.IsReal (φ.comp ↑f) ↔ NumberField.ComplexEmbedding.IsReal φ

full_name: NumberField.ComplexEmbedding.exists_comp_symm_eq_of_comp_eq
code: lemma exists_comp_symm_eq_of_comp_eq [Algebra k K] [IsGalois k K] (φ ψ : K →+* ℂ)
    (h : φ.comp (algebraMap k K) = ψ.comp (algebraMap k K)) :
    ∃ σ : K ≃ₐ[k] K, φ.comp σ.symm = ψ 
goal: ∃ σ, φ.comp ↑σ.symm = ψ

full_name: NumberField.ComplexEmbedding.IsConj
code: /--
`IsConj φ σ` states that `σ : K ≃ₐ[k] K` is the conjugation under the embedding `φ : K →+* ℂ`.
-/
def IsConj : Prop 
goal: Prop

full_name: NumberField.ComplexEmbedding.IsConj.eq
code: lemma IsConj.eq (h : IsConj φ σ) (x) : φ (σ x) = star (φ x) 
goal: φ (σ x) = star (φ x)

full_name: NumberField.ComplexEmbedding.IsConj.ext
code: lemma IsConj.ext {σ₁ σ₂ : K ≃ₐ[k] K} (h₁ : IsConj φ σ₁) (h₂ : IsConj φ σ₂) : σ₁ = σ₂ 
goal: σ₁ = σ₂

full_name: NumberField.ComplexEmbedding.IsConj.ext_iff
code: lemma IsConj.ext_iff {σ₁ σ₂ : K ≃ₐ[k] K} (h₁ : IsConj φ σ₁) : σ₁ = σ₂ ↔ IsConj φ σ₂ 
goal: σ₁ = σ₂ ↔ NumberField.ComplexEmbedding.IsConj φ σ₂

full_name: NumberField.ComplexEmbedding.IsConj.isReal_comp
code: lemma IsConj.isReal_comp (h : IsConj φ σ) : IsReal (φ.comp (algebraMap k K)) 
goal: NumberField.ComplexEmbedding.IsReal (φ.comp (algebraMap k K))

full_name: NumberField.ComplexEmbedding.isConj_one_iff
code: lemma isConj_one_iff : IsConj φ (1 : K ≃ₐ[k] K) ↔ IsReal φ 
goal: NumberField.ComplexEmbedding.IsConj φ 1 ↔ NumberField.ComplexEmbedding.IsReal φ

full_name: NumberField.ComplexEmbedding.IsConj.symm
code: lemma IsConj.symm (hσ : IsConj φ σ) :
    IsConj φ σ.symm 
goal: NumberField.ComplexEmbedding.IsConj φ σ.symm

full_name: NumberField.ComplexEmbedding.isConj_symm
code: lemma isConj_symm : IsConj φ σ.symm ↔ IsConj φ σ 
goal: NumberField.ComplexEmbedding.IsConj φ σ.symm ↔ NumberField.ComplexEmbedding.IsConj φ σ

full_name: NumberField.InfinitePlace
code: /-- An infinite place of a number field `K` is a place associated to a complex embedding. -/
def NumberField.InfinitePlace 
goal: Type u_2

full_name: instNonemptyInfinitePlaceOfNumberField
code: instance [NumberField K] : Nonempty (NumberField.InfinitePlace K) 
goal: Nonempty (NumberField.InfinitePlace K)

full_name: NumberField.InfinitePlace.mk
code: /-- Return the infinite place defined by a complex embedding `φ`. -/
noncomputable def NumberField.InfinitePlace.mk (φ : K →+* ℂ) : NumberField.InfinitePlace K 
goal: NumberField.InfinitePlace K

full_name: NumberField.InfinitePlace.instFunLikeReal
code: instance {K : Type*} [Field K] : FunLike (InfinitePlace K) K ℝ 
goal: FunLike (NumberField.InfinitePlace K) K ℝ

full_name: NumberField.InfinitePlace.instMonoidWithZeroHomClassReal
code: instance : MonoidWithZeroHomClass (InfinitePlace K) K ℝ 
goal: MonoidWithZeroHomClass (NumberField.InfinitePlace K) K ℝ

full_name: NumberField.InfinitePlace.instNonnegHomClassReal
code: instance : NonnegHomClass (InfinitePlace K) K ℝ 
goal: NonnegHomClass (NumberField.InfinitePlace K) K ℝ

full_name: NumberField.InfinitePlace.apply
code: @[simp]
theorem apply (φ : K →+* ℂ) (x : K) : (mk φ) x = Complex.abs (φ x) 
goal: (NumberField.InfinitePlace.mk φ) x = Complex.abs (φ x)

full_name: NumberField.InfinitePlace.embedding
code: /-- For an infinite place `w`, return an embedding `φ` such that `w = infinite_place φ` . -/
noncomputable def embedding (w : InfinitePlace K) : K →+* ℂ 
goal: K →+* ℂ

full_name: NumberField.InfinitePlace.mk_embedding
code: @[simp]
theorem mk_embedding (w : InfinitePlace K) : mk (embedding w) = w 
goal: NumberField.InfinitePlace.mk w.embedding = w

full_name: NumberField.InfinitePlace.mk_conjugate_eq
code: @[simp]
theorem mk_conjugate_eq (φ : K →+* ℂ) : mk (ComplexEmbedding.conjugate φ) = mk φ 
goal: NumberField.InfinitePlace.mk (NumberField.ComplexEmbedding.conjugate φ) = NumberField.InfinitePlace.mk φ

full_name: NumberField.InfinitePlace.norm_embedding_eq
code: theorem norm_embedding_eq (w : InfinitePlace K) (x : K) :
    ‖(embedding w) x‖ = w x 
goal: ‖w.embedding x‖ = w x

full_name: NumberField.InfinitePlace.eq_iff_eq
code: theorem eq_iff_eq (x : K) (r : ℝ) : (∀ w : InfinitePlace K, w x = r) ↔ ∀ φ : K →+* ℂ, ‖φ x‖ = r 
goal: (∀ (w : NumberField.InfinitePlace K), w x = r) ↔ ∀ (φ : K →+* ℂ), ‖φ x‖ = r

full_name: NumberField.InfinitePlace.le_iff_le
code: theorem le_iff_le (x : K) (r : ℝ) : (∀ w : InfinitePlace K, w x ≤ r) ↔ ∀ φ : K →+* ℂ, ‖φ x‖ ≤ r 
goal: (∀ (w : NumberField.InfinitePlace K), w x ≤ r) ↔ ∀ (φ : K →+* ℂ), ‖φ x‖ ≤ r

full_name: NumberField.InfinitePlace.pos_iff
code: theorem pos_iff {w : InfinitePlace K} {x : K} : 0 < w x ↔ x ≠ 0 
goal: 0 < w x ↔ x ≠ 0

full_name: NumberField.InfinitePlace.mk_eq_iff
code: @[simp]
theorem mk_eq_iff {φ ψ : K →+* ℂ} : mk φ = mk ψ ↔ φ = ψ ∨ ComplexEmbedding.conjugate φ = ψ 
goal: NumberField.InfinitePlace.mk φ = NumberField.InfinitePlace.mk ψ ↔ φ = ψ ∨ NumberField.ComplexEmbedding.conjugate φ = ψ

full_name: NumberField.InfinitePlace.IsReal
code: /-- An infinite place is real if it is defined by a real embedding. -/
def IsReal (w : InfinitePlace K) : Prop 
goal: Prop

full_name: NumberField.InfinitePlace.IsComplex
code: /-- An infinite place is complex if it is defined by a complex (ie. not real) embedding. -/
def IsComplex (w : InfinitePlace K) : Prop 
goal: Prop

full_name: NumberField.InfinitePlace.embedding_mk_eq
code: theorem embedding_mk_eq (φ : K →+* ℂ) :
    embedding (mk φ) = φ ∨ embedding (mk φ) = ComplexEmbedding.conjugate φ 
goal: (NumberField.InfinitePlace.mk φ).embedding = φ ∨
  (NumberField.InfinitePlace.mk φ).embedding = NumberField.ComplexEmbedding.conjugate φ

full_name: NumberField.InfinitePlace.embedding_mk_eq_of_isReal
code: @[simp]
theorem embedding_mk_eq_of_isReal {φ : K →+* ℂ} (h : ComplexEmbedding.IsReal φ) :
    embedding (mk φ) = φ 
goal: (NumberField.InfinitePlace.mk φ).embedding = φ

full_name: NumberField.InfinitePlace.isReal_iff
code: theorem isReal_iff {w : InfinitePlace K} :
    IsReal w ↔ ComplexEmbedding.IsReal (embedding w) 
goal: w.IsReal ↔ NumberField.ComplexEmbedding.IsReal w.embedding

full_name: NumberField.InfinitePlace.isComplex_iff
code: theorem isComplex_iff {w : InfinitePlace K} :
    IsComplex w ↔ ¬ComplexEmbedding.IsReal (embedding w) 
goal: w.IsComplex ↔ ¬NumberField.ComplexEmbedding.IsReal w.embedding

full_name: NumberField.InfinitePlace.conjugate_embedding_eq_of_isReal
code: @[simp]
theorem conjugate_embedding_eq_of_isReal {w : InfinitePlace K} (h : IsReal w) :
    ComplexEmbedding.conjugate (embedding w) = embedding w 
goal: NumberField.ComplexEmbedding.conjugate w.embedding = w.embedding

full_name: NumberField.InfinitePlace.not_isReal_iff_isComplex
code: @[simp]
theorem not_isReal_iff_isComplex {w : InfinitePlace K} : ¬IsReal w ↔ IsComplex w 
goal: ¬w.IsReal ↔ w.IsComplex

full_name: NumberField.InfinitePlace.not_isComplex_iff_isReal
code: @[simp]
theorem not_isComplex_iff_isReal {w : InfinitePlace K} : ¬IsComplex w ↔ IsReal w 
goal: ¬w.IsComplex ↔ w.IsReal

full_name: NumberField.InfinitePlace.isReal_or_isComplex
code: theorem isReal_or_isComplex (w : InfinitePlace K) : IsReal w ∨ IsComplex w 
goal: w.IsReal ∨ w.IsComplex

full_name: NumberField.InfinitePlace.ne_of_isReal_isComplex
code: theorem ne_of_isReal_isComplex {w w' : InfinitePlace K} (h : IsReal w) (h' : IsComplex w') :
    w ≠ w' 
goal: w ≠ w'

full_name: NumberField.InfinitePlace.disjoint_isReal_isComplex
code: theorem disjoint_isReal_isComplex :
    Disjoint {(w : InfinitePlace K) | IsReal w} {(w : InfinitePlace K) | IsComplex w} 
goal: Disjoint {w | w.IsReal} {w | w.IsComplex}

full_name: NumberField.InfinitePlace.embedding_of_isReal
code: /-- The real embedding associated to a real infinite place. -/
noncomputable def embedding_of_isReal {w : InfinitePlace K} (hw : IsReal w) : K →+* ℝ 
goal: K →+* ℝ

full_name: NumberField.InfinitePlace.embedding_of_isReal_apply
code: @[simp]
theorem embedding_of_isReal_apply {w : InfinitePlace K} (hw : IsReal w) (x : K) :
    ((embedding_of_isReal hw) x : ℂ) = (embedding w) x 
goal: ↑((NumberField.InfinitePlace.embedding_of_isReal hw) x) = w.embedding x

full_name: NumberField.InfinitePlace.norm_embedding_of_isReal
code: theorem norm_embedding_of_isReal {w : InfinitePlace K} (hw : IsReal w) (x : K) :
    ‖embedding_of_isReal hw x‖ = w x 
goal: ‖(NumberField.InfinitePlace.embedding_of_isReal hw) x‖ = w x

full_name: NumberField.InfinitePlace.isReal_of_mk_isReal
code: @[simp]
theorem isReal_of_mk_isReal {φ : K →+* ℂ} (h : IsReal (mk φ)) :
    ComplexEmbedding.IsReal φ 
goal: NumberField.ComplexEmbedding.IsReal φ

full_name: NumberField.InfinitePlace.isReal_mk_iff
code: lemma isReal_mk_iff {φ : K →+* ℂ} :
    IsReal (mk φ) ↔ ComplexEmbedding.IsReal φ 
goal: (NumberField.InfinitePlace.mk φ).IsReal ↔ NumberField.ComplexEmbedding.IsReal φ

full_name: NumberField.InfinitePlace.isComplex_mk_iff
code: lemma isComplex_mk_iff {φ : K →+* ℂ} :
    IsComplex (mk φ) ↔ ¬ ComplexEmbedding.IsReal φ 
goal: (NumberField.InfinitePlace.mk φ).IsComplex ↔ ¬NumberField.ComplexEmbedding.IsReal φ

full_name: NumberField.InfinitePlace.not_isReal_of_mk_isComplex
code: @[simp]
theorem not_isReal_of_mk_isComplex {φ : K →+* ℂ} (h : IsComplex (mk φ)) :
    ¬ ComplexEmbedding.IsReal φ 
goal: ¬NumberField.ComplexEmbedding.IsReal φ

full_name: NumberField.InfinitePlace.mult
code: /-- The multiplicity of an infinite place, that is the number of distinct complex embeddings that
define it, see `card_filter_mk_eq`. -/
noncomputable def mult (w : InfinitePlace K) : ℕ 
goal: ℕ

full_name: NumberField.InfinitePlace.mult_pos
code: theorem mult_pos {w : InfinitePlace K} : 0 < mult w 
goal: 0 < w.mult

full_name: NumberField.InfinitePlace.mult_ne_zero
code: @[simp]
theorem mult_ne_zero {w : InfinitePlace K} : mult w ≠ 0 
goal: w.mult ≠ 0

full_name: NumberField.InfinitePlace.one_le_mult
code: theorem one_le_mult {w : InfinitePlace K} : (1 : ℝ) ≤ mult w 
goal: 1 ≤ ↑w.mult

full_name: NumberField.InfinitePlace.card_filter_mk_eq
code: theorem card_filter_mk_eq [NumberField K] (w : InfinitePlace K) :
    (Finset.univ.filter fun φ => mk φ = w).card = mult w 
goal: (Finset.filter (fun φ => NumberField.InfinitePlace.mk φ = w) Finset.univ).card = w.mult

full_name: NumberField.InfinitePlace.NumberField.InfinitePlace.fintype
code: noncomputable instance NumberField.InfinitePlace.fintype [NumberField K] :
    Fintype (InfinitePlace K) 
goal: Fintype (NumberField.InfinitePlace K)

full_name: NumberField.InfinitePlace.sum_mult_eq
code: theorem sum_mult_eq [NumberField K] :
    ∑ w : InfinitePlace K, mult w = FiniteDimensional.finrank ℚ K 
goal: ∑ w : NumberField.InfinitePlace K, w.mult = FiniteDimensional.finrank ℚ K

full_name: NumberField.InfinitePlace.mkReal
code: /-- The map from real embeddings to real infinite places as an equiv -/
noncomputable def mkReal :
    { φ : K →+* ℂ // ComplexEmbedding.IsReal φ } ≃ { w : InfinitePlace K // IsReal w } 
goal: { φ // NumberField.ComplexEmbedding.IsReal φ } ≃ { w // w.IsReal }

full_name: NumberField.InfinitePlace.mkComplex
code: /-- The map from nonreal embeddings to complex infinite places -/
noncomputable def mkComplex :
    { φ : K →+* ℂ // ¬ComplexEmbedding.IsReal φ } → { w : InfinitePlace K // IsComplex w } 
goal: { φ // ¬NumberField.ComplexEmbedding.IsReal φ } → { w // w.IsComplex }

full_name: NumberField.InfinitePlace.mkReal_coe
code: @[simp]
theorem mkReal_coe (φ : { φ : K →+* ℂ // ComplexEmbedding.IsReal φ }) :
    (mkReal φ : InfinitePlace K) = mk (φ : K →+* ℂ) 
goal: ↑(NumberField.InfinitePlace.mkReal φ) = NumberField.InfinitePlace.mk ↑φ

full_name: NumberField.InfinitePlace.mkComplex_coe
code: @[simp]
theorem mkComplex_coe (φ : { φ : K →+* ℂ // ¬ComplexEmbedding.IsReal φ }) :
    (mkComplex φ : InfinitePlace K) = mk (φ : K →+* ℂ) 
goal: ↑(NumberField.InfinitePlace.mkComplex φ) = NumberField.InfinitePlace.mk ↑φ

full_name: NumberField.InfinitePlace.prod_eq_abs_norm
code: /-- The infinite part of the product formula : for `x ∈ K`, we have `Π_w ‖x‖_w = |norm(x)|` where
`‖·‖_w` is the normalized absolute value for `w`.  -/
theorem prod_eq_abs_norm (x : K) :
    ∏ w : InfinitePlace K, w x ^ mult w = abs (Algebra.norm ℚ x) 
goal: ∏ w : NumberField.InfinitePlace K, w x ^ w.mult = ↑|(Algebra.norm ℚ) x|

full_name: NumberField.InfinitePlace.one_le_of_lt_one
code: theorem one_le_of_lt_one {w : InfinitePlace K} {a : (𝓞 K)} (ha : a ≠ 0)
    (h : ∀ ⦃z⦄, z ≠ w → z a < 1) : 1 ≤ w a 
goal: 1 ≤ w ↑a

full_name: NumberField.is_primitive_element_of_infinitePlace_lt
code: theorem _root_.NumberField.is_primitive_element_of_infinitePlace_lt {x : 𝓞 K}
    {w : InfinitePlace K} (h₁ : x ≠ 0) (h₂ : ∀ ⦃w'⦄, w' ≠ w → w' x < 1)
    (h₃ : IsReal w ∨ |(w.embedding x).re| < 1) : ℚ⟮(x : K)⟯ = ⊤ 
goal: ℚ⟮↑x⟯ = ⊤

full_name: NumberField.adjoin_eq_top_of_infinitePlace_lt
code: theorem _root_.NumberField.adjoin_eq_top_of_infinitePlace_lt {x : 𝓞 K} {w : InfinitePlace K}
    (h₁ : x ≠ 0) (h₂ : ∀ ⦃w'⦄, w' ≠ w → w' x < 1) (h₃ : IsReal w ∨ |(w.embedding x).re| < 1) :
    Algebra.adjoin ℚ {(x : K)} = ⊤ 
goal: Algebra.adjoin ℚ {↑x} = ⊤

full_name: NumberField.InfinitePlace.NrRealPlaces
code: /-- The number of infinite real places of the number field `K`. -/
noncomputable abbrev NrRealPlaces 
goal: ℕ

full_name: NumberField.InfinitePlace.NrComplexPlaces
code: /-- The number of infinite complex places of the number field `K`. -/
noncomputable abbrev NrComplexPlaces 
goal: ℕ

full_name: NumberField.InfinitePlace.card_real_embeddings
code: theorem card_real_embeddings :
    card { φ : K →+* ℂ // ComplexEmbedding.IsReal φ } = NrRealPlaces K 
goal: Fintype.card { φ // NumberField.ComplexEmbedding.IsReal φ } = NumberField.InfinitePlace.NrRealPlaces K

full_name: NumberField.InfinitePlace.card_eq_nrRealPlaces_add_nrComplexPlaces
code: theorem card_eq_nrRealPlaces_add_nrComplexPlaces :
    Fintype.card (InfinitePlace K) = NrRealPlaces K + NrComplexPlaces K 
goal: Fintype.card (NumberField.InfinitePlace K) =
  NumberField.InfinitePlace.NrRealPlaces K + NumberField.InfinitePlace.NrComplexPlaces K

full_name: NumberField.InfinitePlace.card_complex_embeddings
code: theorem card_complex_embeddings :
    card { φ : K →+* ℂ // ¬ComplexEmbedding.IsReal φ } = 2 * NrComplexPlaces K 
goal: Fintype.card { φ // ¬NumberField.ComplexEmbedding.IsReal φ } = 2 * NumberField.InfinitePlace.NrComplexPlaces K

full_name: NumberField.InfinitePlace.card_add_two_mul_card_eq_rank
code: theorem card_add_two_mul_card_eq_rank :
    NrRealPlaces K + 2 * NrComplexPlaces K = finrank ℚ K 
goal: NumberField.InfinitePlace.NrRealPlaces K + 2 * NumberField.InfinitePlace.NrComplexPlaces K =
  FiniteDimensional.finrank ℚ K

full_name: NumberField.InfinitePlace.nrComplexPlaces_eq_zero_of_finrank_eq_one
code: theorem nrComplexPlaces_eq_zero_of_finrank_eq_one (h : finrank ℚ K = 1) :
    NrComplexPlaces K = 0 
goal: NumberField.InfinitePlace.NrComplexPlaces K = 0

full_name: NumberField.InfinitePlace.nrRealPlaces_eq_one_of_finrank_eq_one
code: theorem nrRealPlaces_eq_one_of_finrank_eq_one (h : finrank ℚ K = 1) :
    NrRealPlaces K = 1 
goal: NumberField.InfinitePlace.NrRealPlaces K = 1

full_name: NumberField.InfinitePlace.comap
code: /-- The restriction of an infinite place along an embedding. -/
def comap (w : InfinitePlace K) (f : k →+* K) : InfinitePlace k 
goal: NumberField.InfinitePlace k

full_name: NumberField.InfinitePlace.comap_mk
code: @[simp]
lemma comap_mk (φ : K →+* ℂ) (f : k →+* K) : (mk φ).comap f = mk (φ.comp f) 
goal: (NumberField.InfinitePlace.mk φ).comap f = NumberField.InfinitePlace.mk (φ.comp f)

full_name: NumberField.InfinitePlace.comap_id
code: lemma comap_id (w : InfinitePlace K) : w.comap (RingHom.id K) = w 
goal: w.comap (RingHom.id K) = w

full_name: NumberField.InfinitePlace.comap_comp
code: lemma comap_comp (w : InfinitePlace K) (f : F →+* K) (g : k →+* F) :
    w.comap (f.comp g) = (w.comap f).comap g 
goal: w.comap (f.comp g) = (w.comap f).comap g

full_name: NumberField.InfinitePlace.IsReal.comap
code: lemma IsReal.comap (f : k →+* K) {w : InfinitePlace K} (hφ : IsReal w) :
    IsReal (w.comap f) 
goal: (w.comap f).IsReal

full_name: NumberField.InfinitePlace.isReal_comap_iff
code: lemma isReal_comap_iff (f : k ≃+* K) {w : InfinitePlace K} :
    IsReal (w.comap (f : k →+* K)) ↔ IsReal w 
goal: (w.comap ↑f).IsReal ↔ w.IsReal

full_name: NumberField.InfinitePlace.comap_surjective
code: lemma comap_surjective [Algebra k K] [Algebra.IsAlgebraic k K] :
    Function.Surjective (comap · (algebraMap k K)) 
goal: Function.Surjective fun x => x.comap (algebraMap k K)

full_name: NumberField.InfinitePlace.mult_comap_le
code: lemma mult_comap_le (f : k →+* K) (w : InfinitePlace K) : mult (w.comap f) ≤ mult w 
goal: (w.comap f).mult ≤ w.mult

full_name: NumberField.InfinitePlace.card_mono
code: lemma card_mono [NumberField k] [NumberField K] :
    card (InfinitePlace k) ≤ card (InfinitePlace K) 
goal: Fintype.card (NumberField.InfinitePlace k) ≤ Fintype.card (NumberField.InfinitePlace K)

full_name: NumberField.InfinitePlace.instMulActionAlgEquiv_smul_coe_apply
code: /-- The action of the galois group on infinite places. -/
@[simps! smul_coe_apply]
instance : MulAction (K ≃ₐ[k] K) (InfinitePlace K) 
goal: ∀ (a : K), ↑(SMul.smul σ w) a = ↑w (σ.symm a)

full_name: NumberField.InfinitePlace.instMulActionAlgEquiv
code: /-- The action of the galois group on infinite places. -/
@[simps! smul_coe_apply]
instance : MulAction (K ≃ₐ[k] K) (InfinitePlace K) 
goal: MulAction (K ≃ₐ[k] K) (NumberField.InfinitePlace K)

full_name: NumberField.InfinitePlace.smul_eq_comap
code: lemma smul_eq_comap : σ • w = w.comap σ.symm 
goal: σ • w = w.comap ↑σ.symm

full_name: NumberField.InfinitePlace.smul_apply
code: @[simp] lemma smul_apply (x) : (σ • w) x = w (σ.symm x) 
goal: (σ • w) x = w (σ.symm x)

full_name: NumberField.InfinitePlace.smul_mk
code: @[simp] lemma smul_mk (φ : K →+* ℂ) : σ • mk φ = mk (φ.comp σ.symm) 
goal: σ • NumberField.InfinitePlace.mk φ = NumberField.InfinitePlace.mk (φ.comp ↑σ.symm)

full_name: NumberField.InfinitePlace.comap_smul
code: lemma comap_smul {f : F →+* K} : (σ • w).comap f = w.comap (RingHom.comp σ.symm f) 
goal: (σ • w).comap f = w.comap ((↑σ.symm).comp f)

full_name: NumberField.InfinitePlace.isReal_smul_iff
code: lemma isReal_smul_iff : IsReal (σ • w) ↔ IsReal w 
goal: (σ • w).IsReal ↔ w.IsReal

full_name: NumberField.InfinitePlace.isComplex_smul_iff
code: lemma isComplex_smul_iff : IsComplex (σ • w) ↔ IsComplex w 
goal: (σ • w).IsComplex ↔ w.IsComplex

full_name: NumberField.InfinitePlace.ComplexEmbedding.exists_comp_symm_eq_of_comp_eq
code: lemma ComplexEmbedding.exists_comp_symm_eq_of_comp_eq [Algebra k K] [IsGalois k K] (φ ψ : K →+* ℂ)
    (h : φ.comp (algebraMap k K) = ψ.comp (algebraMap k K)) :
    ∃ σ : K ≃ₐ[k] K, φ.comp σ.symm = ψ 
goal: ∃ σ, φ.comp ↑σ.symm = ψ

full_name: NumberField.InfinitePlace.exists_smul_eq_of_comap_eq
code: lemma exists_smul_eq_of_comap_eq [Algebra k K] [IsGalois k K] {w w' : InfinitePlace K}
    (h : w.comap (algebraMap k K) = w'.comap (algebraMap k K)) : ∃ σ : K ≃ₐ[k] K, σ • w = w' 
goal: ∃ σ, σ • w = w'

full_name: NumberField.InfinitePlace.mem_orbit_iff
code: lemma mem_orbit_iff [IsGalois k K] {w w' : InfinitePlace K} :
    w' ∈ MulAction.orbit (K ≃ₐ[k] K) w ↔ w.comap (algebraMap k K) = w'.comap (algebraMap k K) 
goal: w' ∈ MulAction.orbit (K ≃ₐ[k] K) w ↔ w.comap (algebraMap k K) = w'.comap (algebraMap k K)

full_name: NumberField.InfinitePlace.orbitRelEquiv
code: /-- The orbits of infinite places under the action of the galois group are indexed by
the infinite places of the base field. -/
noncomputable
def orbitRelEquiv [IsGalois k K] :
    Quotient (MulAction.orbitRel (K ≃ₐ[k] K) (InfinitePlace K)) ≃ InfinitePlace k 
goal: Quotient (MulAction.orbitRel (K ≃ₐ[k] K) (NumberField.InfinitePlace K)) ≃ NumberField.InfinitePlace k

full_name: NumberField.InfinitePlace.orbitRelEquiv_apply_mk''
code: lemma orbitRelEquiv_apply_mk'' [IsGalois k K] (w : InfinitePlace K) :
    orbitRelEquiv (Quotient.mk'' w) = comap w (algebraMap k K) 
goal: NumberField.InfinitePlace.orbitRelEquiv (Quotient.mk'' w) = w.comap (algebraMap k K)

full_name: NumberField.InfinitePlace.IsUnramified
code: /--
An infinite place is unramified in a field extension if the restriction has the same multiplicity.
-/
def IsUnramified : Prop 
goal: Prop

full_name: NumberField.InfinitePlace.isUnramified_self
code: lemma isUnramified_self : IsUnramified K w 
goal: NumberField.InfinitePlace.IsUnramified K w

full_name: NumberField.InfinitePlace.IsUnramified.eq
code: lemma IsUnramified.eq (h : IsUnramified k w) : mult (w.comap (algebraMap k K)) = mult w 
goal: (w.comap (algebraMap k K)).mult = w.mult

full_name: NumberField.InfinitePlace.isUnramified_iff_mult_le
code: lemma isUnramified_iff_mult_le :
    IsUnramified k w ↔ mult w ≤ mult (w.comap (algebraMap k K)) 
goal: NumberField.InfinitePlace.IsUnramified k w ↔ w.mult ≤ (w.comap (algebraMap k K)).mult

full_name: NumberField.InfinitePlace.IsUnramified.comap_algHom
code: lemma IsUnramified.comap_algHom {w : InfinitePlace F} (h : IsUnramified k w) (f : K →ₐ[k] F) :
    IsUnramified k (w.comap (f : K →+* F)) 
goal: NumberField.InfinitePlace.IsUnramified k (w.comap ↑f)

full_name: NumberField.InfinitePlace.IsUnramified.of_restrictScalars
code: lemma IsUnramified.of_restrictScalars {w : InfinitePlace F} (h : IsUnramified k w) :
    IsUnramified K w 
goal: NumberField.InfinitePlace.IsUnramified K w

full_name: NumberField.InfinitePlace.IsUnramified.comap
code: lemma IsUnramified.comap {w : InfinitePlace F} (h : IsUnramified k w) :
    IsUnramified k (w.comap (algebraMap K F)) 
goal: NumberField.InfinitePlace.IsUnramified k (w.comap (algebraMap K F))

full_name: NumberField.InfinitePlace.not_isUnramified_iff
code: lemma not_isUnramified_iff :
    ¬ IsUnramified k w ↔ IsComplex w ∧ IsReal (w.comap (algebraMap k K)) 
goal: ¬NumberField.InfinitePlace.IsUnramified k w ↔ w.IsComplex ∧ (w.comap (algebraMap k K)).IsReal

full_name: NumberField.InfinitePlace.isUnramified_iff
code: lemma isUnramified_iff :
    IsUnramified k w ↔ IsReal w ∨ IsComplex (w.comap (algebraMap k K)) 
goal: NumberField.InfinitePlace.IsUnramified k w ↔ w.IsReal ∨ (w.comap (algebraMap k K)).IsComplex

full_name: NumberField.InfinitePlace.IsReal.isUnramified
code: lemma IsReal.isUnramified (h : IsReal w) : IsUnramified k w 
goal: NumberField.InfinitePlace.IsUnramified k w

full_name: NumberField.ComplexEmbedding.IsConj.isUnramified_mk_iff
code: lemma _root_.NumberField.ComplexEmbedding.IsConj.isUnramified_mk_iff
    {φ : K →+* ℂ} (h : ComplexEmbedding.IsConj φ σ) :
    IsUnramified k (mk φ) ↔ σ = 1 
goal: NumberField.InfinitePlace.IsUnramified k (NumberField.InfinitePlace.mk φ) ↔ σ = 1

full_name: NumberField.InfinitePlace.isUnramified_mk_iff_forall_isConj
code: lemma isUnramified_mk_iff_forall_isConj [IsGalois k K] {φ : K →+* ℂ} :
    IsUnramified k (mk φ) ↔ ∀ σ : K ≃ₐ[k] K, ComplexEmbedding.IsConj φ σ → σ = 1 
goal: NumberField.InfinitePlace.IsUnramified k (NumberField.InfinitePlace.mk φ) ↔
  ∀ (σ : K ≃ₐ[k] K), NumberField.ComplexEmbedding.IsConj φ σ → σ = 1

full_name: NumberField.InfinitePlace._aux_Mathlib_NumberTheory_NumberField_Embeddings___unexpand_MulAction_stabilizer_1
code: local notation "Stab" => MulAction.stabilizer (K ≃ₐ[k] K)
goal: Lean.PrettyPrinter.Unexpander

full_name: NumberField.InfinitePlace._aux_Mathlib_NumberTheory_NumberField_Embeddings___macroRules_NumberField_InfinitePlace_termStab_1
code: local notation "Stab" => MulAction.stabilizer (K ≃ₐ[k] K)
goal: Lean.Macro

full_name: NumberField.InfinitePlace.mem_stabilizer_mk_iff
code: lemma mem_stabilizer_mk_iff (φ : K →+* ℂ) (σ : K ≃ₐ[k] K) :
    σ ∈ Stab (mk φ) ↔ σ = 1 ∨ ComplexEmbedding.IsConj φ σ 
goal: σ ∈ MulAction.stabilizer (K ≃ₐ[k] K) (NumberField.InfinitePlace.mk φ) ↔ σ = 1 ∨ NumberField.ComplexEmbedding.IsConj φ σ

full_name: NumberField.InfinitePlace.IsUnramified.stabilizer_eq_bot
code: lemma IsUnramified.stabilizer_eq_bot (h : IsUnramified k w) : Stab w = ⊥ 
goal: MulAction.stabilizer (K ≃ₐ[k] K) w = ⊥

full_name: NumberField.ComplexEmbedding.IsConj.coe_stabilzer_mk
code: lemma _root_.NumberField.ComplexEmbedding.IsConj.coe_stabilzer_mk
    {φ : K →+* ℂ} (h : ComplexEmbedding.IsConj φ σ) :
    (Stab (mk φ) : Set (K ≃ₐ[k] K)) = {1, σ} 
goal: ↑(MulAction.stabilizer (K ≃ₐ[k] K) (NumberField.InfinitePlace.mk φ)) = {1, σ}

full_name: NumberField.InfinitePlace.nat_card_stabilizer_eq_one_or_two
code: lemma nat_card_stabilizer_eq_one_or_two :
    Nat.card (Stab w) = 1 ∨ Nat.card (Stab w) = 2 
goal: Nat.card ↥(MulAction.stabilizer (K ≃ₐ[k] K) w) = 1 ∨ Nat.card ↥(MulAction.stabilizer (K ≃ₐ[k] K) w) = 2

full_name: NumberField.InfinitePlace.isUnramified_iff_stabilizer_eq_bot
code: lemma isUnramified_iff_stabilizer_eq_bot [IsGalois k K] : IsUnramified k w ↔ Stab w = ⊥ 
goal: NumberField.InfinitePlace.IsUnramified k w ↔ MulAction.stabilizer (K ≃ₐ[k] K) w = ⊥

full_name: NumberField.InfinitePlace.isUnramified_iff_card_stabilizer_eq_one
code: lemma isUnramified_iff_card_stabilizer_eq_one [IsGalois k K] :
    IsUnramified k w ↔ Nat.card (Stab w) = 1 
goal: NumberField.InfinitePlace.IsUnramified k w ↔ Nat.card ↥(MulAction.stabilizer (K ≃ₐ[k] K) w) = 1

full_name: NumberField.InfinitePlace.not_isUnramified_iff_card_stabilizer_eq_two
code: lemma not_isUnramified_iff_card_stabilizer_eq_two [IsGalois k K] :
    ¬ IsUnramified k w ↔ Nat.card (Stab w) = 2 
goal: ¬NumberField.InfinitePlace.IsUnramified k w ↔ Nat.card ↥(MulAction.stabilizer (K ≃ₐ[k] K) w) = 2

full_name: NumberField.InfinitePlace.card_stabilizer
code: lemma card_stabilizer [IsGalois k K] :
    Nat.card (Stab w) = if IsUnramified k w then 1 else 2 
goal: Nat.card ↥(MulAction.stabilizer (K ≃ₐ[k] K) w) = if NumberField.InfinitePlace.IsUnramified k w then 1 else 2

full_name: NumberField.InfinitePlace.even_nat_card_aut_of_not_isUnramified
code: lemma even_nat_card_aut_of_not_isUnramified [IsGalois k K] (hw : ¬ IsUnramified k w) :
    Even (Nat.card <| K ≃ₐ[k] K) 
goal: Even (Nat.card (K ≃ₐ[k] K))

full_name: NumberField.InfinitePlace.even_card_aut_of_not_isUnramified
code: lemma even_card_aut_of_not_isUnramified [IsGalois k K] [FiniteDimensional k K]
    (hw : ¬ IsUnramified k w) :
    Even (Fintype.card <| K ≃ₐ[k] K) 
goal: Even (Fintype.card (K ≃ₐ[k] K))

full_name: NumberField.InfinitePlace.even_finrank_of_not_isUnramified
code: lemma even_finrank_of_not_isUnramified [IsGalois k K]
    (hw : ¬ IsUnramified k w) : Even (finrank k K) 
goal: Even (FiniteDimensional.finrank k K)

full_name: NumberField.InfinitePlace.isUnramified_smul_iff
code: lemma isUnramified_smul_iff :
    IsUnramified k (σ • w) ↔ IsUnramified k w 
goal: NumberField.InfinitePlace.IsUnramified k (σ • w) ↔ NumberField.InfinitePlace.IsUnramified k w

full_name: NumberField.InfinitePlace.IsUnramifiedIn
code: /-- A infinite place of the base field is unramified in a field extension if every
infinite place over it is unramified. -/
def IsUnramifiedIn (w : InfinitePlace k) : Prop 
goal: Prop

full_name: NumberField.InfinitePlace.isUnramifiedIn_comap
code: lemma isUnramifiedIn_comap [IsGalois k K] {w : InfinitePlace K} :
    (w.comap (algebraMap k K)).IsUnramifiedIn K ↔ w.IsUnramified k 
goal: NumberField.InfinitePlace.IsUnramifiedIn K (w.comap (algebraMap k K)) ↔ NumberField.InfinitePlace.IsUnramified k w

full_name: NumberField.InfinitePlace.even_card_aut_of_not_isUnramifiedIn
code: lemma even_card_aut_of_not_isUnramifiedIn [IsGalois k K] [FiniteDimensional k K]
    {w : InfinitePlace k} (hw : ¬ w.IsUnramifiedIn K) :
    Even (Fintype.card <| K ≃ₐ[k] K) 
goal: Even (Fintype.card (K ≃ₐ[k] K))

full_name: NumberField.InfinitePlace.even_finrank_of_not_isUnramifiedIn
code: lemma even_finrank_of_not_isUnramifiedIn
    [IsGalois k K] {w : InfinitePlace k} (hw : ¬ w.IsUnramifiedIn K) :
    Even (finrank k K) 
goal: Even (FiniteDimensional.finrank k K)

full_name: NumberField.InfinitePlace.card_isUnramified
code: lemma card_isUnramified [NumberField k] [IsGalois k K] :
    Finset.card (univ.filter <| IsUnramified k (K := K)) =
      Finset.card (univ.filter <| IsUnramifiedIn K (k := k)) * (finrank k K) 
goal: (Finset.filter (NumberField.InfinitePlace.IsUnramified k) Finset.univ).card =
  (Finset.filter (NumberField.InfinitePlace.IsUnramifiedIn K) Finset.univ).card * FiniteDimensional.finrank k K

full_name: NumberField.InfinitePlace.card_isUnramified_compl
code: lemma card_isUnramified_compl [NumberField k] [IsGalois k K] :
    Finset.card (univ.filter <| IsUnramified k (K := K))ᶜ =
      Finset.card (univ.filter <| IsUnramifiedIn K (k := k))ᶜ * (finrank k K / 2) 
goal: (Finset.filter (NumberField.InfinitePlace.IsUnramified k) Finset.univ)ᶜ.card =
  (Finset.filter (NumberField.InfinitePlace.IsUnramifiedIn K) Finset.univ)ᶜ.card * (FiniteDimensional.finrank k K / 2)

full_name: NumberField.InfinitePlace.card_eq_card_isUnramifiedIn
code: lemma card_eq_card_isUnramifiedIn [NumberField k] [IsGalois k K] :
    Fintype.card (InfinitePlace K) =
      Finset.card (Finset.univ.filter <| IsUnramifiedIn K (k := k)) * finrank k K +
      Finset.card (Finset.univ.filter <| IsUnramifiedIn K (k := k))ᶜ * (finrank k K / 2) 
goal: Fintype.card (NumberField.InfinitePlace K) =
  (Finset.filter (NumberField.InfinitePlace.IsUnramifiedIn K) Finset.univ).card * FiniteDimensional.finrank k K +
    (Finset.filter (NumberField.InfinitePlace.IsUnramifiedIn K) Finset.univ)ᶜ.card * (FiniteDimensional.finrank k K / 2)

full_name: IsUnramifiedAtInfinitePlaces
code: /-- A field extension is unramified at infinite places if every infinite place is unramified. -/
class IsUnramifiedAtInfinitePlaces : Prop where
  isUnramified : ∀ w : InfinitePlace K, w.IsUnramified k
goal: Prop

full_name: IsUnramifiedAtInfinitePlaces.isUnramified
code: /-- A field extension is unramified at infinite places if every infinite place is unramified. -/
class IsUnramifiedAtInfinitePlaces : Prop where
  isUnramified : ∀ w : InfinitePlace K, w.IsUnramified k
goal: NumberField.InfinitePlace.IsUnramified k w

full_name: IsUnramifiedAtInfinitePlaces.id
code: instance IsUnramifiedAtInfinitePlaces.id : IsUnramifiedAtInfinitePlaces K K 
goal: IsUnramifiedAtInfinitePlaces K K

full_name: IsUnramifiedAtInfinitePlaces.trans
code: lemma IsUnramifiedAtInfinitePlaces.trans
    [h₁ : IsUnramifiedAtInfinitePlaces k K] [h₂ : IsUnramifiedAtInfinitePlaces K F] :
    IsUnramifiedAtInfinitePlaces k F 
goal: IsUnramifiedAtInfinitePlaces k F

full_name: IsUnramifiedAtInfinitePlaces.top
code: lemma IsUnramifiedAtInfinitePlaces.top [h : IsUnramifiedAtInfinitePlaces k F] :
    IsUnramifiedAtInfinitePlaces K F 
goal: IsUnramifiedAtInfinitePlaces K F

full_name: IsUnramifiedAtInfinitePlaces.bot
code: lemma IsUnramifiedAtInfinitePlaces.bot [h₁ : IsUnramifiedAtInfinitePlaces k F]
    [Algebra.IsAlgebraic K F] :
    IsUnramifiedAtInfinitePlaces k K 
goal: IsUnramifiedAtInfinitePlaces k K

full_name: NumberField.InfinitePlace.isUnramified
code: lemma NumberField.InfinitePlace.isUnramified [IsUnramifiedAtInfinitePlaces k K]
    (w : InfinitePlace K) : IsUnramified k w 
goal: NumberField.InfinitePlace.IsUnramified k w

full_name: NumberField.InfinitePlace.isUnramifiedIn
code: lemma NumberField.InfinitePlace.isUnramifiedIn [IsUnramifiedAtInfinitePlaces k K]
    (w : InfinitePlace k) : IsUnramifiedIn K w 
goal: NumberField.InfinitePlace.IsUnramifiedIn K w

full_name: IsUnramifiedAtInfinitePlaces_of_odd_card_aut
code: lemma IsUnramifiedAtInfinitePlaces_of_odd_card_aut [IsGalois k K] [FiniteDimensional k K]
    (h : Odd (Fintype.card <| K ≃ₐ[k] K)) : IsUnramifiedAtInfinitePlaces k K 
goal: IsUnramifiedAtInfinitePlaces k K

full_name: IsUnramifiedAtInfinitePlaces_of_odd_finrank
code: lemma IsUnramifiedAtInfinitePlaces_of_odd_finrank [IsGalois k K]
    (h : Odd (FiniteDimensional.finrank k K)) : IsUnramifiedAtInfinitePlaces k K 
goal: IsUnramifiedAtInfinitePlaces k K

full_name: IsUnramifiedAtInfinitePlaces.card_infinitePlace
code: lemma IsUnramifiedAtInfinitePlaces.card_infinitePlace [NumberField k] [NumberField K]
    [IsGalois k K] [IsUnramifiedAtInfinitePlaces k K] :
    Fintype.card (InfinitePlace K) = Fintype.card (InfinitePlace k) * finrank k K 
goal: Fintype.card (NumberField.InfinitePlace K) = Fintype.card (NumberField.InfinitePlace k) * FiniteDimensional.finrank k K

full_name: IsPrimitiveRoot.nrRealPlaces_eq_zero_of_two_lt
code: theorem nrRealPlaces_eq_zero_of_two_lt (hk : 2 < k) (hζ : IsPrimitiveRoot ζ k) :
    NumberField.InfinitePlace.NrRealPlaces K = 0 
goal: NumberField.InfinitePlace.NrRealPlaces K = 0