ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Function.iterate_mem_periodicOrbit
@[simp]
theorem iterate_mem_periodicOrbit (hx : x ∈ periodicPts f) (n : ℕ) :
    f^[n] x ∈ periodicOrbit f x 
Arguments: {α : Type u_1} {f : α → α} {x : α} (hx : x ∈ Function.periodicPts f) (n : ℕ)
Goal: f^[n] x ∈ Function.periodicOrbit f x
-- Function.self_mem_periodicOrbit
@[simp]
theorem self_mem_periodicOrbit (hx : x ∈ periodicPts f) : x ∈ periodicOrbit f x 
Arguments: {α : Type u_1} {f : α → α} {x : α} (hx : x ∈ Function.periodicPts f)
Goal: x ∈ Function.periodicOrbit f x
-- Function.nodup_periodicOrbit
theorem nodup_periodicOrbit : (periodicOrbit f x).Nodup 
Arguments: {α : Type u_1} {f : α → α} {x : α}
Goal: (Function.periodicOrbit f x).Nodup
-- Function.periodicOrbit_apply_iterate_eq
theorem periodicOrbit_apply_iterate_eq (hx : x ∈ periodicPts f) (n : ℕ) :
    periodicOrbit f (f^[n] x) = periodicOrbit f x 
Arguments: {α : Type u_1} {f : α → α} {x : α} (hx : x ∈ Function.periodicPts f) (n : ℕ)
Goal: Function.periodicOrbit f (f^[n] x) = Function.periodicOrbit f x
-- Function.periodicOrbit_apply_eq
theorem periodicOrbit_apply_eq (hx : x ∈ periodicPts f) :
    periodicOrbit f (f x) = periodicOrbit f x 
Arguments: {α : Type u_1} {f : α → α} {x : α} (hx : x ∈ Function.periodicPts f)
Goal: Function.periodicOrbit f (f x) = Function.periodicOrbit f x
-- Function.periodicOrbit_chain
theorem periodicOrbit_chain (r : α → α → Prop) {f : α → α} {x : α} :
    (periodicOrbit f x).Chain r ↔ ∀ n < minimalPeriod f x, r (f^[n] x) (f^[n + 1] x) 
Arguments: {α : Type u_1} (r : α → α → Prop) {f : α → α} {x : α}
Goal: Cycle.Chain r (Function.periodicOrbit f x) ↔ ∀ n < Function.minimalPeriod f x, r (f^[n] x) (f^[n + 1] x)
-- Function.periodicOrbit_chain'
theorem periodicOrbit_chain' (r : α → α → Prop) {f : α → α} {x : α} (hx : x ∈ periodicPts f) :
    (periodicOrbit f x).Chain r ↔ ∀ n, r (f^[n] x) (f^[n + 1] x) 
Arguments: {α : Type u_1} (r : α → α → Prop) {f : α → α} {x : α} (hx : x ∈ Function.periodicPts f)
Goal: Cycle.Chain r (Function.periodicOrbit f x) ↔ ∀ (n : ℕ), r (f^[n] x) (f^[n + 1] x)
-- Function.isFixedPt_prod_map
@[simp]
theorem isFixedPt_prod_map (x : α × β) :
    IsFixedPt (Prod.map f g) x ↔ IsFixedPt f x.1 ∧ IsFixedPt g x.2 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → α} {g : β → β} (x : α × β)
Goal: Function.IsFixedPt (Prod.map f g) x ↔ Function.IsFixedPt f x.1 ∧ Function.IsFixedPt g x.2
-- Function.isPeriodicPt_prod_map
@[simp]
theorem isPeriodicPt_prod_map (x : α × β) :
    IsPeriodicPt (Prod.map f g) n x ↔ IsPeriodicPt f n x.1 ∧ IsPeriodicPt g n x.2 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → α} {g : β → β} {n : ℕ} (x : α × β)
Goal: Function.IsPeriodicPt (Prod.map f g) n x ↔ Function.IsPeriodicPt f n x.1 ∧ Function.IsPeriodicPt g n x.2
-- Function.minimalPeriod_prod_map
theorem minimalPeriod_prod_map (f : α → α) (g : β → β) (x : α × β) :
    minimalPeriod (Prod.map f g) x = (minimalPeriod f x.1).lcm (minimalPeriod g x.2) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → α) (g : β → β) (x : α × β)
Goal: Function.minimalPeriod (Prod.map f g) x = (Function.minimalPeriod f x.1).lcm (Function.minimalPeriod g x.2)
-- Function.minimalPeriod_fst_dvd
theorem minimalPeriod_fst_dvd : minimalPeriod f x.1 ∣ minimalPeriod (Prod.map f g) x 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → α} {g : β → β} {x : α × β}
Goal: Function.minimalPeriod f x.1 ∣ Function.minimalPeriod (Prod.map f g) x
-- Function.minimalPeriod_snd_dvd
theorem minimalPeriod_snd_dvd : minimalPeriod g x.2 ∣ minimalPeriod (Prod.map f g) x 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → α} {g : β → β} {x : α × β}
Goal: Function.minimalPeriod g x.2 ∣ Function.minimalPeriod (Prod.map f g) x
-- MulAction.period_eq_minimalPeriod
@[to_additive "`AddAction.period m a` is definitionally equal to
`Function.minimalPeriod (m +ᵥ ·) a`"]
theorem period_eq_minimalPeriod {m : M} {a : α} :
    MulAction.period m a = minimalPeriod (fun x => m • x) a 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] {m : M} {a : α}
Goal: MulAction.period m a = Function.minimalPeriod (fun x => m • x) a
-- AddAction.period_eq_minimalPeriod
@[to_additive "`AddAction.period m a` is definitionally equal to
`Function.minimalPeriod (m +ᵥ ·) a`"]
theorem period_eq_minimalPeriod {m : M} {a : α} :
    MulAction.period m a = minimalPeriod (fun x => m • x) a 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] {m : M} {a : α}
Goal: AddAction.period m a = Function.minimalPeriod (fun x => m +ᵥ x) a
-- MulAction.pow_period_smul
@[to_additive (attr := simp) "`(period m a) • m` fixes `a`."]
theorem pow_period_smul (m : M) (a : α) : m ^ (period m a) • a = a 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] (m : M) (a : α)
Goal: m ^ MulAction.period m a • a = a
-- AddAction.nsmul_period_vadd
@[to_additive (attr := simp) "`(period m a) • m` fixes `a`."]
theorem pow_period_smul (m : M) (a : α) : m ^ (period m a) • a = a 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] (m : M) (a : α)
Goal: AddAction.period m a • m +ᵥ a = a
-- MulAction.isPeriodicPt_smul_iff
@[to_additive]
lemma isPeriodicPt_smul_iff {m : M} {a : α} {n : ℕ} :
    IsPeriodicPt (m • ·) n a ↔ m ^ n • a = a 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] {m : M} {a : α} {n : ℕ}
Goal: Function.IsPeriodicPt (fun x => m • x) n a ↔ m ^ n • a = a
-- AddAction.isPeriodicPt_vadd_iff
@[to_additive]
lemma isPeriodicPt_smul_iff {m : M} {a : α} {n : ℕ} :
    IsPeriodicPt (m • ·) n a ↔ m ^ n • a = a 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] {m : M} {a : α} {n : ℕ}
Goal: Function.IsPeriodicPt (fun x => m +ᵥ x) n a ↔ n • m +ᵥ a = a
-- AddAction.nsmul_vadd_eq_iff_period_dvd
@[to_additive]
theorem pow_smul_eq_iff_period_dvd {n : ℕ} {m : M} {a : α} :
    m ^ n • a = a ↔ period m a ∣ n 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] {n : ℕ} {m : M} {a : α}
Goal: n • m +ᵥ a = a ↔ AddAction.period m a ∣ n
-- MulAction.pow_smul_eq_iff_period_dvd
@[to_additive]
theorem pow_smul_eq_iff_period_dvd {n : ℕ} {m : M} {a : α} :
    m ^ n • a = a ↔ period m a ∣ n 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] {n : ℕ} {m : M} {a : α}
Goal: m ^ n • a = a ↔ MulAction.period m a ∣ n
-- AddAction.zsmul_vadd_eq_iff_period_dvd
@[to_additive]
theorem zpow_smul_eq_iff_period_dvd {j : ℤ} {g : G} {a : α} :
    g ^ j • a = a ↔ (period g a : ℤ) ∣ j 
Arguments: {α : Type v} {G : Type u} [AddGroup G] [AddAction G α] {j : ℤ} {g : G} {a : α}
Goal: j • g +ᵥ a = a ↔ ↑(AddAction.period g a) ∣ j
-- MulAction.zpow_smul_eq_iff_period_dvd
@[to_additive]
theorem zpow_smul_eq_iff_period_dvd {j : ℤ} {g : G} {a : α} :
    g ^ j • a = a ↔ (period g a : ℤ) ∣ j 
Arguments: {α : Type v} {G : Type u} [Group G] [MulAction G α] {j : ℤ} {g : G} {a : α}
Goal: g ^ j • a = a ↔ ↑(MulAction.period g a) ∣ j
-- AddAction.nsmul_mod_period_vadd
@[to_additive (attr := simp)]
theorem pow_mod_period_smul (n : ℕ) {m : M} {a : α} :
    m ^ (n % period m a) • a = m ^ n • a 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] (n : ℕ) {m : M} {a : α}
Goal: (n % AddAction.period m a) • m +ᵥ a = n • m +ᵥ a
-- MulAction.pow_mod_period_smul
@[to_additive (attr := simp)]
theorem pow_mod_period_smul (n : ℕ) {m : M} {a : α} :
    m ^ (n % period m a) • a = m ^ n • a 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] (n : ℕ) {m : M} {a : α}
Goal: m ^ (n % MulAction.period m a) • a = m ^ n • a
-- MulAction.zpow_mod_period_smul
@[to_additive (attr := simp)]
theorem zpow_mod_period_smul (j : ℤ) {g : G} {a : α} :
    g ^ (j % (period g a : ℤ)) • a = g ^ j • a 
Arguments: {α : Type v} {G : Type u} [Group G] [MulAction G α] (j : ℤ) {g : G} {a : α}
Goal: g ^ (j % ↑(MulAction.period g a)) • a = g ^ j • a
-- AddAction.zsmul_mod_period_vadd
@[to_additive (attr := simp)]
theorem zpow_mod_period_smul (j : ℤ) {g : G} {a : α} :
    g ^ (j % (period g a : ℤ)) • a = g ^ j • a 
Arguments: {α : Type v} {G : Type u} [AddGroup G] [AddAction G α] (j : ℤ) {g : G} {a : α}
Goal: (j % ↑(AddAction.period g a)) • g +ᵥ a = j • g +ᵥ a
-- AddAction.nsmul_add_period_vadd
@[to_additive (attr := simp)]
theorem pow_add_period_smul (n : ℕ) (m : M) (a : α) :
    m ^ (n + period m a) • a = m ^ n • a 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] (n : ℕ) (m : M) (a : α)
Goal: (n + AddAction.period m a) • m +ᵥ a = n • m +ᵥ a
-- MulAction.pow_add_period_smul
@[to_additive (attr := simp)]
theorem pow_add_period_smul (n : ℕ) (m : M) (a : α) :
    m ^ (n + period m a) • a = m ^ n • a 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] (n : ℕ) (m : M) (a : α)
Goal: m ^ (n + MulAction.period m a) • a = m ^ n • a
-- MulAction.pow_period_add_smul
@[to_additive (attr := simp)]
theorem pow_period_add_smul (n : ℕ) (m : M) (a : α) :
    m ^ (period m a + n) • a = m ^ n • a 
Arguments: {α : Type v} {M : Type u} [Monoid M] [MulAction M α] (n : ℕ) (m : M) (a : α)
Goal: m ^ (MulAction.period m a + n) • a = m ^ n • a
-- AddAction.nsmul_period_add_vadd
@[to_additive (attr := simp)]
theorem pow_period_add_smul (n : ℕ) (m : M) (a : α) :
    m ^ (period m a + n) • a = m ^ n • a 
Arguments: {α : Type v} {M : Type u} [AddMonoid M] [AddAction M α] (n : ℕ) (m : M) (a : α)
Goal: (AddAction.period m a + n) • m +ᵥ a = n • m +ᵥ a
-- MulAction.zpow_add_period_smul
@[to_additive (attr := simp)]
theorem zpow_add_period_smul (i : ℤ) (g : G) (a : α) :
    g ^ (i + period g a) • a = g ^ i • a 
Arguments: {α : Type v} {G : Type u} [Group G] [MulAction G α] (i : ℤ) (g : G) (a : α)
Goal: g ^ (i + ↑(MulAction.period g a)) • a = g ^ i • a
-- AddAction.zsmul_add_period_vadd
@[to_additive (attr := simp)]
theorem zpow_add_period_smul (i : ℤ) (g : G) (a : α) :
    g ^ (i + period g a) • a = g ^ i • a 
Arguments: {α : Type v} {G : Type u} [AddGroup G] [AddAction G α] (i : ℤ) (g : G) (a : α)
Goal: (i + ↑(AddAction.period g a)) • g +ᵥ a = i • g +ᵥ a
-- AddAction.zsmul_period_add_vadd
@[to_additive (attr := simp)]
theorem zpow_period_add_smul (i : ℤ) (g : G) (a : α) :
    g ^ (period g a + i) • a = g ^ i • a 
Arguments: {α : Type v} {G : Type u} [AddGroup G] [AddAction G α] (i : ℤ) (g : G) (a : α)
Goal: (↑(AddAction.period g a) + i) • g +ᵥ a = i • g +ᵥ a
-- MulAction.zpow_period_add_smul
@[to_additive (attr := simp)]
theorem zpow_period_add_smul (i : ℤ) (g : G) (a : α) :
    g ^ (period g a + i) • a = g ^ i • a 
Arguments: {α : Type v} {G : Type u} [Group G] [MulAction G α] (i : ℤ) (g : G) (a : α)
Goal: g ^ (↑(MulAction.period g a) + i) • a = g ^ i • a
-- MulAction.pow_smul_eq_iff_minimalPeriod_dvd
@[to_additive]
theorem pow_smul_eq_iff_minimalPeriod_dvd {n : ℕ} :
    a ^ n • b = b ↔ minimalPeriod (a • ·) b ∣ n 
Arguments: {α : Type v} {G : Type u} [Group G] [MulAction G α] {a : G} {b : α} {n : ℕ}
Goal: a ^ n • b = b ↔ Function.minimalPeriod (fun x => a • x) b ∣ n
-- AddAction.nsmul_vadd_eq_iff_minimalPeriod_dvd
@[to_additive]
theorem pow_smul_eq_iff_minimalPeriod_dvd {n : ℕ} :
    a ^ n • b = b ↔ minimalPeriod (a • ·) b ∣ n 
Arguments: {α : Type v} {G : Type u} [AddGroup G] [AddAction G α] {a : G} {b : α} {n : ℕ}
Goal: n • a +ᵥ b = b ↔ Function.minimalPeriod (fun x => a +ᵥ x) b ∣ n
-- MulAction.zpow_smul_eq_iff_minimalPeriod_dvd
@[to_additive]
theorem zpow_smul_eq_iff_minimalPeriod_dvd {n : ℤ} :
    a ^ n • b = b ↔ (minimalPeriod (a • ·) b : ℤ) ∣ n 
Arguments: {α : Type v} {G : Type u} [Group G] [MulAction G α] {a : G} {b : α} {n : ℤ}
Goal: a ^ n • b = b ↔ ↑(Function.minimalPeriod (fun x => a • x) b) ∣ n
-- AddAction.zsmul_vadd_eq_iff_minimalPeriod_dvd
@[to_additive]
theorem zpow_smul_eq_iff_minimalPeriod_dvd {n : ℤ} :
    a ^ n • b = b ↔ (minimalPeriod (a • ·) b : ℤ) ∣ n 
Arguments: {α : Type v} {G : Type u} [AddGroup G] [AddAction G α] {a : G} {b : α} {n : ℤ}
Goal: n • a +ᵥ b = b ↔ ↑(Function.minimalPeriod (fun x => a +ᵥ x) b) ∣ n
-- MulAction.pow_smul_mod_minimalPeriod
@[to_additive (attr := simp)]
theorem pow_smul_mod_minimalPeriod (n : ℕ) :
    a ^ (n % minimalPeriod (a • ·) b) • b = a ^ n • b 
Arguments: {α : Type v} {G : Type u} [Group G] [MulAction G α] (a : G) (b : α) (n : ℕ)
Goal: a ^ (n % Function.minimalPeriod (fun x => a • x) b) • b = a ^ n • b
-- AddAction.nsmul_vadd_mod_minimalPeriod
@[to_additive (attr := simp)]
theorem pow_smul_mod_minimalPeriod (n : ℕ) :
    a ^ (n % minimalPeriod (a • ·) b) • b = a ^ n • b 
Arguments: {α : Type v} {G : Type u} [AddGroup G] [AddAction G α] (a : G) (b : α) (n : ℕ)
Goal: (n % Function.minimalPeriod (fun x => a +ᵥ x) b) • a +ᵥ b = n • a +ᵥ b
-- AddAction.zsmul_vadd_mod_minimalPeriod
@[to_additive (attr := simp)]
theorem zpow_smul_mod_minimalPeriod (n : ℤ) :
    a ^ (n % (minimalPeriod (a • ·) b : ℤ)) • b = a ^ n • b 
Arguments: {α : Type v} {G : Type u} [AddGroup G] [AddAction G α] (a : G) (b : α) (n : ℤ)
Goal: (n % ↑(Function.minimalPeriod (fun x => a +ᵥ x) b)) • a +ᵥ b = n • a +ᵥ b
-- MulAction.zpow_smul_mod_minimalPeriod
@[to_additive (attr := simp)]
theorem zpow_smul_mod_minimalPeriod (n : ℤ) :
    a ^ (n % (minimalPeriod (a • ·) b : ℤ)) • b = a ^ n • b 
Arguments: {α : Type v} {G : Type u} [Group G] [MulAction G α] (a : G) (b : α) (n : ℤ)
Goal: a ^ (n % ↑(Function.minimalPeriod (fun x => a • x) b)) • b = a ^ n • b
-- mem_separableClosure_iff
theorem mem_separableClosure_iff {x : E} :
    x ∈ separableClosure F E ↔ IsSeparable F x 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] {x : E}
Goal: x ∈ separableClosure F E ↔ IsSeparable F x
-- map_mem_separableClosure_iff
theorem map_mem_separableClosure_iff (i : E →ₐ[F] K) {x : E} :
    i x ∈ separableClosure F K ↔ x ∈ separableClosure F E 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] {K : Type w} [Field K] [Algebra F K] (i : E →ₐ[F] K) {x : E}
Goal: i x ∈ separableClosure F K ↔ x ∈ separableClosure F E
-- separableClosure.comap_eq_of_algHom
theorem separableClosure.comap_eq_of_algHom (i : E →ₐ[F] K) :
    (separableClosure F K).comap i = separableClosure F E 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] {K : Type w} [Field K] [Algebra F K] (i : E →ₐ[F] K)
Goal: IntermediateField.comap i (separableClosure F K) = separableClosure F E
-- separableClosure.map_le_of_algHom
theorem separableClosure.map_le_of_algHom (i : E →ₐ[F] K) :
    (separableClosure F E).map i ≤ separableClosure F K 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] {K : Type w} [Field K] [Algebra F K] (i : E →ₐ[F] K)
Goal: IntermediateField.map i (separableClosure F E) ≤ separableClosure F K
-- separableClosure.map_eq_of_separableClosure_eq_bot
theorem separableClosure.map_eq_of_separableClosure_eq_bot [Algebra E K] [IsScalarTower F E K]
    (h : separableClosure E K = ⊥) :
    (separableClosure F E).map (IsScalarTower.toAlgHom F E K) = separableClosure F K 
Arguments: (F : Type u) {E : Type v} [Field F] [Field E] [Algebra F E] {K : Type w} [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K] (h : separableClosure E K = ⊥)
Goal: IntermediateField.map (IsScalarTower.toAlgHom F E K) (separableClosure F E) = separableClosure F K
-- separableClosure.map_eq_of_algEquiv
theorem separableClosure.map_eq_of_algEquiv (i : E ≃ₐ[F] K) :
    (separableClosure F E).map i = separableClosure F K 
Arguments: {F : Type u} {E : Type v} [Field F] [Field E] [Algebra F E] {K : Type w} [Field K] [Algebra F K] (i : E ≃ₐ[F] K)
Goal: IntermediateField.map (↑i) (separableClosure F E) = separableClosure F K
-- le_separableClosure'
theorem le_separableClosure' {L : IntermediateField F E} (hs : ∀ x : L, IsSeparable F x) :
    L ≤ separableClosure F E 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] {L : IntermediateField F E} (hs : ∀ (x : ↥L), IsSeparable F x)
Goal: L ≤ separableClosure F E
-- le_separableClosure
theorem le_separableClosure (L : IntermediateField F E) [Algebra.IsSeparable F L] :
    L ≤ separableClosure F E 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (L : IntermediateField F E) [Algebra.IsSeparable F ↥L]
Goal: L ≤ separableClosure F E
-- le_separableClosure_iff
theorem le_separableClosure_iff (L : IntermediateField F E) :
    L ≤ separableClosure F E ↔ Algebra.IsSeparable F L 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (L : IntermediateField F E)
Goal: L ≤ separableClosure F E ↔ Algebra.IsSeparable F ↥L
-- separableClosure.separableClosure_eq_bot
theorem separableClosure.separableClosure_eq_bot :
    separableClosure (separableClosure F E) E = ⊥ 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E]
Goal: separableClosure (↥(separableClosure F E)) E = ⊥
-- separableClosure.normalClosure_eq_self
theorem separableClosure.normalClosure_eq_self :
    normalClosure F (separableClosure F E) E = separableClosure F E 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E]
Goal: normalClosure F (↥(separableClosure F E)) E = separableClosure F E
-- IsSepClosed.separableClosure_eq_bot_iff
theorem IsSepClosed.separableClosure_eq_bot_iff [IsSepClosed E] :
    separableClosure F E = ⊥ ↔ IsSepClosed F 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] [IsSepClosed E]
Goal: separableClosure F E = ⊥ ↔ IsSepClosed F
-- IntermediateField.isSeparable_adjoin_iff_isSeparable
theorem IntermediateField.isSeparable_adjoin_iff_isSeparable {S : Set E} :
    Algebra.IsSeparable F (adjoin F S) ↔ ∀ x ∈ S, IsSeparable F x 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] {S : Set E}
Goal: Algebra.IsSeparable F ↥(IntermediateField.adjoin F S) ↔ ∀ x ∈ S, IsSeparable F x
-- separableClosure.eq_top_iff
theorem separableClosure.eq_top_iff : separableClosure F E = ⊤ ↔ Algebra.IsSeparable F E 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E]
Goal: separableClosure F E = ⊤ ↔ Algebra.IsSeparable F E
-- separableClosure.le_restrictScalars
theorem separableClosure.le_restrictScalars [Algebra E K] [IsScalarTower F E K] :
    separableClosure F K ≤ (separableClosure E K).restrictScalars F 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type w) [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K]
Goal: separableClosure F K ≤ IntermediateField.restrictScalars F (separableClosure E K)
-- separableClosure.eq_restrictScalars_of_isSeparable
theorem separableClosure.eq_restrictScalars_of_isSeparable [Algebra E K] [IsScalarTower F E K]
    [Algebra.IsSeparable F E] : separableClosure F K = (separableClosure E K).restrictScalars F 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type w) [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K] [Algebra.IsSeparable F E]
Goal: separableClosure F K = IntermediateField.restrictScalars F (separableClosure E K)
-- separableClosure.adjoin_le
theorem separableClosure.adjoin_le [Algebra E K] [IsScalarTower F E K] :
    adjoin E (separableClosure F K) ≤ separableClosure E K 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type w) [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K]
Goal: IntermediateField.adjoin E ↑(separableClosure F K) ≤ separableClosure E K
-- Field.finInsepDegree_def'
theorem finInsepDegree_def' : finInsepDegree F E = Cardinal.toNat (insepDegree F E) 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E]
Goal: Field.finInsepDegree F E = Cardinal.toNat (Field.insepDegree F E)
-- Field.lift_sepDegree_eq_of_equiv
theorem lift_sepDegree_eq_of_equiv (i : E ≃ₐ[F] K) :
    Cardinal.lift.{w} (sepDegree F E) = Cardinal.lift.{v} (sepDegree F K) 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type w) [Field K] [Algebra F K] (i : E ≃ₐ[F] K)
Goal: Cardinal.lift.{w, v} (Field.sepDegree F E) = Cardinal.lift.{v, w} (Field.sepDegree F K)
-- Field.sepDegree_eq_of_equiv
theorem sepDegree_eq_of_equiv (K : Type v) [Field K] [Algebra F K] (i : E ≃ₐ[F] K) :
    sepDegree F E = sepDegree F K 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type v) [Field K] [Algebra F K] (i : E ≃ₐ[F] K)
Goal: Field.sepDegree F E = Field.sepDegree F K
-- Field.sepDegree_mul_insepDegree
theorem sepDegree_mul_insepDegree : sepDegree F E * insepDegree F E = Module.rank F E 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E]
Goal: Field.sepDegree F E * Field.insepDegree F E = Module.rank F E
-- Field.lift_insepDegree_eq_of_equiv
theorem lift_insepDegree_eq_of_equiv (i : E ≃ₐ[F] K) :
    Cardinal.lift.{w} (insepDegree F E) = Cardinal.lift.{v} (insepDegree F K) 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type w) [Field K] [Algebra F K] (i : E ≃ₐ[F] K)
Goal: Cardinal.lift.{w, v} (Field.insepDegree F E) = Cardinal.lift.{v, w} (Field.insepDegree F K)
-- Field.insepDegree_eq_of_equiv
theorem insepDegree_eq_of_equiv (K : Type v) [Field K] [Algebra F K] (i : E ≃ₐ[F] K) :
    insepDegree F E = insepDegree F K 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type v) [Field K] [Algebra F K] (i : E ≃ₐ[F] K)
Goal: Field.insepDegree F E = Field.insepDegree F K
-- Field.finInsepDegree_eq_of_equiv
theorem finInsepDegree_eq_of_equiv (i : E ≃ₐ[F] K) :
    finInsepDegree F E = finInsepDegree F K 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type w) [Field K] [Algebra F K] (i : E ≃ₐ[F] K)
Goal: Field.finInsepDegree F E = Field.finInsepDegree F K
-- Field.sepDegree_self
@[simp]
theorem sepDegree_self : sepDegree F F = 1 
Arguments: (F : Type u) [Field F]
Goal: Field.sepDegree F F = 1
-- Field.insepDegree_self
@[simp]
theorem insepDegree_self : insepDegree F F = 1 
Arguments: (F : Type u) [Field F]
Goal: Field.insepDegree F F = 1
-- Field.finInsepDegree_self
@[simp]
theorem finInsepDegree_self : finInsepDegree F F = 1 
Arguments: (F : Type u) [Field F]
Goal: Field.finInsepDegree F F = 1
-- IntermediateField.sepDegree_bot
@[simp]
theorem sepDegree_bot : sepDegree F (⊥ : IntermediateField F E) = 1 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E]
Goal: Field.sepDegree F ↥⊥ = 1
-- IntermediateField.insepDegree_bot
@[simp]
theorem insepDegree_bot : insepDegree F (⊥ : IntermediateField F E) = 1 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E]
Goal: Field.insepDegree F ↥⊥ = 1
-- IntermediateField.finInsepDegree_bot
@[simp]
theorem finInsepDegree_bot : finInsepDegree F (⊥ : IntermediateField F E) = 1 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E]
Goal: Field.finInsepDegree F ↥⊥ = 1
-- IntermediateField.lift_sepDegree_bot'
theorem lift_sepDegree_bot' : Cardinal.lift.{v} (sepDegree F (⊥ : IntermediateField E K)) =
    Cardinal.lift.{w} (sepDegree F E) 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type w) [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K]
Goal: Cardinal.lift.{v, w} (Field.sepDegree F ↥⊥) = Cardinal.lift.{w, v} (Field.sepDegree F E)
-- IntermediateField.lift_insepDegree_bot'
theorem lift_insepDegree_bot' : Cardinal.lift.{v} (insepDegree F (⊥ : IntermediateField E K)) =
    Cardinal.lift.{w} (insepDegree F E) 
Arguments: (F : Type u) (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type w) [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K]
Goal: Cardinal.lift.{v, w} (Field.insepDegree F ↥⊥) = Cardinal.lift.{w, v} (Field.insepDegree F E)
-- IntermediateField.finInsepDegree_bot'
@[simp]
theorem finInsepDegree_bot' :
    finInsepDegree F (⊥ : IntermediateField E K) = finInsepDegree F E 
Arguments: {F : Type u} (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type w) [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K]
Goal: Field.finInsepDegree F ↥⊥ = Field.finInsepDegree F E
-- IntermediateField.sepDegree_top
@[simp]
theorem sepDegree_top : sepDegree F (⊤ : IntermediateField E K) = sepDegree F K 
Arguments: {F : Type u} (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type w) [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K]
Goal: Field.sepDegree F ↥⊤ = Field.sepDegree F K
-- IntermediateField.insepDegree_top
@[simp]
theorem insepDegree_top : insepDegree F (⊤ : IntermediateField E K) = insepDegree F K 
Arguments: {F : Type u} (E : Type v) [Field F] [Field E] [Algebra F E] (K : Type w) [Field K] [Algebra F K] [Algebra E K] [IsScalarTower F E K]
Goal: Field.insepDegree F ↥⊤ = Field.insepDegree F K