File: Mathlib/Algebra/Field/Subfield.lean

full_name: SubfieldClass
code: /-- `SubfieldClass S K` states `S` is a type of subsets `s ⊆ K` closed under field operations. -/
class SubfieldClass (S K : Type*) [DivisionRing K] [SetLike S K] extends SubringClass S K,
  InvMemClass S K : Prop
goal: Prop

full_name: SubfieldClass.toSubgroupClass
code: /-- A subfield contains `1`, products and inverses.

Be assured that we're not actually proving that subfields are subgroups:
`SubgroupClass` is really an abbreviation of `SubgroupWithOrWithoutZeroClass`.
 -/
instance (priority := 100) toSubgroupClass : SubgroupClass S K 
goal: SubgroupClass S K

full_name: SubfieldClass.nnratCast_mem
code: @[aesop safe apply (rule_sets := [SetLike])]
lemma nnratCast_mem (s : S) (q : ℚ≥0) : (q : K) ∈ s 
goal: ↑q ∈ s

full_name: SubfieldClass.ratCast_mem
code: @[aesop safe apply (rule_sets := [SetLike])]
lemma ratCast_mem (s : S) (q : ℚ) : (q : K) ∈ s 
goal: ↑q ∈ s

full_name: SubfieldClass.instNNRatCast
code: instance instNNRatCast (s : S) : NNRatCast s 
goal: NNRatCast ↥s

full_name: SubfieldClass.instRatCast
code: instance instRatCast (s : S) : RatCast s 
goal: RatCast ↥s

full_name: SubfieldClass.coe_nnratCast
code: @[simp, norm_cast] lemma coe_nnratCast (s : S) (q : ℚ≥0) : ((q : s) : K) = q 
goal: ↑↑q = ↑q

full_name: SubfieldClass.coe_ratCast
code: @[simp, norm_cast] lemma coe_ratCast (s : S) (x : ℚ) : ((x : s) : K) = x 
goal: ↑↑x = ↑x

full_name: SubfieldClass.nnqsmul_mem
code: @[aesop safe apply (rule_sets := [SetLike])]
lemma nnqsmul_mem (s : S) (q : ℚ≥0) (hx : x ∈ s) : q • x ∈ s 
goal: q • x ∈ s

full_name: SubfieldClass.qsmul_mem
code: @[aesop safe apply (rule_sets := [SetLike])]
lemma qsmul_mem (s : S) (q : ℚ) (hx : x ∈ s) : q • x ∈ s 
goal: q • x ∈ s

full_name: SubfieldClass.ofScientific_mem
code: @[aesop safe apply (rule_sets := [SetLike])]
lemma ofScientific_mem (s : S) {b : Bool} {n m : ℕ} :
    (OfScientific.ofScientific n b m : K) ∈ s 
goal: OfScientific.ofScientific n b m ∈ s

full_name: SubfieldClass.instSMulNNRat
code: instance instSMulNNRat (s : S) : SMul ℚ≥0 s 
goal: SMul ℚ≥0 ↥s

full_name: SubfieldClass.instSMulRat
code: instance instSMulRat (s : S) : SMul ℚ s 
goal: SMul ℚ ↥s

full_name: SubfieldClass.coe_nnqsmul
code: @[simp, norm_cast] lemma coe_nnqsmul (s : S) (q : ℚ≥0) (x : s) : ↑(q • x) = q • (x : K) 
goal: ↑(q • x) = q • ↑x

full_name: SubfieldClass.coe_qsmul
code: @[simp, norm_cast] lemma coe_qsmul (s : S) (q : ℚ) (x : s) : ↑(q • x) = q • (x : K) 
goal: ↑(q • x) = q • ↑x

full_name: SubfieldClass.toDivisionRing
code: /-- A subfield inherits a division ring structure -/
instance (priority := 75) toDivisionRing (s : S) : DivisionRing s 
goal: DivisionRing ↥s

full_name: SubfieldClass.toField
code: /-- A subfield of a field inherits a field structure -/
instance (priority := 75) toField {K} [Field K] [SetLike S K] [SubfieldClass S K] (s : S) :
    Field s 
goal: Field ↥s

full_name: Subfield
code: /-- `Subfield R` is the type of subfields of `R`. A subfield of `R` is a subset `s` that is a
  multiplicative submonoid and an additive subgroup. Note in particular that it shares the
  same 0 and 1 as R. -/
structure Subfield (K : Type u) [DivisionRing K] extends Subring K where
  /-- A subfield is closed under multiplicative inverses. -/
  inv_mem' : ∀ x ∈ carrier, x⁻¹ ∈ carrier
goal: Type u

full_name: Subfield.inv_mem'
code: /-- `Subfield R` is the type of subfields of `R`. A subfield of `R` is a subset `s` that is a
  multiplicative submonoid and an additive subgroup. Note in particular that it shares the
  same 0 and 1 as R. -/
structure Subfield (K : Type u) [DivisionRing K] extends Subring K where
  /-- A subfield is closed under multiplicative inverses. -/
  inv_mem' : ∀ x ∈ carrier, x⁻¹ ∈ carrier
goal: x ∈ self.carrier → x⁻¹ ∈ self.carrier

full_name: Subfield.toAddSubgroup
code: /-- The underlying `AddSubgroup` of a subfield. -/
def toAddSubgroup (s : Subfield K) : AddSubgroup K 
goal: AddSubgroup K

full_name: Subfield.instSetLike
code: instance : SetLike (Subfield K) K 
goal: SetLike (Subfield K) K

full_name: Subfield.instSubfieldClass
code: instance : SubfieldClass (Subfield K) K 
goal: SubfieldClass (Subfield K) K

full_name: Subfield.mem_carrier
code: theorem mem_carrier {s : Subfield K} {x : K} : x ∈ s.carrier ↔ x ∈ s 
goal: x ∈ s.carrier ↔ x ∈ s

full_name: Subfield.mem_mk
code: @[simp]
theorem mem_mk {S : Subring K} {x : K} (h) : x ∈ (⟨S, h⟩ : Subfield K) ↔ x ∈ S 
goal: x ∈ { toSubring := S, inv_mem' := h } ↔ x ∈ S

full_name: Subfield.coe_set_mk
code: @[simp]
theorem coe_set_mk (S : Subring K) (h) : ((⟨S, h⟩ : Subfield K) : Set K) = S 
goal: ↑{ toSubring := S, inv_mem' := h } = ↑S

full_name: Subfield.mk_le_mk
code: @[simp]
theorem mk_le_mk {S S' : Subring K} (h h') : (⟨S, h⟩ : Subfield K) ≤ (⟨S', h'⟩ : Subfield K) ↔
    S ≤ S' 
goal: { toSubring := S, inv_mem' := h } ≤ { toSubring := S', inv_mem' := h' } ↔ S ≤ S'

full_name: Subfield.ext
code: /-- Two subfields are equal if they have the same elements. -/
@[ext]
theorem ext {S T : Subfield K} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T 
goal: S = T

full_name: Subfield.copy
code: /-- Copy of a subfield with a new `carrier` equal to the old one. Useful to fix definitional
equalities. -/
protected def copy (S : Subfield K) (s : Set K) (hs : s = ↑S) : Subfield K 
goal: Subfield K

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

full_name: Subfield.copy_eq
code: theorem copy_eq (S : Subfield K) (s : Set K) (hs : s = ↑S) : S.copy s hs = S 
goal: S.copy s hs = S

full_name: Subfield.coe_toSubring
code: @[simp]
theorem coe_toSubring (s : Subfield K) : (s.toSubring : Set K) = s 
goal: ↑s.toSubring = ↑s

full_name: Subfield.mem_toSubring
code: @[simp]
theorem mem_toSubring (s : Subfield K) (x : K) : x ∈ s.toSubring ↔ x ∈ s 
goal: x ∈ s.toSubring ↔ x ∈ s

full_name: Subring.toSubfield
code: /-- A `Subring` containing inverses is a `Subfield`. -/
def Subring.toSubfield (s : Subring K) (hinv : ∀ x ∈ s, x⁻¹ ∈ s) : Subfield K 
goal: Subfield K

full_name: Subfield.one_mem
code: /-- A subfield contains the field's 1. -/
protected theorem one_mem : (1 : K) ∈ s 
goal: 1 ∈ s

full_name: Subfield.zero_mem
code: /-- A subfield contains the field's 0. -/
protected theorem zero_mem : (0 : K) ∈ s 
goal: 0 ∈ s

full_name: Subfield.mul_mem
code: /-- A subfield is closed under multiplication. -/
protected theorem mul_mem {x y : K} : x ∈ s → y ∈ s → x * y ∈ s 
goal: x ∈ s → y ∈ s → x * y ∈ s

full_name: Subfield.add_mem
code: /-- A subfield is closed under addition. -/
protected theorem add_mem {x y : K} : x ∈ s → y ∈ s → x + y ∈ s 
goal: x ∈ s → y ∈ s → x + y ∈ s

full_name: Subfield.neg_mem
code: /-- A subfield is closed under negation. -/
protected theorem neg_mem {x : K} : x ∈ s → -x ∈ s 
goal: x ∈ s → -x ∈ s

full_name: Subfield.sub_mem
code: /-- A subfield is closed under subtraction. -/
protected theorem sub_mem {x y : K} : x ∈ s → y ∈ s → x - y ∈ s 
goal: x ∈ s → y ∈ s → x - y ∈ s

full_name: Subfield.inv_mem
code: /-- A subfield is closed under inverses. -/
protected theorem inv_mem {x : K} : x ∈ s → x⁻¹ ∈ s 
goal: x ∈ s → x⁻¹ ∈ s

full_name: Subfield.div_mem
code: /-- A subfield is closed under division. -/
protected theorem div_mem {x y : K} : x ∈ s → y ∈ s → x / y ∈ s 
goal: x ∈ s → y ∈ s → x / y ∈ s

full_name: Subfield.list_prod_mem
code: /-- Product of a list of elements in a subfield is in the subfield. -/
protected theorem list_prod_mem {l : List K} : (∀ x ∈ l, x ∈ s) → l.prod ∈ s 
goal: (∀ x ∈ l, x ∈ s) → l.prod ∈ s

full_name: Subfield.list_sum_mem
code: /-- Sum of a list of elements in a subfield is in the subfield. -/
protected theorem list_sum_mem {l : List K} : (∀ x ∈ l, x ∈ s) → l.sum ∈ s 
goal: (∀ x ∈ l, x ∈ s) → l.sum ∈ s

full_name: Subfield.multiset_sum_mem
code: /-- Sum of a multiset of elements in a `Subfield` is in the `Subfield`. -/
protected theorem multiset_sum_mem (m : Multiset K) : (∀ a ∈ m, a ∈ s) → m.sum ∈ s 
goal: (∀ a ∈ m, a ∈ s) → m.sum ∈ s

full_name: Subfield.sum_mem
code: /-- Sum of elements in a `Subfield` indexed by a `Finset` is in the `Subfield`. -/
protected theorem sum_mem {ι : Type*} {t : Finset ι} {f : ι → K} (h : ∀ c ∈ t, f c ∈ s) :
    (∑ i ∈ t, f i) ∈ s 
goal: ∑ i ∈ t, f i ∈ s

full_name: Subfield.pow_mem
code: protected theorem pow_mem {x : K} (hx : x ∈ s) (n : ℕ) : x ^ n ∈ s 
goal: x ^ n ∈ s

full_name: Subfield.zsmul_mem
code: protected theorem zsmul_mem {x : K} (hx : x ∈ s) (n : ℤ) : n • x ∈ s 
goal: n • x ∈ s

full_name: Subfield.intCast_mem
code: protected theorem intCast_mem (n : ℤ) : (n : K) ∈ s 
goal: ↑n ∈ s

full_name: Subfield.zpow_mem
code: theorem zpow_mem {x : K} (hx : x ∈ s) (n : ℤ) : x ^ n ∈ s 
goal: x ^ n ∈ s

full_name: Subfield.instRingSubtypeMem
code: instance : Ring s 
goal: Ring ↥s

full_name: Subfield.instDivSubtypeMem
code: instance : Div s 
goal: Div ↥s

full_name: Subfield.instInvSubtypeMem
code: instance : Inv s 
goal: Inv ↥s

full_name: Subfield.instPowSubtypeMemInt
code: instance : Pow s ℤ 
goal: Pow ↥s ℤ

full_name: Subfield.toDivisionRing
code: instance toDivisionRing (s : Subfield K) : DivisionRing s 
goal: DivisionRing ↥s

full_name: Subfield.toField
code: /-- A subfield inherits a field structure -/
instance toField {K} [Field K] (s : Subfield K) : Field s 
goal: Field ↥s

full_name: Subfield.coe_add
code: @[simp, norm_cast]
theorem coe_add (x y : s) : (↑(x + y) : K) = ↑x + ↑y 
goal: ↑(x + y) = ↑x + ↑y

full_name: Subfield.coe_sub
code: @[simp, norm_cast]
theorem coe_sub (x y : s) : (↑(x - y) : K) = ↑x - ↑y 
goal: ↑(x - y) = ↑x - ↑y

full_name: Subfield.coe_neg
code: @[simp, norm_cast]
theorem coe_neg (x : s) : (↑(-x) : K) = -↑x 
goal: ↑(-x) = -↑x

full_name: Subfield.coe_mul
code: @[simp, norm_cast]
theorem coe_mul (x y : s) : (↑(x * y) : K) = ↑x * ↑y 
goal: ↑(x * y) = ↑x * ↑y

full_name: Subfield.coe_div
code: @[simp, norm_cast]
theorem coe_div (x y : s) : (↑(x / y) : K) = ↑x / ↑y 
goal: ↑(x / y) = ↑x / ↑y

full_name: Subfield.coe_inv
code: @[simp, norm_cast]
theorem coe_inv (x : s) : (↑x⁻¹ : K) = (↑x)⁻¹ 
goal: ↑x⁻¹ = (↑x)⁻¹

full_name: Subfield.coe_zero
code: @[simp, norm_cast]
theorem coe_zero : ((0 : s) : K) = 0 
goal: ↑0 = 0

full_name: Subfield.coe_one
code: @[simp, norm_cast]
theorem coe_one : ((1 : s) : K) = 1 
goal: ↑1 = 1

full_name: Subfield.subtype
code: /-- The embedding from a subfield of the field `K` to `K`. -/
def subtype (s : Subfield K) : s →+* K 
goal: ↥s →+* K

full_name: Subfield.coe_subtype
code: @[simp]
theorem coe_subtype : ⇑(s.subtype) = ((↑) : s → K) 
goal: ⇑s.subtype = Subtype.val

full_name: Subfield.toSubring_subtype_eq_subtype
code: theorem toSubring_subtype_eq_subtype (S : Subfield K) :
    S.toSubring.subtype = S.subtype 
goal: S.subtype = S.subtype

full_name: Subfield.mem_toSubmonoid
code: theorem mem_toSubmonoid {s : Subfield K} {x : K} : x ∈ s.toSubmonoid ↔ x ∈ s 
goal: x ∈ s.toSubmonoid ↔ x ∈ s

full_name: Subfield.coe_toSubmonoid
code: @[simp]
theorem coe_toSubmonoid : (s.toSubmonoid : Set K) = s 
goal: ↑s.toSubmonoid = ↑s

full_name: Subfield.mem_toAddSubgroup
code: @[simp]
theorem mem_toAddSubgroup {s : Subfield K} {x : K} : x ∈ s.toAddSubgroup ↔ x ∈ s 
goal: x ∈ s.toAddSubgroup ↔ x ∈ s

full_name: Subfield.coe_toAddSubgroup
code: @[simp]
theorem coe_toAddSubgroup : (s.toAddSubgroup : Set K) = s 
goal: ↑s.toAddSubgroup = ↑s

full_name: Subfield.instTop
code: /-- The subfield of `K` containing all elements of `K`. -/
instance : Top (Subfield K) 
goal: Top (Subfield K)

full_name: Subfield.instInhabited
code: instance : Inhabited (Subfield K) 
goal: Inhabited (Subfield K)

full_name: Subfield.mem_top
code: @[simp]
theorem mem_top (x : K) : x ∈ (⊤ : Subfield K) 
goal: x ∈ ⊤

full_name: Subfield.coe_top
code: @[simp]
theorem coe_top : ((⊤ : Subfield K) : Set K) = Set.univ 
goal: ↑⊤ = Set.univ

full_name: Subfield.topEquiv
code: /-- The ring equiv between the top element of `Subfield K` and `K`. -/
def topEquiv : (⊤ : Subfield K) ≃+* K 
goal: ↥⊤ ≃+* K

full_name: Subfield.comap
code: /-- The preimage of a subfield along a ring homomorphism is a subfield. -/
def comap (s : Subfield L) : Subfield K 
goal: Subfield K

full_name: Subfield.coe_comap
code: @[simp]
theorem coe_comap (s : Subfield L) : (s.comap f : Set K) = f ⁻¹' s 
goal: ↑(Subfield.comap f s) = ⇑f ⁻¹' ↑s

full_name: Subfield.mem_comap
code: @[simp]
theorem mem_comap {s : Subfield L} {f : K →+* L} {x : K} : x ∈ s.comap f ↔ f x ∈ s 
goal: x ∈ Subfield.comap f s ↔ f x ∈ s

full_name: Subfield.comap_comap
code: theorem comap_comap (s : Subfield M) (g : L →+* M) (f : K →+* L) :
    (s.comap g).comap f = s.comap (g.comp f) 
goal: Subfield.comap f (Subfield.comap g s) = Subfield.comap (g.comp f) s

full_name: Subfield.map
code: /-- The image of a subfield along a ring homomorphism is a subfield. -/
def map (s : Subfield K) : Subfield L 
goal: Subfield L

full_name: Subfield.coe_map
code: @[simp]
theorem coe_map : (s.map f : Set L) = f '' s 
goal: ↑(Subfield.map f s) = ⇑f '' ↑s

full_name: Subfield.mem_map
code: @[simp]
theorem mem_map {f : K →+* L} {s : Subfield K} {y : L} : y ∈ s.map f ↔ ∃ x ∈ s, f x = y 
goal: y ∈ Subfield.map f s ↔ ∃ x ∈ s, f x = y

full_name: Subfield.map_map
code: theorem map_map (g : L →+* M) (f : K →+* L) : (s.map f).map g = s.map (g.comp f) 
goal: Subfield.map g (Subfield.map f s) = Subfield.map (g.comp f) s

full_name: Subfield.map_le_iff_le_comap
code: theorem map_le_iff_le_comap {f : K →+* L} {s : Subfield K} {t : Subfield L} :
    s.map f ≤ t ↔ s ≤ t.comap f 
goal: Subfield.map f s ≤ t ↔ s ≤ Subfield.comap f t

full_name: Subfield.gc_map_comap
code: theorem gc_map_comap (f : K →+* L) : GaloisConnection (map f) (comap f) 
goal: GaloisConnection (Subfield.map f) (Subfield.comap f)

full_name: RingHom.fieldRange
code: /-- The range of a ring homomorphism, as a subfield of the target. See Note [range copy pattern]. -/
def fieldRange : Subfield L 
goal: Subfield L

full_name: RingHom.coe_fieldRange
code: @[simp]
theorem coe_fieldRange : (f.fieldRange : Set L) = Set.range f 
goal: ↑f.fieldRange = Set.range ⇑f

full_name: RingHom.mem_fieldRange
code: @[simp]
theorem mem_fieldRange {f : K →+* L} {y : L} : y ∈ f.fieldRange ↔ ∃ x, f x = y 
goal: y ∈ f.fieldRange ↔ ∃ x, f x = y

full_name: RingHom.fieldRange_eq_map
code: theorem fieldRange_eq_map : f.fieldRange = Subfield.map f ⊤ 
goal: f.fieldRange = Subfield.map f ⊤

full_name: RingHom.map_fieldRange
code: theorem map_fieldRange : f.fieldRange.map g = (g.comp f).fieldRange 
goal: Subfield.map g f.fieldRange = (g.comp f).fieldRange

full_name: RingHom.fintypeFieldRange
code: /-- The range of a morphism of fields is a fintype, if the domain is a fintype.

Note that this instance can cause a diamond with `Subtype.Fintype` if `L` is also a fintype. -/
instance fintypeFieldRange [Fintype K] [DecidableEq L] (f : K →+* L) : Fintype f.fieldRange 
goal: Fintype ↥f.fieldRange

full_name: Subfield.instInf
code: /-- The inf of two subfields is their intersection. -/
instance : Inf (Subfield K) 
goal: Inf (Subfield K)

full_name: Subfield.coe_inf
code: @[simp]
theorem coe_inf (p p' : Subfield K) : ((p ⊓ p' : Subfield K) : Set K) = p.carrier ∩ p'.carrier 
goal: ↑(p ⊓ p') = p.carrier ∩ p'.carrier

full_name: Subfield.mem_inf
code: @[simp]
theorem mem_inf {p p' : Subfield K} {x : K} : x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p' 
goal: x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p'

full_name: Subfield.instInfSet
code: instance : InfSet (Subfield K) 
goal: InfSet (Subfield K)

full_name: Subfield.coe_sInf
code: @[simp, norm_cast]
theorem coe_sInf (S : Set (Subfield K)) : ((sInf S : Subfield K) : Set K) = ⋂ s ∈ S, ↑s 
goal: ↑(sInf S) = ⋂ s ∈ S, ↑s

full_name: Subfield.mem_sInf
code: theorem mem_sInf {S : Set (Subfield K)} {x : K} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p 
goal: x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p

full_name: Subfield.sInf_toSubring
code: @[simp]
theorem sInf_toSubring (s : Set (Subfield K)) :
    (sInf s).toSubring = ⨅ t ∈ s, Subfield.toSubring t 
goal: (sInf s).toSubring = ⨅ t ∈ s, t.toSubring

full_name: Subfield.isGLB_sInf
code: theorem isGLB_sInf (S : Set (Subfield K)) : IsGLB S (sInf S) 
goal: IsGLB S (sInf S)

full_name: Subfield.instCompleteLattice
code: /-- Subfields of a ring form a complete lattice. -/
instance : CompleteLattice (Subfield K) 
goal: CompleteLattice (Subfield K)

full_name: Subfield.closure
code: /-- The `Subfield` generated by a set. -/
def closure (s : Set K) : Subfield K 
goal: Subfield K

full_name: Subfield.mem_closure
code: theorem mem_closure {x : K} {s : Set K} : x ∈ closure s ↔ ∀ S : Subfield K, s ⊆ S → x ∈ S 
goal: x ∈ Subfield.closure s ↔ ∀ (S : Subfield K), s ⊆ ↑S → x ∈ S

full_name: Subfield.subset_closure
code: /-- The subfield generated by a set includes the set. -/
@[simp, aesop safe 20 apply (rule_sets := [SetLike])]
theorem subset_closure {s : Set K} : s ⊆ closure s 
goal: s ⊆ ↑(Subfield.closure s)

full_name: Subfield.subring_closure_le
code: theorem subring_closure_le (s : Set K) : Subring.closure s ≤ (closure s).toSubring 
goal: Subring.closure s ≤ (Subfield.closure s).toSubring

full_name: Subfield.not_mem_of_not_mem_closure
code: theorem not_mem_of_not_mem_closure {s : Set K} {P : K} (hP : P ∉ closure s) : P ∉ s 
goal: P ∉ s

full_name: Subfield.closure_le
code: /-- A subfield `t` includes `closure s` if and only if it includes `s`. -/
@[simp]
theorem closure_le {s : Set K} {t : Subfield K} : closure s ≤ t ↔ s ⊆ t 
goal: Subfield.closure s ≤ t ↔ s ⊆ ↑t

full_name: Subfield.closure_mono
code: /-- Subfield closure of a set is monotone in its argument: if `s ⊆ t`,
then `closure s ≤ closure t`. -/
theorem closure_mono ⦃s t : Set K⦄ (h : s ⊆ t) : closure s ≤ closure t 
goal: Subfield.closure s ≤ Subfield.closure t

full_name: Subfield.closure_eq_of_le
code: theorem closure_eq_of_le {s : Set K} {t : Subfield K} (h₁ : s ⊆ t) (h₂ : t ≤ closure s) :
    closure s = t 
goal: Subfield.closure s = t

full_name: Subfield.closure_induction
code: /-- An induction principle for closure membership. If `p` holds for `1`, and all elements
of `s`, and is preserved under addition, negation, and multiplication, then `p` holds for all
elements of the closure of `s`. -/
@[elab_as_elim]
theorem closure_induction {s : Set K} {p : K → Prop} {x} (h : x ∈ closure s) (mem : ∀ x ∈ s, p x)
    (one : p 1) (add : ∀ x y, p x → p y → p (x + y)) (neg : ∀ x, p x → p (-x))
    (inv : ∀ x, p x → p x⁻¹) (mul : ∀ x y, p x → p y → p (x * y)) : p x 
goal: p x

full_name: Subfield.gi
code: /-- `closure` forms a Galois insertion with the coercion to set. -/
protected def gi : GaloisInsertion (@closure K _) (↑) 
goal: GaloisInsertion Subfield.closure SetLike.coe

full_name: Subfield.closure_eq
code: /-- Closure of a subfield `S` equals `S`. -/
theorem closure_eq (s : Subfield K) : closure (s : Set K) = s 
goal: Subfield.closure ↑s = s

full_name: Subfield.closure_empty
code: @[simp]
theorem closure_empty : closure (∅ : Set K) = ⊥ 
goal: Subfield.closure ∅ = ⊥

full_name: Subfield.closure_univ
code: @[simp]
theorem closure_univ : closure (Set.univ : Set K) = ⊤ 
goal: Subfield.closure Set.univ = ⊤

full_name: Subfield.closure_union
code: theorem closure_union (s t : Set K) : closure (s ∪ t) = closure s ⊔ closure t 
goal: Subfield.closure (s ∪ t) = Subfield.closure s ⊔ Subfield.closure t

full_name: Subfield.closure_iUnion
code: theorem closure_iUnion {ι} (s : ι → Set K) : closure (⋃ i, s i) = ⨆ i, closure (s i) 
goal: Subfield.closure (⋃ i, s i) = ⨆ i, Subfield.closure (s i)

full_name: Subfield.closure_sUnion
code: theorem closure_sUnion (s : Set (Set K)) : closure (⋃₀ s) = ⨆ t ∈ s, closure t 
goal: Subfield.closure (⋃₀ s) = ⨆ t ∈ s, Subfield.closure t

full_name: Subfield.map_sup
code: theorem map_sup (s t : Subfield K) (f : K →+* L) : (s ⊔ t).map f = s.map f ⊔ t.map f 
goal: Subfield.map f (s ⊔ t) = Subfield.map f s ⊔ Subfield.map f t

full_name: Subfield.map_iSup
code: theorem map_iSup {ι : Sort*} (f : K →+* L) (s : ι → Subfield K) :
    (iSup s).map f = ⨆ i, (s i).map f 
goal: Subfield.map f (iSup s) = ⨆ i, Subfield.map f (s i)

full_name: Subfield.comap_inf
code: theorem comap_inf (s t : Subfield L) (f : K →+* L) : (s ⊓ t).comap f = s.comap f ⊓ t.comap f 
goal: Subfield.comap f (s ⊓ t) = Subfield.comap f s ⊓ Subfield.comap f t

full_name: Subfield.comap_iInf
code: theorem comap_iInf {ι : Sort*} (f : K →+* L) (s : ι → Subfield L) :
    (iInf s).comap f = ⨅ i, (s i).comap f 
goal: Subfield.comap f (iInf s) = ⨅ i, Subfield.comap f (s i)

full_name: Subfield.map_bot
code: @[simp]
theorem map_bot (f : K →+* L) : (⊥ : Subfield K).map f = ⊥ 
goal: Subfield.map f ⊥ = ⊥

full_name: Subfield.comap_top
code: @[simp]
theorem comap_top (f : K →+* L) : (⊤ : Subfield L).comap f = ⊤ 
goal: Subfield.comap f ⊤ = ⊤

full_name: Subfield.mem_iSup_of_directed
code: /-- The underlying set of a non-empty directed sSup of subfields is just a union of the subfields.
  Note that this fails without the directedness assumption (the union of two subfields is
  typically not a subfield) -/
theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Subfield K} (hS : Directed (· ≤ ·) S)
    {x : K} : (x ∈ ⨆ i, S i) ↔ ∃ i, x ∈ S i 
goal: x ∈ ⨆ i, S i ↔ ∃ i, x ∈ S i

full_name: Subfield.coe_iSup_of_directed
code: theorem coe_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Subfield K} (hS : Directed (· ≤ ·) S) :
    ((⨆ i, S i : Subfield K) : Set K) = ⋃ i, ↑(S i) 
goal: ↑(⨆ i, S i) = ⋃ i, ↑(S i)

full_name: Subfield.mem_sSup_of_directedOn
code: theorem mem_sSup_of_directedOn {S : Set (Subfield K)} (Sne : S.Nonempty) (hS : DirectedOn (· ≤ ·) S)
    {x : K} : x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s 
goal: x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s

full_name: Subfield.coe_sSup_of_directedOn
code: theorem coe_sSup_of_directedOn {S : Set (Subfield K)} (Sne : S.Nonempty)
    (hS : DirectedOn (· ≤ ·) S) : (↑(sSup S) : Set K) = ⋃ s ∈ S, ↑s 
goal: ↑(sSup S) = ⋃ s ∈ S, ↑s

full_name: RingHom.rangeRestrictField
code: /-- Restriction of a ring homomorphism to its range interpreted as a subfield. -/
def rangeRestrictField (f : K →+* L) : K →+* f.fieldRange 
goal: K →+* ↥f.fieldRange

full_name: RingHom.coe_rangeRestrictField
code: @[simp]
theorem coe_rangeRestrictField (f : K →+* L) (x : K) : (f.rangeRestrictField x : L) = f x 
goal: ↑(f.rangeRestrictField x) = f x

full_name: RingHom.eqLocusField
code: /-- The subfield of elements `x : R` such that `f x = g x`, i.e.,
the equalizer of f and g as a subfield of R -/
def eqLocusField (f g : K →+* L) : Subfield K 
goal: Subfield K

full_name: RingHom.eqOn_field_closure
code: /-- If two ring homomorphisms are equal on a set, then they are equal on its subfield closure. -/
theorem eqOn_field_closure {f g : K →+* L} {s : Set K} (h : Set.EqOn f g s) :
    Set.EqOn f g (closure s) 
goal: Set.EqOn ⇑f ⇑g ↑(Subfield.closure s)

full_name: RingHom.eq_of_eqOn_subfield_top
code: theorem eq_of_eqOn_subfield_top {f g : K →+* L} (h : Set.EqOn f g (⊤ : Subfield K)) : f = g 
goal: f = g

full_name: RingHom.eq_of_eqOn_of_field_closure_eq_top
code: theorem eq_of_eqOn_of_field_closure_eq_top {s : Set K} (hs : closure s = ⊤) {f g : K →+* L}
    (h : s.EqOn f g) : f = g 
goal: f = g

full_name: RingHom.field_closure_preimage_le
code: theorem field_closure_preimage_le (f : K →+* L) (s : Set L) :
    closure (f ⁻¹' s) ≤ (closure s).comap f 
goal: Subfield.closure (⇑f ⁻¹' s) ≤ Subfield.comap f (Subfield.closure s)

full_name: RingHom.map_field_closure
code: /-- The image under a ring homomorphism of the subfield generated by a set equals
the subfield generated by the image of the set. -/
theorem map_field_closure (f : K →+* L) (s : Set K) : (closure s).map f = closure (f '' s) 
goal: Subfield.map f (Subfield.closure s) = Subfield.closure (⇑f '' s)

full_name: Subfield.inclusion
code: /-- The ring homomorphism associated to an inclusion of subfields. -/
def inclusion {S T : Subfield K} (h : S ≤ T) : S →+* T 
goal: ↥S →+* ↥T

full_name: Subfield.fieldRange_subtype
code: @[simp]
theorem fieldRange_subtype (s : Subfield K) : s.subtype.fieldRange = s 
goal: s.subtype.fieldRange = s

full_name: RingEquiv.subfieldCongr
code: /-- Makes the identity isomorphism from a proof two subfields of a multiplicative
    monoid are equal. -/
def subfieldCongr (h : s = t) : s ≃+* t 
goal: ↥s ≃+* ↥t

full_name: Subfield.closure_preimage_le
code: theorem closure_preimage_le (f : K →+* L) (s : Set L) : closure (f ⁻¹' s) ≤ (closure s).comap f 
goal: Subfield.closure (⇑f ⁻¹' s) ≤ Subfield.comap f (Subfield.closure s)

full_name: Subfield.multiset_prod_mem
code: /-- Product of a multiset of elements in a subfield is in the subfield. -/
protected theorem multiset_prod_mem (m : Multiset K) : (∀ a ∈ m, a ∈ s) → m.prod ∈ s 
goal: (∀ a ∈ m, a ∈ s) → m.prod ∈ s

full_name: Subfield.prod_mem
code: /-- Product of elements of a subfield indexed by a `Finset` is in the subfield. -/
protected theorem prod_mem {ι : Type*} {t : Finset ι} {f : ι → K} (h : ∀ c ∈ t, f c ∈ s) :
    (∏ i ∈ t, f i) ∈ s 
goal: ∏ i ∈ t, f i ∈ s

full_name: Subfield.toAlgebra
code: instance toAlgebra : Algebra s K 
goal: Algebra (↥s) K

full_name: _private.Mathlib.Algebra.Field.Subfield.0.Subfield.commClosure
code: /-- The `Subfield` generated by a set in a field. -/
private def commClosure (s : Set K) : Subfield K 
goal: Subfield K

full_name: _private.Mathlib.Algebra.Field.Subfield.0.Subfield.commClosure_eq_closure
code: private theorem commClosure_eq_closure {s : Set K} : commClosure s = closure s 
goal: Subfield.commClosure s = Subfield.closure s

full_name: Subfield.mem_closure_iff
code: theorem mem_closure_iff {s : Set K} {x} :
    x ∈ closure s ↔ ∃ y ∈ Subring.closure s, ∃ z ∈ Subring.closure s, y / z = x 
goal: x ∈ Subfield.closure s ↔ ∃ y ∈ Subring.closure s, ∃ z ∈ Subring.closure s, y / z = x

full_name: Subfield.map_comap_eq
code: theorem map_comap_eq (f : K →+* L) (s : Subfield L) : (s.comap f).map f = s ⊓ f.fieldRange 
goal: Subfield.map f (Subfield.comap f s) = s ⊓ f.fieldRange

full_name: Subfield.map_comap_eq_self
code: theorem map_comap_eq_self
    {f : K →+* L} {s : Subfield L} (h : s ≤ f.fieldRange) : (s.comap f).map f = s 
goal: Subfield.map f (Subfield.comap f s) = s

full_name: Subfield.map_comap_eq_self_of_surjective
code: theorem map_comap_eq_self_of_surjective
    {f : K →+* L} (hf : Function.Surjective f) (s : Subfield L) : (s.comap f).map f = s 
goal: Subfield.map f (Subfield.comap f s) = s

full_name: Subfield.comap_map
code: theorem comap_map (f : K →+* L) (s : Subfield K) : (s.map f).comap f = s 
goal: Subfield.comap f (Subfield.map f s) = s