File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

full_name: IsFractional.map
code: theorem _root_.IsFractional.map (g : P →ₐ[R] P') {I : Submodule R P} :
    IsFractional S I → IsFractional S (Submodule.map g.toLinearMap I)
  
goal: IsFractional S I → IsFractional S (Submodule.map g.toLinearMap I)

full_name: FractionalIdeal.map
code: /-- `I.map g` is the pushforward of the fractional ideal `I` along the algebra morphism `g` -/
def map (g : P →ₐ[R] P') : FractionalIdeal S P → FractionalIdeal S P' 
goal: FractionalIdeal S P → FractionalIdeal S P'

full_name: FractionalIdeal.coe_map
code: @[simp, norm_cast]
theorem coe_map (g : P →ₐ[R] P') (I : FractionalIdeal S P) :
    ↑(map g I) = Submodule.map g.toLinearMap I 
goal: ↑(FractionalIdeal.map g I) = Submodule.map g.toLinearMap ↑I

full_name: FractionalIdeal.mem_map
code: @[simp]
theorem mem_map {I : FractionalIdeal S P} {g : P →ₐ[R] P'} {y : P'} :
    y ∈ I.map g ↔ ∃ x, x ∈ I ∧ g x = y 
goal: y ∈ FractionalIdeal.map g I ↔ ∃ x ∈ I, g x = y

full_name: FractionalIdeal.map_id
code: @[simp]
theorem map_id : I.map (AlgHom.id _ _) = I 
goal: FractionalIdeal.map (AlgHom.id R P) I = I

full_name: FractionalIdeal.map_comp
code: @[simp]
theorem map_comp (g' : P' →ₐ[R] P'') : I.map (g'.comp g) = (I.map g).map g' 
goal: FractionalIdeal.map (g'.comp g) I = FractionalIdeal.map g' (FractionalIdeal.map g I)

full_name: FractionalIdeal.map_coeIdeal
code: @[simp, norm_cast]
theorem map_coeIdeal (I : Ideal R) : (I : FractionalIdeal S P).map g = I 
goal: FractionalIdeal.map g ↑I = ↑I

full_name: FractionalIdeal.map_one
code: @[simp]
theorem map_one : (1 : FractionalIdeal S P).map g = 1 
goal: FractionalIdeal.map g 1 = 1

full_name: FractionalIdeal.map_zero
code: @[simp]
theorem map_zero : (0 : FractionalIdeal S P).map g = 0 
goal: FractionalIdeal.map g 0 = 0

full_name: FractionalIdeal.map_add
code: @[simp]
theorem map_add : (I + J).map g = I.map g + J.map g 
goal: FractionalIdeal.map g (I + J) = FractionalIdeal.map g I + FractionalIdeal.map g J

full_name: FractionalIdeal.map_mul
code: @[simp]
theorem map_mul : (I * J).map g = I.map g * J.map g 
goal: FractionalIdeal.map g (I * J) = FractionalIdeal.map g I * FractionalIdeal.map g J

full_name: FractionalIdeal.map_map_symm
code: @[simp]
theorem map_map_symm (g : P ≃ₐ[R] P') : (I.map (g : P →ₐ[R] P')).map (g.symm : P' →ₐ[R] P) = I 
goal: FractionalIdeal.map (↑g.symm) (FractionalIdeal.map (↑g) I) = I

full_name: FractionalIdeal.map_symm_map
code: @[simp]
theorem map_symm_map (I : FractionalIdeal S P') (g : P ≃ₐ[R] P') :
    (I.map (g.symm : P' →ₐ[R] P)).map (g : P →ₐ[R] P') = I 
goal: FractionalIdeal.map (↑g) (FractionalIdeal.map (↑g.symm) I) = I

full_name: FractionalIdeal.map_mem_map
code: theorem map_mem_map {f : P →ₐ[R] P'} (h : Function.Injective f) {x : P} {I : FractionalIdeal S P} :
    f x ∈ map f I ↔ x ∈ I 
goal: f x ∈ FractionalIdeal.map f I ↔ x ∈ I

full_name: FractionalIdeal.map_injective
code: theorem map_injective (f : P →ₐ[R] P') (h : Function.Injective f) :
    Function.Injective (map f : FractionalIdeal S P → FractionalIdeal S P') 
goal: Function.Injective (FractionalIdeal.map f)

full_name: FractionalIdeal.mapEquiv
code: /-- If `g` is an equivalence, `map g` is an isomorphism -/
def mapEquiv (g : P ≃ₐ[R] P') : FractionalIdeal S P ≃+* FractionalIdeal S P' 
goal: FractionalIdeal S P ≃+* FractionalIdeal S P'

full_name: FractionalIdeal.coeFun_mapEquiv
code: @[simp]
theorem coeFun_mapEquiv (g : P ≃ₐ[R] P') :
    (mapEquiv g : FractionalIdeal S P → FractionalIdeal S P') = map g 
goal: ⇑(FractionalIdeal.mapEquiv g) = FractionalIdeal.map ↑g

full_name: FractionalIdeal.mapEquiv_apply
code: @[simp]
theorem mapEquiv_apply (g : P ≃ₐ[R] P') (I : FractionalIdeal S P) : mapEquiv g I = map (↑g) I 
goal: (FractionalIdeal.mapEquiv g) I = FractionalIdeal.map (↑g) I

full_name: FractionalIdeal.mapEquiv_symm
code: @[simp]
theorem mapEquiv_symm (g : P ≃ₐ[R] P') :
    ((mapEquiv g).symm : FractionalIdeal S P' ≃+* _) = mapEquiv g.symm 
goal: (FractionalIdeal.mapEquiv g).symm = FractionalIdeal.mapEquiv g.symm

full_name: FractionalIdeal.mapEquiv_refl
code: @[simp]
theorem mapEquiv_refl : mapEquiv AlgEquiv.refl = RingEquiv.refl (FractionalIdeal S P) 
goal: FractionalIdeal.mapEquiv AlgEquiv.refl = RingEquiv.refl (FractionalIdeal S P)

full_name: FractionalIdeal.isFractional_span_iff
code: theorem isFractional_span_iff {s : Set P} :
    IsFractional S (span R s) ↔ ∃ a ∈ S, ∀ b : P, b ∈ s → IsInteger R (a • b) 
goal: IsFractional S (Submodule.span R s) ↔ ∃ a ∈ S, ∀ b ∈ s, IsLocalization.IsInteger R (a • b)

full_name: FractionalIdeal.isFractional_of_fg
code: theorem isFractional_of_fg {I : Submodule R P} (hI : I.FG) : IsFractional S I 
goal: IsFractional S I

full_name: FractionalIdeal.mem_span_mul_finite_of_mem_mul
code: theorem mem_span_mul_finite_of_mem_mul {I J : FractionalIdeal S P} {x : P} (hx : x ∈ I * J) :
    ∃ T T' : Finset P, (T : Set P) ⊆ I ∧ (T' : Set P) ⊆ J ∧ x ∈ span R (T * T' : Set P) 
goal: ∃ T T', ↑T ⊆ ↑I ∧ ↑T' ⊆ ↑J ∧ x ∈ Submodule.span R (↑T * ↑T')

full_name: FractionalIdeal.coeIdeal_fg
code: theorem coeIdeal_fg (inj : Function.Injective (algebraMap R P)) (I : Ideal R) :
    FG ((I : FractionalIdeal S P) : Submodule R P) ↔ I.FG 
goal: (↑↑I).FG ↔ I.FG

full_name: FractionalIdeal.fg_unit
code: theorem fg_unit (I : (FractionalIdeal S P)ˣ) : FG (I : Submodule R P) 
goal: (↑↑I).FG

full_name: FractionalIdeal.fg_of_isUnit
code: theorem fg_of_isUnit (I : FractionalIdeal S P) (h : IsUnit I) : FG (I : Submodule R P) 
goal: (↑I).FG

full_name: Ideal.fg_of_isUnit
code: theorem _root_.Ideal.fg_of_isUnit (inj : Function.Injective (algebraMap R P)) (I : Ideal R)
    (h : IsUnit (I : FractionalIdeal S P)) : I.FG 
goal: I.FG

full_name: FractionalIdeal.wrapped._@.Mathlib.RingTheory.FractionalIdeal.Operations._hyg.3196
code: /-- `canonicalEquiv f f'` is the canonical equivalence between the fractional
ideals in `P` and in `P'`, which are both localizations of `R` at `S`. -/
noncomputable irreducible_def canonicalEquiv : FractionalIdeal S P ≃+* FractionalIdeal S P' 
goal: Subtype (Eq @FractionalIdeal.definition✝)

full_name: FractionalIdeal.definition._@.Mathlib.RingTheory.FractionalIdeal.Operations._hyg.3196
code: /-- `canonicalEquiv f f'` is the canonical equivalence between the fractional
ideals in `P` and in `P'`, which are both localizations of `R` at `S`. -/
noncomputable irreducible_def canonicalEquiv : FractionalIdeal S P ≃+* FractionalIdeal S P' 
goal: FractionalIdeal S P ≃+* FractionalIdeal S P'

full_name: FractionalIdeal.canonicalEquiv
code: /-- `canonicalEquiv f f'` is the canonical equivalence between the fractional
ideals in `P` and in `P'`, which are both localizations of `R` at `S`. -/
noncomputable irreducible_def canonicalEquiv : FractionalIdeal S P ≃+* FractionalIdeal S P' 
goal: FractionalIdeal S P ≃+* FractionalIdeal S P'

full_name: FractionalIdeal.canonicalEquiv_def
code: /-- `canonicalEquiv f f'` is the canonical equivalence between the fractional
ideals in `P` and in `P'`, which are both localizations of `R` at `S`. -/
noncomputable irreducible_def canonicalEquiv : FractionalIdeal S P ≃+* FractionalIdeal S P' 
goal: FractionalIdeal.canonicalEquiv S P P' =
  FractionalIdeal.mapEquiv
    (let __src := IsLocalization.ringEquivOfRingEquiv P P' (RingEquiv.refl R) ⋯;
    { toEquiv := __src.toEquiv, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ })

full_name: FractionalIdeal.mem_canonicalEquiv_apply
code: @[simp]
theorem mem_canonicalEquiv_apply {I : FractionalIdeal S P} {x : P'} :
    x ∈ canonicalEquiv S P P' I ↔
      ∃ y ∈ I,
        IsLocalization.map P' (RingHom.id R) (fun y (hy : y ∈ S) => show RingHom.id R y ∈ S from hy)
            (y : P) =
          x 
goal: x ∈ (FractionalIdeal.canonicalEquiv S P P') I ↔ ∃ y ∈ I, (IsLocalization.map P' (RingHom.id R) ⋯) y = x

full_name: FractionalIdeal.canonicalEquiv_symm
code: @[simp]
theorem canonicalEquiv_symm : (canonicalEquiv S P P').symm = canonicalEquiv S P' P 
goal: (FractionalIdeal.canonicalEquiv S P P').symm = FractionalIdeal.canonicalEquiv S P' P

full_name: FractionalIdeal.canonicalEquiv_flip
code: theorem canonicalEquiv_flip (I) : canonicalEquiv S P P' (canonicalEquiv S P' P I) = I 
goal: (FractionalIdeal.canonicalEquiv S P P') ((FractionalIdeal.canonicalEquiv S P' P) I) = I

full_name: FractionalIdeal.canonicalEquiv_canonicalEquiv
code: @[simp]
theorem canonicalEquiv_canonicalEquiv (P'' : Type*) [CommRing P''] [Algebra R P'']
    [IsLocalization S P''] (I : FractionalIdeal S P) :
    canonicalEquiv S P' P'' (canonicalEquiv S P P' I) = canonicalEquiv S P P'' I 
goal: (FractionalIdeal.canonicalEquiv S P' P'') ((FractionalIdeal.canonicalEquiv S P P') I) =
  (FractionalIdeal.canonicalEquiv S P P'') I

full_name: FractionalIdeal.canonicalEquiv_trans_canonicalEquiv
code: theorem canonicalEquiv_trans_canonicalEquiv (P'' : Type*) [CommRing P''] [Algebra R P'']
    [IsLocalization S P''] :
    (canonicalEquiv S P P').trans (canonicalEquiv S P' P'') = canonicalEquiv S P P'' 
goal: (FractionalIdeal.canonicalEquiv S P P').trans (FractionalIdeal.canonicalEquiv S P' P'') =
  FractionalIdeal.canonicalEquiv S P P''

full_name: FractionalIdeal.canonicalEquiv_coeIdeal
code: @[simp]
theorem canonicalEquiv_coeIdeal (I : Ideal R) : canonicalEquiv S P P' I = I 
goal: (FractionalIdeal.canonicalEquiv S P P') ↑I = ↑I

full_name: FractionalIdeal.canonicalEquiv_self
code: @[simp]
theorem canonicalEquiv_self : canonicalEquiv S P P = RingEquiv.refl _ 
goal: FractionalIdeal.canonicalEquiv S P P = RingEquiv.refl (FractionalIdeal S P)

full_name: FractionalIdeal.exists_ne_zero_mem_isInteger
code: /-- Nonzero fractional ideals contain a nonzero integer. -/
theorem exists_ne_zero_mem_isInteger [Nontrivial R] (hI : I ≠ 0) :
    ∃ x, x ≠ 0 ∧ algebraMap R K x ∈ I 
goal: ∃ x, x ≠ 0 ∧ (algebraMap R K) x ∈ I

full_name: FractionalIdeal.map_ne_zero
code: theorem map_ne_zero [Nontrivial R] (hI : I ≠ 0) : I.map h ≠ 0 
goal: FractionalIdeal.map h I ≠ 0

full_name: FractionalIdeal.map_eq_zero_iff
code: @[simp]
theorem map_eq_zero_iff [Nontrivial R] : I.map h = 0 ↔ I = 0 
goal: FractionalIdeal.map h I = 0 ↔ I = 0

full_name: FractionalIdeal.coeIdeal_injective
code: theorem coeIdeal_injective : Function.Injective (fun (I : Ideal R) ↦ (I : FractionalIdeal R⁰ K)) 
goal: Function.Injective fun I => ↑I

full_name: FractionalIdeal.coeIdeal_inj
code: theorem coeIdeal_inj {I J : Ideal R} :
    (I : FractionalIdeal R⁰ K) = (J : FractionalIdeal R⁰ K) ↔ I = J 
goal: ↑I = ↑J ↔ I = J

full_name: FractionalIdeal.coeIdeal_eq_zero
code: @[simp]
theorem coeIdeal_eq_zero {I : Ideal R} : (I : FractionalIdeal R⁰ K) = 0 ↔ I = ⊥ 
goal: ↑I = 0 ↔ I = ⊥

full_name: FractionalIdeal.coeIdeal_ne_zero
code: theorem coeIdeal_ne_zero {I : Ideal R} : (I : FractionalIdeal R⁰ K) ≠ 0 ↔ I ≠ ⊥ 
goal: ↑I ≠ 0 ↔ I ≠ ⊥

full_name: FractionalIdeal.coeIdeal_eq_one
code: @[simp]
theorem coeIdeal_eq_one {I : Ideal R} : (I : FractionalIdeal R⁰ K) = 1 ↔ I = 1 
goal: ↑I = 1 ↔ I = 1

full_name: FractionalIdeal.coeIdeal_ne_one
code: theorem coeIdeal_ne_one {I : Ideal R} : (I : FractionalIdeal R⁰ K) ≠ 1 ↔ I ≠ 1 
goal: ↑I ≠ 1 ↔ I ≠ 1

full_name: FractionalIdeal.num_eq_zero_iff
code: theorem num_eq_zero_iff [Nontrivial R] {I : FractionalIdeal R⁰ K} : I.num = 0 ↔ I = 0 
goal: I.num = 0 ↔ I = 0

full_name: FractionalIdeal.instNontrivialNonZeroDivisors
code: instance : Nontrivial (FractionalIdeal R₁⁰ K) 
goal: Nontrivial (FractionalIdeal R₁⁰ K)

full_name: FractionalIdeal.ne_zero_of_mul_eq_one
code: theorem ne_zero_of_mul_eq_one (I J : FractionalIdeal R₁⁰ K) (h : I * J = 1) : I ≠ 0 
goal: I ≠ 0

full_name: IsFractional.div_of_nonzero
code: theorem _root_.IsFractional.div_of_nonzero {I J : Submodule R₁ K} :
    IsFractional R₁⁰ I → IsFractional R₁⁰ J → J ≠ 0 → IsFractional R₁⁰ (I / J)
  
goal: IsFractional R₁⁰ I → IsFractional R₁⁰ J → J ≠ 0 → IsFractional R₁⁰ (I / J)

full_name: FractionalIdeal.fractional_div_of_nonzero
code: theorem fractional_div_of_nonzero {I J : FractionalIdeal R₁⁰ K} (h : J ≠ 0) :
    IsFractional R₁⁰ (I / J : Submodule R₁ K) 
goal: IsFractional R₁⁰ (↑I / ↑J)

full_name: FractionalIdeal.instDivNonZeroDivisors
code: noncomputable instance : Div (FractionalIdeal R₁⁰ K) 
goal: Div (FractionalIdeal R₁⁰ K)

full_name: FractionalIdeal.div_zero
code: @[simp]
theorem div_zero {I : FractionalIdeal R₁⁰ K} : I / 0 = 0 
goal: I / 0 = 0

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

full_name: FractionalIdeal.coe_div
code: @[simp]
theorem coe_div {I J : FractionalIdeal R₁⁰ K} (hJ : J ≠ 0) :
    (↑(I / J) : Submodule R₁ K) = ↑I / (↑J : Submodule R₁ K) 
goal: ↑(I / J) = ↑I / ↑J

full_name: FractionalIdeal.mem_div_iff_of_nonzero
code: theorem mem_div_iff_of_nonzero {I J : FractionalIdeal R₁⁰ K} (h : J ≠ 0) {x} :
    x ∈ I / J ↔ ∀ y ∈ J, x * y ∈ I 
goal: x ∈ I / J ↔ ∀ y ∈ J, x * y ∈ I

full_name: FractionalIdeal.mul_one_div_le_one
code: theorem mul_one_div_le_one {I : FractionalIdeal R₁⁰ K} : I * (1 / I) ≤ 1 
goal: I * (1 / I) ≤ 1

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

full_name: FractionalIdeal.le_div_iff_of_nonzero
code: theorem le_div_iff_of_nonzero {I J J' : FractionalIdeal R₁⁰ K} (hJ' : J' ≠ 0) :
    I ≤ J / J' ↔ ∀ x ∈ I, ∀ y ∈ J', x * y ∈ J 
goal: I ≤ J / J' ↔ ∀ x ∈ I, ∀ y ∈ J', x * y ∈ J

full_name: FractionalIdeal.le_div_iff_mul_le
code: theorem le_div_iff_mul_le {I J J' : FractionalIdeal R₁⁰ K} (hJ' : J' ≠ 0) :
    I ≤ J / J' ↔ I * J' ≤ J 
goal: I ≤ J / J' ↔ I * J' ≤ J

full_name: FractionalIdeal.div_one
code: @[simp]
theorem div_one {I : FractionalIdeal R₁⁰ K} : I / 1 = I 
goal: I / 1 = I

full_name: FractionalIdeal.eq_one_div_of_mul_eq_one_right
code: theorem eq_one_div_of_mul_eq_one_right (I J : FractionalIdeal R₁⁰ K) (h : I * J = 1) :
    J = 1 / I 
goal: J = 1 / I

full_name: FractionalIdeal.mul_div_self_cancel_iff
code: theorem mul_div_self_cancel_iff {I : FractionalIdeal R₁⁰ K} : I * (1 / I) = 1 ↔ ∃ J, I * J = 1 
goal: I * (1 / I) = 1 ↔ ∃ J, I * J = 1

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

full_name: FractionalIdeal.map_one_div
code: theorem map_one_div (I : FractionalIdeal R₁⁰ K) (h : K ≃ₐ[R₁] K') :
    (1 / I).map (h : K →ₐ[R₁] K') = 1 / I.map h 
goal: FractionalIdeal.map (↑h) (1 / I) = 1 / FractionalIdeal.map (↑h) I

full_name: FractionalIdeal.eq_zero_or_one
code: theorem eq_zero_or_one (I : FractionalIdeal K⁰ L) : I = 0 ∨ I = 1 
goal: I = 0 ∨ I = 1

full_name: FractionalIdeal.eq_zero_or_one_of_isField
code: theorem eq_zero_or_one_of_isField (hF : IsField R₁) (I : FractionalIdeal R₁⁰ K) : I = 0 ∨ I = 1 
goal: I = 0 ∨ I = 1

full_name: FractionalIdeal.spanFinset
code: /-- `FractionalIdeal.span_finset R₁ s f` is the fractional ideal of `R₁` generated by `f '' s`. -/
-- Porting note: `@[simps]` generated a `Subtype.val` coercion instead of a
-- `FractionalIdeal.coeToSubmodule` coercion
def spanFinset {ι : Type*} (s : Finset ι) (f : ι → K) : FractionalIdeal R₁⁰ K 
goal: FractionalIdeal R₁⁰ K

full_name: FractionalIdeal.spanFinset_coe
code: @[simp] lemma spanFinset_coe {ι : Type*} (s : Finset ι) (f : ι → K) :
    (spanFinset R₁ s f : Submodule R₁ K) = Submodule.span R₁ (f '' s) 
goal: ↑(FractionalIdeal.spanFinset R₁ s f) = Submodule.span R₁ (f '' ↑s)

full_name: FractionalIdeal.spanFinset_eq_zero
code: @[simp]
theorem spanFinset_eq_zero {ι : Type*} {s : Finset ι} {f : ι → K} :
    spanFinset R₁ s f = 0 ↔ ∀ j ∈ s, f j = 0 
goal: FractionalIdeal.spanFinset R₁ s f = 0 ↔ ∀ j ∈ s, f j = 0

full_name: FractionalIdeal.spanFinset_ne_zero
code: theorem spanFinset_ne_zero {ι : Type*} {s : Finset ι} {f : ι → K} :
    spanFinset R₁ s f ≠ 0 ↔ ∃ j ∈ s, f j ≠ 0 
goal: FractionalIdeal.spanFinset R₁ s f ≠ 0 ↔ ∃ j ∈ s, f j ≠ 0

full_name: FractionalIdeal.isFractional_span_singleton
code: theorem isFractional_span_singleton (x : P) : IsFractional S (span R {x} : Submodule R P) 
goal: IsFractional S (Submodule.span R {x})

full_name: FractionalIdeal.wrapped._@.Mathlib.RingTheory.FractionalIdeal.Operations._hyg.10368
code: /-- `spanSingleton x` is the fractional ideal generated by `x` if `0 ∉ S` -/
irreducible_def spanSingleton (x : P) : FractionalIdeal S P 
goal: Subtype (Eq @FractionalIdeal.definition✝)

full_name: FractionalIdeal.spanSingleton_def
code: /-- `spanSingleton x` is the fractional ideal generated by `x` if `0 ∉ S` -/
irreducible_def spanSingleton (x : P) : FractionalIdeal S P 
goal: FractionalIdeal.spanSingleton S x = ⟨Submodule.span R {x}, ⋯⟩

full_name: FractionalIdeal.definition._@.Mathlib.RingTheory.FractionalIdeal.Operations._hyg.10368
code: /-- `spanSingleton x` is the fractional ideal generated by `x` if `0 ∉ S` -/
irreducible_def spanSingleton (x : P) : FractionalIdeal S P 
goal: FractionalIdeal S P

full_name: FractionalIdeal.spanSingleton
code: /-- `spanSingleton x` is the fractional ideal generated by `x` if `0 ∉ S` -/
irreducible_def spanSingleton (x : P) : FractionalIdeal S P 
goal: FractionalIdeal S P

full_name: FractionalIdeal.coe_spanSingleton
code: @[simp]
theorem coe_spanSingleton (x : P) : (spanSingleton S x : Submodule R P) = span R {x} 
goal: ↑(FractionalIdeal.spanSingleton S x) = Submodule.span R {x}

full_name: FractionalIdeal.mem_spanSingleton
code: @[simp]
theorem mem_spanSingleton {x y : P} : x ∈ spanSingleton S y ↔ ∃ z : R, z • y = x 
goal: x ∈ FractionalIdeal.spanSingleton S y ↔ ∃ z, z • y = x

full_name: FractionalIdeal.mem_spanSingleton_self
code: theorem mem_spanSingleton_self (x : P) : x ∈ spanSingleton S x 
goal: x ∈ FractionalIdeal.spanSingleton S x

full_name: FractionalIdeal.den_mul_self_eq_num'
code: /-- A version of `FractionalIdeal.den_mul_self_eq_num` in terms of fractional ideals. -/
theorem den_mul_self_eq_num' (I : FractionalIdeal S P) :
    spanSingleton S (algebraMap R P I.den) * I = I.num 
goal: FractionalIdeal.spanSingleton S ((algebraMap R P) ↑I.den) * I = ↑I.num

full_name: FractionalIdeal.spanSingleton_le_iff_mem
code: @[simp]
theorem spanSingleton_le_iff_mem {x : P} {I : FractionalIdeal S P} :
    spanSingleton S x ≤ I ↔ x ∈ I 
goal: FractionalIdeal.spanSingleton S x ≤ I ↔ x ∈ I

full_name: FractionalIdeal.spanSingleton_eq_spanSingleton
code: theorem spanSingleton_eq_spanSingleton [NoZeroSMulDivisors R P] {x y : P} :
    spanSingleton S x = spanSingleton S y ↔ ∃ z : Rˣ, z • x = y 
goal: FractionalIdeal.spanSingleton S x = FractionalIdeal.spanSingleton S y ↔ ∃ z, z • x = y

full_name: FractionalIdeal.eq_spanSingleton_of_principal
code: theorem eq_spanSingleton_of_principal (I : FractionalIdeal S P) [IsPrincipal (I : Submodule R P)] :
    I = spanSingleton S (generator (I : Submodule R P)) 
goal: I = FractionalIdeal.spanSingleton S (Submodule.IsPrincipal.generator ↑I)

full_name: FractionalIdeal.isPrincipal_iff
code: theorem isPrincipal_iff (I : FractionalIdeal S P) :
    IsPrincipal (I : Submodule R P) ↔ ∃ x, I = spanSingleton S x 
goal: (↑I).IsPrincipal ↔ ∃ x, I = FractionalIdeal.spanSingleton S x

full_name: FractionalIdeal.spanSingleton_zero
code: @[simp]
theorem spanSingleton_zero : spanSingleton S (0 : P) = 0 
goal: FractionalIdeal.spanSingleton S 0 = 0

full_name: FractionalIdeal.spanSingleton_eq_zero_iff
code: theorem spanSingleton_eq_zero_iff {y : P} : spanSingleton S y = 0 ↔ y = 0 
goal: FractionalIdeal.spanSingleton S y = 0 ↔ y = 0

full_name: FractionalIdeal.spanSingleton_ne_zero_iff
code: theorem spanSingleton_ne_zero_iff {y : P} : spanSingleton S y ≠ 0 ↔ y ≠ 0 
goal: FractionalIdeal.spanSingleton S y ≠ 0 ↔ y ≠ 0

full_name: FractionalIdeal.spanSingleton_one
code: @[simp]
theorem spanSingleton_one : spanSingleton S (1 : P) = 1 
goal: FractionalIdeal.spanSingleton S 1 = 1

full_name: FractionalIdeal.spanSingleton_mul_spanSingleton
code: @[simp]
theorem spanSingleton_mul_spanSingleton (x y : P) :
    spanSingleton S x * spanSingleton S y = spanSingleton S (x * y) 
goal: FractionalIdeal.spanSingleton S x * FractionalIdeal.spanSingleton S y = FractionalIdeal.spanSingleton S (x * y)

full_name: FractionalIdeal.spanSingleton_pow
code: @[simp]
theorem spanSingleton_pow (x : P) (n : ℕ) : spanSingleton S x ^ n = spanSingleton S (x ^ n) 
goal: FractionalIdeal.spanSingleton S x ^ n = FractionalIdeal.spanSingleton S (x ^ n)

full_name: FractionalIdeal.coeIdeal_span_singleton
code: @[simp]
theorem coeIdeal_span_singleton (x : R) :
    (↑(Ideal.span {x} : Ideal R) : FractionalIdeal S P) = spanSingleton S (algebraMap R P x) 
goal: ↑(Ideal.span {x}) = FractionalIdeal.spanSingleton S ((algebraMap R P) x)

full_name: FractionalIdeal.canonicalEquiv_spanSingleton
code: @[simp]
theorem canonicalEquiv_spanSingleton {P'} [CommRing P'] [Algebra R P'] [IsLocalization S P']
    (x : P) :
    canonicalEquiv S P P' (spanSingleton S x) =
      spanSingleton S
        (IsLocalization.map P' (RingHom.id R)
          (fun y (hy : y ∈ S) => show RingHom.id R y ∈ S from hy) x) 
goal: (FractionalIdeal.canonicalEquiv S P P') (FractionalIdeal.spanSingleton S x) =
  FractionalIdeal.spanSingleton S ((IsLocalization.map P' (RingHom.id R) ⋯) x)

full_name: FractionalIdeal.mem_singleton_mul
code: theorem mem_singleton_mul {x y : P} {I : FractionalIdeal S P} :
    y ∈ spanSingleton S x * I ↔ ∃ y' ∈ I, y = x * y' 
goal: y ∈ FractionalIdeal.spanSingleton S x * I ↔ ∃ y' ∈ I, y = x * y'

full_name: FractionalIdeal.mk'_mul_coeIdeal_eq_coeIdeal
code: theorem mk'_mul_coeIdeal_eq_coeIdeal {I J : Ideal R₁} {x y : R₁} (hy : y ∈ R₁⁰) :
    spanSingleton R₁⁰ (IsLocalization.mk' K x ⟨y, hy⟩) * I = (J : FractionalIdeal R₁⁰ K) ↔
      Ideal.span {x} * I = Ideal.span {y} * J 
goal: FractionalIdeal.spanSingleton R₁⁰ (IsLocalization.mk' K x ⟨y, hy⟩) * ↑I = ↑J ↔ Ideal.span {x} * I = Ideal.span {y} * J

full_name: FractionalIdeal.spanSingleton_mul_coeIdeal_eq_coeIdeal
code: theorem spanSingleton_mul_coeIdeal_eq_coeIdeal {I J : Ideal R₁} {z : K} :
    spanSingleton R₁⁰ z * (I : FractionalIdeal R₁⁰ K) = J ↔
      Ideal.span {((IsLocalization.sec R₁⁰ z).1 : R₁)} * I =
        Ideal.span {((IsLocalization.sec R₁⁰ z).2 : R₁)} * J 
goal: FractionalIdeal.spanSingleton R₁⁰ z * ↑I = ↑J ↔
  Ideal.span {(IsLocalization.sec R₁⁰ z).1} * I = Ideal.span {↑(IsLocalization.sec R₁⁰ z).2} * J

full_name: FractionalIdeal.one_div_spanSingleton
code: theorem one_div_spanSingleton (x : K) : 1 / spanSingleton R₁⁰ x = spanSingleton R₁⁰ x⁻¹ 
goal: 1 / FractionalIdeal.spanSingleton R₁⁰ x = FractionalIdeal.spanSingleton R₁⁰ x⁻¹

full_name: FractionalIdeal.div_spanSingleton
code: @[simp]
theorem div_spanSingleton (J : FractionalIdeal R₁⁰ K) (d : K) :
    J / spanSingleton R₁⁰ d = spanSingleton R₁⁰ d⁻¹ * J 
goal: J / FractionalIdeal.spanSingleton R₁⁰ d = FractionalIdeal.spanSingleton R₁⁰ d⁻¹ * J

full_name: FractionalIdeal.exists_eq_spanSingleton_mul
code: theorem exists_eq_spanSingleton_mul (I : FractionalIdeal R₁⁰ K) :
    ∃ (a : R₁) (aI : Ideal R₁), a ≠ 0 ∧ I = spanSingleton R₁⁰ (algebraMap R₁ K a)⁻¹ * aI 
goal: ∃ a aI, a ≠ 0 ∧ I = FractionalIdeal.spanSingleton R₁⁰ ((algebraMap R₁ K) a)⁻¹ * ↑aI

full_name: FractionalIdeal.ideal_factor_ne_zero
code: /-- If `I` is a nonzero fractional ideal, `a ∈ R`, and `J` is an ideal of `R` such that
`I = a⁻¹J`, then `J` is nonzero. -/
theorem ideal_factor_ne_zero {R} [CommRing R] {K : Type*} [Field K] [Algebra R K]
    [IsFractionRing R K] {I : FractionalIdeal R⁰ K} (hI : I ≠ 0) {a : R} {J : Ideal R}
    (haJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J) : J ≠ 0 
goal: J ≠ 0

full_name: FractionalIdeal.constant_factor_ne_zero
code: /-- If `I` is a nonzero fractional ideal, `a ∈ R`, and `J` is an ideal of `R` such that
`I = a⁻¹J`, then `a` is nonzero. -/
theorem constant_factor_ne_zero {R} [CommRing R] {K : Type*} [Field K] [Algebra R K]
    [IsFractionRing R K] {I : FractionalIdeal R⁰ K} (hI : I ≠ 0) {a : R} {J : Ideal R}
    (haJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J) :
    (Ideal.span {a} : Ideal R) ≠ 0 
goal: Ideal.span {a} ≠ 0

full_name: FractionalIdeal.isPrincipal
code: instance isPrincipal {R} [CommRing R] [IsDomain R] [IsPrincipalIdealRing R] [Algebra R K]
    [IsFractionRing R K] (I : FractionalIdeal R⁰ K) : (I : Submodule R K).IsPrincipal 
goal: (↑I).IsPrincipal

full_name: FractionalIdeal.le_spanSingleton_mul_iff
code: theorem le_spanSingleton_mul_iff {x : P} {I J : FractionalIdeal S P} :
    I ≤ spanSingleton S x * J ↔ ∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI 
goal: I ≤ FractionalIdeal.spanSingleton S x * J ↔ ∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI

full_name: FractionalIdeal.spanSingleton_mul_le_iff
code: theorem spanSingleton_mul_le_iff {x : P} {I J : FractionalIdeal S P} :
    spanSingleton _ x * I ≤ J ↔ ∀ z ∈ I, x * z ∈ J 
goal: FractionalIdeal.spanSingleton S x * I ≤ J ↔ ∀ z ∈ I, x * z ∈ J

full_name: FractionalIdeal.eq_spanSingleton_mul
code: theorem eq_spanSingleton_mul {x : P} {I J : FractionalIdeal S P} :
    I = spanSingleton _ x * J ↔ (∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI) ∧ ∀ z ∈ J, x * z ∈ I 
goal: I = FractionalIdeal.spanSingleton S x * J ↔ (∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI) ∧ ∀ z ∈ J, x * z ∈ I

full_name: FractionalIdeal.num_le
code: theorem num_le (I : FractionalIdeal S P) :
    (I.num : FractionalIdeal S P) ≤ I 
goal: ↑I.num ≤ I

full_name: FractionalIdeal.isNoetherian_zero
code: theorem isNoetherian_zero : IsNoetherian R₁ (0 : FractionalIdeal R₁⁰ K) 
goal: IsNoetherian R₁ ↥↑0

full_name: FractionalIdeal.isNoetherian_iff
code: theorem isNoetherian_iff {I : FractionalIdeal R₁⁰ K} :
    IsNoetherian R₁ I ↔ ∀ J ≤ I, (J : Submodule R₁ K).FG 
goal: IsNoetherian R₁ ↥↑I ↔ ∀ J ≤ I, (↑J).FG

full_name: FractionalIdeal.isNoetherian_coeIdeal
code: theorem isNoetherian_coeIdeal [IsNoetherianRing R₁] (I : Ideal R₁) :
    IsNoetherian R₁ (I : FractionalIdeal R₁⁰ K) 
goal: IsNoetherian R₁ ↥↑↑I

full_name: FractionalIdeal.isNoetherian_spanSingleton_inv_to_map_mul
code: theorem isNoetherian_spanSingleton_inv_to_map_mul (x : R₁) {I : FractionalIdeal R₁⁰ K}
    (hI : IsNoetherian R₁ I) :
    IsNoetherian R₁ (spanSingleton R₁⁰ (algebraMap R₁ K x)⁻¹ * I : FractionalIdeal R₁⁰ K) 
goal: IsNoetherian R₁ ↥↑(FractionalIdeal.spanSingleton R₁⁰ ((algebraMap R₁ K) x)⁻¹ * I)

full_name: FractionalIdeal.isNoetherian
code: /-- Every fractional ideal of a noetherian integral domain is noetherian. -/
theorem isNoetherian [IsNoetherianRing R₁] (I : FractionalIdeal R₁⁰ K) : IsNoetherian R₁ I 
goal: IsNoetherian R₁ ↥↑I

full_name: FractionalIdeal.isFractional_adjoin_integral
code: /-- `A[x]` is a fractional ideal for every integral `x`. -/
theorem isFractional_adjoin_integral :
    IsFractional S (Subalgebra.toSubmodule (Algebra.adjoin R ({x} : Set P))) 
goal: IsFractional S (Subalgebra.toSubmodule (Algebra.adjoin R {x}))

full_name: FractionalIdeal.adjoinIntegral
code: /-- `FractionalIdeal.adjoinIntegral (S : Submonoid R) x hx` is `R[x]` as a fractional ideal,
where `hx` is a proof that `x : P` is integral over `R`. -/
-- Porting note: `@[simps]` generated a `Subtype.val` coercion instead of a
-- `FractionalIdeal.coeToSubmodule` coercion
def adjoinIntegral : FractionalIdeal S P 
goal: FractionalIdeal S P

full_name: FractionalIdeal.adjoinIntegral_coe
code: @[simp]
theorem adjoinIntegral_coe :
    (adjoinIntegral S x hx : Submodule R P) =
      (Subalgebra.toSubmodule (Algebra.adjoin R ({x} : Set P))) 
goal: ↑(FractionalIdeal.adjoinIntegral S x hx) = Subalgebra.toSubmodule (Algebra.adjoin R {x})

full_name: FractionalIdeal.mem_adjoinIntegral_self
code: theorem mem_adjoinIntegral_self : x ∈ adjoinIntegral S x hx 
goal: x ∈ FractionalIdeal.adjoinIntegral S x hx