File: Mathlib/RingTheory/Ideal/Maps.lean

full_name: Ideal.map
code: /-- `I.map f` is the span of the image of the ideal `I` under `f`, which may be bigger than
  the image itself. -/
def map (I : Ideal R) : Ideal S 
goal: Ideal S

full_name: Ideal.comap
code: /-- `I.comap f` is the preimage of `I` under `f`. -/
def comap (I : Ideal S) : Ideal R 
goal: Ideal R

full_name: Ideal.coe_comap
code: @[simp]
theorem coe_comap (I : Ideal S) : (comap f I : Set R) = f ⁻¹' I 
goal: ↑(Ideal.comap f I) = ⇑f ⁻¹' ↑I

full_name: Ideal.map_mono
code: theorem map_mono (h : I ≤ J) : map f I ≤ map f J 
goal: Ideal.map f I ≤ Ideal.map f J

full_name: Ideal.mem_map_of_mem
code: theorem mem_map_of_mem (f : F) {I : Ideal R} {x : R} (h : x ∈ I) : f x ∈ map f I 
goal: f x ∈ Ideal.map f I

full_name: Ideal.apply_coe_mem_map
code: theorem apply_coe_mem_map (f : F) (I : Ideal R) (x : I) : f x ∈ I.map f 
goal: f ↑x ∈ Ideal.map f I

full_name: Ideal.map_le_iff_le_comap
code: theorem map_le_iff_le_comap : map f I ≤ K ↔ I ≤ comap f K 
goal: Ideal.map f I ≤ K ↔ I ≤ Ideal.comap f K

full_name: Ideal.mem_comap
code: @[simp]
theorem mem_comap {x} : x ∈ comap f K ↔ f x ∈ K 
goal: x ∈ Ideal.comap f K ↔ f x ∈ K

full_name: Ideal.comap_mono
code: theorem comap_mono (h : K ≤ L) : comap f K ≤ comap f L 
goal: Ideal.comap f K ≤ Ideal.comap f L

full_name: Ideal.comap_ne_top
code: theorem comap_ne_top (hK : K ≠ ⊤) : comap f K ≠ ⊤ 
goal: Ideal.comap f K ≠ ⊤

full_name: Ideal.map_le_comap_of_inv_on
code: theorem map_le_comap_of_inv_on (g : G) (I : Ideal R) (hf : Set.LeftInvOn g f I) :
    I.map f ≤ I.comap g 
goal: Ideal.map f I ≤ Ideal.comap g I

full_name: Ideal.comap_le_map_of_inv_on
code: theorem comap_le_map_of_inv_on (g : G) (I : Ideal S) (hf : Set.LeftInvOn g f (f ⁻¹' I)) :
    I.comap f ≤ I.map g 
goal: Ideal.comap f I ≤ Ideal.map g I

full_name: Ideal.map_le_comap_of_inverse
code: /-- The `Ideal` version of `Set.image_subset_preimage_of_inverse`. -/
theorem map_le_comap_of_inverse (g : G) (I : Ideal R) (h : Function.LeftInverse g f) :
    I.map f ≤ I.comap g 
goal: Ideal.map f I ≤ Ideal.comap g I

full_name: Ideal.comap_le_map_of_inverse
code: /-- The `Ideal` version of `Set.preimage_subset_image_of_inverse`. -/
theorem comap_le_map_of_inverse (g : G) (I : Ideal S) (h : Function.LeftInverse g f) :
    I.comap f ≤ I.map g 
goal: Ideal.comap f I ≤ Ideal.map g I

full_name: Ideal.IsPrime.comap
code: instance IsPrime.comap [hK : K.IsPrime] : (comap f K).IsPrime 
goal: (Ideal.comap f K).IsPrime

full_name: Ideal.map_top
code: theorem map_top : map f ⊤ = ⊤ 
goal: Ideal.map f ⊤ = ⊤

full_name: Ideal.gc_map_comap
code: theorem gc_map_comap : GaloisConnection (Ideal.map f) (Ideal.comap f) 
goal: GaloisConnection (Ideal.map f) (Ideal.comap f)

full_name: Ideal.comap_id
code: @[simp]
theorem comap_id : I.comap (RingHom.id R) = I 
goal: Ideal.comap (RingHom.id R) I = I

full_name: Ideal.map_id
code: @[simp]
theorem map_id : I.map (RingHom.id R) = I 
goal: Ideal.map (RingHom.id R) I = I

full_name: Ideal.comap_comap
code: theorem comap_comap {T : Type*} [Semiring T] {I : Ideal T} (f : R →+* S) (g : S →+* T) :
    (I.comap g).comap f = I.comap (g.comp f) 
goal: Ideal.comap f (Ideal.comap g I) = Ideal.comap (g.comp f) I

full_name: Ideal.map_map
code: theorem map_map {T : Type*} [Semiring T] {I : Ideal R} (f : R →+* S) (g : S →+* T) :
    (I.map f).map g = I.map (g.comp f) 
goal: Ideal.map g (Ideal.map f I) = Ideal.map (g.comp f) I

full_name: Ideal.map_span
code: theorem map_span (f : F) (s : Set R) : map f (span s) = span (f '' s) 
goal: Ideal.map f (Ideal.span s) = Ideal.span (⇑f '' s)

full_name: Ideal.map_le_of_le_comap
code: theorem map_le_of_le_comap : I ≤ K.comap f → I.map f ≤ K 
goal: I ≤ Ideal.comap f K → Ideal.map f I ≤ K

full_name: Ideal.le_comap_of_map_le
code: theorem le_comap_of_map_le : I.map f ≤ K → I ≤ K.comap f 
goal: Ideal.map f I ≤ K → I ≤ Ideal.comap f K

full_name: Ideal.le_comap_map
code: theorem le_comap_map : I ≤ (I.map f).comap f 
goal: I ≤ Ideal.comap f (Ideal.map f I)

full_name: Ideal.map_comap_le
code: theorem map_comap_le : (K.comap f).map f ≤ K 
goal: Ideal.map f (Ideal.comap f K) ≤ K

full_name: Ideal.comap_top
code: @[simp]
theorem comap_top : (⊤ : Ideal S).comap f = ⊤ 
goal: Ideal.comap f ⊤ = ⊤

full_name: Ideal.comap_eq_top_iff
code: @[simp]
theorem comap_eq_top_iff {I : Ideal S} : I.comap f = ⊤ ↔ I = ⊤ 
goal: Ideal.comap f I = ⊤ ↔ I = ⊤

full_name: Ideal.map_bot
code: @[simp]
theorem map_bot : (⊥ : Ideal R).map f = ⊥ 
goal: Ideal.map f ⊥ = ⊥

full_name: Ideal.map_comap_map
code: @[simp]
theorem map_comap_map : ((I.map f).comap f).map f = I.map f 
goal: Ideal.map f (Ideal.comap f (Ideal.map f I)) = Ideal.map f I

full_name: Ideal.comap_map_comap
code: @[simp]
theorem comap_map_comap : ((K.comap f).map f).comap f = K.comap f 
goal: Ideal.comap f (Ideal.map f (Ideal.comap f K)) = Ideal.comap f K

full_name: Ideal.map_sup
code: theorem map_sup : (I ⊔ J).map f = I.map f ⊔ J.map f 
goal: Ideal.map f (I ⊔ J) = Ideal.map f I ⊔ Ideal.map f J

full_name: Ideal.comap_inf
code: theorem comap_inf : comap f (K ⊓ L) = comap f K ⊓ comap f L 
goal: Ideal.comap f (K ⊓ L) = Ideal.comap f K ⊓ Ideal.comap f L

full_name: Ideal.map_iSup
code: theorem map_iSup (K : ι → Ideal R) : (iSup K).map f = ⨆ i, (K i).map f 
goal: Ideal.map f (iSup K) = ⨆ i, Ideal.map f (K i)

full_name: Ideal.comap_iInf
code: theorem comap_iInf (K : ι → Ideal S) : (iInf K).comap f = ⨅ i, (K i).comap f 
goal: Ideal.comap f (iInf K) = ⨅ i, Ideal.comap f (K i)

full_name: Ideal.map_sSup
code: theorem map_sSup (s : Set (Ideal R)) : (sSup s).map f = ⨆ I ∈ s, (I : Ideal R).map f 
goal: Ideal.map f (sSup s) = ⨆ I ∈ s, Ideal.map f I

full_name: Ideal.comap_sInf
code: theorem comap_sInf (s : Set (Ideal S)) : (sInf s).comap f = ⨅ I ∈ s, (I : Ideal S).comap f 
goal: Ideal.comap f (sInf s) = ⨅ I ∈ s, Ideal.comap f I

full_name: Ideal.comap_sInf'
code: theorem comap_sInf' (s : Set (Ideal S)) : (sInf s).comap f = ⨅ I ∈ comap f '' s, I 
goal: Ideal.comap f (sInf s) = ⨅ I ∈ Ideal.comap f '' s, I

full_name: Ideal.comap_isPrime
code: theorem comap_isPrime [H : IsPrime K] : IsPrime (comap f K) 
goal: (Ideal.comap f K).IsPrime

full_name: Ideal.map_inf_le
code: theorem map_inf_le : map f (I ⊓ J) ≤ map f I ⊓ map f J 
goal: Ideal.map f (I ⊓ J) ≤ Ideal.map f I ⊓ Ideal.map f J

full_name: Ideal.le_comap_sup
code: theorem le_comap_sup : comap f K ⊔ comap f L ≤ comap f (K ⊔ L) 
goal: Ideal.comap f K ⊔ Ideal.comap f L ≤ Ideal.comap f (K ⊔ L)

full_name: element_smul_restrictScalars
code: theorem _root_.element_smul_restrictScalars {R S M}
    [CommSemiring R] [CommSemiring S] [Algebra R S] [AddCommMonoid M]
    [Module R M] [Module S M] [IsScalarTower R S M] (r : R) (N : Submodule S M) :
    (algebraMap R S r • N).restrictScalars R = r • N.restrictScalars R 
goal: Submodule.restrictScalars R ((algebraMap R S) r • N) = r • Submodule.restrictScalars R N

full_name: Ideal.smul_restrictScalars
code: theorem smul_restrictScalars {R S M} [CommSemiring R] [CommSemiring S]
    [Algebra R S] [AddCommMonoid M] [Module R M] [Module S M]
    [IsScalarTower R S M] (I : Ideal R) (N : Submodule S M) :
    (I.map (algebraMap R S) • N).restrictScalars R = I • N.restrictScalars R 
goal: Submodule.restrictScalars R (Ideal.map (algebraMap R S) I • N) = I • Submodule.restrictScalars R N

full_name: Ideal.smul_top_eq_map
code: @[simp]
theorem smul_top_eq_map {R S : Type*} [CommSemiring R] [CommSemiring S] [Algebra R S]
    (I : Ideal R) : I • (⊤ : Submodule R S) = (I.map (algebraMap R S)).restrictScalars R 
goal: I • ⊤ = Submodule.restrictScalars R (Ideal.map (algebraMap R S) I)

full_name: Ideal.coe_restrictScalars
code: @[simp]
theorem coe_restrictScalars {R S : Type*} [CommSemiring R] [Semiring S] [Algebra R S]
    (I : Ideal S) : (I.restrictScalars R : Set S) = ↑I 
goal: ↑(Submodule.restrictScalars R I) = ↑I

full_name: Ideal.restrictScalars_mul
code: /-- The smallest `S`-submodule that contains all `x ∈ I * y ∈ J`
is also the smallest `R`-submodule that does so. -/
@[simp]
theorem restrictScalars_mul {R S : Type*} [CommSemiring R] [CommSemiring S] [Algebra R S]
    (I J : Ideal S) : (I * J).restrictScalars R = I.restrictScalars R * J.restrictScalars R 
goal: Submodule.restrictScalars R (I * J) = Submodule.restrictScalars R I * Submodule.restrictScalars R J

full_name: Ideal.map_comap_of_surjective
code: theorem map_comap_of_surjective (I : Ideal S) : map f (comap f I) = I 
goal: Ideal.map f (Ideal.comap f I) = I

full_name: Ideal.giMapComap
code: /-- `map` and `comap` are adjoint, and the composition `map f ∘ comap f` is the
  identity -/
def giMapComap : GaloisInsertion (map f) (comap f) 
goal: GaloisInsertion (Ideal.map f) (Ideal.comap f)

full_name: Ideal.map_surjective_of_surjective
code: theorem map_surjective_of_surjective : Surjective (map f) 
goal: Function.Surjective (Ideal.map f)

full_name: Ideal.comap_injective_of_surjective
code: theorem comap_injective_of_surjective : Injective (comap f) 
goal: Function.Injective (Ideal.comap f)

full_name: Ideal.map_sup_comap_of_surjective
code: theorem map_sup_comap_of_surjective (I J : Ideal S) : (I.comap f ⊔ J.comap f).map f = I ⊔ J 
goal: Ideal.map f (Ideal.comap f I ⊔ Ideal.comap f J) = I ⊔ J

full_name: Ideal.map_iSup_comap_of_surjective
code: theorem map_iSup_comap_of_surjective (K : ι → Ideal S) : (⨆ i, (K i).comap f).map f = iSup K 
goal: Ideal.map f (⨆ i, Ideal.comap f (K i)) = iSup K

full_name: Ideal.map_inf_comap_of_surjective
code: theorem map_inf_comap_of_surjective (I J : Ideal S) : (I.comap f ⊓ J.comap f).map f = I ⊓ J 
goal: Ideal.map f (Ideal.comap f I ⊓ Ideal.comap f J) = I ⊓ J

full_name: Ideal.map_iInf_comap_of_surjective
code: theorem map_iInf_comap_of_surjective (K : ι → Ideal S) : (⨅ i, (K i).comap f).map f = iInf K 
goal: Ideal.map f (⨅ i, Ideal.comap f (K i)) = iInf K

full_name: Ideal.mem_image_of_mem_map_of_surjective
code: theorem mem_image_of_mem_map_of_surjective {I : Ideal R} {y} (H : y ∈ map f I) : y ∈ f '' I 
goal: y ∈ ⇑f '' ↑I

full_name: Ideal.mem_map_iff_of_surjective
code: theorem mem_map_iff_of_surjective {I : Ideal R} {y} : y ∈ map f I ↔ ∃ x, x ∈ I ∧ f x = y 
goal: y ∈ Ideal.map f I ↔ ∃ x ∈ I, f x = y

full_name: Ideal.le_map_of_comap_le_of_surjective
code: theorem le_map_of_comap_le_of_surjective : comap f K ≤ I → K ≤ map f I 
goal: Ideal.comap f K ≤ I → K ≤ Ideal.map f I

full_name: Ideal.map_eq_submodule_map
code: theorem map_eq_submodule_map (f : R →+* S) [h : RingHomSurjective f] (I : Ideal R) :
    I.map f = Submodule.map f.toSemilinearMap I 
goal: Ideal.map f I = Submodule.map f.toSemilinearMap I

full_name: Ideal.comap_bot_le_of_injective
code: theorem comap_bot_le_of_injective (hf : Function.Injective f) : comap f ⊥ ≤ I 
goal: Ideal.comap f ⊥ ≤ I

full_name: Ideal.comap_bot_of_injective
code: theorem comap_bot_of_injective (hf : Function.Injective f) : Ideal.comap f ⊥ = ⊥ 
goal: Ideal.comap f ⊥ = ⊥

full_name: Ideal.map_of_equiv
code: /-- If `f : R ≃+* S` is a ring isomorphism and `I : Ideal R`, then `map f.symm (map f I) = I`. -/
@[simp]
theorem map_of_equiv (I : Ideal R) (f : R ≃+* S) :
    (I.map (f : R →+* S)).map (f.symm : S →+* R) = I 
goal: Ideal.map (↑f.symm) (Ideal.map (↑f) I) = I

full_name: Ideal.comap_of_equiv
code: /-- If `f : R ≃+* S` is a ring isomorphism and `I : Ideal R`,
  then `comap f (comap f.symm I) = I`. -/
@[simp]
theorem comap_of_equiv (I : Ideal R) (f : R ≃+* S) :
    (I.comap (f.symm : S →+* R)).comap (f : R →+* S) = I 
goal: Ideal.comap (↑f) (Ideal.comap (↑f.symm) I) = I

full_name: Ideal.map_comap_of_equiv
code: /-- If `f : R ≃+* S` is a ring isomorphism and `I : Ideal R`, then `map f I = comap f.symm I`. -/
theorem map_comap_of_equiv (I : Ideal R) (f : R ≃+* S) : I.map (f : R →+* S) = I.comap f.symm 
goal: Ideal.map (↑f) I = Ideal.comap f.symm I

full_name: Ideal.comap_symm
code: /-- If `f : R ≃+* S` is a ring isomorphism and `I : Ideal R`, then `comap f.symm I = map f I`. -/
@[simp]
theorem comap_symm (I : Ideal R) (f : R ≃+* S) : I.comap f.symm = I.map f 
goal: Ideal.comap f.symm I = Ideal.map f I

full_name: Ideal.map_symm
code: /-- If `f : R ≃+* S` is a ring isomorphism and `I : Ideal R`, then `map f.symm I = comap f I`. -/
@[simp]
theorem map_symm (I : Ideal S) (f : R ≃+* S) : I.map f.symm = I.comap f 
goal: Ideal.map f.symm I = Ideal.comap f I

full_name: Ideal.comap_map_of_surjective
code: theorem comap_map_of_surjective (hf : Function.Surjective f) (I : Ideal R) :
    comap f (map f I) = I ⊔ comap f ⊥ 
goal: Ideal.comap f (Ideal.map f I) = I ⊔ Ideal.comap f ⊥

full_name: Ideal.relIsoOfSurjective
code: /-- Correspondence theorem -/
def relIsoOfSurjective (hf : Function.Surjective f) :
    Ideal S ≃o { p : Ideal R // comap f ⊥ ≤ p } 
goal: Ideal S ≃o { p // Ideal.comap f ⊥ ≤ p }

full_name: Ideal.orderEmbeddingOfSurjective
code: /-- The map on ideals induced by a surjective map preserves inclusion. -/
def orderEmbeddingOfSurjective (hf : Function.Surjective f) : Ideal S ↪o Ideal R 
goal: Ideal S ↪o Ideal R

full_name: Ideal.map_eq_top_or_isMaximal_of_surjective
code: theorem map_eq_top_or_isMaximal_of_surjective (hf : Function.Surjective f) {I : Ideal R}
    (H : IsMaximal I) : map f I = ⊤ ∨ IsMaximal (map f I) 
goal: Ideal.map f I = ⊤ ∨ (Ideal.map f I).IsMaximal

full_name: Ideal.comap_isMaximal_of_surjective
code: theorem comap_isMaximal_of_surjective (hf : Function.Surjective f) {K : Ideal S} [H : IsMaximal K]:
    IsMaximal (comap f K) 
goal: (Ideal.comap f K).IsMaximal

full_name: Ideal.comap_le_comap_iff_of_surjective
code: theorem comap_le_comap_iff_of_surjective (hf : Function.Surjective f) (I J : Ideal S) :
    comap f I ≤ comap f J ↔ I ≤ J 
goal: Ideal.comap f I ≤ Ideal.comap f J ↔ I ≤ J

full_name: Ideal.relIsoOfBijective
code: /-- Special case of the correspondence theorem for isomorphic rings -/
def relIsoOfBijective (hf : Function.Bijective f) : Ideal S ≃o Ideal R 
goal: Ideal S ≃o Ideal R

full_name: Ideal.comap_le_iff_le_map
code: theorem comap_le_iff_le_map (hf : Function.Bijective f) {I : Ideal R} {K : Ideal S} :
    comap f K ≤ I ↔ K ≤ map f I 
goal: Ideal.comap f K ≤ I ↔ K ≤ Ideal.map f I

full_name: Ideal.map.isMaximal
code: theorem map.isMaximal (hf : Function.Bijective f) {I : Ideal R} (H : IsMaximal I) :
    IsMaximal (map f I) 
goal: (Ideal.map f I).IsMaximal

full_name: Ideal.RingEquiv.bot_maximal_iff
code: theorem RingEquiv.bot_maximal_iff (e : R ≃+* S) :
    (⊥ : Ideal R).IsMaximal ↔ (⊥ : Ideal S).IsMaximal 
goal: ⊥.IsMaximal ↔ ⊥.IsMaximal

full_name: Ideal.map_mul
code: theorem map_mul : map f (I * J) = map f I * map f J 
goal: Ideal.map f (I * J) = Ideal.map f I * Ideal.map f J

full_name: Ideal.mapHom
code: /-- The pushforward `Ideal.map` as a monoid-with-zero homomorphism. -/
@[simps]
def mapHom : Ideal R →*₀ Ideal S 
goal: Ideal R →*₀ Ideal S

full_name: Ideal.mapHom_apply
code: /-- The pushforward `Ideal.map` as a monoid-with-zero homomorphism. -/
@[simps]
def mapHom : Ideal R →*₀ Ideal S 
goal: (Ideal.mapHom f) I = Ideal.map f I

full_name: Ideal.map_pow
code: protected theorem map_pow (n : ℕ) : map f (I ^ n) = map f I ^ n 
goal: Ideal.map f (I ^ n) = Ideal.map f I ^ n

full_name: Ideal.comap_radical
code: theorem comap_radical : comap f (radical K) = radical (comap f K) 
goal: Ideal.comap f K.radical = (Ideal.comap f K).radical

full_name: Ideal.IsRadical.comap
code: theorem IsRadical.comap (hK : K.IsRadical) : (comap f K).IsRadical 
goal: (Ideal.comap f K).IsRadical

full_name: Ideal.map_radical_le
code: theorem map_radical_le : map f (radical I) ≤ radical (map f I) 
goal: Ideal.map f I.radical ≤ (Ideal.map f I).radical

full_name: Ideal.le_comap_mul
code: theorem le_comap_mul : comap f K * comap f L ≤ comap f (K * L) 
goal: Ideal.comap f K * Ideal.comap f L ≤ Ideal.comap f (K * L)

full_name: Ideal.le_comap_pow
code: theorem le_comap_pow (n : ℕ) : K.comap f ^ n ≤ (K ^ n).comap f 
goal: Ideal.comap f K ^ n ≤ Ideal.comap f (K ^ n)

full_name: RingHom.ker
code: /-- Kernel of a ring homomorphism as an ideal of the domain. -/
def ker : Ideal R 
goal: Ideal R

full_name: RingHom.mem_ker
code: /-- An element is in the kernel if and only if it maps to zero. -/
theorem mem_ker {r} : r ∈ ker f ↔ f r = 0 
goal: r ∈ RingHom.ker f ↔ f r = 0

full_name: RingHom.ker_eq
code: theorem ker_eq : (ker f : Set R) = Set.preimage f {0} 
goal: ↑(RingHom.ker f) = ⇑f ⁻¹' {0}

full_name: RingHom.ker_eq_comap_bot
code: theorem ker_eq_comap_bot (f : F) : ker f = Ideal.comap f ⊥ 
goal: RingHom.ker f = Ideal.comap f ⊥

full_name: RingHom.comap_ker
code: theorem comap_ker (f : S →+* R) (g : T →+* S) : f.ker.comap g = ker (f.comp g) 
goal: Ideal.comap g (RingHom.ker f) = RingHom.ker (f.comp g)

full_name: RingHom.not_one_mem_ker
code: /-- If the target is not the zero ring, then one is not in the kernel. -/
theorem not_one_mem_ker [Nontrivial S] (f : F) : (1 : R) ∉ ker f 
goal: 1 ∉ RingHom.ker f

full_name: RingHom.ker_ne_top
code: theorem ker_ne_top [Nontrivial S] (f : F) : ker f ≠ ⊤ 
goal: RingHom.ker f ≠ ⊤

full_name: Pi.ker_ringHom
code: lemma _root_.Pi.ker_ringHom {ι : Type*} {R : ι → Type*} [∀ i, Semiring (R i)]
    (φ : ∀ i, S →+* R i) : ker (Pi.ringHom φ) = ⨅ i, ker (φ i) 
goal: RingHom.ker (Pi.ringHom φ) = ⨅ i, RingHom.ker (φ i)

full_name: RingHom.ker_rangeSRestrict
code: @[simp]
theorem ker_rangeSRestrict (f : R →+* S) : ker f.rangeSRestrict = ker f 
goal: RingHom.ker f.rangeSRestrict = RingHom.ker f

full_name: RingHom.injective_iff_ker_eq_bot
code: theorem injective_iff_ker_eq_bot : Function.Injective f ↔ ker f = ⊥ 
goal: Function.Injective ⇑f ↔ RingHom.ker f = ⊥

full_name: RingHom.ker_eq_bot_iff_eq_zero
code: theorem ker_eq_bot_iff_eq_zero : ker f = ⊥ ↔ ∀ x, f x = 0 → x = 0 
goal: RingHom.ker f = ⊥ ↔ ∀ (x : R), f x = 0 → x = 0

full_name: RingHom.ker_coe_equiv
code: @[simp]
theorem ker_coe_equiv (f : R ≃+* S) : ker (f : R →+* S) = ⊥ 
goal: RingHom.ker ↑f = ⊥

full_name: RingHom.ker_equiv
code: @[simp]
theorem ker_equiv {F' : Type*} [EquivLike F' R S] [RingEquivClass F' R S] (f : F') : ker f = ⊥ 
goal: RingHom.ker f = ⊥

full_name: RingHom.sub_mem_ker_iff
code: theorem sub_mem_ker_iff {x y} : x - y ∈ ker f ↔ f x = f y 
goal: x - y ∈ RingHom.ker f ↔ f x = f y

full_name: RingHom.ker_rangeRestrict
code: @[simp]
theorem ker_rangeRestrict (f : R →+* S) : ker f.rangeRestrict = ker f 
goal: RingHom.ker f.rangeRestrict = RingHom.ker f

full_name: RingHom.ker_isPrime
code: /-- The kernel of a homomorphism to a domain is a prime ideal. -/
theorem ker_isPrime {F : Type*} [Ring R] [Ring S] [IsDomain S]
    [FunLike F R S] [RingHomClass F R S] (f : F) :
    (ker f).IsPrime 
goal: (RingHom.ker f).IsPrime

full_name: RingHom.ker_isMaximal_of_surjective
code: /-- The kernel of a homomorphism to a field is a maximal ideal. -/
theorem ker_isMaximal_of_surjective {R K F : Type*} [Ring R] [Field K]
    [FunLike F R K] [RingHomClass F R K] (f : F)
    (hf : Function.Surjective f) : (ker f).IsMaximal 
goal: (RingHom.ker f).IsMaximal

full_name: Ideal.map_eq_bot_iff_le_ker
code: theorem map_eq_bot_iff_le_ker {I : Ideal R} (f : F) : I.map f = ⊥ ↔ I ≤ RingHom.ker f 
goal: Ideal.map f I = ⊥ ↔ I ≤ RingHom.ker f

full_name: Ideal.ker_le_comap
code: theorem ker_le_comap {K : Ideal S} (f : F) : RingHom.ker f ≤ comap f K 
goal: RingHom.ker f ≤ Ideal.comap f K

full_name: Ideal.map_isPrime_of_equiv
code: theorem map_isPrime_of_equiv {F' : Type*} [EquivLike F' R S] [RingEquivClass F' R S]
    (f : F') {I : Ideal R} [IsPrime I] : IsPrime (map f I) 
goal: (Ideal.map f I).IsPrime

full_name: Ideal.map_sInf
code: theorem map_sInf {A : Set (Ideal R)} {f : F} (hf : Function.Surjective f) :
    (∀ J ∈ A, RingHom.ker f ≤ J) → map f (sInf A) = sInf (map f '' A) 
goal: (∀ J ∈ A, RingHom.ker f ≤ J) → Ideal.map f (sInf A) = sInf (Ideal.map f '' A)

full_name: Ideal.map_isPrime_of_surjective
code: theorem map_isPrime_of_surjective {f : F} (hf : Function.Surjective f) {I : Ideal R} [H : IsPrime I]
    (hk : RingHom.ker f ≤ I) : IsPrime (map f I) 
goal: (Ideal.map f I).IsPrime

full_name: Ideal.map_eq_bot_iff_of_injective
code: theorem map_eq_bot_iff_of_injective {I : Ideal R} {f : F} (hf : Function.Injective f) :
    I.map f = ⊥ ↔ I = ⊥ 
goal: Ideal.map f I = ⊥ ↔ I = ⊥

full_name: Ideal.map_eq_iff_sup_ker_eq_of_surjective
code: theorem map_eq_iff_sup_ker_eq_of_surjective {I J : Ideal R} (f : R →+* S)
    (hf : Function.Surjective f) : map f I = map f J ↔ I ⊔ RingHom.ker f = J ⊔ RingHom.ker f 
goal: Ideal.map f I = Ideal.map f J ↔ I ⊔ RingHom.ker f = J ⊔ RingHom.ker f

full_name: Ideal.map_radical_of_surjective
code: theorem map_radical_of_surjective {f : R →+* S} (hf : Function.Surjective f) {I : Ideal R}
    (h : RingHom.ker f ≤ I) : map f I.radical = (map f I).radical 
goal: Ideal.map f I.radical = (Ideal.map f I).radical

full_name: RingHom.liftOfRightInverseAux
code: /-- Auxiliary definition used to define `liftOfRightInverse` -/
def liftOfRightInverseAux (hf : Function.RightInverse f_inv f) (g : A →+* C)
    (hg : RingHom.ker f ≤ RingHom.ker g) :
    B →+* C 
goal: B →+* C

full_name: RingHom.liftOfRightInverseAux_comp_apply
code: @[simp]
theorem liftOfRightInverseAux_comp_apply (hf : Function.RightInverse f_inv f) (g : A →+* C)
    (hg : RingHom.ker f ≤ RingHom.ker g) (a : A) :
    (f.liftOfRightInverseAux f_inv hf g hg) (f a) = g a 
goal: (f.liftOfRightInverseAux f_inv hf g hg) (f a) = g a

full_name: RingHom.liftOfRightInverse
code: /-- `liftOfRightInverse f hf g hg` is the unique ring homomorphism `φ`

* such that `φ.comp f = g` (`RingHom.liftOfRightInverse_comp`),
* where `f : A →+* B` has a right_inverse `f_inv` (`hf`),
* and `g : B →+* C` satisfies `hg : f.ker ≤ g.ker`.

See `RingHom.eq_liftOfRightInverse` for the uniqueness lemma.

```
   A .
   |  \
 f |   \ g
   |    \
   v     \⌟
   B ----> C
      ∃!φ
```
-/
def liftOfRightInverse (hf : Function.RightInverse f_inv f) :
    { g : A →+* C // RingHom.ker f ≤ RingHom.ker g } ≃ (B →+* C) 
goal: { g // RingHom.ker f ≤ RingHom.ker g } ≃ (B →+* C)

full_name: RingHom.liftOfSurjective
code: /-- A non-computable version of `RingHom.liftOfRightInverse` for when no computable right
inverse is available, that uses `Function.surjInv`. -/
@[simp]
noncomputable abbrev liftOfSurjective (hf : Function.Surjective f) :
    { g : A →+* C // RingHom.ker f ≤ RingHom.ker g } ≃ (B →+* C) 
goal: { g // RingHom.ker f ≤ RingHom.ker g } ≃ (B →+* C)

full_name: RingHom.liftOfRightInverse_comp_apply
code: theorem liftOfRightInverse_comp_apply (hf : Function.RightInverse f_inv f)
    (g : { g : A →+* C // RingHom.ker f ≤ RingHom.ker g }) (x : A) :
    (f.liftOfRightInverse f_inv hf g) (f x) = g.1 x 
goal: ((f.liftOfRightInverse f_inv hf) g) (f x) = ↑g x

full_name: RingHom.liftOfRightInverse_comp
code: theorem liftOfRightInverse_comp (hf : Function.RightInverse f_inv f)
    (g : { g : A →+* C // RingHom.ker f ≤ RingHom.ker g }) :
    (f.liftOfRightInverse f_inv hf g).comp f = g 
goal: ((f.liftOfRightInverse f_inv hf) g).comp f = ↑g

full_name: RingHom.eq_liftOfRightInverse
code: theorem eq_liftOfRightInverse (hf : Function.RightInverse f_inv f) (g : A →+* C)
    (hg : RingHom.ker f ≤ RingHom.ker g) (h : B →+* C) (hh : h.comp f = g) :
    h = f.liftOfRightInverse f_inv hf ⟨g, hg⟩ 
goal: h = (f.liftOfRightInverse f_inv hf) ⟨g, hg⟩

full_name: AlgHom.coe_ker
code: lemma coe_ker : RingHom.ker f = RingHom.ker (f : A →+* B) 
goal: RingHom.ker f = RingHom.ker ↑f

full_name: AlgHom.coe_ideal_map
code: lemma coe_ideal_map (I : Ideal A) :
    Ideal.map f I = Ideal.map (f : A →+* B) I 
goal: Ideal.map f I = Ideal.map (↑f) I

full_name: Algebra.idealMap
code: /-- The induced linear map from `I` to the span of `I` in an `R`-algebra `S`. -/
@[simps!]
def idealMap (I : Ideal R) : I →ₗ[R] I.map (algebraMap R S) 
goal: ↥I →ₗ[R] ↥(Ideal.map (algebraMap R S) I)

full_name: Algebra.idealMap_apply_coe
code: /-- The induced linear map from `I` to the span of `I` in an `R`-algebra `S`. -/
@[simps!]
def idealMap (I : Ideal R) : I →ₗ[R] I.map (algebraMap R S) 
goal: ↑((Algebra.idealMap S I) c) = (algebraMap R S) ↑c