File: Mathlib/RingTheory/FractionalIdeal/Basic.lean

full_name: IsFractional
code: /-- A submodule `I` is a fractional ideal if `a I ⊆ R` for some `a ≠ 0`. -/
def IsFractional (I : Submodule R P) 
goal: Prop

full_name: FractionalIdeal
code: /-- The fractional ideals of a domain `R` are ideals of `R` divided by some `a ∈ R`.

More precisely, let `P` be a localization of `R` at some submonoid `S`,
then a fractional ideal `I ⊆ P` is an `R`-submodule of `P`,
such that there is a nonzero `a : R` with `a I ⊆ R`.
-/
def FractionalIdeal 
goal: Type u_2

full_name: FractionalIdeal.coeToSubmodule
code: /-- Map a fractional ideal `I` to a submodule by forgetting that `∃ a, a I ⊆ R`.

This implements the coercion `FractionalIdeal S P → Submodule R P`.
-/
@[coe]
def coeToSubmodule (I : FractionalIdeal S P) : Submodule R P 
goal: Submodule R P

full_name: FractionalIdeal.instCoeOutSubmodule
code: /-- Map a fractional ideal `I` to a submodule by forgetting that `∃ a, a I ⊆ R`.

This coercion is typically called `coeToSubmodule` in lemma names
(or `coe` when the coercion is clear from the context),
not to be confused with `IsLocalization.coeSubmodule : Ideal R → Submodule R P`
(which we use to define `coe : Ideal R → FractionalIdeal S P`).
-/
instance : CoeOut (FractionalIdeal S P) (Submodule R P) 
goal: CoeOut (FractionalIdeal S P) (Submodule R P)

full_name: FractionalIdeal.isFractional
code: protected theorem isFractional (I : FractionalIdeal S P) : IsFractional S (I : Submodule R P) 
goal: IsFractional S ↑I

full_name: FractionalIdeal.den
code: /-- An element of `S` such that `I.den • I = I.num`, see `FractionalIdeal.num` and
`FractionalIdeal.den_mul_self_eq_num`. -/
noncomputable def den (I : FractionalIdeal S P) : S 
goal: ↥S

full_name: FractionalIdeal.num
code: /-- An ideal of `R` such that `I.den • I = I.num`, see `FractionalIdeal.den` and
`FractionalIdeal.den_mul_self_eq_num`. -/
noncomputable def num (I : FractionalIdeal S P) : Ideal R 
goal: Ideal R

full_name: FractionalIdeal.den_mul_self_eq_num
code: theorem den_mul_self_eq_num (I : FractionalIdeal S P) :
    I.den • (I : Submodule R P) = Submodule.map (Algebra.linearMap R P) I.num 
goal: I.den • ↑I = Submodule.map (Algebra.linearMap R P) I.num

full_name: FractionalIdeal.equivNum
code: /-- The linear equivalence between the fractional ideal `I` and the integral ideal `I.num`
defined by mapping `x` to `den I • x`. -/
noncomputable def equivNum [Nontrivial P] [NoZeroSMulDivisors R P]
    {I : FractionalIdeal S P} (h_nz : (I.den : R) ≠ 0) : I ≃ₗ[R] I.num 
goal: ↥↑I ≃ₗ[R] ↥I.num

full_name: FractionalIdeal.instSetLike
code: instance : SetLike (FractionalIdeal S P) P 
goal: SetLike (FractionalIdeal S P) P

full_name: FractionalIdeal.mem_coe
code: @[simp]
theorem mem_coe {I : FractionalIdeal S P} {x : P} : x ∈ (I : Submodule R P) ↔ x ∈ I 
goal: x ∈ ↑I ↔ x ∈ I

full_name: FractionalIdeal.ext
code: @[ext]
theorem ext {I J : FractionalIdeal S P} : (∀ x, x ∈ I ↔ x ∈ J) → I = J 
goal: (∀ (x : P), x ∈ I ↔ x ∈ J) → I = J

full_name: FractionalIdeal.equivNum_apply
code: @[simp]
 theorem equivNum_apply [Nontrivial P] [NoZeroSMulDivisors R P] {I : FractionalIdeal S P}
    (h_nz : (I.den : R) ≠ 0) (x : I) :
    algebraMap R P (equivNum h_nz x) = I.den • x 
goal: (algebraMap R P) ↑((FractionalIdeal.equivNum h_nz) x) = I.den • ↑x

full_name: FractionalIdeal.copy
code: /-- Copy of a `FractionalIdeal` with a new underlying set equal to the old one.
Useful to fix definitional equalities. -/
protected def copy (p : FractionalIdeal S P) (s : Set P) (hs : s = ↑p) : FractionalIdeal S P 
goal: FractionalIdeal S P

full_name: FractionalIdeal.coe_copy
code: @[simp]
theorem coe_copy (p : FractionalIdeal S P) (s : Set P) (hs : s = ↑p) : ↑(p.copy s hs) = s 
goal: ↑(p.copy s hs) = s

full_name: FractionalIdeal.coe_eq
code: theorem coe_eq (p : FractionalIdeal S P) (s : Set P) (hs : s = ↑p) : p.copy s hs = p 
goal: p.copy s hs = p

full_name: FractionalIdeal.zero_mem
code: lemma zero_mem (I : FractionalIdeal S P) : 0 ∈ I 
goal: 0 ∈ I

full_name: FractionalIdeal.val_eq_coe
code: @[simp]
theorem val_eq_coe (I : FractionalIdeal S P) : I.val = I 
goal: ↑I = ↑I

full_name: FractionalIdeal.coe_mk
code: @[simp, norm_cast]
theorem coe_mk (I : Submodule R P) (hI : IsFractional S I) :
    coeToSubmodule ⟨I, hI⟩ = I 
goal: ↑⟨I, hI⟩ = I

full_name: FractionalIdeal.coeToSet_coeToSubmodule
code: theorem coeToSet_coeToSubmodule (I : FractionalIdeal S P) :
    ((I : Submodule R P) : Set P) = I 
goal: ↑↑I = ↑I

full_name: FractionalIdeal.instModuleSubtypeMemSubmoduleCoeToSubmodule
code: instance (I : FractionalIdeal S P) : Module R I 
goal: Module R ↥↑I

full_name: FractionalIdeal.coeToSubmodule_injective
code: theorem coeToSubmodule_injective :
    Function.Injective (fun (I : FractionalIdeal S P) ↦ (I : Submodule R P)) 
goal: Function.Injective fun I => ↑I

full_name: FractionalIdeal.coeToSubmodule_inj
code: theorem coeToSubmodule_inj {I J : FractionalIdeal S P} : (I : Submodule R P) = J ↔ I = J 
goal: ↑I = ↑J ↔ I = J

full_name: FractionalIdeal.isFractional_of_le_one
code: theorem isFractional_of_le_one (I : Submodule R P) (h : I ≤ 1) : IsFractional S I 
goal: IsFractional S I

full_name: FractionalIdeal.isFractional_of_le
code: theorem isFractional_of_le {I : Submodule R P} {J : FractionalIdeal S P} (hIJ : I ≤ J) :
    IsFractional S I 
goal: IsFractional S I

full_name: FractionalIdeal.coeIdeal
code: /-- Map an ideal `I` to a fractional ideal by forgetting `I` is integral.

This is the function that implements the coercion `Ideal R → FractionalIdeal S P`. -/
@[coe]
def coeIdeal (I : Ideal R) : FractionalIdeal S P 
goal: FractionalIdeal S P

full_name: FractionalIdeal.instCoeTCIdeal
code: /-- Map an ideal `I` to a fractional ideal by forgetting `I` is integral.

This is a bundled version of `IsLocalization.coeSubmodule : Ideal R → Submodule R P`,
which is not to be confused with the `coe : FractionalIdeal S P → Submodule R P`,
also called `coeToSubmodule` in theorem names.

This map is available as a ring hom, called `FractionalIdeal.coeIdealHom`.
-/
instance : CoeTC (Ideal R) (FractionalIdeal S P) 
goal: CoeTC (Ideal R) (FractionalIdeal S P)

full_name: FractionalIdeal.coe_coeIdeal
code: @[simp, norm_cast]
theorem coe_coeIdeal (I : Ideal R) :
    ((I : FractionalIdeal S P) : Submodule R P) = coeSubmodule P I 
goal: ↑↑I = IsLocalization.coeSubmodule P I

full_name: FractionalIdeal.mem_coeIdeal
code: @[simp]
theorem mem_coeIdeal {x : P} {I : Ideal R} :
    x ∈ (I : FractionalIdeal S P) ↔ ∃ x', x' ∈ I ∧ algebraMap R P x' = x 
goal: x ∈ ↑I ↔ ∃ x' ∈ I, (algebraMap R P) x' = x

full_name: FractionalIdeal.mem_coeIdeal_of_mem
code: theorem mem_coeIdeal_of_mem {x : R} {I : Ideal R} (hx : x ∈ I) :
    algebraMap R P x ∈ (I : FractionalIdeal S P) 
goal: (algebraMap R P) x ∈ ↑I

full_name: FractionalIdeal.coeIdeal_le_coeIdeal'
code: theorem coeIdeal_le_coeIdeal' [IsLocalization S P] (h : S ≤ nonZeroDivisors R) {I J : Ideal R} :
    (I : FractionalIdeal S P) ≤ J ↔ I ≤ J 
goal: ↑I ≤ ↑J ↔ I ≤ J

full_name: FractionalIdeal.coeIdeal_le_coeIdeal
code: @[simp]
theorem coeIdeal_le_coeIdeal (K : Type*) [CommRing K] [Algebra R K] [IsFractionRing R K]
    {I J : Ideal R} : (I : FractionalIdeal R⁰ K) ≤ J ↔ I ≤ J 
goal: ↑I ≤ ↑J ↔ I ≤ J

full_name: FractionalIdeal.instZero
code: instance : Zero (FractionalIdeal S P) 
goal: Zero (FractionalIdeal S P)

full_name: FractionalIdeal.mem_zero_iff
code: @[simp]
theorem mem_zero_iff {x : P} : x ∈ (0 : FractionalIdeal S P) ↔ x = 0 
goal: x ∈ 0 ↔ x = 0

full_name: FractionalIdeal.coe_zero
code: @[simp, norm_cast]
theorem coe_zero : ↑(0 : FractionalIdeal S P) = (⊥ : Submodule R P) 
goal: ↑0 = ⊥

full_name: FractionalIdeal.coeIdeal_bot
code: @[simp, norm_cast]
theorem coeIdeal_bot : ((⊥ : Ideal R) : FractionalIdeal S P) = 0 
goal: ↑⊥ = 0

full_name: FractionalIdeal.exists_mem_algebraMap_eq
code: @[simp]
theorem exists_mem_algebraMap_eq {x : R} {I : Ideal R} (h : S ≤ nonZeroDivisors R) :
    (∃ x', x' ∈ I ∧ algebraMap R P x' = algebraMap R P x) ↔ x ∈ I 
goal: (∃ x' ∈ I, (algebraMap R P) x' = (algebraMap R P) x) ↔ x ∈ I

full_name: FractionalIdeal.coeIdeal_injective'
code: theorem coeIdeal_injective' (h : S ≤ nonZeroDivisors R) :
    Function.Injective (fun (I : Ideal R) ↦ (I : FractionalIdeal S P)) 
goal: Function.Injective fun I => ↑I

full_name: FractionalIdeal.coeIdeal_inj'
code: theorem coeIdeal_inj' (h : S ≤ nonZeroDivisors R) {I J : Ideal R} :
    (I : FractionalIdeal S P) = J ↔ I = J 
goal: ↑I = ↑J ↔ I = J

full_name: FractionalIdeal.coeIdeal_eq_zero'
code: theorem coeIdeal_eq_zero' {I : Ideal R} (h : S ≤ nonZeroDivisors R) :
    (I : FractionalIdeal S P) = 0 ↔ I = (⊥ : Ideal R) 
goal: ↑I = 0 ↔ I = ⊥

full_name: FractionalIdeal.coeIdeal_ne_zero'
code: theorem coeIdeal_ne_zero' {I : Ideal R} (h : S ≤ nonZeroDivisors R) :
    (I : FractionalIdeal S P) ≠ 0 ↔ I ≠ (⊥ : Ideal R) 
goal: ↑I ≠ 0 ↔ I ≠ ⊥

full_name: FractionalIdeal.coeToSubmodule_eq_bot
code: theorem coeToSubmodule_eq_bot {I : FractionalIdeal S P} : (I : Submodule R P) = ⊥ ↔ I = 0 
goal: ↑I = ⊥ ↔ I = 0

full_name: FractionalIdeal.coeToSubmodule_ne_bot
code: theorem coeToSubmodule_ne_bot {I : FractionalIdeal S P} : ↑I ≠ (⊥ : Submodule R P) ↔ I ≠ 0 
goal: ↑I ≠ ⊥ ↔ I ≠ 0

full_name: FractionalIdeal.instInhabited
code: instance : Inhabited (FractionalIdeal S P) 
goal: Inhabited (FractionalIdeal S P)

full_name: FractionalIdeal.instOne
code: instance : One (FractionalIdeal S P) 
goal: One (FractionalIdeal S P)

full_name: FractionalIdeal.zero_of_num_eq_bot
code: theorem zero_of_num_eq_bot [NoZeroSMulDivisors R P] (hS : 0 ∉ S) {I : FractionalIdeal S P}
    (hI : I.num = ⊥) : I = 0 
goal: I = 0

full_name: FractionalIdeal.num_zero_eq
code: theorem num_zero_eq (h_inj : Function.Injective (algebraMap R P)) :
    num (0 : FractionalIdeal S P) = 0 
goal: FractionalIdeal.num 0 = 0

full_name: FractionalIdeal.coeIdeal_top
code: @[simp, norm_cast]
theorem coeIdeal_top : ((⊤ : Ideal R) : FractionalIdeal S P) = 1 
goal: ↑⊤ = 1

full_name: FractionalIdeal.mem_one_iff
code: theorem mem_one_iff {x : P} : x ∈ (1 : FractionalIdeal S P) ↔ ∃ x' : R, algebraMap R P x' = x 
goal: x ∈ 1 ↔ ∃ x', (algebraMap R P) x' = x

full_name: FractionalIdeal.coe_mem_one
code: theorem coe_mem_one (x : R) : algebraMap R P x ∈ (1 : FractionalIdeal S P) 
goal: (algebraMap R P) x ∈ 1

full_name: FractionalIdeal.one_mem_one
code: theorem one_mem_one : (1 : P) ∈ (1 : FractionalIdeal S P) 
goal: 1 ∈ 1

full_name: FractionalIdeal.coe_one_eq_coeSubmodule_top
code: /-- `(1 : FractionalIdeal S P)` is defined as the R-submodule `f(R) ≤ P`.

However, this is not definitionally equal to `1 : Submodule R P`,
which is proved in the actual `simp` lemma `coe_one`. -/
theorem coe_one_eq_coeSubmodule_top : ↑(1 : FractionalIdeal S P) = coeSubmodule P (⊤ : Ideal R) 
goal: ↑1 = IsLocalization.coeSubmodule P ⊤

full_name: FractionalIdeal.coe_one
code: @[simp, norm_cast]
theorem coe_one : (↑(1 : FractionalIdeal S P) : Submodule R P) = 1 
goal: ↑1 = 1

full_name: FractionalIdeal.coe_le_coe
code: @[simp]
theorem coe_le_coe {I J : FractionalIdeal S P} :
    (I : Submodule R P) ≤ (J : Submodule R P) ↔ I ≤ J 
goal: ↑I ≤ ↑J ↔ I ≤ J

full_name: FractionalIdeal.zero_le
code: theorem zero_le (I : FractionalIdeal S P) : 0 ≤ I 
goal: 0 ≤ I

full_name: FractionalIdeal.orderBot
code: instance orderBot : OrderBot (FractionalIdeal S P) 
goal: OrderBot (FractionalIdeal S P)

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

full_name: FractionalIdeal.le_zero_iff
code: @[simp]
theorem le_zero_iff {I : FractionalIdeal S P} : I ≤ 0 ↔ I = 0 
goal: I ≤ 0 ↔ I = 0

full_name: FractionalIdeal.eq_zero_iff
code: theorem eq_zero_iff {I : FractionalIdeal S P} : I = 0 ↔ ∀ x ∈ I, x = (0 : P) 
goal: I = 0 ↔ ∀ x ∈ I, x = 0

full_name: IsFractional.sup
code: theorem _root_.IsFractional.sup {I J : Submodule R P} :
    IsFractional S I → IsFractional S J → IsFractional S (I ⊔ J)
  
goal: IsFractional S I → IsFractional S J → IsFractional S (I ⊔ J)

full_name: IsFractional.inf_right
code: theorem _root_.IsFractional.inf_right {I : Submodule R P} :
    IsFractional S I → ∀ J, IsFractional S (I ⊓ J)
  
goal: IsFractional S I → ∀ (J : Submodule R P), IsFractional S (I ⊓ J)

full_name: FractionalIdeal.instInf
code: instance : Inf (FractionalIdeal S P) 
goal: Inf (FractionalIdeal S P)

full_name: FractionalIdeal.coe_inf
code: @[simp, norm_cast]
theorem coe_inf (I J : FractionalIdeal S P) : ↑(I ⊓ J) = (I ⊓ J : Submodule R P) 
goal: ↑(I ⊓ J) = ↑I ⊓ ↑J

full_name: FractionalIdeal.instSup
code: instance : Sup (FractionalIdeal S P) 
goal: Sup (FractionalIdeal S P)

full_name: FractionalIdeal.coe_sup
code: @[norm_cast]
theorem coe_sup (I J : FractionalIdeal S P) : ↑(I ⊔ J) = (I ⊔ J : Submodule R P) 
goal: ↑(I ⊔ J) = ↑I ⊔ ↑J

full_name: FractionalIdeal.lattice
code: instance lattice : Lattice (FractionalIdeal S P) 
goal: Lattice (FractionalIdeal S P)

full_name: FractionalIdeal.instSemilatticeSup
code: instance : SemilatticeSup (FractionalIdeal S P) 
goal: SemilatticeSup (FractionalIdeal S P)

full_name: FractionalIdeal.instAdd
code: instance : Add (FractionalIdeal S P) 
goal: Add (FractionalIdeal S P)

full_name: FractionalIdeal.sup_eq_add
code: @[simp]
theorem sup_eq_add (I J : FractionalIdeal S P) : I ⊔ J = I + J 
goal: I ⊔ J = I + J

full_name: FractionalIdeal.coe_add
code: @[simp, norm_cast]
theorem coe_add (I J : FractionalIdeal S P) : (↑(I + J) : Submodule R P) = I + J 
goal: ↑(I + J) = ↑I + ↑J

full_name: FractionalIdeal.coeIdeal_sup
code: @[simp, norm_cast]
theorem coeIdeal_sup (I J : Ideal R) : ↑(I ⊔ J) = (I + J : FractionalIdeal S P) 
goal: ↑(I ⊔ J) = ↑I + ↑J

full_name: IsFractional.nsmul
code: theorem _root_.IsFractional.nsmul {I : Submodule R P} :
    ∀ n : ℕ, IsFractional S I → IsFractional S (n • I : Submodule R P)
  
goal: IsFractional S I → IsFractional S (n • I)

full_name: FractionalIdeal.instSMulNat
code: instance : SMul ℕ (FractionalIdeal S P) 
goal: SMul ℕ (FractionalIdeal S P)

full_name: FractionalIdeal.coe_nsmul
code: @[norm_cast]
theorem coe_nsmul (n : ℕ) (I : FractionalIdeal S P) :
    (↑(n • I) : Submodule R P) = n • (I : Submodule R P) 
goal: ↑(n • I) = n • ↑I

full_name: IsFractional.mul
code: theorem _root_.IsFractional.mul {I J : Submodule R P} :
    IsFractional S I → IsFractional S J → IsFractional S (I * J : Submodule R P)
  
goal: IsFractional S I → IsFractional S J → IsFractional S (I * J)

full_name: IsFractional.pow
code: theorem _root_.IsFractional.pow {I : Submodule R P} (h : IsFractional S I) :
    ∀ n : ℕ, IsFractional S (I ^ n : Submodule R P)
  
goal: IsFractional S (I ^ n)

full_name: FractionalIdeal.mul_def'
code: /-- `FractionalIdeal.mul` is the product of two fractional ideals,
used to define the `Mul` instance.

This is only an auxiliary definition: the preferred way of writing `I.mul J` is `I * J`.

Elaborated terms involving `FractionalIdeal` tend to grow quite large,
so by making definitions irreducible, we hope to avoid deep unfolds.
-/
irreducible_def mul (lemma := mul_def') (I J : FractionalIdeal S P) : FractionalIdeal S P 
goal: I.mul J = ⟨↑I * ↑J, ⋯⟩

full_name: FractionalIdeal.definition._@.Mathlib.RingTheory.FractionalIdeal.Basic._hyg.5517
code: /-- `FractionalIdeal.mul` is the product of two fractional ideals,
used to define the `Mul` instance.

This is only an auxiliary definition: the preferred way of writing `I.mul J` is `I * J`.

Elaborated terms involving `FractionalIdeal` tend to grow quite large,
so by making definitions irreducible, we hope to avoid deep unfolds.
-/
irreducible_def mul (lemma := mul_def') (I J : FractionalIdeal S P) : FractionalIdeal S P 
goal: FractionalIdeal S P

full_name: FractionalIdeal.mul
code: /-- `FractionalIdeal.mul` is the product of two fractional ideals,
used to define the `Mul` instance.

This is only an auxiliary definition: the preferred way of writing `I.mul J` is `I * J`.

Elaborated terms involving `FractionalIdeal` tend to grow quite large,
so by making definitions irreducible, we hope to avoid deep unfolds.
-/
irreducible_def mul (lemma := mul_def') (I J : FractionalIdeal S P) : FractionalIdeal S P 
goal: FractionalIdeal S P

full_name: FractionalIdeal.wrapped._@.Mathlib.RingTheory.FractionalIdeal.Basic._hyg.5517
code: /-- `FractionalIdeal.mul` is the product of two fractional ideals,
used to define the `Mul` instance.

This is only an auxiliary definition: the preferred way of writing `I.mul J` is `I * J`.

Elaborated terms involving `FractionalIdeal` tend to grow quite large,
so by making definitions irreducible, we hope to avoid deep unfolds.
-/
irreducible_def mul (lemma := mul_def') (I J : FractionalIdeal S P) : FractionalIdeal S P 
goal: Subtype (Eq @FractionalIdeal.definition✝)

full_name: FractionalIdeal.instMul
code: instance : Mul (FractionalIdeal S P) 
goal: Mul (FractionalIdeal S P)

full_name: FractionalIdeal.mul_eq_mul
code: @[simp]
theorem mul_eq_mul (I J : FractionalIdeal S P) : mul I J = I * J 
goal: I.mul J = I * J

full_name: FractionalIdeal.mul_def
code: theorem mul_def (I J : FractionalIdeal S P) :
    I * J = ⟨I * J, I.isFractional.mul J.isFractional⟩ 
goal: I * J = ⟨↑I * ↑J, ⋯⟩

full_name: FractionalIdeal.coe_mul
code: @[simp, norm_cast]
theorem coe_mul (I J : FractionalIdeal S P) : (↑(I * J) : Submodule R P) = I * J 
goal: ↑(I * J) = ↑I * ↑J

full_name: FractionalIdeal.coeIdeal_mul
code: @[simp, norm_cast]
theorem coeIdeal_mul (I J : Ideal R) : (↑(I * J) : FractionalIdeal S P) = I * J 
goal: ↑(I * J) = ↑I * ↑J

full_name: FractionalIdeal.mul_left_mono
code: theorem mul_left_mono (I : FractionalIdeal S P) : Monotone (I * ·) 
goal: Monotone fun x => I * x

full_name: FractionalIdeal.mul_right_mono
code: theorem mul_right_mono (I : FractionalIdeal S P) : Monotone fun J => J * I 
goal: Monotone fun J => J * I

full_name: FractionalIdeal.mul_mem_mul
code: theorem mul_mem_mul {I J : FractionalIdeal S P} {i j : P} (hi : i ∈ I) (hj : j ∈ J) :
    i * j ∈ I * J 
goal: i * j ∈ I * J

full_name: FractionalIdeal.mul_le
code: theorem mul_le {I J K : FractionalIdeal S P} : I * J ≤ K ↔ ∀ i ∈ I, ∀ j ∈ J, i * j ∈ K 
goal: I * J ≤ K ↔ ∀ i ∈ I, ∀ j ∈ J, i * j ∈ K

full_name: FractionalIdeal.instPowNat
code: instance : Pow (FractionalIdeal S P) ℕ 
goal: Pow (FractionalIdeal S P) ℕ

full_name: FractionalIdeal.coe_pow
code: @[simp, norm_cast]
theorem coe_pow (I : FractionalIdeal S P) (n : ℕ) : ↑(I ^ n) = (I : Submodule R P) ^ n 
goal: ↑(I ^ n) = ↑I ^ n

full_name: FractionalIdeal.mul_induction_on
code: @[elab_as_elim]
protected theorem mul_induction_on {I J : FractionalIdeal S P} {C : P → Prop} {r : P}
    (hr : r ∈ I * J) (hm : ∀ i ∈ I, ∀ j ∈ J, C (i * j)) (ha : ∀ x y, C x → C y → C (x + y)) :
    C r 
goal: C r

full_name: FractionalIdeal.instNatCast
code: instance : NatCast (FractionalIdeal S P) 
goal: NatCast (FractionalIdeal S P)

full_name: FractionalIdeal.coe_natCast
code: theorem coe_natCast (n : ℕ) : ((n : FractionalIdeal S P) : Submodule R P) = n 
goal: ↑↑n = ↑n

full_name: FractionalIdeal.commSemiring
code: instance commSemiring : CommSemiring (FractionalIdeal S P) 
goal: CommSemiring (FractionalIdeal S P)

full_name: FractionalIdeal.coeSubmoduleHom_apply
code: /-- `FractionalIdeal.coeToSubmodule` as a bundled `RingHom`. -/
@[simps]
def coeSubmoduleHom : FractionalIdeal S P →+* Submodule R P 
goal: (FractionalIdeal.coeSubmoduleHom S P) I = ↑I

full_name: FractionalIdeal.coeSubmoduleHom
code: /-- `FractionalIdeal.coeToSubmodule` as a bundled `RingHom`. -/
@[simps]
def coeSubmoduleHom : FractionalIdeal S P →+* Submodule R P 
goal: FractionalIdeal S P →+* Submodule R P

full_name: FractionalIdeal.add_le_add_left
code: theorem add_le_add_left {I J : FractionalIdeal S P} (hIJ : I ≤ J) (J' : FractionalIdeal S P) :
    J' + I ≤ J' + J 
goal: J' + I ≤ J' + J

full_name: FractionalIdeal.mul_le_mul_left
code: theorem mul_le_mul_left {I J : FractionalIdeal S P} (hIJ : I ≤ J) (J' : FractionalIdeal S P) :
    J' * I ≤ J' * J 
goal: J' * I ≤ J' * J

full_name: FractionalIdeal.le_self_mul_self
code: theorem le_self_mul_self {I : FractionalIdeal S P} (hI : 1 ≤ I) : I ≤ I * I 
goal: I ≤ I * I

full_name: FractionalIdeal.mul_self_le_self
code: theorem mul_self_le_self {I : FractionalIdeal S P} (hI : I ≤ 1) : I * I ≤ I 
goal: I * I ≤ I

full_name: FractionalIdeal.coeIdeal_le_one
code: theorem coeIdeal_le_one {I : Ideal R} : (I : FractionalIdeal S P) ≤ 1 
goal: ↑I ≤ 1

full_name: FractionalIdeal.le_one_iff_exists_coeIdeal
code: theorem le_one_iff_exists_coeIdeal {J : FractionalIdeal S P} :
    J ≤ (1 : FractionalIdeal S P) ↔ ∃ I : Ideal R, ↑I = J 
goal: J ≤ 1 ↔ ∃ I, ↑I = J

full_name: FractionalIdeal.one_le
code: @[simp]
theorem one_le {I : FractionalIdeal S P} : 1 ≤ I ↔ (1 : P) ∈ I 
goal: 1 ≤ I ↔ 1 ∈ I

full_name: FractionalIdeal.coeIdealHom
code: /-- `coeIdealHom (S : Submonoid R) P` is `(↑) : Ideal R → FractionalIdeal S P` as a ring hom -/
@[simps]
def coeIdealHom : Ideal R →+* FractionalIdeal S P 
goal: Ideal R →+* FractionalIdeal S P

full_name: FractionalIdeal.coeIdealHom_apply
code: /-- `coeIdealHom (S : Submonoid R) P` is `(↑) : Ideal R → FractionalIdeal S P` as a ring hom -/
@[simps]
def coeIdealHom : Ideal R →+* FractionalIdeal S P 
goal: (FractionalIdeal.coeIdealHom S P) I = ↑I

full_name: FractionalIdeal.coeIdeal_pow
code: theorem coeIdeal_pow (I : Ideal R) (n : ℕ) : ↑(I ^ n) = (I : FractionalIdeal S P) ^ n 
goal: ↑(I ^ n) = ↑I ^ n

full_name: FractionalIdeal.coeIdeal_finprod
code: theorem coeIdeal_finprod [IsLocalization S P] {α : Sort*} {f : α → Ideal R}
    (hS : S ≤ nonZeroDivisors R) :
    ((∏ᶠ a : α, f a : Ideal R) : FractionalIdeal S P) = ∏ᶠ a : α, (f a : FractionalIdeal S P) 
goal: ↑(∏ᶠ (a : α), f a) = ∏ᶠ (a : α), ↑(f a)

full_name: FractionalIdeal.fg_of_isNoetherianRing
code: /-- The fractional ideals of a Noetherian ring are finitely generated. -/
lemma fg_of_isNoetherianRing [hR : IsNoetherianRing R] (hS : S ≤ R⁰) (I : FractionalIdeal S P) :
    FG I.coeToSubmodule 
goal: (↑I).FG