l3lab/ntp-mathlib huggingface dataset:
lemma coeSubmodule_differentIdeal [NoZeroSMulDivisors A B] :
    coeSubmodule L (differentIdeal A B) = 1 / Submodule.traceDual A K 1 := by
  have : (FractionRing.algEquiv B L).toLinearEquiv.comp (Algebra.linearMap B (FractionRing B)) =
    Algebra.linearMap B L := by ext; simp
  rw [coeSubmodule, ← this]
  have H : RingHom.comp (algebraMap (FractionRing A) (FractionRing B))
    ↑(FractionRing.algEquiv A K).symm.toRingEquiv =
      RingHom.comp ↑(FractionRing.algEquiv B L).symm.toRingEquiv (algebraMap K L)
  · apply IsLocalization.ringHom_ext A⁰
    ext
    simp only [AlgEquiv.toRingEquiv_eq_coe, RingHom.coe_comp, RingHom.coe_coe,
      AlgEquiv.coe_ringEquiv, Function.comp_apply, AlgEquiv.commutes,
      ← IsScalarTower.algebraMap_apply]
    rw [IsScalarTower.algebraMap_apply A B L, AlgEquiv.commutes, ← IsScalarTower.algebraMap_apply]
  have : IsSeparable (FractionRing A) (FractionRing B) := IsSeparable.of_equiv_equiv _ _ H
  have : FiniteDimensional (FractionRing A) (FractionRing B) := Module.Finite.of_equiv_equiv _ _ H
  simp only [AlgEquiv.toLinearEquiv_toLinearMap, Submodule.map_comp]
  

Proof state:
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²⁰ : CommRing A
inst✝¹⁹ : Field K
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Field L
inst✝¹⁶ : Algebra A K
inst✝¹⁵ : Algebra B L
inst✝¹⁴ : Algebra A B
inst✝¹³ : Algebra K L
inst✝¹² : Algebra A L
inst✝¹¹ : IsScalarTower A K L
inst✝¹⁰ : IsScalarTower A B L
inst✝⁹ : IsDomain A
inst✝⁸ : IsDomain B
inst✝⁷ : IsFractionRing A K
inst✝⁶ : IsIntegralClosure B A L
inst✝⁵ : IsFractionRing B L
inst✝⁴ : FiniteDimensional K L
inst✝³ : IsSeparable K L
inst✝² : IsIntegrallyClosed A
inst✝¹ : IsDedekindDomain B
inst✝ : NoZeroSMulDivisors A B
this✝¹ :
  ↑(AlgEquiv.toLinearEquiv (FractionRing.algEquiv B L)) ∘ₗ Algebra.linearMap B (FractionRing B) = Algebra.linearMap B L
H :
  RingHom.comp (algebraMap (FractionRing A) (FractionRing B))
      ↑(AlgEquiv.toRingEquiv (AlgEquiv.symm (FractionRing.algEquiv A K))) =
    RingHom.comp (↑(AlgEquiv.toRingEquiv (AlgEquiv.symm (FractionRing.algEquiv B L)))) (algebraMap K L)
this✝ : IsSeparable (FractionRing A) (FractionRing B)
this : FiniteDimensional (FractionRing A) (FractionRing B)
⊢ Submodule.map (AlgEquiv.toLinearMap (FractionRing.algEquiv B L))
      (Submodule.map (Algebra.linearMap B (FractionRing B)) (differentIdeal A B)) =
    1 / 1ᵛ

Next tactic:
rw [← coeSubmodule, coeSubmodule_differentIdeal_fractionRing _ _
      (IsIntegralClosure.isIntegral_algebra _ L),
    Submodule.map_div, ← AlgEquiv.toAlgHom_toLinearMap, Submodule.map_one]
lemma coeSubmodule_differentIdeal [NoZeroSMulDivisors A B] :
    coeSubmodule L (differentIdeal A B) = 1 / Submodule.traceDual A K 1 := by
  have : (FractionRing.algEquiv B L).toLinearEquiv.comp (Algebra.linearMap B (FractionRing B)) =
    Algebra.linearMap B L := by ext; simp
  rw [coeSubmodule, ← this]
  have H : RingHom.comp (algebraMap (FractionRing A) (FractionRing B))
    ↑(FractionRing.algEquiv A K).symm.toRingEquiv =
      RingHom.comp ↑(FractionRing.algEquiv B L).symm.toRingEquiv (algebraMap K L)
  · apply IsLocalization.ringHom_ext A⁰
    ext
    simp only [AlgEquiv.toRingEquiv_eq_coe, RingHom.coe_comp, RingHom.coe_coe,
      AlgEquiv.coe_ringEquiv, Function.comp_apply, AlgEquiv.commutes,
      ← IsScalarTower.algebraMap_apply]
    rw [IsScalarTower.algebraMap_apply A B L, AlgEquiv.commutes, ← IsScalarTower.algebraMap_apply]
  have : IsSeparable (FractionRing A) (FractionRing B) := IsSeparable.of_equiv_equiv _ _ H
  have : FiniteDimensional (FractionRing A) (FractionRing B) := Module.Finite.of_equiv_equiv _ _ H
  simp only [AlgEquiv.toLinearEquiv_toLinearMap, Submodule.map_comp]
  rw [← coeSubmodule, coeSubmodule_differentIdeal_fractionRing _ _
      (IsIntegralClosure.isIntegral_algebra _ L),
    Submodule.map_div, ← AlgEquiv.toAlgHom_toLinearMap, Submodule.map_one]
  

Proof state:
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²⁰ : CommRing A
inst✝¹⁹ : Field K
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Field L
inst✝¹⁶ : Algebra A K
inst✝¹⁵ : Algebra B L
inst✝¹⁴ : Algebra A B
inst✝¹³ : Algebra K L
inst✝¹² : Algebra A L
inst✝¹¹ : IsScalarTower A K L
inst✝¹⁰ : IsScalarTower A B L
inst✝⁹ : IsDomain A
inst✝⁸ : IsDomain B
inst✝⁷ : IsFractionRing A K
inst✝⁶ : IsIntegralClosure B A L
inst✝⁵ : IsFractionRing B L
inst✝⁴ : FiniteDimensional K L
inst✝³ : IsSeparable K L
inst✝² : IsIntegrallyClosed A
inst✝¹ : IsDedekindDomain B
inst✝ : NoZeroSMulDivisors A B
this✝¹ :
  ↑(AlgEquiv.toLinearEquiv (FractionRing.algEquiv B L)) ∘ₗ Algebra.linearMap B (FractionRing B) = Algebra.linearMap B L
H :
  RingHom.comp (algebraMap (FractionRing A) (FractionRing B))
      ↑(AlgEquiv.toRingEquiv (AlgEquiv.symm (FractionRing.algEquiv A K))) =
    RingHom.comp (↑(AlgEquiv.toRingEquiv (AlgEquiv.symm (FractionRing.algEquiv B L)))) (algebraMap K L)
this✝ : IsSeparable (FractionRing A) (FractionRing B)
this : FiniteDimensional (FractionRing A) (FractionRing B)
⊢ 1 / Submodule.map (AlgHom.toLinearMap ↑(FractionRing.algEquiv B L)) (traceDual A (FractionRing A) 1) = 1 / 1ᵛ

Next tactic:
congr 1
lemma coeSubmodule_differentIdeal [NoZeroSMulDivisors A B] :
    coeSubmodule L (differentIdeal A B) = 1 / Submodule.traceDual A K 1 := by
  have : (FractionRing.algEquiv B L).toLinearEquiv.comp (Algebra.linearMap B (FractionRing B)) =
    Algebra.linearMap B L := by ext; simp
  rw [coeSubmodule, ← this]
  have H : RingHom.comp (algebraMap (FractionRing A) (FractionRing B))
    ↑(FractionRing.algEquiv A K).symm.toRingEquiv =
      RingHom.comp ↑(FractionRing.algEquiv B L).symm.toRingEquiv (algebraMap K L)
  · apply IsLocalization.ringHom_ext A⁰
    ext
    simp only [AlgEquiv.toRingEquiv_eq_coe, RingHom.coe_comp, RingHom.coe_coe,
      AlgEquiv.coe_ringEquiv, Function.comp_apply, AlgEquiv.commutes,
      ← IsScalarTower.algebraMap_apply]
    rw [IsScalarTower.algebraMap_apply A B L, AlgEquiv.commutes, ← IsScalarTower.algebraMap_apply]
  have : IsSeparable (FractionRing A) (FractionRing B) := IsSeparable.of_equiv_equiv _ _ H
  have : FiniteDimensional (FractionRing A) (FractionRing B) := Module.Finite.of_equiv_equiv _ _ H
  simp only [AlgEquiv.toLinearEquiv_toLinearMap, Submodule.map_comp]
  rw [← coeSubmodule, coeSubmodule_differentIdeal_fractionRing _ _
      (IsIntegralClosure.isIntegral_algebra _ L),
    Submodule.map_div, ← AlgEquiv.toAlgHom_toLinearMap, Submodule.map_one]
  congr 1
  

Proof state:
case e_a
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²⁰ : CommRing A
inst✝¹⁹ : Field K
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Field L
inst✝¹⁶ : Algebra A K
inst✝¹⁵ : Algebra B L
inst✝¹⁴ : Algebra A B
inst✝¹³ : Algebra K L
inst✝¹² : Algebra A L
inst✝¹¹ : IsScalarTower A K L
inst✝¹⁰ : IsScalarTower A B L
inst✝⁹ : IsDomain A
inst✝⁸ : IsDomain B
inst✝⁷ : IsFractionRing A K
inst✝⁶ : IsIntegralClosure B A L
inst✝⁵ : IsFractionRing B L
inst✝⁴ : FiniteDimensional K L
inst✝³ : IsSeparable K L
inst✝² : IsIntegrallyClosed A
inst✝¹ : IsDedekindDomain B
inst✝ : NoZeroSMulDivisors A B
this✝¹ :
  ↑(AlgEquiv.toLinearEquiv (FractionRing.algEquiv B L)) ∘ₗ Algebra.linearMap B (FractionRing B) = Algebra.linearMap B L
H :
  RingHom.comp (algebraMap (FractionRing A) (FractionRing B))
      ↑(AlgEquiv.toRingEquiv (AlgEquiv.symm (FractionRing.algEquiv A K))) =
    RingHom.comp (↑(AlgEquiv.toRingEquiv (AlgEquiv.symm (FractionRing.algEquiv B L)))) (algebraMap K L)
this✝ : IsSeparable (FractionRing A) (FractionRing B)
this : FiniteDimensional (FractionRing A) (FractionRing B)
⊢ Submodule.map (AlgHom.toLinearMap ↑(FractionRing.algEquiv B L)) (traceDual A (FractionRing A) 1) = 1ᵛ

Next tactic:
refine (map_equiv_traceDual A K _).trans ?_
lemma coeSubmodule_differentIdeal [NoZeroSMulDivisors A B] :
    coeSubmodule L (differentIdeal A B) = 1 / Submodule.traceDual A K 1 := by
  have : (FractionRing.algEquiv B L).toLinearEquiv.comp (Algebra.linearMap B (FractionRing B)) =
    Algebra.linearMap B L := by ext; simp
  rw [coeSubmodule, ← this]
  have H : RingHom.comp (algebraMap (FractionRing A) (FractionRing B))
    ↑(FractionRing.algEquiv A K).symm.toRingEquiv =
      RingHom.comp ↑(FractionRing.algEquiv B L).symm.toRingEquiv (algebraMap K L)
  · apply IsLocalization.ringHom_ext A⁰
    ext
    simp only [AlgEquiv.toRingEquiv_eq_coe, RingHom.coe_comp, RingHom.coe_coe,
      AlgEquiv.coe_ringEquiv, Function.comp_apply, AlgEquiv.commutes,
      ← IsScalarTower.algebraMap_apply]
    rw [IsScalarTower.algebraMap_apply A B L, AlgEquiv.commutes, ← IsScalarTower.algebraMap_apply]
  have : IsSeparable (FractionRing A) (FractionRing B) := IsSeparable.of_equiv_equiv _ _ H
  have : FiniteDimensional (FractionRing A) (FractionRing B) := Module.Finite.of_equiv_equiv _ _ H
  simp only [AlgEquiv.toLinearEquiv_toLinearMap, Submodule.map_comp]
  rw [← coeSubmodule, coeSubmodule_differentIdeal_fractionRing _ _
      (IsIntegralClosure.isIntegral_algebra _ L),
    Submodule.map_div, ← AlgEquiv.toAlgHom_toLinearMap, Submodule.map_one]
  congr 1
  refine (map_equiv_traceDual A K _).trans ?_
  

Proof state:
case e_a
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²⁰ : CommRing A
inst✝¹⁹ : Field K
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Field L
inst✝¹⁶ : Algebra A K
inst✝¹⁵ : Algebra B L
inst✝¹⁴ : Algebra A B
inst✝¹³ : Algebra K L
inst✝¹² : Algebra A L
inst✝¹¹ : IsScalarTower A K L
inst✝¹⁰ : IsScalarTower A B L
inst✝⁹ : IsDomain A
inst✝⁸ : IsDomain B
inst✝⁷ : IsFractionRing A K
inst✝⁶ : IsIntegralClosure B A L
inst✝⁵ : IsFractionRing B L
inst✝⁴ : FiniteDimensional K L
inst✝³ : IsSeparable K L
inst✝² : IsIntegrallyClosed A
inst✝¹ : IsDedekindDomain B
inst✝ : NoZeroSMulDivisors A B
this✝¹ :
  ↑(AlgEquiv.toLinearEquiv (FractionRing.algEquiv B L)) ∘ₗ Algebra.linearMap B (FractionRing B) = Algebra.linearMap B L
H :
  RingHom.comp (algebraMap (FractionRing A) (FractionRing B))
      ↑(AlgEquiv.toRingEquiv (AlgEquiv.symm (FractionRing.algEquiv A K))) =
    RingHom.comp (↑(AlgEquiv.toRingEquiv (AlgEquiv.symm (FractionRing.algEquiv B L)))) (algebraMap K L)
this✝ : IsSeparable (FractionRing A) (FractionRing B)
this : FiniteDimensional (FractionRing A) (FractionRing B)
⊢ (Submodule.map (FractionRing.algEquiv B L) 1)ᵛ = 1ᵛ

Next tactic:
congr 1
lemma coeSubmodule_differentIdeal [NoZeroSMulDivisors A B] :
    coeSubmodule L (differentIdeal A B) = 1 / Submodule.traceDual A K 1 := by
  have : (FractionRing.algEquiv B L).toLinearEquiv.comp (Algebra.linearMap B (FractionRing B)) =
    Algebra.linearMap B L := by ext; simp
  rw [coeSubmodule, ← this]
  have H : RingHom.comp (algebraMap (FractionRing A) (FractionRing B))
    ↑(FractionRing.algEquiv A K).symm.toRingEquiv =
      RingHom.comp ↑(FractionRing.algEquiv B L).symm.toRingEquiv (algebraMap K L)
  · apply IsLocalization.ringHom_ext A⁰
    ext
    simp only [AlgEquiv.toRingEquiv_eq_coe, RingHom.coe_comp, RingHom.coe_coe,
      AlgEquiv.coe_ringEquiv, Function.comp_apply, AlgEquiv.commutes,
      ← IsScalarTower.algebraMap_apply]
    rw [IsScalarTower.algebraMap_apply A B L, AlgEquiv.commutes, ← IsScalarTower.algebraMap_apply]
  have : IsSeparable (FractionRing A) (FractionRing B) := IsSeparable.of_equiv_equiv _ _ H
  have : FiniteDimensional (FractionRing A) (FractionRing B) := Module.Finite.of_equiv_equiv _ _ H
  simp only [AlgEquiv.toLinearEquiv_toLinearMap, Submodule.map_comp]
  rw [← coeSubmodule, coeSubmodule_differentIdeal_fractionRing _ _
      (IsIntegralClosure.isIntegral_algebra _ L),
    Submodule.map_div, ← AlgEquiv.toAlgHom_toLinearMap, Submodule.map_one]
  congr 1
  refine (map_equiv_traceDual A K _).trans ?_
  congr 1
  

Proof state:
case e_a.e_I
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²⁰ : CommRing A
inst✝¹⁹ : Field K
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Field L
inst✝¹⁶ : Algebra A K
inst✝¹⁵ : Algebra B L
inst✝¹⁴ : Algebra A B
inst✝¹³ : Algebra K L
inst✝¹² : Algebra A L
inst✝¹¹ : IsScalarTower A K L
inst✝¹⁰ : IsScalarTower A B L
inst✝⁹ : IsDomain A
inst✝⁸ : IsDomain B
inst✝⁷ : IsFractionRing A K
inst✝⁶ : IsIntegralClosure B A L
inst✝⁵ : IsFractionRing B L
inst✝⁴ : FiniteDimensional K L
inst✝³ : IsSeparable K L
inst✝² : IsIntegrallyClosed A
inst✝¹ : IsDedekindDomain B
inst✝ : NoZeroSMulDivisors A B
this✝¹ :
  ↑(AlgEquiv.toLinearEquiv (FractionRing.algEquiv B L)) ∘ₗ Algebra.linearMap B (FractionRing B) = Algebra.linearMap B L
H :
  RingHom.comp (algebraMap (FractionRing A) (FractionRing B))
      ↑(AlgEquiv.toRingEquiv (AlgEquiv.symm (FractionRing.algEquiv A K))) =
    RingHom.comp (↑(AlgEquiv.toRingEquiv (AlgEquiv.symm (FractionRing.algEquiv B L)))) (algebraMap K L)
this✝ : IsSeparable (FractionRing A) (FractionRing B)
this : FiniteDimensional (FractionRing A) (FractionRing B)
⊢ Submodule.map (FractionRing.algEquiv B L) 1 = 1

Next tactic:
ext
lemma coeSubmodule_differentIdeal [NoZeroSMulDivisors A B] :
    coeSubmodule L (differentIdeal A B) = 1 / Submodule.traceDual A K 1 := by
  have : (FractionRing.algEquiv B L).toLinearEquiv.comp (Algebra.linearMap B (FractionRing B)) =
    Algebra.linearMap B L := by ext; simp
  rw [coeSubmodule, ← this]
  have H : RingHom.comp (algebraMap (FractionRing A) (FractionRing B))
    ↑(FractionRing.algEquiv A K).symm.toRingEquiv =
      RingHom.comp ↑(FractionRing.algEquiv B L).symm.toRingEquiv (algebraMap K L)
  · apply IsLocalization.ringHom_ext A⁰
    ext
    simp only [AlgEquiv.toRingEquiv_eq_coe, RingHom.coe_comp, RingHom.coe_coe,
      AlgEquiv.coe_ringEquiv, Function.comp_apply, AlgEquiv.commutes,
      ← IsScalarTower.algebraMap_apply]
    rw [IsScalarTower.algebraMap_apply A B L, AlgEquiv.commutes, ← IsScalarTower.algebraMap_apply]
  have : IsSeparable (FractionRing A) (FractionRing B) := IsSeparable.of_equiv_equiv _ _ H
  have : FiniteDimensional (FractionRing A) (FractionRing B) := Module.Finite.of_equiv_equiv _ _ H
  simp only [AlgEquiv.toLinearEquiv_toLinearMap, Submodule.map_comp]
  rw [← coeSubmodule, coeSubmodule_differentIdeal_fractionRing _ _
      (IsIntegralClosure.isIntegral_algebra _ L),
    Submodule.map_div, ← AlgEquiv.toAlgHom_toLinearMap, Submodule.map_one]
  congr 1
  refine (map_equiv_traceDual A K _).trans ?_
  congr 1
  ext
  

Proof state:
case e_a.e_I.h
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²⁰ : CommRing A
inst✝¹⁹ : Field K
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Field L
inst✝¹⁶ : Algebra A K
inst✝¹⁵ : Algebra B L
inst✝¹⁴ : Algebra A B
inst✝¹³ : Algebra K L
inst✝¹² : Algebra A L
inst✝¹¹ : IsScalarTower A K L
inst✝¹⁰ : IsScalarTower A B L
inst✝⁹ : IsDomain A
inst✝⁸ : IsDomain B
inst✝⁷ : IsFractionRing A K
inst✝⁶ : IsIntegralClosure B A L
inst✝⁵ : IsFractionRing B L
inst✝⁴ : FiniteDimensional K L
inst✝³ : IsSeparable K L
inst✝² : IsIntegrallyClosed A
inst✝¹ : IsDedekindDomain B
inst✝ : NoZeroSMulDivisors A B
this✝¹ :
  ↑(AlgEquiv.toLinearEquiv (FractionRing.algEquiv B L)) ∘ₗ Algebra.linearMap B (FractionRing B) = Algebra.linearMap B L
H :
  RingHom.comp (algebraMap (FractionRing A) (FractionRing B))
      ↑(AlgEquiv.toRingEquiv (AlgEquiv.symm (FractionRing.algEquiv A K))) =
    RingHom.comp (↑(AlgEquiv.toRingEquiv (AlgEquiv.symm (FractionRing.algEquiv B L)))) (algebraMap K L)
this✝ : IsSeparable (FractionRing A) (FractionRing B)
this : FiniteDimensional (FractionRing A) (FractionRing B)
x✝ : L
⊢ x✝ ∈ Submodule.map (FractionRing.algEquiv B L) 1 ↔ x✝ ∈ 1

Next tactic:
simp
lemma coeIdeal_differentIdeal [NoZeroSMulDivisors A B] :
    ↑(differentIdeal A B) = (FractionalIdeal.dual A K (1 : FractionalIdeal B⁰ L))⁻¹ := by
  

Proof state:
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²⁰ : CommRing A
inst✝¹⁹ : Field K
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Field L
inst✝¹⁶ : Algebra A K
inst✝¹⁵ : Algebra B L
inst✝¹⁴ : Algebra A B
inst✝¹³ : Algebra K L
inst✝¹² : Algebra A L
inst✝¹¹ : IsScalarTower A K L
inst✝¹⁰ : IsScalarTower A B L
inst✝⁹ : IsDomain A
inst✝⁸ : IsDomain B
inst✝⁷ : IsFractionRing A K
inst✝⁶ : IsIntegralClosure B A L
inst✝⁵ : IsFractionRing B L
inst✝⁴ : FiniteDimensional K L
inst✝³ : IsSeparable K L
inst✝² : IsIntegrallyClosed A
inst✝¹ : IsDedekindDomain B
inst✝ : NoZeroSMulDivisors A B
⊢ ↑(differentIdeal A B) = (FractionalIdeal.dual A K 1)⁻¹

Next tactic:
apply FractionalIdeal.coeToSubmodule_injective
lemma coeIdeal_differentIdeal [NoZeroSMulDivisors A B] :
    ↑(differentIdeal A B) = (FractionalIdeal.dual A K (1 : FractionalIdeal B⁰ L))⁻¹ := by
  apply FractionalIdeal.coeToSubmodule_injective
  

Proof state:
case a
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²⁰ : CommRing A
inst✝¹⁹ : Field K
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Field L
inst✝¹⁶ : Algebra A K
inst✝¹⁵ : Algebra B L
inst✝¹⁴ : Algebra A B
inst✝¹³ : Algebra K L
inst✝¹² : Algebra A L
inst✝¹¹ : IsScalarTower A K L
inst✝¹⁰ : IsScalarTower A B L
inst✝⁹ : IsDomain A
inst✝⁸ : IsDomain B
inst✝⁷ : IsFractionRing A K
inst✝⁶ : IsIntegralClosure B A L
inst✝⁵ : IsFractionRing B L
inst✝⁴ : FiniteDimensional K L
inst✝³ : IsSeparable K L
inst✝² : IsIntegrallyClosed A
inst✝¹ : IsDedekindDomain B
inst✝ : NoZeroSMulDivisors A B
⊢ (fun I => ↑I) ↑(differentIdeal A B) = (fun I => ↑I) (FractionalIdeal.dual A K 1)⁻¹

Next tactic:
simp only [FractionalIdeal.coe_div
    (FractionalIdeal.dual_ne_zero _ _ (@one_ne_zero (FractionalIdeal B⁰ L) _ _ _)),
    FractionalIdeal.coe_coeIdeal, coeSubmodule_differentIdeal A K, inv_eq_one_div,
    FractionalIdeal.coe_dual_one, FractionalIdeal.coe_one]
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 := by
  

Proof state:
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²⁰ : CommRing A
inst✝¹⁹ : Field K
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Field L
inst✝¹⁶ : Algebra A K
inst✝¹⁵ : Algebra B L
inst✝¹⁴ : Algebra A B
inst✝¹³ : Algebra K L
inst✝¹² : Algebra A L
inst✝¹¹ : IsScalarTower A K L
inst✝¹⁰ : IsScalarTower A B L
inst✝⁹ : IsDomain A
inst✝⁸ : IsDomain B
inst✝⁷ : IsFractionRing A K
inst✝⁶ : IsIntegralClosure B A L
inst✝⁵ : IsFractionRing B L
inst✝⁴ : FiniteDimensional K L
inst✝³ : IsSeparable K L
inst✝² : IsIntegrallyClosed A
inst✝¹ : IsDedekindDomain B
I : FractionalIdeal B⁰ L
hI : I ≠ 0
inst✝ : NoZeroSMulDivisors A B
⊢ ↑(differentIdeal A B) ≤ I ↔ Submodule.map (↑A (Algebra.trace K L)) (restrictScalars A ↑I⁻¹) ≤ 1

Next tactic:
rw [coeIdeal_differentIdeal A K L B, FractionalIdeal.inv_le_comm (by simp) hI,
    ← FractionalIdeal.coe_le_coe, FractionalIdeal.coe_dual_one]
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 := by
  rw [coeIdeal_differentIdeal A K L B, FractionalIdeal.inv_le_comm (by 

Proof state:
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²⁰ : CommRing A
inst✝¹⁹ : Field K
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Field L
inst✝¹⁶ : Algebra A K
inst✝¹⁵ : Algebra B L
inst✝¹⁴ : Algebra A B
inst✝¹³ : Algebra K L
inst✝¹² : Algebra A L
inst✝¹¹ : IsScalarTower A K L
inst✝¹⁰ : IsScalarTower A B L
inst✝⁹ : IsDomain A
inst✝⁸ : IsDomain B
inst✝⁷ : IsFractionRing A K
inst✝⁶ : IsIntegralClosure B A L
inst✝⁵ : IsFractionRing B L
inst✝⁴ : FiniteDimensional K L
inst✝³ : IsSeparable K L
inst✝² : IsIntegrallyClosed A
inst✝¹ : IsDedekindDomain B
I : FractionalIdeal B⁰ L
hI : I ≠ 0
inst✝ : NoZeroSMulDivisors A B
⊢ FractionalIdeal.dual A K 1 ≠ 0

Next tactic:
simp
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 := by
  rw [coeIdeal_differentIdeal A K L B, FractionalIdeal.inv_le_comm (by simp) hI,
    ← FractionalIdeal.coe_le_coe, FractionalIdeal.coe_dual_one]
  

Proof state:
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²⁰ : CommRing A
inst✝¹⁹ : Field K
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Field L
inst✝¹⁶ : Algebra A K
inst✝¹⁵ : Algebra B L
inst✝¹⁴ : Algebra A B
inst✝¹³ : Algebra K L
inst✝¹² : Algebra A L
inst✝¹¹ : IsScalarTower A K L
inst✝¹⁰ : IsScalarTower A B L
inst✝⁹ : IsDomain A
inst✝⁸ : IsDomain B
inst✝⁷ : IsFractionRing A K
inst✝⁶ : IsIntegralClosure B A L
inst✝⁵ : IsFractionRing B L
inst✝⁴ : FiniteDimensional K L
inst✝³ : IsSeparable K L
inst✝² : IsIntegrallyClosed A
inst✝¹ : IsDedekindDomain B
I : FractionalIdeal B⁰ L
hI : I ≠ 0
inst✝ : NoZeroSMulDivisors A B
⊢ ↑I⁻¹ ≤ 1ᵛ ↔ Submodule.map (↑A (Algebra.trace K L)) (restrictScalars A ↑I⁻¹) ≤ 1

Next tactic:
refine le_traceDual_iff_map_le_one.trans ?_
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 := by
  rw [coeIdeal_differentIdeal A K L B, FractionalIdeal.inv_le_comm (by simp) hI,
    ← FractionalIdeal.coe_le_coe, FractionalIdeal.coe_dual_one]
  refine le_traceDual_iff_map_le_one.trans ?_
  

Proof state:
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²⁰ : CommRing A
inst✝¹⁹ : Field K
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Field L
inst✝¹⁶ : Algebra A K
inst✝¹⁵ : Algebra B L
inst✝¹⁴ : Algebra A B
inst✝¹³ : Algebra K L
inst✝¹² : Algebra A L
inst✝¹¹ : IsScalarTower A K L
inst✝¹⁰ : IsScalarTower A B L
inst✝⁹ : IsDomain A
inst✝⁸ : IsDomain B
inst✝⁷ : IsFractionRing A K
inst✝⁶ : IsIntegralClosure B A L
inst✝⁵ : IsFractionRing B L
inst✝⁴ : FiniteDimensional K L
inst✝³ : IsSeparable K L
inst✝² : IsIntegrallyClosed A
inst✝¹ : IsDedekindDomain B
I : FractionalIdeal B⁰ L
hI : I ≠ 0
inst✝ : NoZeroSMulDivisors A B
⊢ Submodule.map (↑A (Algebra.trace K L)) (restrictScalars A (↑I⁻¹ * 1)) ≤ 1 ↔
    Submodule.map (↑A (Algebra.trace K L)) (restrictScalars A ↑I⁻¹) ≤ 1

Next tactic:
simp
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 :=
  (FractionalIdeal.coeIdeal_le_coeIdeal _).symm.trans
    (differentialIdeal_le_fractionalIdeal_iff (I := (I : FractionalIdeal B⁰ L)) (by 

Proof state:
A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝²⁰ : CommRing A
inst✝¹⁹ : Field K
inst✝¹⁸ : CommRing B
inst✝¹⁷ : Field L
inst✝¹⁶ : Algebra A K
inst✝¹⁵ : Algebra B L
inst✝¹⁴ : Algebra A B
inst✝¹³ : Algebra K L
inst✝¹² : Algebra A L
inst✝¹¹ : IsScalarTower A K L
inst✝¹⁰ : IsScalarTower A B L
inst✝⁹ : IsDomain A
inst✝⁸ : IsDomain B
inst✝⁷ : IsFractionRing A K
inst✝⁶ : IsIntegralClosure B A L
inst✝⁵ : IsFractionRing B L
inst✝⁴ : FiniteDimensional K L
inst✝³ : IsSeparable K L
inst✝² : IsIntegrallyClosed A
inst✝¹ : IsDedekindDomain B
I : Ideal B
hI : I ≠ ⊥
inst✝ : NoZeroSMulDivisors A B
⊢ ↑I ≠ 0

Next tactic:
simpa
@[inherit_doc IsLocalization.exists_of_eq]
theorem eq_iff_exists {x y} : algebraMap R S x = algebraMap R S y ↔ ∃ c : M, ↑c * x = ↑c * y :=
  Iff.intro IsLocalization.exists_of_eq fun ⟨c, h⟩ ↦ by
    

Proof state:
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x y : R
x✝ : ∃ c, ↑c * x = ↑c * y
c : ↥M
h : ↑c * x = ↑c * y
⊢ (algebraMap R S) x = (algebraMap R S) y

Next tactic:
apply_fun algebraMap R S at h
@[inherit_doc IsLocalization.exists_of_eq]
theorem eq_iff_exists {x y} : algebraMap R S x = algebraMap R S y ↔ ∃ c : M, ↑c * x = ↑c * y :=
  Iff.intro IsLocalization.exists_of_eq fun ⟨c, h⟩ ↦ by
    apply_fun algebraMap R S at h
    

Proof state:
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x y : R
x✝ : ∃ c, ↑c * x = ↑c * y
c : ↥M
h : (algebraMap R S) (↑c * x) = (algebraMap R S) (↑c * y)
⊢ (algebraMap R S) x = (algebraMap R S) y

Next tactic:
rw [map_mul, map_mul] at h