File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean

full_name: NumberField.canonicalEmbedding
code: /-- The canonical embedding of a number field `K` of degree `n` into `ℂ^n`. -/
def _root_.NumberField.canonicalEmbedding : K →+* ((K →+* ℂ) → ℂ) 
goal: K →+* (K →+* ℂ) → ℂ

full_name: NumberField.canonicalEmbedding_injective
code: theorem _root_.NumberField.canonicalEmbedding_injective [NumberField K] :
    Function.Injective (NumberField.canonicalEmbedding K) 
goal: Function.Injective ⇑(NumberField.canonicalEmbedding K)

full_name: NumberField.canonicalEmbedding.apply_at
code: @[simp]
theorem apply_at (φ : K →+* ℂ) (x : K) : (NumberField.canonicalEmbedding K x) φ = φ x 
goal: (NumberField.canonicalEmbedding K) x φ = φ x

full_name: NumberField.canonicalEmbedding.conj_apply
code: /-- The image of `canonicalEmbedding` lives in the `ℝ`-submodule of the `x ∈ ((K →+* ℂ) → ℂ)` such
that `conj x_φ = x_(conj φ)` for all `∀ φ : K →+* ℂ`. -/
theorem conj_apply {x : ((K →+* ℂ) → ℂ)} (φ : K →+* ℂ)
    (hx : x ∈ Submodule.span ℝ (Set.range (canonicalEmbedding K))) :
    conj (x φ) = x (ComplexEmbedding.conjugate φ) 
goal: (starRingEnd ℂ) (x φ) = x (NumberField.ComplexEmbedding.conjugate φ)

full_name: NumberField.canonicalEmbedding.nnnorm_eq
code: theorem nnnorm_eq [NumberField K] (x : K) :
    ‖canonicalEmbedding K x‖₊ = Finset.univ.sup (fun φ : K →+* ℂ => ‖φ x‖₊) 
goal: ‖(NumberField.canonicalEmbedding K) x‖₊ = Finset.univ.sup fun φ => ‖φ x‖₊

full_name: NumberField.canonicalEmbedding.norm_le_iff
code: theorem norm_le_iff [NumberField K] (x : K) (r : ℝ) :
    ‖canonicalEmbedding K x‖ ≤ r ↔ ∀ φ : K →+* ℂ, ‖φ x‖ ≤ r 
goal: ‖(NumberField.canonicalEmbedding K) x‖ ≤ r ↔ ∀ (φ : K →+* ℂ), ‖φ x‖ ≤ r

full_name: NumberField.canonicalEmbedding.integerLattice
code: /-- The image of `𝓞 K` as a subring of `ℂ^n`. -/
def integerLattice : Subring ((K →+* ℂ) → ℂ) 
goal: Subring ((K →+* ℂ) → ℂ)

full_name: NumberField.canonicalEmbedding.integerLattice.inter_ball_finite
code: theorem integerLattice.inter_ball_finite [NumberField K] (r : ℝ) :
    ((integerLattice K : Set ((K →+* ℂ) → ℂ)) ∩ Metric.closedBall 0 r).Finite 
goal: (↑(NumberField.canonicalEmbedding.integerLattice K) ∩ Metric.closedBall 0 r).Finite

full_name: NumberField.canonicalEmbedding.latticeBasis
code: /-- A `ℂ`-basis of `ℂ^n` that is also a `ℤ`-basis of the `integerLattice`. -/
noncomputable def latticeBasis [NumberField K] :
    Basis (Free.ChooseBasisIndex ℤ (𝓞 K)) ℂ ((K →+* ℂ) → ℂ) 
goal: Basis (Module.Free.ChooseBasisIndex ℤ (NumberField.RingOfIntegers K)) ℂ ((K →+* ℂ) → ℂ)

full_name: NumberField.canonicalEmbedding.latticeBasis_apply
code: @[simp]
theorem latticeBasis_apply [NumberField K] (i : Free.ChooseBasisIndex ℤ (𝓞 K)) :
    latticeBasis K i = (canonicalEmbedding K) (integralBasis K i) 
goal: (NumberField.canonicalEmbedding.latticeBasis K) i = (NumberField.canonicalEmbedding K) ((NumberField.integralBasis K) i)

full_name: NumberField.canonicalEmbedding.mem_span_latticeBasis
code: theorem mem_span_latticeBasis [NumberField K] (x : (K →+* ℂ) → ℂ) :
    x ∈ Submodule.span ℤ (Set.range (latticeBasis K)) ↔
      x ∈ ((canonicalEmbedding K).comp (algebraMap (𝓞 K) K)).range 
goal: x ∈ Submodule.span ℤ (Set.range ⇑(NumberField.canonicalEmbedding.latticeBasis K)) ↔
  x ∈ ((NumberField.canonicalEmbedding K).comp (algebraMap (NumberField.RingOfIntegers K) K)).range

full_name: NumberField.canonicalEmbedding.mem_rat_span_latticeBasis
code: theorem mem_rat_span_latticeBasis [NumberField K] (x : K) :
    canonicalEmbedding K x ∈ Submodule.span ℚ (Set.range (latticeBasis K)) 
goal: (NumberField.canonicalEmbedding K) x ∈ Submodule.span ℚ (Set.range ⇑(NumberField.canonicalEmbedding.latticeBasis K))

full_name: NumberField.canonicalEmbedding.integralBasis_repr_apply
code: theorem integralBasis_repr_apply [NumberField K] (x : K) (i : Free.ChooseBasisIndex ℤ (𝓞 K)) :
    (latticeBasis K).repr (canonicalEmbedding K x) i = (integralBasis K).repr x i 
goal: ((NumberField.canonicalEmbedding.latticeBasis K).repr ((NumberField.canonicalEmbedding K) x)) i =
  ↑(((NumberField.integralBasis K).repr x) i)

full_name: NumberField.mixedEmbedding._aux_Mathlib_NumberTheory_NumberField_CanonicalEmbedding_Basic___macroRules_NumberField_mixedEmbedding_termE__1
code: /-- The space `ℝ^r₁ × ℂ^r₂` with `(r₁, r₂)` the signature of `K`. -/
local notation "E" K =>
  ({w : InfinitePlace K // IsReal w} → ℝ) × ({w : InfinitePlace K // IsComplex w} → ℂ)
goal: Lean.Macro

full_name: NumberField.mixedEmbedding
code: /-- The mixed embedding of a number field `K` of signature `(r₁, r₂)` into `ℝ^r₁ × ℂ^r₂`. -/
noncomputable def _root_.NumberField.mixedEmbedding : K →+* (E K) 
goal: K →+* ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)

full_name: NumberField.mixedEmbedding.instNontrivialProdForallSubtypeInfinitePlaceIsRealRealForallIsComplexComplex
code: instance [NumberField K] : Nontrivial (E K) 
goal: Nontrivial (({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ))

full_name: NumberField.mixedEmbedding.finrank
code: protected theorem finrank [NumberField K] : finrank ℝ (E K) = finrank ℚ K 
goal: FiniteDimensional.finrank ℝ (({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)) = FiniteDimensional.finrank ℚ K

full_name: NumberField.mixedEmbedding_injective
code: theorem _root_.NumberField.mixedEmbedding_injective [NumberField K] :
    Function.Injective (NumberField.mixedEmbedding K) 
goal: Function.Injective ⇑(NumberField.mixedEmbedding K)

full_name: NumberField.mixedEmbedding.commMap
code: /-- The linear map that makes `canonicalEmbedding` and `mixedEmbedding` commute, see
`commMap_canonical_eq_mixed`. -/
noncomputable def commMap : ((K →+* ℂ) → ℂ) →ₗ[ℝ] (E K) 
goal: ((K →+* ℂ) → ℂ) →ₗ[ℝ] ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)

full_name: NumberField.mixedEmbedding.commMap_apply_of_isReal
code: theorem commMap_apply_of_isReal (x : (K →+* ℂ) → ℂ) {w : InfinitePlace K} (hw : IsReal w) :
    (commMap K x).1 ⟨w, hw⟩ = (x w.embedding).re 
goal: ((NumberField.mixedEmbedding.commMap K) x).1 ⟨w, hw⟩ = (x w.embedding).re

full_name: NumberField.mixedEmbedding.commMap_apply_of_isComplex
code: theorem commMap_apply_of_isComplex (x : (K →+* ℂ) → ℂ) {w : InfinitePlace K} (hw : IsComplex w) :
    (commMap K x).2 ⟨w, hw⟩ = x w.embedding 
goal: ((NumberField.mixedEmbedding.commMap K) x).2 ⟨w, hw⟩ = x w.embedding

full_name: NumberField.mixedEmbedding.commMap_canonical_eq_mixed
code: @[simp]
theorem commMap_canonical_eq_mixed (x : K) :
    commMap K (canonicalEmbedding K x) = mixedEmbedding K x 
goal: (NumberField.mixedEmbedding.commMap K) ((NumberField.canonicalEmbedding K) x) = (NumberField.mixedEmbedding K) x

full_name: NumberField.mixedEmbedding.disjoint_span_commMap_ker
code: /-- This is a technical result to ensure that the image of the `ℂ`-basis of `ℂ^n` defined in
`canonicalEmbedding.latticeBasis` is a `ℝ`-basis of `ℝ^r₁ × ℂ^r₂`,
see `mixedEmbedding.latticeBasis`. -/
theorem disjoint_span_commMap_ker [NumberField K] :
    Disjoint (Submodule.span ℝ (Set.range (canonicalEmbedding.latticeBasis K)))
      (LinearMap.ker (commMap K)) 
goal: Disjoint (Submodule.span ℝ (Set.range ⇑(NumberField.canonicalEmbedding.latticeBasis K)))
  (LinearMap.ker (NumberField.mixedEmbedding.commMap K))

full_name: NumberField.mixedEmbedding.normAtPlace
code: /-- The norm at the infinite place `w` of an element of
`({w // IsReal w} → ℝ) × ({ w // IsComplex w } → ℂ)`. -/
def normAtPlace (w : InfinitePlace K) : (E K) →*₀ ℝ 
goal: ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ) →*₀ ℝ

full_name: NumberField.mixedEmbedding.normAtPlace_nonneg
code: theorem normAtPlace_nonneg  (w : InfinitePlace K) (x : E K) :
    0 ≤ normAtPlace w x 
goal: 0 ≤ (NumberField.mixedEmbedding.normAtPlace w) x

full_name: NumberField.mixedEmbedding.normAtPlace_neg
code: theorem normAtPlace_neg (w : InfinitePlace K) (x : E K)  :
    normAtPlace w (- x) = normAtPlace w x 
goal: (NumberField.mixedEmbedding.normAtPlace w) (-x) = (NumberField.mixedEmbedding.normAtPlace w) x

full_name: NumberField.mixedEmbedding.normAtPlace_add_le
code: theorem normAtPlace_add_le (w : InfinitePlace K) (x y : E K) :
    normAtPlace w (x + y) ≤ normAtPlace w x + normAtPlace w y 
goal: (NumberField.mixedEmbedding.normAtPlace w) (x + y) ≤
  (NumberField.mixedEmbedding.normAtPlace w) x + (NumberField.mixedEmbedding.normAtPlace w) y

full_name: NumberField.mixedEmbedding.normAtPlace_smul
code: theorem normAtPlace_smul (w : InfinitePlace K) (x : E K) (c : ℝ) :
    normAtPlace w (c • x) = |c| * normAtPlace w x 
goal: (NumberField.mixedEmbedding.normAtPlace w) (c • x) = |c| * (NumberField.mixedEmbedding.normAtPlace w) x

full_name: NumberField.mixedEmbedding.normAtPlace_real
code: theorem normAtPlace_real (w : InfinitePlace K) (c : ℝ) :
    normAtPlace w ((fun _ ↦ c, fun _ ↦ c) : (E K)) = |c| 
goal: (NumberField.mixedEmbedding.normAtPlace w) (fun x => c, fun x => ↑c) = |c|

full_name: NumberField.mixedEmbedding.normAtPlace_apply_isReal
code: theorem normAtPlace_apply_isReal {w : InfinitePlace K} (hw : IsReal w) (x : E K) :
    normAtPlace w x = ‖x.1 ⟨w, hw⟩‖ 
goal: (NumberField.mixedEmbedding.normAtPlace w) x = ‖x.1 ⟨w, hw⟩‖

full_name: NumberField.mixedEmbedding.normAtPlace_apply_isComplex
code: theorem normAtPlace_apply_isComplex {w : InfinitePlace K} (hw : IsComplex w) (x : E K) :
    normAtPlace w x = ‖x.2 ⟨w, hw⟩‖ 
goal: (NumberField.mixedEmbedding.normAtPlace w) x = ‖x.2 ⟨w, hw⟩‖

full_name: NumberField.mixedEmbedding.normAtPlace_apply
code: @[simp]
theorem normAtPlace_apply (w : InfinitePlace K) (x : K) :
    normAtPlace w (mixedEmbedding K x) = w x 
goal: (NumberField.mixedEmbedding.normAtPlace w) ((NumberField.mixedEmbedding K) x) = w x

full_name: NumberField.mixedEmbedding.normAtPlace_eq_zero
code: theorem normAtPlace_eq_zero {x : E K} :
    (∀ w, normAtPlace w x = 0) ↔ x = 0 
goal: (∀ (w : NumberField.InfinitePlace K), (NumberField.mixedEmbedding.normAtPlace w) x = 0) ↔ x = 0

full_name: NumberField.mixedEmbedding.nnnorm_eq_sup_normAtPlace
code: theorem nnnorm_eq_sup_normAtPlace (x : E K) :
    ‖x‖₊ = univ.sup fun w ↦ ⟨normAtPlace w x, normAtPlace_nonneg w x⟩ 
goal: ‖x‖₊ = Finset.univ.sup fun w => ⟨(NumberField.mixedEmbedding.normAtPlace w) x, ⋯⟩

full_name: NumberField.mixedEmbedding.norm_eq_sup'_normAtPlace
code: theorem norm_eq_sup'_normAtPlace (x : E K) :
    ‖x‖ = univ.sup' univ_nonempty fun w ↦ normAtPlace w x 
goal: ‖x‖ = Finset.univ.sup' ⋯ fun w => (NumberField.mixedEmbedding.normAtPlace w) x

full_name: NumberField.mixedEmbedding.norm
code: /-- The norm of `x` is `∏ w, (normAtPlace x) ^ mult w`. It is defined such that the norm of
`mixedEmbedding K a` for `a : K` is equal to the absolute value of the norm of `a` over `ℚ`,
see `norm_eq_norm`. -/
protected def norm : (E K) →*₀ ℝ 
goal: ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ) →*₀ ℝ

full_name: NumberField.mixedEmbedding.norm_apply
code: protected theorem norm_apply (x : E K) :
    mixedEmbedding.norm x = ∏ w, (normAtPlace w x) ^ (mult w) 
goal: NumberField.mixedEmbedding.norm x =
  ∏ w : NumberField.InfinitePlace K, (NumberField.mixedEmbedding.normAtPlace w) x ^ w.mult

full_name: NumberField.mixedEmbedding.norm_nonneg
code: protected theorem norm_nonneg (x : E K) :
    0 ≤ mixedEmbedding.norm x 
goal: 0 ≤ NumberField.mixedEmbedding.norm x

full_name: NumberField.mixedEmbedding.norm_eq_zero_iff
code: protected theorem norm_eq_zero_iff {x : E K} :
    mixedEmbedding.norm x = 0 ↔ ∃ w, normAtPlace w x = 0 
goal: NumberField.mixedEmbedding.norm x = 0 ↔ ∃ w, (NumberField.mixedEmbedding.normAtPlace w) x = 0

full_name: NumberField.mixedEmbedding.norm_ne_zero_iff
code: protected theorem norm_ne_zero_iff {x : E K} :
    mixedEmbedding.norm x ≠ 0 ↔ ∀ w, normAtPlace w x ≠ 0 
goal: NumberField.mixedEmbedding.norm x ≠ 0 ↔
  ∀ (w : NumberField.InfinitePlace K), (NumberField.mixedEmbedding.normAtPlace w) x ≠ 0

full_name: NumberField.mixedEmbedding.norm_smul
code: theorem norm_smul (c : ℝ) (x : E K) :
    mixedEmbedding.norm (c • x) = |c| ^ finrank ℚ K * (mixedEmbedding.norm x) 
goal: NumberField.mixedEmbedding.norm (c • x) = |c| ^ FiniteDimensional.finrank ℚ K * NumberField.mixedEmbedding.norm x

full_name: NumberField.mixedEmbedding.norm_real
code: theorem norm_real (c : ℝ) :
    mixedEmbedding.norm ((fun _ ↦ c, fun _ ↦ c) : (E K)) = |c| ^ finrank ℚ K 
goal: NumberField.mixedEmbedding.norm (fun x => c, fun x => ↑c) = |c| ^ FiniteDimensional.finrank ℚ K

full_name: NumberField.mixedEmbedding.norm_eq_norm
code: @[simp]
theorem norm_eq_norm (x : K) :
    mixedEmbedding.norm (mixedEmbedding K x) = |Algebra.norm ℚ x| 
goal: NumberField.mixedEmbedding.norm ((NumberField.mixedEmbedding K) x) = ↑|(Algebra.norm ℚ) x|

full_name: NumberField.mixedEmbedding.norm_eq_zero_iff'
code: theorem norm_eq_zero_iff' {x : E K} (hx : x ∈ Set.range (mixedEmbedding K)) :
    mixedEmbedding.norm x = 0 ↔ x = 0 
goal: NumberField.mixedEmbedding.norm x = 0 ↔ x = 0

full_name: NumberField.mixedEmbedding.index
code: /-- The type indexing the basis `stdBasis`. -/
abbrev index 
goal: Type u_1

full_name: NumberField.mixedEmbedding.stdBasis
code: /-- The `ℝ`-basis of `({w // IsReal w} → ℝ) × ({ w // IsComplex w } → ℂ)` formed by the vector
equal to `1` at `w` and `0` elsewhere for `IsReal w` and by the couple of vectors equal to `1`
(resp. `I`) at `w` and `0` elsewhere for `IsComplex w`. -/
def stdBasis : Basis (index K) ℝ (E K) 
goal: Basis (NumberField.mixedEmbedding.index K) ℝ (({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ))

full_name: NumberField.mixedEmbedding.stdBasis_apply_ofIsReal
code: @[simp]
theorem stdBasis_apply_ofIsReal (x : E K) (w : {w : InfinitePlace K // IsReal w}) :
    (stdBasis K).repr x (Sum.inl w) = x.1 w 
goal: ((NumberField.mixedEmbedding.stdBasis K).repr x) (Sum.inl w) = x.1 w

full_name: NumberField.mixedEmbedding.stdBasis_apply_ofIsComplex_fst
code: @[simp]
theorem stdBasis_apply_ofIsComplex_fst (x : E K) (w : {w : InfinitePlace K // IsComplex w}) :
    (stdBasis K).repr x (Sum.inr ⟨w, 0⟩) = (x.2 w).re 
goal: ((NumberField.mixedEmbedding.stdBasis K).repr x) (Sum.inr (w, 0)) = (x.2 w).re

full_name: NumberField.mixedEmbedding.stdBasis_apply_ofIsComplex_snd
code: @[simp]
theorem stdBasis_apply_ofIsComplex_snd (x : E K) (w : {w : InfinitePlace K // IsComplex w}) :
    (stdBasis K).repr x (Sum.inr ⟨w, 1⟩) = (x.2 w).im 
goal: ((NumberField.mixedEmbedding.stdBasis K).repr x) (Sum.inr (w, 1)) = (x.2 w).im

full_name: NumberField.mixedEmbedding.fundamentalDomain_stdBasis
code: theorem fundamentalDomain_stdBasis :
    fundamentalDomain (stdBasis K) =
        (Set.univ.pi fun _ => Set.Ico 0 1) ×ˢ
        (Set.univ.pi fun _ => Complex.measurableEquivPi⁻¹' (Set.univ.pi fun _ => Set.Ico 0 1)) 
goal: Zspan.fundamentalDomain (NumberField.mixedEmbedding.stdBasis K) =
  (Set.univ.pi fun x => Set.Ico 0 1) ×ˢ
    Set.univ.pi fun x => ⇑Complex.measurableEquivPi ⁻¹' Set.univ.pi fun x => Set.Ico 0 1

full_name: NumberField.mixedEmbedding.volume_fundamentalDomain_stdBasis
code: theorem volume_fundamentalDomain_stdBasis :
    volume (fundamentalDomain (stdBasis K)) = 1 
goal: MeasureTheory.volume (Zspan.fundamentalDomain (NumberField.mixedEmbedding.stdBasis K)) = 1

full_name: NumberField.mixedEmbedding.indexEquiv
code: /-- The `Equiv` between `index K` and `K →+* ℂ` defined by sending a real infinite place `w` to
the unique corresponding embedding `w.embedding`, and the pair `⟨w, 0⟩` (resp. `⟨w, 1⟩`) for a
complex infinite place `w` to `w.embedding` (resp. `conjugate w.embedding`). -/
def indexEquiv : (index K) ≃ (K →+* ℂ) 
goal: NumberField.mixedEmbedding.index K ≃ (K →+* ℂ)

full_name: NumberField.mixedEmbedding.indexEquiv_apply_ofIsReal
code: @[simp]
theorem indexEquiv_apply_ofIsReal (w : {w : InfinitePlace K // IsReal w}) :
    (indexEquiv K) (Sum.inl w) = w.val.embedding 
goal: (NumberField.mixedEmbedding.indexEquiv K) (Sum.inl w) = (↑w).embedding

full_name: NumberField.mixedEmbedding.indexEquiv_apply_ofIsComplex_fst
code: @[simp]
theorem indexEquiv_apply_ofIsComplex_fst (w : {w : InfinitePlace K // IsComplex w}) :
    (indexEquiv K) (Sum.inr ⟨w, 0⟩) = w.val.embedding 
goal: (NumberField.mixedEmbedding.indexEquiv K) (Sum.inr (w, 0)) = (↑w).embedding

full_name: NumberField.mixedEmbedding.indexEquiv_apply_ofIsComplex_snd
code: @[simp]
theorem indexEquiv_apply_ofIsComplex_snd (w : {w : InfinitePlace K // IsComplex w}) :
    (indexEquiv K) (Sum.inr ⟨w, 1⟩) = ComplexEmbedding.conjugate w.val.embedding 
goal: (NumberField.mixedEmbedding.indexEquiv K) (Sum.inr (w, 1)) = NumberField.ComplexEmbedding.conjugate (↑w).embedding

full_name: NumberField.mixedEmbedding.matrixToStdBasis
code: /-- The matrix that gives the representation on `stdBasis` of the image by `commMap` of an
element `x` of `(K →+* ℂ) → ℂ` fixed by the map `x_φ ↦ conj x_(conjugate φ)`,
see `stdBasis_repr_eq_matrixToStdBasis_mul`. -/
def matrixToStdBasis : Matrix (index K) (index K) ℂ 
goal: Matrix (NumberField.mixedEmbedding.index K) (NumberField.mixedEmbedding.index K) ℂ

full_name: NumberField.mixedEmbedding.det_matrixToStdBasis
code: theorem det_matrixToStdBasis :
    (matrixToStdBasis K).det = (2⁻¹ * I) ^ NrComplexPlaces K 
goal: (NumberField.mixedEmbedding.matrixToStdBasis K).det = (2⁻¹ * Complex.I) ^ NumberField.InfinitePlace.NrComplexPlaces K

full_name: NumberField.mixedEmbedding.stdBasis_repr_eq_matrixToStdBasis_mul
code: /-- Let `x : (K →+* ℂ) → ℂ` such that `x_φ = conj x_(conj φ)` for all `φ : K →+* ℂ`, then the
representation of `commMap K x` on `stdBasis` is given (up to reindexing) by the product of
`matrixToStdBasis` by `x`. -/
theorem stdBasis_repr_eq_matrixToStdBasis_mul (x : (K →+* ℂ) → ℂ)
    (hx : ∀ φ, conj (x φ) = x (ComplexEmbedding.conjugate φ)) (c : index K) :
    ((stdBasis K).repr (commMap K x) c : ℂ) =
      (matrixToStdBasis K *ᵥ (x ∘ (indexEquiv K))) c 
goal: ↑(((NumberField.mixedEmbedding.stdBasis K).repr ((NumberField.mixedEmbedding.commMap K) x)) c) =
  (NumberField.mixedEmbedding.matrixToStdBasis K).mulVec (x ∘ ⇑(NumberField.mixedEmbedding.indexEquiv K)) c

full_name: NumberField.mixedEmbedding.latticeBasis
code: /-- A `ℝ`-basis of `ℝ^r₁ × ℂ^r₂` that is also a `ℤ`-basis of the image of `𝓞 K`. -/
def latticeBasis :
    Basis (ChooseBasisIndex ℤ (𝓞 K)) ℝ (E K) 
goal: Basis (Module.Free.ChooseBasisIndex ℤ (NumberField.RingOfIntegers K)) ℝ
  (({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ))

full_name: NumberField.mixedEmbedding.latticeBasis_apply
code: @[simp]
theorem latticeBasis_apply (i : ChooseBasisIndex ℤ (𝓞 K)) :
    latticeBasis K i = (mixedEmbedding K) (integralBasis K i) 
goal: (NumberField.mixedEmbedding.latticeBasis K) i = (NumberField.mixedEmbedding K) ((NumberField.integralBasis K) i)

full_name: NumberField.mixedEmbedding.mem_span_latticeBasis
code: theorem mem_span_latticeBasis (x : (E K)) :
    x ∈ Submodule.span ℤ (Set.range (latticeBasis K)) ↔
      x ∈ ((mixedEmbedding K).comp (algebraMap (𝓞 K) K)).range 
goal: x ∈ Submodule.span ℤ (Set.range ⇑(NumberField.mixedEmbedding.latticeBasis K)) ↔
  x ∈ ((NumberField.mixedEmbedding K).comp (algebraMap (NumberField.RingOfIntegers K) K)).range

full_name: NumberField.mixedEmbedding.mem_rat_span_latticeBasis
code: theorem mem_rat_span_latticeBasis (x : K) :
    mixedEmbedding K x ∈ Submodule.span ℚ (Set.range (latticeBasis K)) 
goal: (NumberField.mixedEmbedding K) x ∈ Submodule.span ℚ (Set.range ⇑(NumberField.mixedEmbedding.latticeBasis K))

full_name: NumberField.mixedEmbedding.latticeBasis_repr_apply
code: theorem latticeBasis_repr_apply (x : K) (i : ChooseBasisIndex ℤ (𝓞 K)) :
    (latticeBasis K).repr (mixedEmbedding K x) i = (integralBasis K).repr x i 
goal: ((NumberField.mixedEmbedding.latticeBasis K).repr ((NumberField.mixedEmbedding K) x)) i =
  ↑(((NumberField.integralBasis K).repr x) i)

full_name: NumberField.mixedEmbedding.det_basisOfFractionalIdeal_eq_norm
code: /-- The generalized index of the lattice generated by `I` in the lattice generated by
`𝓞 K` is equal to the norm of the ideal `I`. The result is stated in terms of base change
determinant and is the translation of `NumberField.det_basisOfFractionalIdeal_eq_absNorm` in
`ℝ^r₁ × ℂ^r₂`. This is useful, in particular, to prove that the family obtained from
the `ℤ`-basis of `I` is actually an `ℝ`-basis of `ℝ^r₁ × ℂ^r₂`, see
`fractionalIdealLatticeBasis`. -/
theorem det_basisOfFractionalIdeal_eq_norm
    (e : (ChooseBasisIndex ℤ (𝓞 K)) ≃ (ChooseBasisIndex ℤ I)) :
    |Basis.det (latticeBasis K) ((mixedEmbedding K ∘ (basisOfFractionalIdeal K I) ∘ e))| =
      FractionalIdeal.absNorm I.1 
goal: |(NumberField.mixedEmbedding.latticeBasis K).det
      (⇑(NumberField.mixedEmbedding K) ∘ ⇑(NumberField.basisOfFractionalIdeal K I) ∘ ⇑e)| =
  ↑(FractionalIdeal.absNorm ↑I)

full_name: NumberField.mixedEmbedding.fractionalIdealLatticeBasis
code: /-- A `ℝ`-basis of `ℝ^r₁ × ℂ^r₂` that is also a `ℤ`-basis of the image of the fractional
ideal `I`. -/
def fractionalIdealLatticeBasis :
    Basis (ChooseBasisIndex ℤ I) ℝ (E K) 
goal: Basis (Module.Free.ChooseBasisIndex ℤ ↥↑↑I) ℝ (({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ))

full_name: NumberField.mixedEmbedding.fractionalIdealLatticeBasis_apply
code: @[simp]
theorem fractionalIdealLatticeBasis_apply (i : ChooseBasisIndex ℤ I) :
    fractionalIdealLatticeBasis K I i = (mixedEmbedding K) (basisOfFractionalIdeal K I i) 
goal: (NumberField.mixedEmbedding.fractionalIdealLatticeBasis K I) i =
  (NumberField.mixedEmbedding K) ((NumberField.basisOfFractionalIdeal K I) i)

full_name: NumberField.mixedEmbedding.mem_span_fractionalIdealLatticeBasis
code: theorem mem_span_fractionalIdealLatticeBasis (x : (E K)) :
    x ∈ Submodule.span ℤ (Set.range (fractionalIdealLatticeBasis K I)) ↔
      x ∈ mixedEmbedding K '' I 
goal: x ∈ Submodule.span ℤ (Set.range ⇑(NumberField.mixedEmbedding.fractionalIdealLatticeBasis K I)) ↔
  x ∈ ⇑(NumberField.mixedEmbedding K) '' ↑↑I