File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

full_name: FractionalIdeal.instInvNonZeroDivisors
code: noncomputable instance : Inv (FractionalIdeal R₁⁰ K) 
goal: Inv (FractionalIdeal R₁⁰ K)

full_name: FractionalIdeal.inv_eq
code: theorem inv_eq : I⁻¹ = 1 / I 
goal: I⁻¹ = 1 / I

full_name: FractionalIdeal.inv_zero'
code: theorem inv_zero' : (0 : FractionalIdeal R₁⁰ K)⁻¹ = 0 
goal: 0⁻¹ = 0

full_name: FractionalIdeal.inv_nonzero
code: theorem inv_nonzero {J : FractionalIdeal R₁⁰ K} (h : J ≠ 0) :
    J⁻¹ = ⟨(1 : FractionalIdeal R₁⁰ K) / J, fractional_div_of_nonzero h⟩ 
goal: J⁻¹ = ⟨↑1 / ↑J, ⋯⟩

full_name: FractionalIdeal.coe_inv_of_nonzero
code: theorem coe_inv_of_nonzero {J : FractionalIdeal R₁⁰ K} (h : J ≠ 0) :
    (↑J⁻¹ : Submodule R₁ K) = IsLocalization.coeSubmodule K ⊤ / (J : Submodule R₁ K) 
goal: ↑J⁻¹ = IsLocalization.coeSubmodule K ⊤ / ↑J

full_name: FractionalIdeal.mem_inv_iff
code: theorem mem_inv_iff (hI : I ≠ 0) {x : K} : x ∈ I⁻¹ ↔ ∀ y ∈ I, x * y ∈ (1 : FractionalIdeal R₁⁰ K) 
goal: x ∈ I⁻¹ ↔ ∀ y ∈ I, x * y ∈ 1

full_name: FractionalIdeal.inv_anti_mono
code: theorem inv_anti_mono (hI : I ≠ 0) (hJ : J ≠ 0) (hIJ : I ≤ J) : J⁻¹ ≤ I⁻¹ 
goal: J⁻¹ ≤ I⁻¹

full_name: FractionalIdeal.le_self_mul_inv
code: theorem le_self_mul_inv {I : FractionalIdeal R₁⁰ K} (hI : I ≤ (1 : FractionalIdeal R₁⁰ K)) :
    I ≤ I * I⁻¹ 
goal: I ≤ I * I⁻¹

full_name: FractionalIdeal.coe_ideal_le_self_mul_inv
code: theorem coe_ideal_le_self_mul_inv (I : Ideal R₁) :
    (I : FractionalIdeal R₁⁰ K) ≤ I * (I : FractionalIdeal R₁⁰ K)⁻¹ 
goal: ↑I ≤ ↑I * (↑I)⁻¹

full_name: FractionalIdeal.right_inverse_eq
code: /-- `I⁻¹` is the inverse of `I` if `I` has an inverse. -/
theorem right_inverse_eq (I J : FractionalIdeal R₁⁰ K) (h : I * J = 1) : J = I⁻¹ 
goal: J = I⁻¹

full_name: FractionalIdeal.mul_inv_cancel_iff
code: theorem mul_inv_cancel_iff {I : FractionalIdeal R₁⁰ K} : I * I⁻¹ = 1 ↔ ∃ J, I * J = 1 
goal: I * I⁻¹ = 1 ↔ ∃ J, I * J = 1

full_name: FractionalIdeal.mul_inv_cancel_iff_isUnit
code: theorem mul_inv_cancel_iff_isUnit {I : FractionalIdeal R₁⁰ K} : I * I⁻¹ = 1 ↔ IsUnit I 
goal: I * I⁻¹ = 1 ↔ IsUnit I

full_name: FractionalIdeal.map_inv
code: @[simp]
theorem map_inv (I : FractionalIdeal R₁⁰ K) (h : K ≃ₐ[R₁] K') :
    I⁻¹.map (h : K →ₐ[R₁] K') = (I.map h)⁻¹ 
goal: FractionalIdeal.map (↑h) I⁻¹ = (FractionalIdeal.map (↑h) I)⁻¹

full_name: FractionalIdeal.spanSingleton_inv
code: @[simp]
theorem spanSingleton_inv (x : K) : (spanSingleton R₁⁰ x)⁻¹ = spanSingleton _ x⁻¹ 
goal: (FractionalIdeal.spanSingleton R₁⁰ x)⁻¹ = FractionalIdeal.spanSingleton R₁⁰ x⁻¹

full_name: FractionalIdeal.spanSingleton_div_spanSingleton
code: theorem spanSingleton_div_spanSingleton (x y : K) :
    spanSingleton R₁⁰ x / spanSingleton R₁⁰ y = spanSingleton R₁⁰ (x / y) 
goal: FractionalIdeal.spanSingleton R₁⁰ x / FractionalIdeal.spanSingleton R₁⁰ y = FractionalIdeal.spanSingleton R₁⁰ (x / y)

full_name: FractionalIdeal.spanSingleton_div_self
code: theorem spanSingleton_div_self {x : K} (hx : x ≠ 0) :
    spanSingleton R₁⁰ x / spanSingleton R₁⁰ x = 1 
goal: FractionalIdeal.spanSingleton R₁⁰ x / FractionalIdeal.spanSingleton R₁⁰ x = 1

full_name: FractionalIdeal.coe_ideal_span_singleton_div_self
code: theorem coe_ideal_span_singleton_div_self {x : R₁} (hx : x ≠ 0) :
    (Ideal.span ({x} : Set R₁) : FractionalIdeal R₁⁰ K) / Ideal.span ({x} : Set R₁) = 1 
goal: ↑(Ideal.span {x}) / ↑(Ideal.span {x}) = 1

full_name: FractionalIdeal.spanSingleton_mul_inv
code: theorem spanSingleton_mul_inv {x : K} (hx : x ≠ 0) :
    spanSingleton R₁⁰ x * (spanSingleton R₁⁰ x)⁻¹ = 1 
goal: FractionalIdeal.spanSingleton R₁⁰ x * (FractionalIdeal.spanSingleton R₁⁰ x)⁻¹ = 1

full_name: FractionalIdeal.coe_ideal_span_singleton_mul_inv
code: theorem coe_ideal_span_singleton_mul_inv {x : R₁} (hx : x ≠ 0) :
    (Ideal.span ({x} : Set R₁) : FractionalIdeal R₁⁰ K) *
    (Ideal.span ({x} : Set R₁) : FractionalIdeal R₁⁰ K)⁻¹ = 1 
goal: ↑(Ideal.span {x}) * (↑(Ideal.span {x}))⁻¹ = 1

full_name: FractionalIdeal.spanSingleton_inv_mul
code: theorem spanSingleton_inv_mul {x : K} (hx : x ≠ 0) :
    (spanSingleton R₁⁰ x)⁻¹ * spanSingleton R₁⁰ x = 1 
goal: (FractionalIdeal.spanSingleton R₁⁰ x)⁻¹ * FractionalIdeal.spanSingleton R₁⁰ x = 1

full_name: FractionalIdeal.coe_ideal_span_singleton_inv_mul
code: theorem coe_ideal_span_singleton_inv_mul {x : R₁} (hx : x ≠ 0) :
    (Ideal.span ({x} : Set R₁) : FractionalIdeal R₁⁰ K)⁻¹ * Ideal.span ({x} : Set R₁) = 1 
goal: (↑(Ideal.span {x}))⁻¹ * ↑(Ideal.span {x}) = 1

full_name: FractionalIdeal.mul_generator_self_inv
code: theorem mul_generator_self_inv {R₁ : Type*} [CommRing R₁] [Algebra R₁ K] [IsLocalization R₁⁰ K]
    (I : FractionalIdeal R₁⁰ K) [Submodule.IsPrincipal (I : Submodule R₁ K)] (h : I ≠ 0) :
    I * spanSingleton _ (generator (I : Submodule R₁ K))⁻¹ = 1 
goal: I * FractionalIdeal.spanSingleton R₁⁰ (Submodule.IsPrincipal.generator ↑I)⁻¹ = 1

full_name: FractionalIdeal.invertible_of_principal
code: theorem invertible_of_principal (I : FractionalIdeal R₁⁰ K)
    [Submodule.IsPrincipal (I : Submodule R₁ K)] (h : I ≠ 0) : I * I⁻¹ = 1 
goal: I * I⁻¹ = 1

full_name: FractionalIdeal.invertible_iff_generator_nonzero
code: theorem invertible_iff_generator_nonzero (I : FractionalIdeal R₁⁰ K)
    [Submodule.IsPrincipal (I : Submodule R₁ K)] :
    I * I⁻¹ = 1 ↔ generator (I : Submodule R₁ K) ≠ 0 
goal: I * I⁻¹ = 1 ↔ Submodule.IsPrincipal.generator ↑I ≠ 0

full_name: FractionalIdeal.isPrincipal_inv
code: theorem isPrincipal_inv (I : FractionalIdeal R₁⁰ K) [Submodule.IsPrincipal (I : Submodule R₁ K)]
    (h : I ≠ 0) : Submodule.IsPrincipal I⁻¹.1 
goal: (↑I⁻¹).IsPrincipal

full_name: FractionalIdeal.den_mem_inv
code: lemma den_mem_inv {I : FractionalIdeal R₁⁰ K} (hI : I ≠ ⊥) :
    (algebraMap R₁ K) (I.den : R₁) ∈ I⁻¹ 
goal: (algebraMap R₁ K) ↑I.den ∈ I⁻¹

full_name: FractionalIdeal.num_le_mul_inv
code: lemma num_le_mul_inv (I : FractionalIdeal R₁⁰ K) : I.num ≤ I * I⁻¹ 
goal: ↑I.num ≤ I * I⁻¹

full_name: FractionalIdeal.bot_lt_mul_inv
code: lemma bot_lt_mul_inv {I : FractionalIdeal R₁⁰ K} (hI : I ≠ ⊥) : ⊥ < I * I⁻¹ 
goal: ⊥ < I * I⁻¹

full_name: FractionalIdeal.instInvOneClassNonZeroDivisors
code: noncomputable instance : InvOneClass (FractionalIdeal R₁⁰ K) 
goal: InvOneClass (FractionalIdeal R₁⁰ K)

full_name: IsDedekindDomainInv
code: /-- A Dedekind domain is an integral domain such that every fractional ideal has an inverse.

This is equivalent to `IsDedekindDomain`.
In particular we provide a `fractional_ideal.comm_group_with_zero` instance,
assuming `IsDedekindDomain A`, which implies `IsDedekindDomainInv`. For **integral** ideals,
`IsDedekindDomain`(`_inv`) implies only `Ideal.cancelCommMonoidWithZero`.
-/
def IsDedekindDomainInv : Prop 
goal: Prop

full_name: isDedekindDomainInv_iff
code: theorem isDedekindDomainInv_iff [Algebra A K] [IsFractionRing A K] :
    IsDedekindDomainInv A ↔ ∀ I ≠ (⊥ : FractionalIdeal A⁰ K), I * I⁻¹ = 1 
goal: IsDedekindDomainInv A ↔ ∀ (I : FractionalIdeal A⁰ K), I ≠ ⊥ → I * I⁻¹ = 1

full_name: FractionalIdeal.adjoinIntegral_eq_one_of_isUnit
code: theorem FractionalIdeal.adjoinIntegral_eq_one_of_isUnit [Algebra A K] [IsFractionRing A K] (x : K)
    (hx : IsIntegral A x) (hI : IsUnit (adjoinIntegral A⁰ x hx)) : adjoinIntegral A⁰ x hx = 1 
goal: FractionalIdeal.adjoinIntegral A⁰ x hx = 1

full_name: IsDedekindDomainInv.mul_inv_eq_one
code: theorem mul_inv_eq_one {I : FractionalIdeal A⁰ K} (hI : I ≠ 0) : I * I⁻¹ = 1 
goal: I * I⁻¹ = 1

full_name: IsDedekindDomainInv.inv_mul_eq_one
code: theorem inv_mul_eq_one {I : FractionalIdeal A⁰ K} (hI : I ≠ 0) : I⁻¹ * I = 1 
goal: I⁻¹ * I = 1

full_name: IsDedekindDomainInv.isUnit
code: protected theorem isUnit {I : FractionalIdeal A⁰ K} (hI : I ≠ 0) : IsUnit I 
goal: IsUnit I

full_name: IsDedekindDomainInv.isNoetherianRing
code: theorem isNoetherianRing : IsNoetherianRing A 
goal: IsNoetherianRing A

full_name: IsDedekindDomainInv.integrallyClosed
code: theorem integrallyClosed : IsIntegrallyClosed A 
goal: IsIntegrallyClosed A

full_name: IsDedekindDomainInv.dimensionLEOne
code: theorem dimensionLEOne : DimensionLEOne A 
goal: Ring.DimensionLEOne A

full_name: IsDedekindDomainInv.isDedekindDomain
code: /-- Showing one side of the equivalence between the definitions
`IsDedekindDomainInv` and `IsDedekindDomain` of Dedekind domains. -/
theorem isDedekindDomain : IsDedekindDomain A 
goal: IsDedekindDomain A

full_name: one_mem_inv_coe_ideal
code: theorem one_mem_inv_coe_ideal [IsDomain A] {I : Ideal A} (hI : I ≠ ⊥) :
    (1 : K) ∈ (I : FractionalIdeal A⁰ K)⁻¹ 
goal: 1 ∈ (↑I)⁻¹

full_name: exists_multiset_prod_cons_le_and_prod_not_le
code: /-- Specialization of `exists_primeSpectrum_prod_le_and_ne_bot_of_domain` to Dedekind domains:
Let `I : Ideal A` be a nonzero ideal, where `A` is a Dedekind domain that is not a field.
Then `exists_primeSpectrum_prod_le_and_ne_bot_of_domain` states we can find a product of prime
ideals that is contained within `I`. This lemma extends that result by making the product minimal:
let `M` be a maximal ideal that contains `I`, then the product including `M` is contained within `I`
and the product excluding `M` is not contained within `I`. -/
theorem exists_multiset_prod_cons_le_and_prod_not_le [IsDedekindDomain A] (hNF : ¬IsField A)
    {I M : Ideal A} (hI0 : I ≠ ⊥) (hIM : I ≤ M) [hM : M.IsMaximal] :
    ∃ Z : Multiset (PrimeSpectrum A),
      (M ::ₘ Z.map PrimeSpectrum.asIdeal).prod ≤ I ∧
        ¬Multiset.prod (Z.map PrimeSpectrum.asIdeal) ≤ I 
goal: ∃ Z, (M ::ₘ Multiset.map PrimeSpectrum.asIdeal Z).prod ≤ I ∧ ¬(Multiset.map PrimeSpectrum.asIdeal Z).prod ≤ I

full_name: FractionalIdeal.not_inv_le_one_of_ne_bot
code: lemma not_inv_le_one_of_ne_bot [IsDedekindDomain A] {I : Ideal A}
    (hI0 : I ≠ ⊥) (hI1 : I ≠ ⊤) : ¬(I⁻¹ : FractionalIdeal A⁰ K) ≤ 1 
goal: ¬(↑I)⁻¹ ≤ 1

full_name: FractionalIdeal.exists_not_mem_one_of_ne_bot
code: theorem exists_not_mem_one_of_ne_bot [IsDedekindDomain A] {I : Ideal A} (hI0 : I ≠ ⊥)
    (hI1 : I ≠ ⊤) : ∃ x ∈ (I⁻¹ : FractionalIdeal A⁰ K), x ∉ (1 : FractionalIdeal A⁰ K) 
goal: ∃ x ∈ (↑I)⁻¹, x ∉ 1

full_name: FractionalIdeal.mul_inv_cancel_of_le_one
code: theorem mul_inv_cancel_of_le_one [h : IsDedekindDomain A] {I : Ideal A} (hI0 : I ≠ ⊥)
    (hI : (I * (I : FractionalIdeal A⁰ K)⁻¹)⁻¹ ≤ 1) : I * (I : FractionalIdeal A⁰ K)⁻¹ = 1 
goal: ↑I * (↑I)⁻¹ = 1

full_name: FractionalIdeal.coe_ideal_mul_inv
code: /-- Nonzero integral ideals in a Dedekind domain are invertible.

We will use this to show that nonzero fractional ideals are invertible,
and finally conclude that fractional ideals in a Dedekind domain form a group with zero.
-/
theorem coe_ideal_mul_inv [h : IsDedekindDomain A] (I : Ideal A) (hI0 : I ≠ ⊥) :
    I * (I : FractionalIdeal A⁰ K)⁻¹ = 1 
goal: ↑I * (↑I)⁻¹ = 1

full_name: FractionalIdeal.mul_inv_cancel
code: /-- Nonzero fractional ideals in a Dedekind domain are units.

This is also available as `_root_.mul_inv_cancel`, using the
`Semifield` instance defined below.
-/
protected theorem mul_inv_cancel [IsDedekindDomain A] {I : FractionalIdeal A⁰ K} (hne : I ≠ 0) :
    I * I⁻¹ = 1 
goal: I * I⁻¹ = 1

full_name: FractionalIdeal.mul_right_le_iff
code: theorem mul_right_le_iff [IsDedekindDomain A] {J : FractionalIdeal A⁰ K} (hJ : J ≠ 0) :
    ∀ {I I'}, I * J ≤ I' * J ↔ I ≤ I' 
goal: I * J ≤ I' * J ↔ I ≤ I'

full_name: FractionalIdeal.mul_left_le_iff
code: theorem mul_left_le_iff [IsDedekindDomain A] {J : FractionalIdeal A⁰ K} (hJ : J ≠ 0) {I I'} :
    J * I ≤ J * I' ↔ I ≤ I' 
goal: J * I ≤ J * I' ↔ I ≤ I'

full_name: FractionalIdeal.mul_right_strictMono
code: theorem mul_right_strictMono [IsDedekindDomain A] {I : FractionalIdeal A⁰ K} (hI : I ≠ 0) :
    StrictMono (· * I) 
goal: StrictMono fun x => x * I

full_name: FractionalIdeal.mul_left_strictMono
code: theorem mul_left_strictMono [IsDedekindDomain A] {I : FractionalIdeal A⁰ K} (hI : I ≠ 0) :
    StrictMono (I * ·) 
goal: StrictMono fun x => I * x

full_name: FractionalIdeal.div_eq_mul_inv
code: /-- This is also available as `_root_.div_eq_mul_inv`, using the
`Semifield` instance defined below.
-/
protected theorem div_eq_mul_inv [IsDedekindDomain A] (I J : FractionalIdeal A⁰ K) :
    I / J = I * J⁻¹ 
goal: I / J = I * J⁻¹

full_name: isDedekindDomain_iff_isDedekindDomainInv
code: /-- `IsDedekindDomain` and `IsDedekindDomainInv` are equivalent ways
to express that an integral domain is a Dedekind domain. -/
theorem isDedekindDomain_iff_isDedekindDomainInv [IsDomain A] :
    IsDedekindDomain A ↔ IsDedekindDomainInv A 
goal: IsDedekindDomain A ↔ IsDedekindDomainInv A

full_name: FractionalIdeal.semifield
code: noncomputable instance FractionalIdeal.semifield : Semifield (FractionalIdeal A⁰ K) 
goal: Semifield (FractionalIdeal A⁰ K)

full_name: FractionalIdeal.cancelCommMonoidWithZero
code: /-- Fractional ideals have cancellative multiplication in a Dedekind domain.

Although this instance is a direct consequence of the instance
`FractionalIdeal.semifield`, we define this instance to provide
a computable alternative.
-/
instance FractionalIdeal.cancelCommMonoidWithZero :
    CancelCommMonoidWithZero (FractionalIdeal A⁰ K) 
goal: CancelCommMonoidWithZero (FractionalIdeal A⁰ K)

full_name: Ideal.cancelCommMonoidWithZero
code: instance Ideal.cancelCommMonoidWithZero : CancelCommMonoidWithZero (Ideal A) 
goal: CancelCommMonoidWithZero (Ideal A)

full_name: Ideal.isDomain
code: instance Ideal.isDomain : IsDomain (Ideal A) 
goal: IsDomain (Ideal A)

full_name: Ideal.dvd_iff_le
code: /-- For ideals in a Dedekind domain, to divide is to contain. -/
theorem Ideal.dvd_iff_le {I J : Ideal A} : I ∣ J ↔ J ≤ I 
goal: I ∣ J ↔ J ≤ I

full_name: Ideal.dvdNotUnit_iff_lt
code: theorem Ideal.dvdNotUnit_iff_lt {I J : Ideal A} : DvdNotUnit I J ↔ J < I 
goal: DvdNotUnit I J ↔ J < I

full_name: instWfDvdMonoidIdeal
code: instance : WfDvdMonoid (Ideal A) 
goal: WfDvdMonoid (Ideal A)

full_name: Ideal.uniqueFactorizationMonoid
code: instance Ideal.uniqueFactorizationMonoid : UniqueFactorizationMonoid (Ideal A) 
goal: UniqueFactorizationMonoid (Ideal A)

full_name: Ideal.normalizationMonoid
code: instance Ideal.normalizationMonoid : NormalizationMonoid (Ideal A) 
goal: NormalizationMonoid (Ideal A)

full_name: Ideal.dvd_span_singleton
code: @[simp]
theorem Ideal.dvd_span_singleton {I : Ideal A} {x : A} : I ∣ Ideal.span {x} ↔ x ∈ I 
goal: I ∣ Ideal.span {x} ↔ x ∈ I

full_name: Ideal.isPrime_of_prime
code: theorem Ideal.isPrime_of_prime {P : Ideal A} (h : Prime P) : IsPrime P 
goal: P.IsPrime

full_name: Ideal.prime_of_isPrime
code: theorem Ideal.prime_of_isPrime {P : Ideal A} (hP : P ≠ ⊥) (h : IsPrime P) : Prime P 
goal: Prime P

full_name: Ideal.prime_iff_isPrime
code: /-- In a Dedekind domain, the (nonzero) prime elements of the monoid with zero `Ideal A`
are exactly the prime ideals. -/
theorem Ideal.prime_iff_isPrime {P : Ideal A} (hP : P ≠ ⊥) : Prime P ↔ IsPrime P 
goal: Prime P ↔ P.IsPrime

full_name: Ideal.isPrime_iff_bot_or_prime
code: /-- In a Dedekind domain, the prime ideals are the zero ideal together with the prime elements
of the monoid with zero `Ideal A`. -/
theorem Ideal.isPrime_iff_bot_or_prime {P : Ideal A} : IsPrime P ↔ P = ⊥ ∨ Prime P 
goal: P.IsPrime ↔ P = ⊥ ∨ Prime P

full_name: Ideal.prime_span_singleton_iff
code: @[simp]
theorem Ideal.prime_span_singleton_iff {a : A} : Prime (Ideal.span {a}) ↔ Prime a 
goal: Prime (Ideal.span {a}) ↔ Prime a

full_name: Ideal.prime_generator_of_prime
code: theorem Ideal.prime_generator_of_prime {P : Ideal A} (h : Prime P) [P.IsPrincipal] :
    Prime (generator P) 
goal: Prime (Submodule.IsPrincipal.generator P)

full_name: Ideal.mem_normalizedFactors_iff
code: nonrec theorem Ideal.mem_normalizedFactors_iff {p I : Ideal A} (hI : I ≠ ⊥) :
    p ∈ normalizedFactors I ↔ p.IsPrime ∧ I ≤ p 
goal: p ∈ UniqueFactorizationMonoid.normalizedFactors I ↔ p.IsPrime ∧ I ≤ p

full_name: Ideal.pow_right_strictAnti
code: theorem Ideal.pow_right_strictAnti (I : Ideal A) (hI0 : I ≠ ⊥) (hI1 : I ≠ ⊤) :
    StrictAnti (I ^ · : ℕ → Ideal A) 
goal: StrictAnti fun x => I ^ x

full_name: Ideal.pow_lt_self
code: theorem Ideal.pow_lt_self (I : Ideal A) (hI0 : I ≠ ⊥) (hI1 : I ≠ ⊤) (e : ℕ) (he : 2 ≤ e) :
    I ^ e < I 
goal: I ^ e < I

full_name: Ideal.exists_mem_pow_not_mem_pow_succ
code: theorem Ideal.exists_mem_pow_not_mem_pow_succ (I : Ideal A) (hI0 : I ≠ ⊥) (hI1 : I ≠ ⊤) (e : ℕ) :
    ∃ x ∈ I ^ e, x ∉ I ^ (e + 1) 
goal: ∃ x ∈ I ^ e, x ∉ I ^ (e + 1)

full_name: Ideal.eq_prime_pow_of_succ_lt_of_le
code: theorem Ideal.eq_prime_pow_of_succ_lt_of_le {P I : Ideal A} [P_prime : P.IsPrime] (hP : P ≠ ⊥)
    {i : ℕ} (hlt : P ^ (i + 1) < I) (hle : I ≤ P ^ i) : I = P ^ i 
goal: I = P ^ i

full_name: Ideal.pow_succ_lt_pow
code: theorem Ideal.pow_succ_lt_pow {P : Ideal A} [P_prime : P.IsPrime] (hP : P ≠ ⊥) (i : ℕ) :
    P ^ (i + 1) < P ^ i 
goal: P ^ (i + 1) < P ^ i

full_name: Associates.le_singleton_iff
code: theorem Associates.le_singleton_iff (x : A) (n : ℕ) (I : Ideal A) :
    Associates.mk I ^ n ≤ Associates.mk (Ideal.span {x}) ↔ x ∈ I ^ n 
goal: Associates.mk I ^ n ≤ Associates.mk (Ideal.span {x}) ↔ x ∈ I ^ n

full_name: FractionalIdeal.le_inv_comm
code: lemma FractionalIdeal.le_inv_comm {I J : FractionalIdeal A⁰ K} (hI : I ≠ 0) (hJ : J ≠ 0) :
    I ≤ J⁻¹ ↔ J ≤ I⁻¹ 
goal: I ≤ J⁻¹ ↔ J ≤ I⁻¹

full_name: FractionalIdeal.inv_le_comm
code: lemma FractionalIdeal.inv_le_comm {I J : FractionalIdeal A⁰ K} (hI : I ≠ 0) (hJ : J ≠ 0) :
    I⁻¹ ≤ J ↔ J⁻¹ ≤ I 
goal: I⁻¹ ≤ J ↔ J⁻¹ ≤ I

full_name: Ideal.exist_integer_multiples_not_mem
code: /-- Strengthening of `IsLocalization.exist_integer_multiples`:
Let `J ≠ ⊤` be an ideal in a Dedekind domain `A`, and `f ≠ 0` a finite collection
of elements of `K = Frac(A)`, then we can multiply the elements of `f` by some `a : K`
to find a collection of elements of `A` that is not completely contained in `J`. -/
theorem Ideal.exist_integer_multiples_not_mem {J : Ideal A} (hJ : J ≠ ⊤) {ι : Type*} (s : Finset ι)
    (f : ι → K) {j} (hjs : j ∈ s) (hjf : f j ≠ 0) :
    ∃ a : K,
      (∀ i ∈ s, IsLocalization.IsInteger A (a * f i)) ∧
        ∃ i ∈ s, a * f i ∉ (J : FractionalIdeal A⁰ K) 
goal: ∃ a, (∀ i ∈ s, IsLocalization.IsInteger A (a * f i)) ∧ ∃ i ∈ s, a * f i ∉ ↑J

full_name: Ideal.sup_mul_inf
code: @[simp]
theorem sup_mul_inf (I J : Ideal A) : (I ⊔ J) * (I ⊓ J) = I * J 
goal: (I ⊔ J) * (I ⊓ J) = I * J

full_name: Ideal.instNormalizedGCDMonoid
code: /-- Ideals in a Dedekind domain have gcd and lcm operators that (trivially) are compatible with
the normalization operator. -/
instance : NormalizedGCDMonoid (Ideal A) 
goal: NormalizedGCDMonoid (Ideal A)

full_name: Ideal.gcd_eq_sup
code: @[simp]
theorem gcd_eq_sup (I J : Ideal A) : gcd I J = I ⊔ J 
goal: gcd I J = I ⊔ J

full_name: Ideal.lcm_eq_inf
code: @[simp]
theorem lcm_eq_inf (I J : Ideal A) : lcm I J = I ⊓ J 
goal: lcm I J = I ⊓ J

full_name: Ideal.isCoprime_iff_gcd
code: theorem isCoprime_iff_gcd {I J : Ideal A} : IsCoprime I J ↔ gcd I J = 1 
goal: IsCoprime I J ↔ gcd I J = 1

full_name: Ideal.factors_span_eq
code: theorem factors_span_eq {p : K[X]} : factors (span {p}) = (factors p).map (fun q ↦ span {q}) 
goal: UniqueFactorizationMonoid.factors (Ideal.span {p}) =
  Multiset.map (fun q => Ideal.span {q}) (UniqueFactorizationMonoid.factors p)

full_name: prod_normalizedFactors_eq_self
code: theorem prod_normalizedFactors_eq_self (hI : I ≠ ⊥) : (normalizedFactors I).prod = I 
goal: (UniqueFactorizationMonoid.normalizedFactors I).prod = I

full_name: count_le_of_ideal_ge
code: theorem count_le_of_ideal_ge {I J : Ideal T} (h : I ≤ J) (hI : I ≠ ⊥) (K : Ideal T) :
    count K (normalizedFactors J) ≤ count K (normalizedFactors I) 
goal: Multiset.count K (UniqueFactorizationMonoid.normalizedFactors J) ≤
  Multiset.count K (UniqueFactorizationMonoid.normalizedFactors I)

full_name: sup_eq_prod_inf_factors
code: theorem sup_eq_prod_inf_factors (hI : I ≠ ⊥) (hJ : J ≠ ⊥) :
    I ⊔ J = (normalizedFactors I ∩ normalizedFactors J).prod 
goal: I ⊔ J = (UniqueFactorizationMonoid.normalizedFactors I ∩ UniqueFactorizationMonoid.normalizedFactors J).prod

full_name: irreducible_pow_sup
code: theorem irreducible_pow_sup (hI : I ≠ ⊥) (hJ : Irreducible J) (n : ℕ) :
    J ^ n ⊔ I = J ^ min ((normalizedFactors I).count J) n 
goal: J ^ n ⊔ I = J ^ min (Multiset.count J (UniqueFactorizationMonoid.normalizedFactors I)) n

full_name: irreducible_pow_sup_of_le
code: theorem irreducible_pow_sup_of_le (hJ : Irreducible J) (n : ℕ) (hn : ↑n ≤ multiplicity J I) :
    J ^ n ⊔ I = J ^ n 
goal: J ^ n ⊔ I = J ^ n

full_name: irreducible_pow_sup_of_ge
code: theorem irreducible_pow_sup_of_ge (hI : I ≠ ⊥) (hJ : Irreducible J) (n : ℕ)
    (hn : multiplicity J I ≤ n) :
    J ^ n ⊔ I = J ^ (multiplicity J I).get (PartENat.dom_of_le_natCast hn) 
goal: J ^ n ⊔ I = J ^ (multiplicity J I).get ⋯

full_name: IsDedekindDomain.HeightOneSpectrum.ne_bot
code: /-- The height one prime spectrum of a Dedekind domain `R` is the type of nonzero prime ideals of
`R`. Note that this equals the maximal spectrum if `R` has Krull dimension 1. -/
-- Porting note(#5171): removed `has_nonempty_instance`, linter doesn't exist yet
@[ext, nolint unusedArguments]
structure HeightOneSpectrum where
  asIdeal : Ideal R
  isPrime : asIdeal.IsPrime
  ne_bot : asIdeal ≠ ⊥
goal: self.asIdeal ≠ ⊥

full_name: IsDedekindDomain.HeightOneSpectrum.isPrime
code: /-- The height one prime spectrum of a Dedekind domain `R` is the type of nonzero prime ideals of
`R`. Note that this equals the maximal spectrum if `R` has Krull dimension 1. -/
-- Porting note(#5171): removed `has_nonempty_instance`, linter doesn't exist yet
@[ext, nolint unusedArguments]
structure HeightOneSpectrum where
  asIdeal : Ideal R
  isPrime : asIdeal.IsPrime
  ne_bot : asIdeal ≠ ⊥
goal: self.asIdeal.IsPrime

full_name: IsDedekindDomain.HeightOneSpectrum
code: /-- The height one prime spectrum of a Dedekind domain `R` is the type of nonzero prime ideals of
`R`. Note that this equals the maximal spectrum if `R` has Krull dimension 1. -/
-- Porting note(#5171): removed `has_nonempty_instance`, linter doesn't exist yet
@[ext, nolint unusedArguments]
structure HeightOneSpectrum where
  asIdeal : Ideal R
  isPrime : asIdeal.IsPrime
  ne_bot : asIdeal ≠ ⊥
goal: Type u_1

full_name: IsDedekindDomain.HeightOneSpectrum.asIdeal
code: /-- The height one prime spectrum of a Dedekind domain `R` is the type of nonzero prime ideals of
`R`. Note that this equals the maximal spectrum if `R` has Krull dimension 1. -/
-- Porting note(#5171): removed `has_nonempty_instance`, linter doesn't exist yet
@[ext, nolint unusedArguments]
structure HeightOneSpectrum where
  asIdeal : Ideal R
  isPrime : asIdeal.IsPrime
  ne_bot : asIdeal ≠ ⊥
goal: Ideal R

full_name: IsDedekindDomain.HeightOneSpectrum.isMaximal
code: instance isMaximal : v.asIdeal.IsMaximal 
goal: v.asIdeal.IsMaximal

full_name: IsDedekindDomain.HeightOneSpectrum.prime
code: theorem prime : Prime v.asIdeal 
goal: Prime v.asIdeal

full_name: IsDedekindDomain.HeightOneSpectrum.irreducible
code: theorem irreducible : Irreducible v.asIdeal 
goal: Irreducible v.asIdeal

full_name: IsDedekindDomain.HeightOneSpectrum.associates_irreducible
code: theorem associates_irreducible : Irreducible <| Associates.mk v.asIdeal 
goal: Irreducible (Associates.mk v.asIdeal)

full_name: IsDedekindDomain.HeightOneSpectrum.equivMaximalSpectrum
code: /-- An equivalence between the height one and maximal spectra for rings of Krull dimension 1. -/
def equivMaximalSpectrum (hR : ¬IsField R) : HeightOneSpectrum R ≃ MaximalSpectrum R 
goal: IsDedekindDomain.HeightOneSpectrum R ≃ MaximalSpectrum R

full_name: IsDedekindDomain.HeightOneSpectrum.iInf_localization_eq_bot
code: /-- A Dedekind domain is equal to the intersection of its localizations at all its height one
non-zero prime ideals viewed as subalgebras of its field of fractions. -/
theorem iInf_localization_eq_bot [Algebra R K] [hK : IsFractionRing R K] :
    (⨅ v : HeightOneSpectrum R,
        Localization.subalgebra.ofField K _ v.asIdeal.primeCompl_le_nonZeroDivisors) = ⊥ 
goal: ⨅ v, Localization.subalgebra.ofField K v.asIdeal.primeCompl ⋯ = ⊥

full_name: idealFactorsFunOfQuotHom
code: /-- The map from ideals of `R` dividing `I` to the ideals of `A` dividing `J` induced by
  a homomorphism `f : R/I →+* A/J` -/
@[simps] -- Porting note: use `Subtype` instead of `Set` to make linter happy
def idealFactorsFunOfQuotHom {f : R ⧸ I →+* A ⧸ J} (hf : Function.Surjective f) :
    {p : Ideal R // p ∣ I} →o {p : Ideal A // p ∣ J} 
goal: { p // p ∣ I } →o { p // p ∣ J }

full_name: idealFactorsFunOfQuotHom_coe_coe
code: /-- The map from ideals of `R` dividing `I` to the ideals of `A` dividing `J` induced by
  a homomorphism `f : R/I →+* A/J` -/
@[simps] -- Porting note: use `Subtype` instead of `Set` to make linter happy
def idealFactorsFunOfQuotHom {f : R ⧸ I →+* A ⧸ J} (hf : Function.Surjective f) :
    {p : Ideal R // p ∣ I} →o {p : Ideal A // p ∣ J} 
goal: ↑((idealFactorsFunOfQuotHom hf) X) =
  Ideal.comap (Ideal.Quotient.mk J) (Ideal.map f (Ideal.map (Ideal.Quotient.mk I) ↑X))

full_name: idealFactorsFunOfQuotHom_id
code: @[simp]
theorem idealFactorsFunOfQuotHom_id :
    idealFactorsFunOfQuotHom (RingHom.id (A ⧸ J)).surjective = OrderHom.id 
goal: idealFactorsFunOfQuotHom ⋯ = OrderHom.id

full_name: idealFactorsFunOfQuotHom_comp
code: theorem idealFactorsFunOfQuotHom_comp {f : R ⧸ I →+* A ⧸ J} {g : A ⧸ J →+* B ⧸ L}
    (hf : Function.Surjective f) (hg : Function.Surjective g) :
    (idealFactorsFunOfQuotHom hg).comp (idealFactorsFunOfQuotHom hf) =
      idealFactorsFunOfQuotHom (show Function.Surjective (g.comp f) from hg.comp hf) 
goal: (idealFactorsFunOfQuotHom hg).comp (idealFactorsFunOfQuotHom hf) = idealFactorsFunOfQuotHom ⋯

full_name: idealFactorsEquivOfQuotEquiv
code: /-- The bijection between ideals of `R` dividing `I` and the ideals of `A` dividing `J` induced by
  an isomorphism `f : R/I ≅ A/J`. -/
-- @[simps] -- Porting note: simpNF complains about the lemmas generated by simps
def idealFactorsEquivOfQuotEquiv : { p : Ideal R | p ∣ I } ≃o { p : Ideal A | p ∣ J } 
goal: ↑{p | p ∣ I} ≃o ↑{p | p ∣ J}

full_name: idealFactorsEquivOfQuotEquiv_symm
code: theorem idealFactorsEquivOfQuotEquiv_symm :
    (idealFactorsEquivOfQuotEquiv f).symm = idealFactorsEquivOfQuotEquiv f.symm 
goal: (idealFactorsEquivOfQuotEquiv f).symm = idealFactorsEquivOfQuotEquiv f.symm

full_name: idealFactorsEquivOfQuotEquiv_is_dvd_iso
code: theorem idealFactorsEquivOfQuotEquiv_is_dvd_iso {L M : Ideal R} (hL : L ∣ I) (hM : M ∣ I) :
    (idealFactorsEquivOfQuotEquiv f ⟨L, hL⟩ : Ideal A) ∣ idealFactorsEquivOfQuotEquiv f ⟨M, hM⟩ ↔
      L ∣ M 
goal: ↑((idealFactorsEquivOfQuotEquiv f) ⟨L, hL⟩) ∣ ↑((idealFactorsEquivOfQuotEquiv f) ⟨M, hM⟩) ↔ L ∣ M

full_name: idealFactorsEquivOfQuotEquiv_mem_normalizedFactors_of_mem_normalizedFactors
code: theorem idealFactorsEquivOfQuotEquiv_mem_normalizedFactors_of_mem_normalizedFactors (hJ : J ≠ ⊥)
    {L : Ideal R} (hL : L ∈ normalizedFactors I) :
    ↑(idealFactorsEquivOfQuotEquiv f ⟨L, dvd_of_mem_normalizedFactors hL⟩)
      ∈ normalizedFactors J 
goal: ↑((idealFactorsEquivOfQuotEquiv f) ⟨L, ⋯⟩) ∈ UniqueFactorizationMonoid.normalizedFactors J

full_name: normalizedFactorsEquivOfQuotEquiv
code: /-- The bijection between the sets of normalized factors of I and J induced by a ring
    isomorphism `f : R/I ≅ A/J`. -/
-- @[simps apply] -- Porting note: simpNF complains about the lemmas generated by simps
def normalizedFactorsEquivOfQuotEquiv (hI : I ≠ ⊥) (hJ : J ≠ ⊥) :
    { L : Ideal R | L ∈ normalizedFactors I } ≃ { M : Ideal A | M ∈ normalizedFactors J } 
goal: ↑{L | L ∈ UniqueFactorizationMonoid.normalizedFactors I} ≃ ↑{M | M ∈ UniqueFactorizationMonoid.normalizedFactors J}

full_name: normalizedFactorsEquivOfQuotEquiv_symm
code: @[simp]
theorem normalizedFactorsEquivOfQuotEquiv_symm (hI : I ≠ ⊥) (hJ : J ≠ ⊥) :
    (normalizedFactorsEquivOfQuotEquiv f hI hJ).symm =
      normalizedFactorsEquivOfQuotEquiv f.symm hJ hI 
goal: (normalizedFactorsEquivOfQuotEquiv f hI hJ).symm = normalizedFactorsEquivOfQuotEquiv f.symm hJ hI

full_name: normalizedFactorsEquivOfQuotEquiv_multiplicity_eq_multiplicity
code: /-- The map `normalizedFactorsEquivOfQuotEquiv` preserves multiplicities. -/
theorem normalizedFactorsEquivOfQuotEquiv_multiplicity_eq_multiplicity (hI : I ≠ ⊥) (hJ : J ≠ ⊥)
    (L : Ideal R) (hL : L ∈ normalizedFactors I) :
    multiplicity (↑(normalizedFactorsEquivOfQuotEquiv f hI hJ ⟨L, hL⟩)) J = multiplicity L I 
goal: multiplicity (↑((normalizedFactorsEquivOfQuotEquiv f hI hJ) ⟨L, hL⟩)) J = multiplicity L I

full_name: Ring.DimensionLeOne.prime_le_prime_iff_eq
code: theorem Ring.DimensionLeOne.prime_le_prime_iff_eq [Ring.DimensionLEOne R] {P Q : Ideal R}
    [hP : P.IsPrime] [hQ : Q.IsPrime] (hP0 : P ≠ ⊥) : P ≤ Q ↔ P = Q 
goal: P ≤ Q ↔ P = Q

full_name: Ideal.coprime_of_no_prime_ge
code: theorem Ideal.coprime_of_no_prime_ge {I J : Ideal R} (h : ∀ P, I ≤ P → J ≤ P → ¬IsPrime P) :
    IsCoprime I J 
goal: IsCoprime I J

full_name: Ideal.IsPrime.mul_mem_pow
code: theorem Ideal.IsPrime.mul_mem_pow (I : Ideal R) [hI : I.IsPrime] {a b : R} {n : ℕ}
    (h : a * b ∈ I ^ n) : a ∈ I ∨ b ∈ I ^ n 
goal: a ∈ I ∨ b ∈ I ^ n

full_name: Ideal.IsPrime.mem_pow_mul
code: theorem Ideal.IsPrime.mem_pow_mul (I : Ideal R) [hI : I.IsPrime] {a b : R} {n : ℕ}
    (h : a * b ∈ I ^ n) : a ∈ I ^ n ∨ b ∈ I 
goal: a ∈ I ^ n ∨ b ∈ I

full_name: Ideal.count_normalizedFactors_eq
code: theorem Ideal.count_normalizedFactors_eq {p x : Ideal R} [hp : p.IsPrime] {n : ℕ} (hle : x ≤ p ^ n)
    [DecidableEq (Ideal R)] (hlt : ¬x ≤ p ^ (n + 1)) : (normalizedFactors x).count p = n 
goal: Multiset.count p (UniqueFactorizationMonoid.normalizedFactors x) = n

full_name: Ideal.le_mul_of_no_prime_factors
code: theorem Ideal.le_mul_of_no_prime_factors {I J K : Ideal R}
    (coprime : ∀ P, J ≤ P → K ≤ P → ¬IsPrime P) (hJ : I ≤ J) (hK : I ≤ K) : I ≤ J * K 
goal: I ≤ J * K

full_name: Ideal.le_of_pow_le_prime
code: theorem Ideal.le_of_pow_le_prime {I P : Ideal R} [hP : P.IsPrime] {n : ℕ} (h : I ^ n ≤ P) :
    I ≤ P 
goal: I ≤ P

full_name: Ideal.pow_le_prime_iff
code: theorem Ideal.pow_le_prime_iff {I P : Ideal R} [_hP : P.IsPrime] {n : ℕ} (hn : n ≠ 0) :
    I ^ n ≤ P ↔ I ≤ P 
goal: I ^ n ≤ P ↔ I ≤ P

full_name: Ideal.prod_le_prime
code: theorem Ideal.prod_le_prime {ι : Type*} {s : Finset ι} {f : ι → Ideal R} {P : Ideal R}
    [hP : P.IsPrime] : ∏ i ∈ s, f i ≤ P ↔ ∃ i ∈ s, f i ≤ P 
goal: ∏ i ∈ s, f i ≤ P ↔ ∃ i ∈ s, f i ≤ P

full_name: IsDedekindDomain.inf_prime_pow_eq_prod
code: /-- The intersection of distinct prime powers in a Dedekind domain is the product of these
prime powers. -/
theorem IsDedekindDomain.inf_prime_pow_eq_prod {ι : Type*} (s : Finset ι) (f : ι → Ideal R)
    (e : ι → ℕ) (prime : ∀ i ∈ s, Prime (f i))
    (coprime : ∀ᵉ (i ∈ s) (j ∈ s), i ≠ j → f i ≠ f j) :
    (s.inf fun i => f i ^ e i) = ∏ i ∈ s, f i ^ e i 
goal: (s.inf fun i => f i ^ e i) = ∏ i ∈ s, f i ^ e i

full_name: IsDedekindDomain.quotientEquivPiOfProdEq
code: /-- **Chinese remainder theorem** for a Dedekind domain: if the ideal `I` factors as
`∏ i, P i ^ e i`, then `R ⧸ I` factors as `Π i, R ⧸ (P i ^ e i)`. -/
noncomputable def IsDedekindDomain.quotientEquivPiOfProdEq {ι : Type*} [Fintype ι] (I : Ideal R)
    (P : ι → Ideal R) (e : ι → ℕ) (prime : ∀ i, Prime (P i))
    (coprime : Pairwise fun i j => P i ≠ P j)
    (prod_eq : ∏ i, P i ^ e i = I) : R ⧸ I ≃+* ∀ i, R ⧸ P i ^ e i 
goal: R ⧸ I ≃+* ((i : ι) → R ⧸ P i ^ e i)

full_name: IsDedekindDomain.quotientEquivPiFactors
code: /-- **Chinese remainder theorem** for a Dedekind domain: `R ⧸ I` factors as `Π i, R ⧸ (P i ^ e i)`,
where `P i` ranges over the prime factors of `I` and `e i` over the multiplicities. -/
noncomputable def IsDedekindDomain.quotientEquivPiFactors {I : Ideal R} (hI : I ≠ ⊥) :
    R ⧸ I ≃+* ∀ P : (factors I).toFinset, R ⧸ (P : Ideal R) ^ (Multiset.count ↑P (factors I)) 
goal: R ⧸ I ≃+*
  ((P : { x // x ∈ (UniqueFactorizationMonoid.factors I).toFinset }) →
    R ⧸ ↑P ^ Multiset.count (↑P) (UniqueFactorizationMonoid.factors I))

full_name: IsDedekindDomain.quotientEquivPiFactors_mk
code: @[simp]
theorem IsDedekindDomain.quotientEquivPiFactors_mk {I : Ideal R} (hI : I ≠ ⊥) (x : R) :
    IsDedekindDomain.quotientEquivPiFactors hI (Ideal.Quotient.mk I x) = fun _P =>
      Ideal.Quotient.mk _ x 
goal: (IsDedekindDomain.quotientEquivPiFactors hI) ((Ideal.Quotient.mk I) x) = fun _P =>
  (Ideal.Quotient.mk (↑_P ^ Multiset.count (↑_P) (UniqueFactorizationMonoid.factors I))) x

full_name: IsDedekindDomain.quotientEquivPiOfFinsetProdEq
code: /-- **Chinese remainder theorem** for a Dedekind domain: if the ideal `I` factors as
`∏ i ∈ s, P i ^ e i`, then `R ⧸ I` factors as `Π (i : s), R ⧸ (P i ^ e i)`.

This is a version of `IsDedekindDomain.quotientEquivPiOfProdEq` where we restrict
the product to a finite subset `s` of a potentially infinite indexing type `ι`.
-/
noncomputable def IsDedekindDomain.quotientEquivPiOfFinsetProdEq {ι : Type*} {s : Finset ι}
    (I : Ideal R) (P : ι → Ideal R) (e : ι → ℕ) (prime : ∀ i ∈ s, Prime (P i))
    (coprime : ∀ᵉ (i ∈ s) (j ∈ s), i ≠ j → P i ≠ P j)
    (prod_eq : ∏ i ∈ s, P i ^ e i = I) : R ⧸ I ≃+* ∀ i : s, R ⧸ P i ^ e i 
goal: R ⧸ I ≃+* ((i : { x // x ∈ s }) → R ⧸ P ↑i ^ e ↑i)

full_name: IsDedekindDomain.exists_representative_mod_finset
code: /-- Corollary of the Chinese remainder theorem: given elements `x i : R / P i ^ e i`,
we can choose a representative `y : R` such that `y ≡ x i (mod P i ^ e i)`. -/
theorem IsDedekindDomain.exists_representative_mod_finset {ι : Type*} {s : Finset ι}
    (P : ι → Ideal R) (e : ι → ℕ) (prime : ∀ i ∈ s, Prime (P i))
    (coprime : ∀ᵉ (i ∈ s) (j ∈ s), i ≠ j → P i ≠ P j) (x : ∀ i : s, R ⧸ P i ^ e i) :
    ∃ y, ∀ (i) (hi : i ∈ s), Ideal.Quotient.mk (P i ^ e i) y = x ⟨i, hi⟩ 
goal: ∃ y, ∀ (i : ι) (hi : i ∈ s), (Ideal.Quotient.mk (P i ^ e i)) y = x ⟨i, hi⟩

full_name: IsDedekindDomain.exists_forall_sub_mem_ideal
code: /-- Corollary of the Chinese remainder theorem: given elements `x i : R`,
we can choose a representative `y : R` such that `y - x i ∈ P i ^ e i`. -/
theorem IsDedekindDomain.exists_forall_sub_mem_ideal {ι : Type*} {s : Finset ι} (P : ι → Ideal R)
    (e : ι → ℕ) (prime : ∀ i ∈ s, Prime (P i))
    (coprime : ∀ᵉ (i ∈ s) (j ∈ s), i ≠ j → P i ≠ P j) (x : s → R) :
    ∃ y, ∀ (i) (hi : i ∈ s), y - x ⟨i, hi⟩ ∈ P i ^ e i 
goal: ∃ y, ∀ (i : ι) (hi : i ∈ s), y - x ⟨i, hi⟩ ∈ P i ^ e i

full_name: span_singleton_dvd_span_singleton_iff_dvd
code: theorem span_singleton_dvd_span_singleton_iff_dvd {a b : R} :
    Ideal.span {a} ∣ Ideal.span ({b} : Set R) ↔ a ∣ b 
goal: Ideal.span {a} ∣ Ideal.span {b} ↔ a ∣ b

full_name: Ideal.squarefree_span_singleton
code: @[simp]
theorem Ideal.squarefree_span_singleton {a : R} :
    Squarefree (span {a}) ↔ Squarefree a 
goal: Squarefree (Ideal.span {a}) ↔ Squarefree a

full_name: singleton_span_mem_normalizedFactors_of_mem_normalizedFactors
code: theorem singleton_span_mem_normalizedFactors_of_mem_normalizedFactors [NormalizationMonoid R]
    {a b : R} (ha : a ∈ normalizedFactors b) :
    Ideal.span ({a} : Set R) ∈ normalizedFactors (Ideal.span ({b} : Set R)) 
goal: Ideal.span {a} ∈ UniqueFactorizationMonoid.normalizedFactors (Ideal.span {b})

full_name: multiplicity_eq_multiplicity_span
code: theorem multiplicity_eq_multiplicity_span [DecidableRel ((· ∣ ·) : R → R → Prop)]
    [DecidableRel ((· ∣ ·) : Ideal R → Ideal R → Prop)] {a b : R} :
    multiplicity (Ideal.span {a}) (Ideal.span ({b} : Set R)) = multiplicity a b 
goal: multiplicity (Ideal.span {a}) (Ideal.span {b}) = multiplicity a b

full_name: normalizedFactorsEquivSpanNormalizedFactors
code: /-- The bijection between the (normalized) prime factors of `r` and the (normalized) prime factors
    of `span {r}` -/
-- @[simps] -- Porting note: simpNF complains about the lemmas generated by simps
noncomputable def normalizedFactorsEquivSpanNormalizedFactors {r : R} (hr : r ≠ 0) :
    { d : R | d ∈ normalizedFactors r } ≃
      { I : Ideal R | I ∈ normalizedFactors (Ideal.span ({r} : Set R)) } 
goal: ↑{d | d ∈ UniqueFactorizationMonoid.normalizedFactors r} ≃
  ↑{I | I ∈ UniqueFactorizationMonoid.normalizedFactors (Ideal.span {r})}

full_name: multiplicity_normalizedFactorsEquivSpanNormalizedFactors_eq_multiplicity
code: /-- The bijection `normalizedFactorsEquivSpanNormalizedFactors` between the set of prime
    factors of `r` and the set of prime factors of the ideal `⟨r⟩` preserves multiplicities. See
    `count_normalizedFactorsSpan_eq_count` for the version stated in terms of multisets `count`.-/
theorem multiplicity_normalizedFactorsEquivSpanNormalizedFactors_eq_multiplicity {r d : R}
    (hr : r ≠ 0) (hd : d ∈ normalizedFactors r) :
    multiplicity d r =
      multiplicity (normalizedFactorsEquivSpanNormalizedFactors hr ⟨d, hd⟩ : Ideal R)
        (Ideal.span {r}) 
goal: multiplicity d r = multiplicity (↑((normalizedFactorsEquivSpanNormalizedFactors hr) ⟨d, hd⟩)) (Ideal.span {r})

full_name: multiplicity_normalizedFactorsEquivSpanNormalizedFactors_symm_eq_multiplicity
code: /-- The bijection `normalized_factors_equiv_span_normalized_factors.symm` between the set of prime
    factors of the ideal `⟨r⟩` and the set of prime factors of `r` preserves multiplicities. -/
theorem multiplicity_normalizedFactorsEquivSpanNormalizedFactors_symm_eq_multiplicity {r : R}
    (hr : r ≠ 0) (I : { I : Ideal R | I ∈ normalizedFactors (Ideal.span ({r} : Set R)) }) :
    multiplicity ((normalizedFactorsEquivSpanNormalizedFactors hr).symm I : R) r =
      multiplicity (I : Ideal R) (Ideal.span {r}) 
goal: multiplicity (↑((normalizedFactorsEquivSpanNormalizedFactors hr).symm I)) r = multiplicity (↑I) (Ideal.span {r})

full_name: count_span_normalizedFactors_eq
code: /-- The bijection between the set of prime factors of the ideal `⟨r⟩` and the set of prime factors
  of `r` preserves `count` of the corresponding multisets. See
  `multiplicity_normalizedFactorsEquivSpanNormalizedFactors_eq_multiplicity` for the version
  stated in terms of multiplicity. -/
theorem count_span_normalizedFactors_eq {r X : R} (hr : r ≠ 0) (hX : Prime X) :
    Multiset.count (Ideal.span {X} : Ideal R) (normalizedFactors (Ideal.span {r}))  =
        Multiset.count (normalize X) (normalizedFactors r) 
goal: Multiset.count (Ideal.span {X}) (UniqueFactorizationMonoid.normalizedFactors (Ideal.span {r})) =
  Multiset.count (normalize X) (UniqueFactorizationMonoid.normalizedFactors r)

full_name: count_span_normalizedFactors_eq_of_normUnit
code: theorem count_span_normalizedFactors_eq_of_normUnit {r X : R}
    (hr : r ≠ 0) (hX₁ : normUnit X = 1) (hX : Prime X) :
      Multiset.count (Ideal.span {X} : Ideal R) (normalizedFactors (Ideal.span {r})) =
        Multiset.count X (normalizedFactors r) 
goal: Multiset.count (Ideal.span {X}) (UniqueFactorizationMonoid.normalizedFactors (Ideal.span {r})) =
  Multiset.count X (UniqueFactorizationMonoid.normalizedFactors r)

full_name: count_associates_factors_eq
code: /-- The number of times an ideal `I` occurs as normalized factor of another ideal `J` is stable
  when regarding at these ideals as associated elements of the monoid of ideals.-/
theorem count_associates_factors_eq [DecidableEq <| Associates (Ideal R)]
    [∀ (p : Associates <| Ideal R), Decidable (Irreducible p)]
    (I J : Ideal R) (hI : I ≠ 0) (hJ : J.IsPrime) (hJ₀ : J ≠ ⊥) :
    (Associates.mk J).count (Associates.mk I).factors = Multiset.count J (normalizedFactors I) 
goal: (Associates.mk J).count (Associates.mk I).factors = Multiset.count J (UniqueFactorizationMonoid.normalizedFactors I)