File: Mathlib/RingTheory/DedekindDomain/Different.lean

full_name: Submodule.traceDual
code: /-- Under the AKLB setting, `Iᵛ := traceDual A K (I : Submodule B L)` is the
`Submodule B L` such that `x ∈ Iᵛ ↔ ∀ y ∈ I, Tr(x, y) ∈ A` -/
noncomputable
def Submodule.traceDual (I : Submodule B L) : Submodule B L 
goal: Submodule B L

full_name: _aux_Mathlib_RingTheory_DedekindDomain_Different___unexpand_Submodule_traceDual_1
code: local notation:max I:max "ᵛ" => Submodule.traceDual A K I
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_RingTheory_DedekindDomain_Different___macroRules_term_ᵛ_1»
code: local notation:max I:max "ᵛ" => Submodule.traceDual A K I
goal: Lean.Macro

full_name: Submodule.mem_traceDual
code: lemma mem_traceDual {I : Submodule B L} {x} :
    x ∈ Iᵛ ↔ ∀ a ∈ I, traceForm K L x a ∈ (algebraMap A K).range 
goal: x ∈ Submodule.traceDual A K I ↔ ∀ a ∈ I, ((Algebra.traceForm K L) x) a ∈ (algebraMap A K).range

full_name: Submodule.le_traceDual_iff_map_le_one
code: lemma le_traceDual_iff_map_le_one {I J : Submodule B L} :
    I ≤ Jᵛ ↔ ((I * J : Submodule B L).restrictScalars A).map
      ((trace K L).restrictScalars A) ≤ 1 
goal: I ≤ Submodule.traceDual A K J ↔ Submodule.map (↑A (Algebra.trace K L)) (Submodule.restrictScalars A (I * J)) ≤ 1

full_name: Submodule.le_traceDual_mul_iff
code: lemma le_traceDual_mul_iff {I J J' : Submodule B L} :
    I ≤ (J * J')ᵛ ↔ I * J ≤ J'ᵛ 
goal: I ≤ Submodule.traceDual A K (J * J') ↔ I * J ≤ Submodule.traceDual A K J'

full_name: Submodule.le_traceDual
code: lemma le_traceDual {I J : Submodule B L} :
    I ≤ Jᵛ ↔ I * J ≤ 1ᵛ 
goal: I ≤ Submodule.traceDual A K J ↔ I * J ≤ Submodule.traceDual A K 1

full_name: Submodule.le_traceDual_comm
code: lemma le_traceDual_comm {I J : Submodule B L} :
    I ≤ Jᵛ ↔ J ≤ Iᵛ 
goal: I ≤ Submodule.traceDual A K J ↔ J ≤ Submodule.traceDual A K I

full_name: Submodule.le_traceDual_traceDual
code: lemma le_traceDual_traceDual {I : Submodule B L} :
    I ≤ Iᵛᵛ 
goal: I ≤ Submodule.traceDual A K (Submodule.traceDual A K I)

full_name: Submodule.traceDual_bot
code: @[simp]
lemma traceDual_bot :
    (⊥ : Submodule B L)ᵛ = ⊤ 
goal: Submodule.traceDual A K ⊥ = ⊤

full_name: Submodule.traceDual_top'
code: lemma traceDual_top' :
    (⊤ : Submodule B L)ᵛ =
      if ((LinearMap.range (Algebra.trace K L)).restrictScalars A ≤ 1) then ⊤ else ⊥ 
goal: Submodule.traceDual A K ⊤ = if Submodule.restrictScalars A (LinearMap.range (Algebra.trace K L)) ≤ 1 then ⊤ else ⊥

full_name: Submodule.traceDual_top
code: lemma traceDual_top [Decidable (IsField A)] :
    (⊤ : Submodule B L)ᵛ = if IsField A then ⊤ else ⊥ 
goal: Submodule.traceDual A K ⊤ = if IsField A then ⊤ else ⊥

full_name: Submodule.mem_traceDual_iff_isIntegral
code: lemma Submodule.mem_traceDual_iff_isIntegral {I : Submodule B L} {x} :
    x ∈ Iᵛ ↔ ∀ a ∈ I, IsIntegral A (traceForm K L x a) 
goal: x ∈ Submodule.traceDual A K I ↔ ∀ a ∈ I, IsIntegral A (((Algebra.traceForm K L) x) a)

full_name: Submodule.one_le_traceDual_one
code: lemma Submodule.one_le_traceDual_one :
    (1 : Submodule B L) ≤ 1ᵛ 
goal: 1 ≤ Submodule.traceDual A K 1

full_name: isIntegral_discr_mul_of_mem_traceDual
code: /-- If `b` is an `A`-integral basis of `L` with discriminant `b`, then `d • a * x` is integral over
  `A` for all `a ∈ I` and `x ∈ Iᵛ`. -/
lemma isIntegral_discr_mul_of_mem_traceDual
    (I : Submodule B L) {ι} [DecidableEq ι] [Fintype ι]
    {b : Basis ι K L} (hb : ∀ i, IsIntegral A (b i))
    {a x : L} (ha : a ∈ I) (hx : x ∈ Iᵛ) :
    IsIntegral A ((discr K b) • a * x) 
goal: IsIntegral A (Algebra.discr K ⇑b • a * x)

full_name: map_equiv_traceDual
code: lemma map_equiv_traceDual [NoZeroSMulDivisors A B] (I : Submodule B (FractionRing B)) :
    (traceDual A (FractionRing A) I).map (FractionRing.algEquiv B L) =
      traceDual A K (I.map (FractionRing.algEquiv B L)) 
goal: Submodule.map (FractionRing.algEquiv B L) (Submodule.traceDual A (FractionRing A) I) =
  Submodule.traceDual A K (Submodule.map (FractionRing.algEquiv B L) I)

full_name: FractionalIdeal.dual
code: /-- The dual of a non-zero fractional ideal is the dual of the submodule under the traceform. -/
noncomputable
def dual (I : FractionalIdeal B⁰ L) :
    FractionalIdeal B⁰ L 
goal: FractionalIdeal B⁰ L

full_name: FractionalIdeal.«_aux_Mathlib_RingTheory_DedekindDomain_Different___macroRules_FractionalIdeal_term_ᵛ_1»
code: local notation:max I:max "ᵛ" => Submodule.traceDual A K I
goal: Lean.Macro

full_name: FractionalIdeal._aux_Mathlib_RingTheory_DedekindDomain_Different___unexpand_Submodule_traceDual_1
code: local notation:max I:max "ᵛ" => Submodule.traceDual A K I
goal: Lean.PrettyPrinter.Unexpander

full_name: FractionalIdeal.coe_dual
code: lemma coe_dual :
    (dual A K I : Submodule B L) = Iᵛ 
goal: ↑(FractionalIdeal.dual A K I) = Submodule.traceDual A K ↑I

full_name: FractionalIdeal.coe_dual_one
code: @[simp]
lemma coe_dual_one :
    (dual A K (1 : FractionalIdeal B⁰ L) : Submodule B L) = 1ᵛ 
goal: ↑(FractionalIdeal.dual A K 1) = Submodule.traceDual A K 1

full_name: FractionalIdeal.dual_zero
code: @[simp]
lemma dual_zero :
    dual A K (0 : FractionalIdeal B⁰ L) = 0 
goal: FractionalIdeal.dual A K 0 = 0

full_name: FractionalIdeal.mem_dual
code: lemma mem_dual {x} :
    x ∈ dual A K I ↔ ∀ a ∈ I, traceForm K L x a ∈ (algebraMap A K).range 
goal: x ∈ FractionalIdeal.dual A K I ↔ ∀ a ∈ I, ((Algebra.traceForm K L) x) a ∈ (algebraMap A K).range

full_name: FractionalIdeal.dual_ne_zero
code: lemma dual_ne_zero :
    dual A K I ≠ 0 
goal: FractionalIdeal.dual A K I ≠ 0

full_name: FractionalIdeal.dual_eq_zero_iff
code: @[simp]
lemma dual_eq_zero_iff :
    dual A K I = 0 ↔ I = 0 
goal: FractionalIdeal.dual A K I = 0 ↔ I = 0

full_name: FractionalIdeal.dual_ne_zero_iff
code: lemma dual_ne_zero_iff :
    dual A K I ≠ 0 ↔ I ≠ 0 
goal: FractionalIdeal.dual A K I ≠ 0 ↔ I ≠ 0

full_name: FractionalIdeal.le_dual_inv_aux
code: lemma le_dual_inv_aux (hIJ : I * J ≤ 1) :
    J ≤ dual A K I 
goal: J ≤ FractionalIdeal.dual A K I

full_name: FractionalIdeal.one_le_dual_one
code: lemma one_le_dual_one :
    1 ≤ dual A K (1 : FractionalIdeal B⁰ L) 
goal: 1 ≤ FractionalIdeal.dual A K 1

full_name: FractionalIdeal.le_dual_iff
code: lemma le_dual_iff :
    I ≤ dual A K J ↔ I * J ≤ dual A K 1 
goal: I ≤ FractionalIdeal.dual A K J ↔ I * J ≤ FractionalIdeal.dual A K 1

full_name: FractionalIdeal.inv_le_dual
code: lemma inv_le_dual :
    I⁻¹ ≤ dual A K I 
goal: I⁻¹ ≤ FractionalIdeal.dual A K I

full_name: FractionalIdeal.dual_inv_le
code: lemma dual_inv_le :
    (dual A K I)⁻¹ ≤ I 
goal: (FractionalIdeal.dual A K I)⁻¹ ≤ I

full_name: FractionalIdeal.dual_eq_mul_inv
code: lemma dual_eq_mul_inv :
    dual A K I = dual A K 1 * I⁻¹ 
goal: FractionalIdeal.dual A K I = FractionalIdeal.dual A K 1 * I⁻¹

full_name: FractionalIdeal.dual_div_dual
code: lemma dual_div_dual :
    dual A K J / dual A K I = I / J 
goal: FractionalIdeal.dual A K J / FractionalIdeal.dual A K I = I / J

full_name: FractionalIdeal.dual_mul_self
code: lemma dual_mul_self :
    dual A K I * I = dual A K 1 
goal: FractionalIdeal.dual A K I * I = FractionalIdeal.dual A K 1

full_name: FractionalIdeal.self_mul_dual
code: lemma self_mul_dual :
    I * dual A K I = dual A K 1 
goal: I * FractionalIdeal.dual A K I = FractionalIdeal.dual A K 1

full_name: FractionalIdeal.dual_inv
code: lemma dual_inv :
    dual A K I⁻¹ = dual A K 1 * I 
goal: FractionalIdeal.dual A K I⁻¹ = FractionalIdeal.dual A K 1 * I

full_name: FractionalIdeal.dual_dual
code: @[simp]
lemma dual_dual :
    dual A K (dual A K I) = I 
goal: FractionalIdeal.dual A K (FractionalIdeal.dual A K I) = I

full_name: FractionalIdeal.dual_le_dual
code: @[simp]
lemma dual_le_dual :
    dual A K I ≤ dual A K J ↔ J ≤ I 
goal: FractionalIdeal.dual A K I ≤ FractionalIdeal.dual A K J ↔ J ≤ I

full_name: FractionalIdeal.dual_involutive
code: lemma dual_involutive :
    Function.Involutive (dual A K : FractionalIdeal B⁰ L → FractionalIdeal B⁰ L) 
goal: Function.Involutive (FractionalIdeal.dual A K)

full_name: FractionalIdeal.dual_injective
code: lemma dual_injective :
    Function.Injective (dual A K : FractionalIdeal B⁰ L → FractionalIdeal B⁰ L) 
goal: Function.Injective (FractionalIdeal.dual A K)

full_name: differentIdeal
code: /-- The different ideal of an extension of integral domains `B/A` is the inverse of the dual of `A`
as an ideal of `B`. See `coeIdeal_differentIdeal` and `coeSubmodule_differentIdeal`. -/
def differentIdeal [NoZeroSMulDivisors A B] : Ideal B 
goal: Ideal B

full_name: coeSubmodule_differentIdeal_fractionRing
code: lemma coeSubmodule_differentIdeal_fractionRing
    [NoZeroSMulDivisors A B] [Algebra.IsIntegral A B]
    [Algebra.IsSeparable (FractionRing A) (FractionRing B)]
    [FiniteDimensional (FractionRing A) (FractionRing B)] :
    coeSubmodule (FractionRing B) (differentIdeal A B) =
      1 / Submodule.traceDual A (FractionRing A) 1 
goal: IsLocalization.coeSubmodule (FractionRing B) (differentIdeal A B) = 1 / Submodule.traceDual A (FractionRing A) 1

full_name: coeSubmodule_differentIdeal
code: lemma coeSubmodule_differentIdeal [NoZeroSMulDivisors A B] :
    coeSubmodule L (differentIdeal A B) = 1 / Submodule.traceDual A K 1 
goal: IsLocalization.coeSubmodule L (differentIdeal A B) = 1 / Submodule.traceDual A K 1

full_name: coeIdeal_differentIdeal
code: lemma coeIdeal_differentIdeal [NoZeroSMulDivisors A B] :
    ↑(differentIdeal A B) = (FractionalIdeal.dual A K (1 : FractionalIdeal B⁰ L))⁻¹ 
goal: ↑(differentIdeal A B) = (FractionalIdeal.dual A K 1)⁻¹

full_name: differentialIdeal_le_fractionalIdeal_iff
code: lemma differentialIdeal_le_fractionalIdeal_iff
    {I : FractionalIdeal B⁰ L} (hI : I ≠ 0) [NoZeroSMulDivisors A B] :
    differentIdeal A B ≤ I ↔ (((I⁻¹ : _) : Submodule B L).restrictScalars A).map
      ((Algebra.trace K L).restrictScalars A) ≤ 1 
goal: ↑(differentIdeal A B) ≤ I ↔ Submodule.map (↑A (Algebra.trace K L)) (Submodule.restrictScalars A ↑I⁻¹) ≤ 1

full_name: differentialIdeal_le_iff
code: lemma differentialIdeal_le_iff {I : Ideal B} (hI : I ≠ ⊥) [NoZeroSMulDivisors A B] :
    differentIdeal A B ≤ I ↔ (((I⁻¹ : FractionalIdeal B⁰ L) : Submodule B L).restrictScalars A).map
      ((Algebra.trace K L).restrictScalars A) ≤ 1 
goal: differentIdeal A B ≤ I ↔ Submodule.map (↑A (Algebra.trace K L)) (Submodule.restrictScalars A ↑(↑I)⁻¹) ≤ 1

full_name: traceForm_dualSubmodule_adjoin
code: lemma traceForm_dualSubmodule_adjoin
    {x : L} (hx : Algebra.adjoin K {x} = ⊤) (hAx : IsIntegral A x) :
    (traceForm K L).dualSubmodule (Subalgebra.toSubmodule (Algebra.adjoin A {x})) =
      (aeval x (derivative <| minpoly K x) : L)⁻¹ •
        (Subalgebra.toSubmodule (Algebra.adjoin A {x})) 
goal: (Algebra.traceForm K L).dualSubmodule (Subalgebra.toSubmodule (Algebra.adjoin A {x})) =
  ((Polynomial.aeval x) (Polynomial.derivative (minpoly K x)))⁻¹ • Subalgebra.toSubmodule (Algebra.adjoin A {x})

full_name: conductor_mul_differentIdeal
code: lemma conductor_mul_differentIdeal [NoZeroSMulDivisors A B]
    (x : B) (hx : Algebra.adjoin K {algebraMap B L x} = ⊤) :
    (conductor A x) * differentIdeal A B = Ideal.span {aeval x (derivative (minpoly A x))} 
goal: conductor A x * differentIdeal A B = Ideal.span {(Polynomial.aeval x) (Polynomial.derivative (minpoly A x))}

full_name: aeval_derivative_mem_differentIdeal
code: lemma aeval_derivative_mem_differentIdeal [NoZeroSMulDivisors A B]
    (x : B) (hx : Algebra.adjoin K {algebraMap B L x} = ⊤) :
    aeval x (derivative (minpoly A x)) ∈ differentIdeal A B 
goal: (Polynomial.aeval x) (Polynomial.derivative (minpoly A x)) ∈ differentIdeal A B