File: Mathlib/FieldTheory/Adjoin.lean

full_name: IntermediateField.adjoin
code: /-- `adjoin F S` extends a field `F` by adjoining a set `S ⊆ E`. -/
def adjoin : IntermediateField F E 
goal: IntermediateField F E

full_name: IntermediateField.mem_adjoin_iff
code: theorem mem_adjoin_iff (x : E) :
    x ∈ adjoin F S ↔ ∃ r s : MvPolynomial S F,
      x = MvPolynomial.aeval Subtype.val r / MvPolynomial.aeval Subtype.val s 
goal: x ∈ IntermediateField.adjoin F S ↔ ∃ r s, x = (MvPolynomial.aeval Subtype.val) r / (MvPolynomial.aeval Subtype.val) s

full_name: IntermediateField.mem_adjoin_simple_iff
code: theorem mem_adjoin_simple_iff {α : E} (x : E) :
    x ∈ adjoin F {α} ↔ ∃ r s : F[X], x = aeval α r / aeval α s 
goal: x ∈ F⟮α⟯ ↔ ∃ r s, x = (Polynomial.aeval α) r / (Polynomial.aeval α) s

full_name: IntermediateField.adjoin_le_iff
code: @[simp]
theorem adjoin_le_iff {S : Set E} {T : IntermediateField F E} : adjoin F S ≤ T ↔ S ≤ T 
goal: IntermediateField.adjoin F S ≤ T ↔ S ≤ ↑T

full_name: IntermediateField.gc
code: theorem gc : GaloisConnection (adjoin F : Set E → IntermediateField F E)
    (fun (x : IntermediateField F E) => (x : Set E)) 
goal: GaloisConnection (IntermediateField.adjoin F) fun x => ↑x

full_name: IntermediateField.gi
code: /-- Galois insertion between `adjoin` and `coe`. -/
def gi : GaloisInsertion (adjoin F : Set E → IntermediateField F E)
    (fun (x : IntermediateField F E) => (x : Set E)) 
goal: GaloisInsertion (IntermediateField.adjoin F) fun x => ↑x

full_name: IntermediateField.instCompleteLattice
code: instance : CompleteLattice (IntermediateField F E) 
goal: CompleteLattice (IntermediateField F E)

full_name: IntermediateField.instInhabited
code: instance : Inhabited (IntermediateField F E) 
goal: Inhabited (IntermediateField F E)

full_name: IntermediateField.instUnique
code: instance : Unique (IntermediateField F F) 
goal: Unique (IntermediateField F F)

full_name: IntermediateField.coe_bot
code: theorem coe_bot : ↑(⊥ : IntermediateField F E) = Set.range (algebraMap F E) 
goal: ↑⊥ = Set.range ⇑(algebraMap F E)

full_name: IntermediateField.mem_bot
code: theorem mem_bot {x : E} : x ∈ (⊥ : IntermediateField F E) ↔ x ∈ Set.range (algebraMap F E) 
goal: x ∈ ⊥ ↔ x ∈ Set.range ⇑(algebraMap F E)

full_name: IntermediateField.bot_toSubalgebra
code: @[simp]
theorem bot_toSubalgebra : (⊥ : IntermediateField F E).toSubalgebra = ⊥ 
goal: ⊥.toSubalgebra = ⊥

full_name: IntermediateField.coe_top
code: @[simp]
theorem coe_top : ↑(⊤ : IntermediateField F E) = (Set.univ : Set E) 
goal: ↑⊤ = Set.univ

full_name: IntermediateField.mem_top
code: @[simp]
theorem mem_top {x : E} : x ∈ (⊤ : IntermediateField F E) 
goal: x ∈ ⊤

full_name: IntermediateField.top_toSubalgebra
code: @[simp]
theorem top_toSubalgebra : (⊤ : IntermediateField F E).toSubalgebra = ⊤ 
goal: ⊤.toSubalgebra = ⊤

full_name: IntermediateField.top_toSubfield
code: @[simp]
theorem top_toSubfield : (⊤ : IntermediateField F E).toSubfield = ⊤ 
goal: ⊤.toSubfield = ⊤

full_name: IntermediateField.coe_inf
code: @[simp, norm_cast]
theorem coe_inf (S T : IntermediateField F E) : (↑(S ⊓ T) : Set E) = (S : Set E) ∩ T 
goal: ↑(S ⊓ T) = ↑S ∩ ↑T

full_name: IntermediateField.mem_inf
code: @[simp]
theorem mem_inf {S T : IntermediateField F E} {x : E} : x ∈ S ⊓ T ↔ x ∈ S ∧ x ∈ T 
goal: x ∈ S ⊓ T ↔ x ∈ S ∧ x ∈ T

full_name: IntermediateField.inf_toSubalgebra
code: @[simp]
theorem inf_toSubalgebra (S T : IntermediateField F E) :
    (S ⊓ T).toSubalgebra = S.toSubalgebra ⊓ T.toSubalgebra 
goal: (S ⊓ T).toSubalgebra = S.toSubalgebra ⊓ T.toSubalgebra

full_name: IntermediateField.inf_toSubfield
code: @[simp]
theorem inf_toSubfield (S T : IntermediateField F E) :
    (S ⊓ T).toSubfield = S.toSubfield ⊓ T.toSubfield 
goal: (S ⊓ T).toSubfield = S.toSubfield ⊓ T.toSubfield

full_name: IntermediateField.coe_sInf
code: @[simp, norm_cast]
theorem coe_sInf (S : Set (IntermediateField F E)) : (↑(sInf S) : Set E) =
    sInf ((fun (x : IntermediateField F E) => (x : Set E)) '' S) 
goal: ↑(sInf S) = sInf ((fun x => ↑x) '' S)

full_name: IntermediateField.sInf_toSubalgebra
code: @[simp]
theorem sInf_toSubalgebra (S : Set (IntermediateField F E)) :
    (sInf S).toSubalgebra = sInf (toSubalgebra '' S) 
goal: (sInf S).toSubalgebra = sInf (IntermediateField.toSubalgebra '' S)

full_name: IntermediateField.sInf_toSubfield
code: @[simp]
theorem sInf_toSubfield (S : Set (IntermediateField F E)) :
    (sInf S).toSubfield = sInf (toSubfield '' S) 
goal: (sInf S).toSubfield = sInf (IntermediateField.toSubfield '' S)

full_name: IntermediateField.coe_iInf
code: @[simp, norm_cast]
theorem coe_iInf {ι : Sort*} (S : ι → IntermediateField F E) : (↑(iInf S) : Set E) = ⋂ i, S i 
goal: ↑(iInf S) = ⋂ i, ↑(S i)

full_name: IntermediateField.iInf_toSubalgebra
code: @[simp]
theorem iInf_toSubalgebra {ι : Sort*} (S : ι → IntermediateField F E) :
    (iInf S).toSubalgebra = ⨅ i, (S i).toSubalgebra 
goal: (iInf S).toSubalgebra = ⨅ i, (S i).toSubalgebra

full_name: IntermediateField.iInf_toSubfield
code: @[simp]
theorem iInf_toSubfield {ι : Sort*} (S : ι → IntermediateField F E) :
    (iInf S).toSubfield = ⨅ i, (S i).toSubfield 
goal: (iInf S).toSubfield = ⨅ i, (S i).toSubfield

full_name: IntermediateField.equivOfEq
code: /-- Construct an algebra isomorphism from an equality of intermediate fields -/
@[simps! apply]
def equivOfEq {S T : IntermediateField F E} (h : S = T) : S ≃ₐ[F] T 
goal: ↥S ≃ₐ[F] ↥T

full_name: IntermediateField.equivOfEq_apply
code: /-- Construct an algebra isomorphism from an equality of intermediate fields -/
@[simps! apply]
def equivOfEq {S T : IntermediateField F E} (h : S = T) : S ≃ₐ[F] T 
goal: (IntermediateField.equivOfEq h) x = ⟨↑x, ⋯⟩

full_name: IntermediateField.equivOfEq_symm
code: @[simp]
theorem equivOfEq_symm {S T : IntermediateField F E} (h : S = T) :
    (equivOfEq h).symm = equivOfEq h.symm 
goal: (IntermediateField.equivOfEq h).symm = IntermediateField.equivOfEq ⋯

full_name: IntermediateField.equivOfEq_rfl
code: @[simp]
theorem equivOfEq_rfl (S : IntermediateField F E) : equivOfEq (rfl : S = S) = AlgEquiv.refl 
goal: IntermediateField.equivOfEq ⋯ = AlgEquiv.refl

full_name: IntermediateField.equivOfEq_trans
code: @[simp]
theorem equivOfEq_trans {S T U : IntermediateField F E} (hST : S = T) (hTU : T = U) :
    (equivOfEq hST).trans (equivOfEq hTU) = equivOfEq (hST.trans hTU) 
goal: (IntermediateField.equivOfEq hST).trans (IntermediateField.equivOfEq hTU) = IntermediateField.equivOfEq ⋯

full_name: IntermediateField.botEquiv
code: /-- The bottom intermediate_field is isomorphic to the field. -/
noncomputable def botEquiv : (⊥ : IntermediateField F E) ≃ₐ[F] F 
goal: ↥⊥ ≃ₐ[F] F

full_name: IntermediateField.botEquiv_def
code: theorem botEquiv_def (x : F) : botEquiv F E (algebraMap F (⊥ : IntermediateField F E) x) = x 
goal: (IntermediateField.botEquiv F E) ((algebraMap F ↥⊥) x) = x

full_name: IntermediateField.botEquiv_symm
code: @[simp]
theorem botEquiv_symm (x : F) : (botEquiv F E).symm x = algebraMap F _ x 
goal: (IntermediateField.botEquiv F E).symm x = (algebraMap F ↥⊥) x

full_name: IntermediateField.algebraOverBot
code: noncomputable instance algebraOverBot : Algebra (⊥ : IntermediateField F E) F 
goal: Algebra (↥⊥) F

full_name: IntermediateField.coe_algebraMap_over_bot
code: theorem coe_algebraMap_over_bot :
    (algebraMap (⊥ : IntermediateField F E) F : (⊥ : IntermediateField F E) → F) =
      IntermediateField.botEquiv F E 
goal: ⇑(algebraMap (↥⊥) F) = ⇑(IntermediateField.botEquiv F E)

full_name: IntermediateField.isScalarTower_over_bot
code: instance isScalarTower_over_bot : IsScalarTower (⊥ : IntermediateField F E) F E 
goal: IsScalarTower (↥⊥) F E

full_name: IntermediateField.topEquiv_symm_apply_coe
code: /-- The top `IntermediateField` is isomorphic to the field.

This is the intermediate field version of `Subalgebra.topEquiv`. -/
@[simps!]
def topEquiv : (⊤ : IntermediateField F E) ≃ₐ[F] E 
goal: ∀ (a : E), ↑(IntermediateField.topEquiv.symm a) = ↑((↑↑Subalgebra.topEquiv).symm a)

full_name: IntermediateField.topEquiv_apply
code: /-- The top `IntermediateField` is isomorphic to the field.

This is the intermediate field version of `Subalgebra.topEquiv`. -/
@[simps!]
def topEquiv : (⊤ : IntermediateField F E) ≃ₐ[F] E 
goal: ∀ (a : ↥⊤.toSubalgebra), IntermediateField.topEquiv a = ↑a

full_name: IntermediateField.topEquiv
code: /-- The top `IntermediateField` is isomorphic to the field.

This is the intermediate field version of `Subalgebra.topEquiv`. -/
@[simps!]
def topEquiv : (⊤ : IntermediateField F E) ≃ₐ[F] E 
goal: ↥⊤ ≃ₐ[F] E

full_name: IntermediateField.restrictScalars_bot_eq_self
code: @[simp]
theorem restrictScalars_bot_eq_self (K : IntermediateField F E) :
    (⊥ : IntermediateField K E).restrictScalars _ = K 
goal: IntermediateField.restrictScalars F ⊥ = K

full_name: IntermediateField.restrictScalars_top
code: @[simp]
theorem restrictScalars_top {K : Type*} [Field K] [Algebra K E] [Algebra K F]
    [IsScalarTower K F E] : (⊤ : IntermediateField F E).restrictScalars K = ⊤ 
goal: IntermediateField.restrictScalars K ⊤ = ⊤

full_name: IntermediateField.map_bot
code: @[simp]
theorem map_bot (f : E →ₐ[F] K) :
    IntermediateField.map f ⊥ = ⊥ 
goal: IntermediateField.map f ⊥ = ⊥

full_name: IntermediateField.map_sup
code: theorem map_sup (s t : IntermediateField F E) (f : E →ₐ[F] K) : (s ⊔ t).map f = s.map f ⊔ t.map f 
goal: IntermediateField.map f (s ⊔ t) = IntermediateField.map f s ⊔ IntermediateField.map f t

full_name: IntermediateField.map_iSup
code: theorem map_iSup {ι : Sort*} (f : E →ₐ[F] K) (s : ι → IntermediateField F E) :
    (iSup s).map f = ⨆ i, (s i).map f 
goal: IntermediateField.map f (iSup s) = ⨆ i, IntermediateField.map f (s i)

full_name: AlgHom.fieldRange_eq_map
code: theorem _root_.AlgHom.fieldRange_eq_map (f : E →ₐ[F] K) :
    f.fieldRange = IntermediateField.map f ⊤ 
goal: f.fieldRange = IntermediateField.map f ⊤

full_name: AlgHom.map_fieldRange
code: theorem _root_.AlgHom.map_fieldRange {L : Type*} [Field L] [Algebra F L]
    (f : E →ₐ[F] K) (g : K →ₐ[F] L) : f.fieldRange.map g = (g.comp f).fieldRange 
goal: IntermediateField.map g f.fieldRange = (g.comp f).fieldRange

full_name: AlgHom.fieldRange_eq_top
code: theorem _root_.AlgHom.fieldRange_eq_top {f : E →ₐ[F] K} :
    f.fieldRange = ⊤ ↔ Function.Surjective f 
goal: f.fieldRange = ⊤ ↔ Function.Surjective ⇑f

full_name: AlgEquiv.fieldRange_eq_top
code: @[simp]
theorem _root_.AlgEquiv.fieldRange_eq_top (f : E ≃ₐ[F] K) :
    (f : E →ₐ[F] K).fieldRange = ⊤ 
goal: (↑f).fieldRange = ⊤

full_name: IntermediateField.fieldRange_comp_val
code: theorem fieldRange_comp_val : (f.comp L.val).fieldRange = L.map f 
goal: (f.comp L.val).fieldRange = IntermediateField.map f L

full_name: IntermediateField.equivMap
code: /-- An intermediate field is isomorphic to its image under an `AlgHom`
(which is automatically injective) -/
noncomputable def equivMap : L ≃ₐ[F] L.map f 
goal: ↥L ≃ₐ[F] ↥(IntermediateField.map f L)

full_name: IntermediateField.coe_equivMap_apply
code: @[simp]
theorem coe_equivMap_apply (x : L) : ↑(equivMap L f x) = f x 
goal: ↑((L.equivMap f) x) = f ↑x

full_name: IntermediateField.adjoin_eq_range_algebraMap_adjoin
code: theorem adjoin_eq_range_algebraMap_adjoin :
    (adjoin F S : Set E) = Set.range (algebraMap (adjoin F S) E) 
goal: ↑(IntermediateField.adjoin F S) = Set.range ⇑(algebraMap (↥(IntermediateField.adjoin F S)) E)

full_name: IntermediateField.adjoin.algebraMap_mem
code: theorem adjoin.algebraMap_mem (x : F) : algebraMap F E x ∈ adjoin F S 
goal: (algebraMap F E) x ∈ IntermediateField.adjoin F S

full_name: IntermediateField.adjoin.range_algebraMap_subset
code: theorem adjoin.range_algebraMap_subset : Set.range (algebraMap F E) ⊆ adjoin F S 
goal: Set.range ⇑(algebraMap F E) ⊆ ↑(IntermediateField.adjoin F S)

full_name: IntermediateField.adjoin.fieldCoe
code: instance adjoin.fieldCoe : CoeTC F (adjoin F S) 
goal: CoeTC F ↥(IntermediateField.adjoin F S)

full_name: IntermediateField.subset_adjoin
code: theorem subset_adjoin : S ⊆ adjoin F S 
goal: S ⊆ ↑(IntermediateField.adjoin F S)

full_name: IntermediateField.adjoin.setCoe
code: instance adjoin.setCoe : CoeTC S (adjoin F S) 
goal: CoeTC ↑S ↥(IntermediateField.adjoin F S)

full_name: IntermediateField.adjoin.mono
code: @[mono]
theorem adjoin.mono (T : Set E) (h : S ⊆ T) : adjoin F S ≤ adjoin F T 
goal: IntermediateField.adjoin F S ≤ IntermediateField.adjoin F T

full_name: IntermediateField.adjoin_contains_field_as_subfield
code: theorem adjoin_contains_field_as_subfield (F : Subfield E) : (F : Set E) ⊆ adjoin F S 
goal: ↑F ⊆ ↑(IntermediateField.adjoin (↥F) S)

full_name: IntermediateField.subset_adjoin_of_subset_left
code: theorem subset_adjoin_of_subset_left {F : Subfield E} {T : Set E} (HT : T ⊆ F) : T ⊆ adjoin F S 
goal: T ⊆ ↑(IntermediateField.adjoin (↥F) S)

full_name: IntermediateField.subset_adjoin_of_subset_right
code: theorem subset_adjoin_of_subset_right {T : Set E} (H : T ⊆ S) : T ⊆ adjoin F S 
goal: T ⊆ ↑(IntermediateField.adjoin F S)

full_name: IntermediateField.adjoin_empty
code: @[simp]
theorem adjoin_empty (F E : Type*) [Field F] [Field E] [Algebra F E] : adjoin F (∅ : Set E) = ⊥ 
goal: F⟮⟯ = ⊥

full_name: IntermediateField.adjoin_univ
code: @[simp]
theorem adjoin_univ (F E : Type*) [Field F] [Field E] [Algebra F E] :
    adjoin F (Set.univ : Set E) = ⊤ 
goal: IntermediateField.adjoin F Set.univ = ⊤

full_name: IntermediateField.adjoin_le_subfield
code: /-- If `K` is a field with `F ⊆ K` and `S ⊆ K` then `adjoin F S ≤ K`. -/
theorem adjoin_le_subfield {K : Subfield E} (HF : Set.range (algebraMap F E) ⊆ K) (HS : S ⊆ K) :
    (adjoin F S).toSubfield ≤ K 
goal: (IntermediateField.adjoin F S).toSubfield ≤ K

full_name: IntermediateField.adjoin_subset_adjoin_iff
code: theorem adjoin_subset_adjoin_iff {F' : Type*} [Field F'] [Algebra F' E] {S S' : Set E} :
    (adjoin F S : Set E) ⊆ adjoin F' S' ↔
      Set.range (algebraMap F E) ⊆ adjoin F' S' ∧ S ⊆ adjoin F' S' 
goal: ↑(IntermediateField.adjoin F S) ⊆ ↑(IntermediateField.adjoin F' S') ↔
  Set.range ⇑(algebraMap F E) ⊆ ↑(IntermediateField.adjoin F' S') ∧ S ⊆ ↑(IntermediateField.adjoin F' S')

full_name: IntermediateField.adjoin_adjoin_left
code: /-- `F[S][T] = F[S ∪ T]` -/
theorem adjoin_adjoin_left (T : Set E) :
    (adjoin (adjoin F S) T).restrictScalars _ = adjoin F (S ∪ T) 
goal: IntermediateField.restrictScalars F (IntermediateField.adjoin (↥(IntermediateField.adjoin F S)) T) =
  IntermediateField.adjoin F (S ∪ T)

full_name: IntermediateField.adjoin_insert_adjoin
code: @[simp]
theorem adjoin_insert_adjoin (x : E) :
    adjoin F (insert x (adjoin F S : Set E)) = adjoin F (insert x S) 
goal: IntermediateField.adjoin F (insert x ↑(IntermediateField.adjoin F S)) = IntermediateField.adjoin F (insert x S)

full_name: IntermediateField.adjoin_adjoin_comm
code: /-- `F[S][T] = F[T][S]` -/
theorem adjoin_adjoin_comm (T : Set E) :
    (adjoin (adjoin F S) T).restrictScalars F = (adjoin (adjoin F T) S).restrictScalars F 
goal: IntermediateField.restrictScalars F (IntermediateField.adjoin (↥(IntermediateField.adjoin F S)) T) =
  IntermediateField.restrictScalars F (IntermediateField.adjoin (↥(IntermediateField.adjoin F T)) S)

full_name: IntermediateField.adjoin_map
code: theorem adjoin_map {E' : Type*} [Field E'] [Algebra F E'] (f : E →ₐ[F] E') :
    (adjoin F S).map f = adjoin F (f '' S) 
goal: IntermediateField.map f (IntermediateField.adjoin F S) = IntermediateField.adjoin F (⇑f '' S)

full_name: IntermediateField.lift_adjoin
code: @[simp]
theorem lift_adjoin (K : IntermediateField F E) (S : Set K) :
    lift (adjoin F S) = adjoin F (Subtype.val '' S) 
goal: IntermediateField.lift (IntermediateField.adjoin F S) = IntermediateField.adjoin F (Subtype.val '' S)

full_name: IntermediateField.lift_adjoin_simple
code: theorem lift_adjoin_simple (K : IntermediateField F E) (α : K) :
    lift (adjoin F {α}) = adjoin F {α.1} 
goal: IntermediateField.lift F⟮α⟯ = F⟮↑α⟯

full_name: IntermediateField.lift_bot
code: @[simp]
theorem lift_bot (K : IntermediateField F E) :
    lift (F := K) ⊥ = ⊥ 
goal: IntermediateField.lift ⊥ = ⊥

full_name: IntermediateField.lift_top
code: @[simp]
theorem lift_top (K : IntermediateField F E) :
    lift (F := K) ⊤ = K 
goal: IntermediateField.lift ⊤ = K

full_name: IntermediateField.adjoin_self
code: @[simp]
theorem adjoin_self (K : IntermediateField F E) :
    adjoin F K = K 
goal: IntermediateField.adjoin F ↑K = K

full_name: IntermediateField.restrictScalars_adjoin
code: theorem restrictScalars_adjoin (K : IntermediateField F E) (S : Set E) :
    restrictScalars F (adjoin K S) = adjoin F (K ∪ S) 
goal: IntermediateField.restrictScalars F (IntermediateField.adjoin (↥K) S) = IntermediateField.adjoin F (↑K ∪ S)

full_name: IntermediateField.extendScalars_adjoin
code: theorem extendScalars_adjoin {K : IntermediateField F E} {S : Set E} (h : K ≤ adjoin F S) :
    extendScalars h = adjoin K S 
goal: IntermediateField.extendScalars h = IntermediateField.adjoin (↥K) S

full_name: IntermediateField.restrictScalars_adjoin_of_algEquiv
code: /-- If `E / L / F` and `E / L' / F` are two field extension towers, `L ≃ₐ[F] L'` is an isomorphism
compatible with `E / L` and `E / L'`, then for any subset `S` of `E`, `L(S)` and `L'(S)` are
equal as intermediate fields of `E / F`. -/
theorem restrictScalars_adjoin_of_algEquiv
    {L L' : Type*} [Field L] [Field L']
    [Algebra F L] [Algebra L E] [Algebra F L'] [Algebra L' E]
    [IsScalarTower F L E] [IsScalarTower F L' E] (i : L ≃ₐ[F] L')
    (hi : algebraMap L E = (algebraMap L' E) ∘ i) (S : Set E) :
    (adjoin L S).restrictScalars F = (adjoin L' S).restrictScalars F 
goal: IntermediateField.restrictScalars F (IntermediateField.adjoin L S) =
  IntermediateField.restrictScalars F (IntermediateField.adjoin L' S)

full_name: IntermediateField.algebra_adjoin_le_adjoin
code: theorem algebra_adjoin_le_adjoin : Algebra.adjoin F S ≤ (adjoin F S).toSubalgebra 
goal: Algebra.adjoin F S ≤ (IntermediateField.adjoin F S).toSubalgebra

full_name: IntermediateField.adjoin_eq_algebra_adjoin
code: theorem adjoin_eq_algebra_adjoin (inv_mem : ∀ x ∈ Algebra.adjoin F S, x⁻¹ ∈ Algebra.adjoin F S) :
    (adjoin F S).toSubalgebra = Algebra.adjoin F S 
goal: (IntermediateField.adjoin F S).toSubalgebra = Algebra.adjoin F S

full_name: IntermediateField.eq_adjoin_of_eq_algebra_adjoin
code: theorem eq_adjoin_of_eq_algebra_adjoin (K : IntermediateField F E)
    (h : K.toSubalgebra = Algebra.adjoin F S) : K = adjoin F S 
goal: K = IntermediateField.adjoin F S

full_name: IntermediateField.adjoin_eq_top_of_algebra
code: theorem adjoin_eq_top_of_algebra (hS : Algebra.adjoin F S = ⊤) : adjoin F S = ⊤ 
goal: IntermediateField.adjoin F S = ⊤

full_name: IntermediateField.adjoin_induction
code: @[elab_as_elim]
theorem adjoin_induction {s : Set E} {p : E → Prop} {x} (h : x ∈ adjoin F s) (mem : ∀ x ∈ s, p x)
    (algebraMap : ∀ x, p (algebraMap F E x)) (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: _private.Mathlib.FieldTheory.Adjoin.0.IntermediateField.mkInsertTerm.run
code: /-- Supporting function for the `F⟮x₁,x₂,...,xₙ⟯` adjunction notation. -/
private partial def mkInsertTerm {m : Type → Type} [Monad m] [MonadQuotation m]
    (xs : TSyntaxArray `term) : m Term 
goal: m Lean.Term

full_name: _private.Mathlib.FieldTheory.Adjoin.0.IntermediateField.mkInsertTerm
code: /-- Supporting function for the `F⟮x₁,x₂,...,xₙ⟯` adjunction notation. -/
private partial def mkInsertTerm {m : Type → Type} [Monad m] [MonadQuotation m]
    (xs : TSyntaxArray `term) : m Term 
goal: m Lean.Term

full_name: IntermediateField.«_aux_Mathlib_FieldTheory_Adjoin___macroRules_IntermediateField_term_⟮_,,⟯_1»
code: macro:max K:term "⟮" xs:term,* "⟯" : term => do ``(adjoin $K $(← mkInsertTerm xs.getElems))
goal: Lean.Macro

full_name: IntermediateField.«term_⟮_,,⟯»
code: macro:max K:term "⟮" xs:term,* "⟯" : term => do ``(adjoin $K $(← mkInsertTerm xs.getElems))
goal: Lean.TrailingParserDescr

full_name: IntermediateField.delabAdjoinNotation
code: @[delab app.IntermediateField.adjoin]
partial def delabAdjoinNotation : Delab 
goal: Lean.PrettyPrinter.Delaborator.Delab

full_name: IntermediateField.delabAdjoinNotation.delabInsertArray
code: @[delab app.IntermediateField.adjoin]
partial def delabAdjoinNotation : Delab 
goal: Lean.PrettyPrinter.Delaborator.DelabM (List Lean.Term)

full_name: IntermediateField.mem_adjoin_simple_self
code: theorem mem_adjoin_simple_self : α ∈ F⟮α⟯ 
goal: α ∈ F⟮α⟯

full_name: IntermediateField.AdjoinSimple.gen
code: /-- generator of `F⟮α⟯` -/
def AdjoinSimple.gen : F⟮α⟯ 
goal: ↥F⟮α⟯

full_name: IntermediateField.AdjoinSimple.coe_gen
code: @[simp]
theorem AdjoinSimple.coe_gen : (AdjoinSimple.gen F α : E) = α 
goal: ↑(IntermediateField.AdjoinSimple.gen F α) = α

full_name: IntermediateField.AdjoinSimple.algebraMap_gen
code: theorem AdjoinSimple.algebraMap_gen : algebraMap F⟮α⟯ E (AdjoinSimple.gen F α) = α 
goal: (algebraMap (↥F⟮α⟯) E) (IntermediateField.AdjoinSimple.gen F α) = α

full_name: IntermediateField.AdjoinSimple.isIntegral_gen
code: @[simp]
theorem AdjoinSimple.isIntegral_gen : IsIntegral F (AdjoinSimple.gen F α) ↔ IsIntegral F α 
goal: IsIntegral F (IntermediateField.AdjoinSimple.gen F α) ↔ IsIntegral F α

full_name: IntermediateField.adjoin_simple_adjoin_simple
code: theorem adjoin_simple_adjoin_simple (β : E) : F⟮α⟯⟮β⟯.restrictScalars F = F⟮α, β⟯ 
goal: IntermediateField.restrictScalars F (↥F⟮α⟯)⟮β⟯ = F⟮α, β⟯

full_name: IntermediateField.adjoin_simple_comm
code: theorem adjoin_simple_comm (β : E) : F⟮α⟯⟮β⟯.restrictScalars F = F⟮β⟯⟮α⟯.restrictScalars F 
goal: IntermediateField.restrictScalars F (↥F⟮α⟯)⟮β⟯ = IntermediateField.restrictScalars F (↥F⟮β⟯)⟮α⟯

full_name: IntermediateField.adjoin_algebraic_toSubalgebra
code: theorem adjoin_algebraic_toSubalgebra {S : Set E} (hS : ∀ x ∈ S, IsAlgebraic F x) :
    (IntermediateField.adjoin F S).toSubalgebra = Algebra.adjoin F S 
goal: (IntermediateField.adjoin F S).toSubalgebra = Algebra.adjoin F S

full_name: IntermediateField.adjoin_simple_toSubalgebra_of_integral
code: theorem adjoin_simple_toSubalgebra_of_integral (hα : IsIntegral F α) :
    F⟮α⟯.toSubalgebra = Algebra.adjoin F {α} 
goal: F⟮α⟯.toSubalgebra = Algebra.adjoin F {α}

full_name: isSplittingField_iff_intermediateField
code: /-- Characterize `IsSplittingField` with `IntermediateField.adjoin` instead of `Algebra.adjoin`. -/
theorem _root_.isSplittingField_iff_intermediateField {p : F[X]} :
    p.IsSplittingField F E ↔ p.Splits (algebraMap F E) ∧ adjoin F (p.rootSet E) = ⊤ 
goal: Polynomial.IsSplittingField F E p ↔ Polynomial.Splits (algebraMap F E) p ∧ IntermediateField.adjoin F (p.rootSet E) = ⊤

full_name: IntermediateField.isSplittingField_iff
code: theorem isSplittingField_iff {p : F[X]} {K : IntermediateField F E} :
    p.IsSplittingField F K ↔ p.Splits (algebraMap F K) ∧ K = adjoin F (p.rootSet E) 
goal: Polynomial.IsSplittingField F (↥K) p ↔
  Polynomial.Splits (algebraMap F ↥K) p ∧ K = IntermediateField.adjoin F (p.rootSet E)

full_name: IntermediateField.adjoin_rootSet_isSplittingField
code: theorem adjoin_rootSet_isSplittingField {p : F[X]} (hp : p.Splits (algebraMap F E)) :
    p.IsSplittingField F (adjoin F (p.rootSet E)) 
goal: Polynomial.IsSplittingField F (↥(IntermediateField.adjoin F (p.rootSet E))) p

full_name: IntermediateField.le_sup_toSubalgebra
code: theorem le_sup_toSubalgebra : E1.toSubalgebra ⊔ E2.toSubalgebra ≤ (E1 ⊔ E2).toSubalgebra 
goal: E1.toSubalgebra ⊔ E2.toSubalgebra ≤ (E1 ⊔ E2).toSubalgebra

full_name: IntermediateField.sup_toSubalgebra_of_isAlgebraic_right
code: theorem sup_toSubalgebra_of_isAlgebraic_right [Algebra.IsAlgebraic K E2] :
    (E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra 
goal: (E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra

full_name: IntermediateField.sup_toSubalgebra_of_isAlgebraic_left
code: theorem sup_toSubalgebra_of_isAlgebraic_left [Algebra.IsAlgebraic K E1] :
    (E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra 
goal: (E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra

full_name: IntermediateField.sup_toSubalgebra_of_isAlgebraic
code: /-- The compositum of two intermediate fields is equal to the compositum of them
as subalgebras, if one of them is algebraic over the base field. -/
theorem sup_toSubalgebra_of_isAlgebraic
    (halg : Algebra.IsAlgebraic K E1 ∨ Algebra.IsAlgebraic K E2) :
    (E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra 
goal: (E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra

full_name: IntermediateField.sup_toSubalgebra_of_left
code: theorem sup_toSubalgebra_of_left [FiniteDimensional K E1] :
    (E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra 
goal: (E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra

full_name: IntermediateField.sup_toSubalgebra_of_right
code: theorem sup_toSubalgebra_of_right [FiniteDimensional K E2] :
    (E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra 
goal: (E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra

full_name: IntermediateField.finiteDimensional_sup
code: instance finiteDimensional_sup [FiniteDimensional K E1] [FiniteDimensional K E2] :
    FiniteDimensional K (E1 ⊔ E2 : IntermediateField K L) 
goal: FiniteDimensional K ↥(E1 ⊔ E2)

full_name: IntermediateField.coe_iSup_of_directed
code: theorem coe_iSup_of_directed [Nonempty ι] (dir : Directed (· ≤ ·) t) :
    ↑(iSup t) = ⋃ i, (t i : Set L) 
goal: ↑(iSup t) = ⋃ i, ↑(t i)

full_name: IntermediateField.toSubalgebra_iSup_of_directed
code: theorem toSubalgebra_iSup_of_directed (dir : Directed (· ≤ ·) t) :
    (iSup t).toSubalgebra = ⨆ i, (t i).toSubalgebra 
goal: (iSup t).toSubalgebra = ⨆ i, (t i).toSubalgebra

full_name: IntermediateField.finiteDimensional_iSup_of_finite
code: instance finiteDimensional_iSup_of_finite [h : Finite ι] [∀ i, FiniteDimensional K (t i)] :
    FiniteDimensional K (⨆ i, t i : IntermediateField K L) 
goal: FiniteDimensional K ↥(⨆ i, t i)

full_name: IntermediateField.finiteDimensional_iSup_of_finset
code: instance finiteDimensional_iSup_of_finset
    /- Porting note: changed `h` from `∀ i ∈ s, FiniteDimensional K (t i)` because this caused an
      error. See `finiteDimensional_iSup_of_finset'` for a stronger version, that was the one
      used in mathlib3. -/
    {s : Finset ι} [∀ i, FiniteDimensional K (t i)] :
    FiniteDimensional K (⨆ i ∈ s, t i : IntermediateField K L) 
goal: FiniteDimensional K ↥(⨆ i ∈ s, t i)

full_name: IntermediateField.finiteDimensional_iSup_of_finset'
code: theorem finiteDimensional_iSup_of_finset'
    /- Porting note: this was the mathlib3 version. Using `[h : ...]`, as in mathlib3, causes the
    error "invalid parametric local instance". -/
    {s : Finset ι} (h : ∀ i ∈ s, FiniteDimensional K (t i)) :
    FiniteDimensional K (⨆ i ∈ s, t i : IntermediateField K L) 
goal: FiniteDimensional K ↥(⨆ i ∈ s, t i)

full_name: IntermediateField.isSplittingField_iSup
code: /-- A compositum of splitting fields is a splitting field -/
theorem isSplittingField_iSup {p : ι → K[X]}
    {s : Finset ι} (h0 : ∏ i ∈ s, p i ≠ 0) (h : ∀ i ∈ s, (p i).IsSplittingField K (t i)) :
    (∏ i ∈ s, p i).IsSplittingField K (⨆ i ∈ s, t i : IntermediateField K L) 
goal: Polynomial.IsSplittingField K (↥(⨆ i ∈ s, t i)) (∏ i ∈ s, p i)

full_name: IntermediateField.adjoin_toSubalgebra_of_isAlgebraic
code: /-- If `K / E / F` is a field extension tower, `L` is an intermediate field of `K / F`, such that
either `E / F` or `L / F` is algebraic, then `E(L) = E[L]`. -/
theorem adjoin_toSubalgebra_of_isAlgebraic (L : IntermediateField F K)
    (halg : Algebra.IsAlgebraic F E ∨ Algebra.IsAlgebraic F L) :
    (adjoin E (L : Set K)).toSubalgebra = Algebra.adjoin E (L : Set K) 
goal: (IntermediateField.adjoin E ↑L).toSubalgebra = Algebra.adjoin E ↑L

full_name: IntermediateField.adjoin_toSubalgebra_of_isAlgebraic_left
code: theorem adjoin_toSubalgebra_of_isAlgebraic_left (L : IntermediateField F K)
    [halg : Algebra.IsAlgebraic F E] :
    (adjoin E (L : Set K)).toSubalgebra = Algebra.adjoin E (L : Set K) 
goal: (IntermediateField.adjoin E ↑L).toSubalgebra = Algebra.adjoin E ↑L

full_name: IntermediateField.adjoin_toSubalgebra_of_isAlgebraic_right
code: theorem adjoin_toSubalgebra_of_isAlgebraic_right (L : IntermediateField F K)
    [halg : Algebra.IsAlgebraic F L] :
    (adjoin E (L : Set K)).toSubalgebra = Algebra.adjoin E (L : Set K) 
goal: (IntermediateField.adjoin E ↑L).toSubalgebra = Algebra.adjoin E ↑L

full_name: IntermediateField.adjoin_rank_le_of_isAlgebraic
code: /-- If `K / E / F` is a field extension tower, `L` is an intermediate field of `K / F`, such that
either `E / F` or `L / F` is algebraic, then `[E(L) : E] ≤ [L : F]`. A corollary of
`Subalgebra.adjoin_rank_le` since in this case `E(L) = E[L]`. -/
theorem adjoin_rank_le_of_isAlgebraic (L : IntermediateField F K)
    (halg : Algebra.IsAlgebraic F E ∨ Algebra.IsAlgebraic F L) :
    Module.rank E (adjoin E (L : Set K)) ≤ Module.rank F L 
goal: Module.rank E ↥(IntermediateField.adjoin E ↑L) ≤ Module.rank F ↥L

full_name: IntermediateField.adjoin_rank_le_of_isAlgebraic_left
code: theorem adjoin_rank_le_of_isAlgebraic_left (L : IntermediateField F K)
    [halg : Algebra.IsAlgebraic F E] :
    Module.rank E (adjoin E (L : Set K)) ≤ Module.rank F L 
goal: Module.rank E ↥(IntermediateField.adjoin E ↑L) ≤ Module.rank F ↥L

full_name: IntermediateField.adjoin_rank_le_of_isAlgebraic_right
code: theorem adjoin_rank_le_of_isAlgebraic_right (L : IntermediateField F K)
    [halg : Algebra.IsAlgebraic F L] :
    Module.rank E (adjoin E (L : Set K)) ≤ Module.rank F L 
goal: Module.rank E ↥(IntermediateField.adjoin E ↑L) ≤ Module.rank F ↥L

full_name: IntermediateField.adjoin_simple_le_iff
code: theorem adjoin_simple_le_iff {K : IntermediateField F E} : F⟮α⟯ ≤ K ↔ α ∈ K 
goal: F⟮α⟯ ≤ K ↔ α ∈ K

full_name: IntermediateField.biSup_adjoin_simple
code: theorem biSup_adjoin_simple : ⨆ x ∈ S, F⟮x⟯ = adjoin F S 
goal: ⨆ x ∈ S, F⟮x⟯ = IntermediateField.adjoin F S

full_name: IntermediateField.adjoin_simple_isCompactElement
code: /-- Adjoining a single element is compact in the lattice of intermediate fields. -/
theorem adjoin_simple_isCompactElement (x : E) : IsCompactElement F⟮x⟯ 
goal: CompleteLattice.IsCompactElement F⟮x⟯

full_name: IntermediateField.adjoin_finset_isCompactElement
code: /-- Adjoining a finite subset is compact in the lattice of intermediate fields. -/
theorem adjoin_finset_isCompactElement (S : Finset E) :
    IsCompactElement (adjoin F S : IntermediateField F E) 
goal: CompleteLattice.IsCompactElement (IntermediateField.adjoin F ↑S)

full_name: IntermediateField.adjoin_finite_isCompactElement
code: /-- Adjoining a finite subset is compact in the lattice of intermediate fields. -/
theorem adjoin_finite_isCompactElement {S : Set E} (h : S.Finite) : IsCompactElement (adjoin F S) 
goal: CompleteLattice.IsCompactElement (IntermediateField.adjoin F S)

full_name: IntermediateField.instIsCompactlyGenerated
code: /-- The lattice of intermediate fields is compactly generated. -/
instance : IsCompactlyGenerated (IntermediateField F E) 
goal: IsCompactlyGenerated (IntermediateField F E)

full_name: IntermediateField.exists_finset_of_mem_iSup
code: theorem exists_finset_of_mem_iSup {ι : Type*} {f : ι → IntermediateField F E} {x : E}
    (hx : x ∈ ⨆ i, f i) : ∃ s : Finset ι, x ∈ ⨆ i ∈ s, f i 
goal: ∃ s, x ∈ ⨆ i ∈ s, f i

full_name: IntermediateField.exists_finset_of_mem_supr'
code: theorem exists_finset_of_mem_supr' {ι : Type*} {f : ι → IntermediateField F E} {x : E}
    (hx : x ∈ ⨆ i, f i) : ∃ s : Finset (Σ i, f i), x ∈ ⨆ i ∈ s, F⟮(i.2 : E)⟯ 
goal: ∃ s, x ∈ ⨆ i ∈ s, F⟮↑i.snd⟯

full_name: IntermediateField.exists_finset_of_mem_supr''
code: theorem exists_finset_of_mem_supr'' {ι : Type*} {f : ι → IntermediateField F E}
    (h : ∀ i, Algebra.IsAlgebraic F (f i)) {x : E} (hx : x ∈ ⨆ i, f i) :
    ∃ s : Finset (Σ i, f i), x ∈ ⨆ i ∈ s, adjoin F ((minpoly F (i.2 : _)).rootSet E) 
goal: ∃ s, x ∈ ⨆ i ∈ s, IntermediateField.adjoin F ((minpoly F i.snd).rootSet E)

full_name: IntermediateField.exists_finset_of_mem_adjoin
code: theorem exists_finset_of_mem_adjoin {S : Set E} {x : E} (hx : x ∈ adjoin F S) :
    ∃ T : Finset E, (T : Set E) ⊆ S ∧ x ∈ adjoin F (T : Set E) 
goal: ∃ T, ↑T ⊆ S ∧ x ∈ IntermediateField.adjoin F ↑T

full_name: IntermediateField.adjoin_eq_bot_iff
code: @[simp]
theorem adjoin_eq_bot_iff : adjoin F S = ⊥ ↔ S ⊆ (⊥ : IntermediateField F E) 
goal: IntermediateField.adjoin F S = ⊥ ↔ S ⊆ ↑⊥

full_name: IntermediateField.adjoin_simple_eq_bot_iff
code: theorem adjoin_simple_eq_bot_iff : F⟮α⟯ = ⊥ ↔ α ∈ (⊥ : IntermediateField F E) 
goal: F⟮α⟯ = ⊥ ↔ α ∈ ⊥

full_name: IntermediateField.adjoin_zero
code: @[simp]
theorem adjoin_zero : F⟮(0 : E)⟯ = ⊥ 
goal: F⟮0⟯ = ⊥

full_name: IntermediateField.adjoin_one
code: @[simp]
theorem adjoin_one : F⟮(1 : E)⟯ = ⊥ 
goal: F⟮1⟯ = ⊥

full_name: IntermediateField.adjoin_intCast
code: @[simp]
theorem adjoin_intCast (n : ℤ) : F⟮(n : E)⟯ = ⊥ 
goal: F⟮↑n⟯ = ⊥

full_name: IntermediateField.adjoin_natCast
code: @[simp]
theorem adjoin_natCast (n : ℕ) : F⟮(n : E)⟯ = ⊥ 
goal: F⟮↑n⟯ = ⊥

full_name: IntermediateField.rank_eq_one_iff
code: @[simp]
theorem rank_eq_one_iff : Module.rank F K = 1 ↔ K = ⊥ 
goal: Module.rank F ↥K = 1 ↔ K = ⊥

full_name: IntermediateField.finrank_eq_one_iff
code: @[simp]
theorem finrank_eq_one_iff : finrank F K = 1 ↔ K = ⊥ 
goal: FiniteDimensional.finrank F ↥K = 1 ↔ K = ⊥

full_name: IntermediateField.rank_bot
code: @[simp] protected
theorem rank_bot : Module.rank F (⊥ : IntermediateField F E) = 1 
goal: Module.rank F ↥⊥ = 1

full_name: IntermediateField.finrank_bot
code: @[simp] protected
theorem finrank_bot : finrank F (⊥ : IntermediateField F E) = 1 
goal: FiniteDimensional.finrank F ↥⊥ = 1

full_name: IntermediateField.rank_bot'
code: @[simp] theorem rank_bot' : Module.rank (⊥ : IntermediateField F E) E = Module.rank F E 
goal: Module.rank (↥⊥) E = Module.rank F E

full_name: IntermediateField.finrank_bot'
code: @[simp] theorem finrank_bot' : finrank (⊥ : IntermediateField F E) E = finrank F E 
goal: FiniteDimensional.finrank (↥⊥) E = FiniteDimensional.finrank F E

full_name: IntermediateField.rank_top
code: @[simp] protected theorem rank_top : Module.rank (⊤ : IntermediateField F E) E = 1 
goal: Module.rank (↥⊤) E = 1

full_name: IntermediateField.finrank_top
code: @[simp] protected theorem finrank_top : finrank (⊤ : IntermediateField F E) E = 1 
goal: FiniteDimensional.finrank (↥⊤) E = 1

full_name: IntermediateField.rank_top'
code: @[simp] theorem rank_top' : Module.rank F (⊤ : IntermediateField F E) = Module.rank F E 
goal: Module.rank F ↥⊤ = Module.rank F E

full_name: IntermediateField.finrank_top'
code: @[simp] theorem finrank_top' : finrank F (⊤ : IntermediateField F E) = finrank F E 
goal: FiniteDimensional.finrank F ↥⊤ = FiniteDimensional.finrank F E

full_name: IntermediateField.rank_adjoin_eq_one_iff
code: theorem rank_adjoin_eq_one_iff : Module.rank F (adjoin F S) = 1 ↔ S ⊆ (⊥ : IntermediateField F E) 
goal: Module.rank F ↥(IntermediateField.adjoin F S) = 1 ↔ S ⊆ ↑⊥

full_name: IntermediateField.rank_adjoin_simple_eq_one_iff
code: theorem rank_adjoin_simple_eq_one_iff :
    Module.rank F F⟮α⟯ = 1 ↔ α ∈ (⊥ : IntermediateField F E) 
goal: Module.rank F ↥F⟮α⟯ = 1 ↔ α ∈ ⊥

full_name: IntermediateField.finrank_adjoin_eq_one_iff
code: theorem finrank_adjoin_eq_one_iff : finrank F (adjoin F S) = 1 ↔ S ⊆ (⊥ : IntermediateField F E) 
goal: FiniteDimensional.finrank F ↥(IntermediateField.adjoin F S) = 1 ↔ S ⊆ ↑⊥

full_name: IntermediateField.finrank_adjoin_simple_eq_one_iff
code: theorem finrank_adjoin_simple_eq_one_iff :
    finrank F F⟮α⟯ = 1 ↔ α ∈ (⊥ : IntermediateField F E) 
goal: FiniteDimensional.finrank F ↥F⟮α⟯ = 1 ↔ α ∈ ⊥

full_name: IntermediateField.bot_eq_top_of_rank_adjoin_eq_one
code: /-- If `F⟮x⟯` has dimension `1` over `F` for every `x ∈ E` then `F = E`. -/
theorem bot_eq_top_of_rank_adjoin_eq_one (h : ∀ x : E, Module.rank F F⟮x⟯ = 1) :
    (⊥ : IntermediateField F E) = ⊤ 
goal: ⊥ = ⊤

full_name: IntermediateField.bot_eq_top_of_finrank_adjoin_eq_one
code: theorem bot_eq_top_of_finrank_adjoin_eq_one (h : ∀ x : E, finrank F F⟮x⟯ = 1) :
    (⊥ : IntermediateField F E) = ⊤ 
goal: ⊥ = ⊤

full_name: IntermediateField.subsingleton_of_rank_adjoin_eq_one
code: theorem subsingleton_of_rank_adjoin_eq_one (h : ∀ x : E, Module.rank F F⟮x⟯ = 1) :
    Subsingleton (IntermediateField F E) 
goal: Subsingleton (IntermediateField F E)

full_name: IntermediateField.subsingleton_of_finrank_adjoin_eq_one
code: theorem subsingleton_of_finrank_adjoin_eq_one (h : ∀ x : E, finrank F F⟮x⟯ = 1) :
    Subsingleton (IntermediateField F E) 
goal: Subsingleton (IntermediateField F E)

full_name: IntermediateField.bot_eq_top_of_finrank_adjoin_le_one
code: /-- If `F⟮x⟯` has dimension `≤1` over `F` for every `x ∈ E` then `F = E`. -/
theorem bot_eq_top_of_finrank_adjoin_le_one [FiniteDimensional F E]
    (h : ∀ x : E, finrank F F⟮x⟯ ≤ 1) : (⊥ : IntermediateField F E) = ⊤ 
goal: ⊥ = ⊤

full_name: IntermediateField.subsingleton_of_finrank_adjoin_le_one
code: theorem subsingleton_of_finrank_adjoin_le_one [FiniteDimensional F E]
    (h : ∀ x : E, finrank F F⟮x⟯ ≤ 1) : Subsingleton (IntermediateField F E) 
goal: Subsingleton (IntermediateField F E)

full_name: IntermediateField.minpoly_gen
code: theorem minpoly_gen (α : E) :
    minpoly F (AdjoinSimple.gen F α) = minpoly F α 
goal: minpoly F (IntermediateField.AdjoinSimple.gen F α) = minpoly F α

full_name: IntermediateField.aeval_gen_minpoly
code: theorem aeval_gen_minpoly (α : E) : aeval (AdjoinSimple.gen F α) (minpoly F α) = 0 
goal: (Polynomial.aeval (IntermediateField.AdjoinSimple.gen F α)) (minpoly F α) = 0

full_name: IntermediateField.adjoinRootEquivAdjoin
code: /-- algebra isomorphism between `AdjoinRoot` and `F⟮α⟯` -/
noncomputable def adjoinRootEquivAdjoin (h : IsIntegral F α) :
    AdjoinRoot (minpoly F α) ≃ₐ[F] F⟮α⟯ 
goal: AdjoinRoot (minpoly F α) ≃ₐ[F] ↥F⟮α⟯

full_name: IntermediateField.adjoinRootEquivAdjoin_apply_root
code: theorem adjoinRootEquivAdjoin_apply_root (h : IsIntegral F α) :
    adjoinRootEquivAdjoin F h (AdjoinRoot.root (minpoly F α)) = AdjoinSimple.gen F α 
goal: (IntermediateField.adjoinRootEquivAdjoin F h) (AdjoinRoot.root (minpoly F α)) = IntermediateField.AdjoinSimple.gen F α

full_name: IntermediateField.adjoin_root_eq_top
code: theorem adjoin_root_eq_top (p : K[X]) [Fact (Irreducible p)] : K⟮AdjoinRoot.root p⟯ = ⊤ 
goal: K⟮AdjoinRoot.root p⟯ = ⊤

full_name: IntermediateField.powerBasisAux
code: /-- The elements `1, x, ..., x ^ (d - 1)` form a basis for `K⟮x⟯`,
where `d` is the degree of the minimal polynomial of `x`. -/
noncomputable def powerBasisAux {x : L} (hx : IsIntegral K x) :
    Basis (Fin (minpoly K x).natDegree) K K⟮x⟯ 
goal: Basis (Fin (minpoly K x).natDegree) K ↥K⟮x⟯

full_name: IntermediateField.adjoin.powerBasis_gen
code: /-- The power basis `1, x, ..., x ^ (d - 1)` for `K⟮x⟯`,
where `d` is the degree of the minimal polynomial of `x`. -/
@[simps]
noncomputable def adjoin.powerBasis {x : L} (hx : IsIntegral K x) : PowerBasis K K⟮x⟯ 
goal: (IntermediateField.adjoin.powerBasis hx).gen = IntermediateField.AdjoinSimple.gen K x

full_name: IntermediateField.adjoin.powerBasis_dim
code: /-- The power basis `1, x, ..., x ^ (d - 1)` for `K⟮x⟯`,
where `d` is the degree of the minimal polynomial of `x`. -/
@[simps]
noncomputable def adjoin.powerBasis {x : L} (hx : IsIntegral K x) : PowerBasis K K⟮x⟯ 
goal: (IntermediateField.adjoin.powerBasis hx).dim = (minpoly K x).natDegree

full_name: IntermediateField.adjoin.powerBasis
code: /-- The power basis `1, x, ..., x ^ (d - 1)` for `K⟮x⟯`,
where `d` is the degree of the minimal polynomial of `x`. -/
@[simps]
noncomputable def adjoin.powerBasis {x : L} (hx : IsIntegral K x) : PowerBasis K K⟮x⟯ 
goal: PowerBasis K ↥K⟮x⟯

full_name: IntermediateField.adjoin.finiteDimensional
code: theorem adjoin.finiteDimensional {x : L} (hx : IsIntegral K x) : FiniteDimensional K K⟮x⟯ 
goal: FiniteDimensional K ↥K⟮x⟯

full_name: IntermediateField.isAlgebraic_adjoin_simple
code: theorem isAlgebraic_adjoin_simple {x : L} (hx : IsIntegral K x) : Algebra.IsAlgebraic K K⟮x⟯ 
goal: Algebra.IsAlgebraic K ↥K⟮x⟯

full_name: IntermediateField.adjoin.finrank
code: theorem adjoin.finrank {x : L} (hx : IsIntegral K x) :
    FiniteDimensional.finrank K K⟮x⟯ = (minpoly K x).natDegree 
goal: FiniteDimensional.finrank K ↥K⟮x⟯ = (minpoly K x).natDegree

full_name: IntermediateField.adjoin_eq_top_of_adjoin_eq_top
code: /-- If `K / E / F` is a field extension tower, `S ⊂ K` is such that `F(S) = K`,
then `E(S) = K`. -/
theorem adjoin_eq_top_of_adjoin_eq_top [Algebra E K] [IsScalarTower F E K]
    {S : Set K} (hprim : adjoin F S = ⊤) : adjoin E S = ⊤ 
goal: IntermediateField.adjoin E S = ⊤

full_name: IntermediateField.adjoin_minpoly_coeff_of_exists_primitive_element
code: /-- If `E / F` is a finite extension such that `E = F(α)`, then for any intermediate field `K`, the
`F` adjoin the coefficients of `minpoly K α` is equal to `K` itself. -/
theorem adjoin_minpoly_coeff_of_exists_primitive_element
    [FiniteDimensional F E] (hprim : adjoin F {α} = ⊤) (K : IntermediateField F E) :
    adjoin F ((minpoly K α).map (algebraMap K E)).coeffs = K 
goal: IntermediateField.adjoin F ↑(Polynomial.map (algebraMap (↥K) E) (minpoly (↥K) α)).coeffs = K

full_name: IntermediateField.exists_lt_finrank_of_infinite_dimensional
code: /-- If `E / F` is an infinite algebraic extension, then there exists an intermediate field
`L / F` with arbitrarily large finite extension degree. -/
theorem exists_lt_finrank_of_infinite_dimensional
    [Algebra.IsAlgebraic F E] (hnfd : ¬ FiniteDimensional F E) (n : ℕ) :
    ∃ L : IntermediateField F E, FiniteDimensional F L ∧ n < finrank F L 
goal: ∃ L, FiniteDimensional F ↥L ∧ n < FiniteDimensional.finrank F ↥L

full_name: minpoly.natDegree_le
code: theorem _root_.minpoly.natDegree_le (x : L) [FiniteDimensional K L] :
    (minpoly K x).natDegree ≤ finrank K L 
goal: (minpoly K x).natDegree ≤ FiniteDimensional.finrank K L

full_name: minpoly.degree_le
code: theorem _root_.minpoly.degree_le (x : L) [FiniteDimensional K L] :
    (minpoly K x).degree ≤ finrank K L 
goal: (minpoly K x).degree ≤ ↑(FiniteDimensional.finrank K L)

full_name: IntermediateField.isAlgebraic_iSup
code: /-- A compositum of algebraic extensions is algebraic -/
theorem isAlgebraic_iSup {ι : Type*} {t : ι → IntermediateField K L}
    (h : ∀ i, Algebra.IsAlgebraic K (t i)) :
    Algebra.IsAlgebraic K (⨆ i, t i : IntermediateField K L) 
goal: Algebra.IsAlgebraic K ↥(⨆ i, t i)

full_name: IntermediateField.isAlgebraic_adjoin
code: theorem isAlgebraic_adjoin {S : Set L} (hS : ∀ x ∈ S, IsIntegral K x) :
    Algebra.IsAlgebraic K (adjoin K S) 
goal: Algebra.IsAlgebraic K ↥(IntermediateField.adjoin K S)

full_name: IntermediateField.finiteDimensional_adjoin
code: /-- If `L / K` is a field extension, `S` is a finite subset of `L`, such that every element of `S`
is integral (= algebraic) over `K`, then `K(S) / K` is a finite extension.
A direct corollary of `finiteDimensional_iSup_of_finite`. -/
theorem finiteDimensional_adjoin {S : Set L} [Finite S] (hS : ∀ x ∈ S, IsIntegral K x) :
    FiniteDimensional K (adjoin K S) 
goal: FiniteDimensional K ↥(IntermediateField.adjoin K S)

full_name: IntermediateField.algHomAdjoinIntegralEquiv
code: /-- Algebra homomorphism `F⟮α⟯ →ₐ[F] K` are in bijection with the set of roots
of `minpoly α` in `K`. -/
noncomputable def algHomAdjoinIntegralEquiv (h : IsIntegral F α) :
    (F⟮α⟯ →ₐ[F] K) ≃ { x // x ∈ (minpoly F α).aroots K } 
goal: (↥F⟮α⟯ →ₐ[F] K) ≃ { x // x ∈ (minpoly F α).aroots K }

full_name: IntermediateField.algHomAdjoinIntegralEquiv_symm_apply_gen
code: lemma algHomAdjoinIntegralEquiv_symm_apply_gen (h : IsIntegral F α)
    (x : { x // x ∈ (minpoly F α).aroots K }) :
    (algHomAdjoinIntegralEquiv F h).symm x (AdjoinSimple.gen F α) = x 
goal: ((IntermediateField.algHomAdjoinIntegralEquiv F h).symm x) (IntermediateField.AdjoinSimple.gen F α) = ↑x

full_name: IntermediateField.fintypeOfAlgHomAdjoinIntegral
code: /-- Fintype of algebra homomorphism `F⟮α⟯ →ₐ[F] K` -/
noncomputable def fintypeOfAlgHomAdjoinIntegral (h : IsIntegral F α) : Fintype (F⟮α⟯ →ₐ[F] K) 
goal: Fintype (↥F⟮α⟯ →ₐ[F] K)

full_name: IntermediateField.card_algHom_adjoin_integral
code: theorem card_algHom_adjoin_integral (h : IsIntegral F α) (h_sep : IsSeparable F α)
    (h_splits : (minpoly F α).Splits (algebraMap F K)) :
    @Fintype.card (F⟮α⟯ →ₐ[F] K) (fintypeOfAlgHomAdjoinIntegral F h) = (minpoly F α).natDegree 
goal: Fintype.card (↥F⟮α⟯ →ₐ[F] K) = (minpoly F α).natDegree

full_name: Polynomial.irreducible_comp
code: /-- Let `f, g` be monic polynomials over `K`. If `f` is irreducible, and `g(x) - α` is irreducible
in `K⟮α⟯` with `α` a root of `f`, then `f(g(x))` is irreducible. -/
theorem _root_.Polynomial.irreducible_comp {f g : K[X]} (hfm : f.Monic) (hgm : g.Monic)
    (hf : Irreducible f)
    (hg : ∀ (E : Type u) [Field E] [Algebra K E] (x : E) (hx : minpoly K x = f),
      Irreducible (g.map (algebraMap _ _) - C (AdjoinSimple.gen K x))) :
    Irreducible (f.comp g) 
goal: Irreducible (f.comp g)

full_name: IntermediateField.FG
code: /-- An intermediate field `S` is finitely generated if there exists `t : Finset E` such that
`IntermediateField.adjoin F t = S`. -/
def FG (S : IntermediateField F E) : Prop 
goal: Prop

full_name: IntermediateField.fg_adjoin_finset
code: theorem fg_adjoin_finset (t : Finset E) : (adjoin F (↑t : Set E)).FG 
goal: (IntermediateField.adjoin F ↑t).FG

full_name: IntermediateField.fg_def
code: theorem fg_def {S : IntermediateField F E} : S.FG ↔ ∃ t : Set E, Set.Finite t ∧ adjoin F t = S 
goal: S.FG ↔ ∃ t, t.Finite ∧ IntermediateField.adjoin F t = S

full_name: IntermediateField.fg_bot
code: theorem fg_bot : (⊥ : IntermediateField F E).FG 
goal: ⊥.FG

full_name: IntermediateField.fG_of_fG_toSubalgebra
code: theorem fG_of_fG_toSubalgebra (S : IntermediateField F E) (h : S.toSubalgebra.FG) : S.FG 
goal: S.FG

full_name: IntermediateField.fg_of_noetherian
code: theorem fg_of_noetherian (S : IntermediateField F E) [IsNoetherian F E] : S.FG 
goal: S.FG

full_name: IntermediateField.induction_on_adjoin_finset
code: theorem induction_on_adjoin_finset (S : Finset E) (P : IntermediateField F E → Prop) (base : P ⊥)
    (ih : ∀ (K : IntermediateField F E), ∀ x ∈ S, P K → P (K⟮x⟯.restrictScalars F)) :
    P (adjoin F S) 
goal: P (IntermediateField.adjoin F ↑S)

full_name: IntermediateField.induction_on_adjoin_fg
code: theorem induction_on_adjoin_fg (P : IntermediateField F E → Prop) (base : P ⊥)
    (ih : ∀ (K : IntermediateField F E) (x : E), P K → P (K⟮x⟯.restrictScalars F))
    (K : IntermediateField F E) (hK : K.FG) : P K 
goal: P K

full_name: IntermediateField.induction_on_adjoin
code: theorem induction_on_adjoin [FiniteDimensional F E] (P : IntermediateField F E → Prop)
    (base : P ⊥) (ih : ∀ (K : IntermediateField F E) (x : E), P K → P (K⟮x⟯.restrictScalars F))
    (K : IntermediateField F E) : P K 
goal: P K

full_name: AdjoinRoot.algHomOfDvd
code: /-- The canonical algebraic homomorphism from `AdjoinRoot p` to `AdjoinRoot q`, where
  the polynomial `q : K[X]` divides `p`. -/
noncomputable def algHomOfDvd {p q : K[X]} (hpq : q ∣ p) :
    AdjoinRoot p →ₐ[K] AdjoinRoot q 
goal: AdjoinRoot p →ₐ[K] AdjoinRoot q

full_name: AdjoinRoot.coe_algHomOfDvd
code: theorem coe_algHomOfDvd {p q : K[X]} (hpq : q ∣ p) :
    (algHomOfDvd hpq).toFun = liftHom p (root q) (by simp only [aeval_eq, mk_eq_zero, hpq]) 
goal: (↑↑(AdjoinRoot.algHomOfDvd hpq).toRingHom).toFun = ⇑(AdjoinRoot.liftHom p (AdjoinRoot.root q) ⋯)

full_name: AdjoinRoot.algHomOfDvd_apply_root
code: /-- `algHomOfDvd` sends `AdjoinRoot.root p` to `AdjoinRoot.root q`. -/
theorem algHomOfDvd_apply_root {p q : K[X]} (hpq : q ∣ p) :
    algHomOfDvd hpq (root p) = root q 
goal: (AdjoinRoot.algHomOfDvd hpq) (AdjoinRoot.root p) = AdjoinRoot.root q

full_name: AdjoinRoot.algEquivOfEq
code: /-- The canonical algebraic equivalence between `AdjoinRoot p` and `AdjoinRoot q`, where
  the two polynomials `p q : K[X]` are equal. -/
noncomputable def algEquivOfEq {p q : K[X]} (hp : p ≠ 0) (h_eq : p = q) :
    AdjoinRoot p ≃ₐ[K] AdjoinRoot q 
goal: AdjoinRoot p ≃ₐ[K] AdjoinRoot q

full_name: AdjoinRoot.coe_algEquivOfEq
code: theorem coe_algEquivOfEq {p q : K[X]} (hp : p ≠ 0) (h_eq : p = q) :
    (algEquivOfEq hp h_eq).toFun = liftHom p (root q) (by rw [h_eq, aeval_eq, mk_self]) 
goal: (AdjoinRoot.algEquivOfEq hp h_eq).toFun = ⇑(AdjoinRoot.liftHom p (AdjoinRoot.root q) ⋯)

full_name: AdjoinRoot.algEquivOfEq_toAlgHom
code: theorem algEquivOfEq_toAlgHom {p q : K[X]} (hp : p ≠ 0) (h_eq : p = q) :
    (algEquivOfEq hp h_eq).toAlgHom = liftHom p (root q) (by rw [h_eq, aeval_eq, mk_self]) 
goal: ↑(AdjoinRoot.algEquivOfEq hp h_eq) = AdjoinRoot.liftHom p (AdjoinRoot.root q) ⋯

full_name: AdjoinRoot.algEquivOfEq_apply_root
code: /-- `algEquivOfEq` sends `AdjoinRoot.root p` to `AdjoinRoot.root q`. -/
theorem algEquivOfEq_apply_root {p q : K[X]} (hp : p ≠ 0) (h_eq : p = q) :
    algEquivOfEq hp h_eq (root p) = root q 
goal: (AdjoinRoot.algEquivOfEq hp h_eq) (AdjoinRoot.root p) = AdjoinRoot.root q

full_name: AdjoinRoot.algEquivOfAssociated
code: /-- The canonical algebraic equivalence between `AdjoinRoot p` and `AdjoinRoot q`,
where the two polynomials `p q : K[X]` are associated.-/
noncomputable def algEquivOfAssociated {p q : K[X]} (hp : p ≠ 0) (hpq : Associated p q) :
    AdjoinRoot p ≃ₐ[K] AdjoinRoot q 
goal: AdjoinRoot p ≃ₐ[K] AdjoinRoot q

full_name: AdjoinRoot.coe_algEquivOfAssociated
code: theorem coe_algEquivOfAssociated {p q : K[X]} (hp : p ≠ 0) (hpq : Associated p q) :
    (algEquivOfAssociated hp hpq).toFun =
      liftHom p (root q) (by simp only [aeval_eq, mk_eq_zero, hpq.symm.dvd]) 
goal: (AdjoinRoot.algEquivOfAssociated hp hpq).toFun = ⇑(AdjoinRoot.liftHom p (AdjoinRoot.root q) ⋯)

full_name: AdjoinRoot.algEquivOfAssociated_toAlgHom
code: theorem algEquivOfAssociated_toAlgHom {p q : K[X]} (hp : p ≠ 0) (hpq : Associated p q) :
    (algEquivOfAssociated hp hpq).toAlgHom =
      liftHom p (root q) (by simp only [aeval_eq, mk_eq_zero, hpq.symm.dvd]) 
goal: ↑(AdjoinRoot.algEquivOfAssociated hp hpq) = AdjoinRoot.liftHom p (AdjoinRoot.root q) ⋯

full_name: AdjoinRoot.algEquivOfAssociated_apply_root
code: /-- `algEquivOfAssociated` sends `AdjoinRoot.root p` to `AdjoinRoot.root q`. -/
theorem algEquivOfAssociated_apply_root {p q : K[X]} (hp : p ≠ 0) (hpq : Associated p q) :
    algEquivOfAssociated hp hpq (root p) = root q 
goal: (AdjoinRoot.algEquivOfAssociated hp hpq) (AdjoinRoot.root p) = AdjoinRoot.root q

full_name: minpoly.eq_of_root
code: /-- If `y : L` is a root of `minpoly K x`, then `minpoly K y = minpoly K x`. -/
theorem eq_of_root {x y : L} (hx : IsAlgebraic K x)
    (h_ev : (Polynomial.aeval y) (minpoly K x) = 0) : minpoly K y = minpoly K x 
goal: minpoly K y = minpoly K x

full_name: minpoly.algEquiv
code: /-- The canonical `algEquiv` between `K⟮x⟯`and `K⟮y⟯`, sending `x` to `y`, where `x` and `y` have
  the same minimal polynomial over `K`. -/
noncomputable def algEquiv {x y : L} (hx : IsAlgebraic K x)
    (h_mp : minpoly K x = minpoly K y) : K⟮x⟯ ≃ₐ[K] K⟮y⟯ 
goal: ↥K⟮x⟯ ≃ₐ[K] ↥K⟮y⟯

full_name: minpoly.algEquiv_apply
code: /-- `minpoly.algEquiv` sends the generator of `K⟮x⟯` to the generator of `K⟮y⟯`. -/
theorem algEquiv_apply {x y : L} (hx : IsAlgebraic K x) (h_mp : minpoly K x = minpoly K y) :
    algEquiv hx h_mp (AdjoinSimple.gen K x) = AdjoinSimple.gen K y 
goal: (minpoly.algEquiv hx h_mp) (IntermediateField.AdjoinSimple.gen K x) = IntermediateField.AdjoinSimple.gen K y

full_name: PowerBasis.equivAdjoinSimple
code: /-- `pb.equivAdjoinSimple` is the equivalence between `K⟮pb.gen⟯` and `L` itself. -/
noncomputable def equivAdjoinSimple (pb : PowerBasis K L) : K⟮pb.gen⟯ ≃ₐ[K] L 
goal: ↥K⟮pb.gen⟯ ≃ₐ[K] L

full_name: PowerBasis.equivAdjoinSimple_aeval
code: @[simp]
theorem equivAdjoinSimple_aeval (pb : PowerBasis K L) (f : K[X]) :
    pb.equivAdjoinSimple (aeval (AdjoinSimple.gen K pb.gen) f) = aeval pb.gen f 
goal: pb.equivAdjoinSimple ((Polynomial.aeval (IntermediateField.AdjoinSimple.gen K pb.gen)) f) = (Polynomial.aeval pb.gen) f

full_name: PowerBasis.equivAdjoinSimple_gen
code: @[simp]
theorem equivAdjoinSimple_gen (pb : PowerBasis K L) :
    pb.equivAdjoinSimple (AdjoinSimple.gen K pb.gen) = pb.gen 
goal: pb.equivAdjoinSimple (IntermediateField.AdjoinSimple.gen K pb.gen) = pb.gen

full_name: PowerBasis.equivAdjoinSimple_symm_aeval
code: @[simp]
theorem equivAdjoinSimple_symm_aeval (pb : PowerBasis K L) (f : K[X]) :
    pb.equivAdjoinSimple.symm (aeval pb.gen f) = aeval (AdjoinSimple.gen K pb.gen) f 
goal: pb.equivAdjoinSimple.symm ((Polynomial.aeval pb.gen) f) =
  (Polynomial.aeval (IntermediateField.AdjoinSimple.gen K pb.gen)) f

full_name: PowerBasis.equivAdjoinSimple_symm_gen
code: @[simp]
theorem equivAdjoinSimple_symm_gen (pb : PowerBasis K L) :
    pb.equivAdjoinSimple.symm pb.gen = AdjoinSimple.gen K pb.gen 
goal: pb.equivAdjoinSimple.symm pb.gen = IntermediateField.AdjoinSimple.gen K pb.gen

full_name: IntermediateField.map_comap_eq
code: theorem map_comap_eq (f : L →ₐ[K] L') (S : IntermediateField K L') :
    (S.comap f).map f = S ⊓ f.fieldRange 
goal: IntermediateField.map f (IntermediateField.comap f S) = S ⊓ f.fieldRange

full_name: IntermediateField.map_comap_eq_self
code: theorem map_comap_eq_self {f : L →ₐ[K] L'} {S : IntermediateField K L'} (h : S ≤ f.fieldRange) :
    (S.comap f).map f = S 
goal: IntermediateField.map f (IntermediateField.comap f S) = S

full_name: IntermediateField.map_comap_eq_self_of_surjective
code: theorem map_comap_eq_self_of_surjective {f : L →ₐ[K] L'} (hf : Function.Surjective f)
    (S : IntermediateField K L') : (S.comap f).map f = S 
goal: IntermediateField.map f (IntermediateField.comap f S) = S

full_name: IntermediateField.comap_map
code: theorem comap_map (f : L →ₐ[K] L') (S : IntermediateField K L) : (S.map f).comap f = S 
goal: IntermediateField.comap f (IntermediateField.map f S) = S