fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
relrank_self : relrank A A = 1 := A.toSubfield.relrank_self
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_self | null |
relfinrank_self : relfinrank A A = 1 := A.toSubfield.relfinrank_self
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_self | null |
relrank_eq_one_of_le (h : B ≤ A) : relrank A B = 1 := by
rw [← inf_relrank_right, inf_eq_right.2 h, relrank_self]
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_eq_one_of_le | null |
relfinrank_eq_one_of_le (h : B ≤ A) : relfinrank A B = 1 := by
simp [relfinrank_eq_toNat_relrank, relrank_eq_one_of_le h] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_eq_one_of_le | null |
lift_rank_comap (f : L →ₐ[F] E) :
Cardinal.lift.{v} (Module.rank (A.comap f) L) = Cardinal.lift.{w} (relrank A f.fieldRange) :=
A.toSubfield.lift_rank_comap f.toRingHom | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | lift_rank_comap | null |
rank_comap {L : Type v} [Field L] [Algebra F L] (f : L →ₐ[F] E) :
Module.rank (A.comap f) L = relrank A f.fieldRange := by
simpa only [lift_id] using A.lift_rank_comap f | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | rank_comap | null |
finrank_comap (f : L →ₐ[F] E) : finrank (A.comap f) L = relfinrank A f.fieldRange := by
simpa using congr(toNat $(lift_rank_comap A f)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | finrank_comap | null |
lift_relrank_comap (f : L →ₐ[F] E) (B : IntermediateField F L) :
Cardinal.lift.{v} (relrank (A.comap f) B) = Cardinal.lift.{w} (relrank A (B.map f)) :=
A.toSubfield.lift_relrank_comap f.toRingHom B.toSubfield | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | lift_relrank_comap | null |
relrank_comap {L : Type v} [Field L] [Algebra F L] (f : L →ₐ[F] E)
(B : IntermediateField F L) : relrank (A.comap f) B = relrank A (B.map f) := by
simpa only [lift_id] using A.lift_relrank_comap f B | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_comap | null |
relfinrank_comap (f : L →ₐ[F] E) (B : IntermediateField F L) :
relfinrank (A.comap f) B = relfinrank A (B.map f) := by
simpa using congr(toNat $(lift_relrank_comap A f B)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_comap | null |
lift_relrank_map_map (f : E →ₐ[F] L) :
Cardinal.lift.{v} (relrank (A.map f) (B.map f)) = Cardinal.lift.{w} (relrank A B) := by
rw [← lift_relrank_comap, comap_map] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | lift_relrank_map_map | null |
relrank_map_map {L : Type v} [Field L] [Algebra F L] (f : E →ₐ[F] L) :
relrank (A.map f) (B.map f) = relrank A B := by
simpa only [lift_id] using lift_relrank_map_map A B f | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_map_map | null |
relfinrank_map_map (f : E →ₐ[F] L) :
relfinrank (A.map f) (B.map f) = relfinrank A B := by
simpa using congr(toNat $(lift_relrank_map_map A B f)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_map_map | null |
lift_relrank_comap_comap_eq_lift_relrank_inf (f : L →ₐ[F] E) :
Cardinal.lift.{v} (relrank (A.comap f) (B.comap f)) =
Cardinal.lift.{w} (relrank A (B ⊓ f.fieldRange)) :=
A.toSubfield.lift_relrank_comap_comap_eq_lift_relrank_inf B.toSubfield f.toRingHom | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | lift_relrank_comap_comap_eq_lift_relrank_inf | null |
relrank_comap_comap_eq_relrank_inf
{L : Type v} [Field L] [Algebra F L] (f : L →ₐ[F] E) :
relrank (A.comap f) (B.comap f) = relrank A (B ⊓ f.fieldRange) := by
simpa only [lift_id] using lift_relrank_comap_comap_eq_lift_relrank_inf A B f | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_comap_comap_eq_relrank_inf | null |
relfinrank_comap_comap_eq_relfinrank_inf (f : L →ₐ[F] E) :
relfinrank (A.comap f) (B.comap f) = relfinrank A (B ⊓ f.fieldRange) := by
simpa using congr(toNat $(lift_relrank_comap_comap_eq_lift_relrank_inf A B f)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_comap_comap_eq_relfinrank_inf | null |
lift_relrank_comap_comap_eq_lift_relrank_of_le (f : L →ₐ[F] E) (h : B ≤ f.fieldRange) :
Cardinal.lift.{v} (relrank (A.comap f) (B.comap f)) = Cardinal.lift.{w} (relrank A B) := by
simpa only [inf_of_le_left h] using lift_relrank_comap_comap_eq_lift_relrank_inf A B f | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | lift_relrank_comap_comap_eq_lift_relrank_of_le | null |
relrank_comap_comap_eq_relrank_of_le
{L : Type v} [Field L] [Algebra F L] (f : L →ₐ[F] E) (h : B ≤ f.fieldRange) :
relrank (A.comap f) (B.comap f) = relrank A B := by
simpa only [lift_id] using lift_relrank_comap_comap_eq_lift_relrank_of_le A B f h | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_comap_comap_eq_relrank_of_le | null |
relfinrank_comap_comap_eq_relfinrank_of_le (f : L →ₐ[F] E) (h : B ≤ f.fieldRange) :
relfinrank (A.comap f) (B.comap f) = relfinrank A B := by
simpa using congr(toNat $(lift_relrank_comap_comap_eq_lift_relrank_of_le A B f h)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_comap_comap_eq_relfinrank_of_le | null |
lift_relrank_comap_comap_eq_lift_relrank_of_surjective
(f : L →ₐ[F] E) (h : Function.Surjective f) :
Cardinal.lift.{v} (relrank (A.comap f) (B.comap f)) = Cardinal.lift.{w} (relrank A B) :=
lift_relrank_comap_comap_eq_lift_relrank_of_le A B f fun x _ ↦ h x | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | lift_relrank_comap_comap_eq_lift_relrank_of_surjective | null |
relrank_comap_comap_eq_relrank_of_surjective
{L : Type v} [Field L] [Algebra F L] (f : L →ₐ[F] E) (h : Function.Surjective f) :
relrank (A.comap f) (B.comap f) = relrank A B := by
simpa using lift_relrank_comap_comap_eq_lift_relrank_of_surjective A B f h | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_comap_comap_eq_relrank_of_surjective | null |
relfinrank_comap_comap_eq_relfinrank_of_surjective
(f : L →ₐ[F] E) (h : Function.Surjective f) :
relfinrank (A.comap f) (B.comap f) = relfinrank A B := by
simpa using congr(toNat $(lift_relrank_comap_comap_eq_lift_relrank_of_surjective A B f h))
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_comap_comap_eq_relfinrank_of_surjective | null |
relrank_mul_rank_top (h : A ≤ B) : relrank A B * Module.rank B E = Module.rank A E :=
Subfield.relrank_mul_rank_top h
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_mul_rank_top | null |
relfinrank_mul_finrank_top (h : A ≤ B) : relfinrank A B * finrank B E = finrank A E := by
simpa using congr(toNat $(relrank_mul_rank_top h))
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_mul_finrank_top | null |
rank_bot_mul_relrank (h : A ≤ B) : Module.rank F A * relrank A B = Module.rank F B := by
rw [relrank_eq_rank_of_le h]
letI : Algebra A B := (inclusion h).toAlgebra
haveI : IsScalarTower F A B := IsScalarTower.of_algebraMap_eq' rfl
exact rank_mul_rank F A B
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | rank_bot_mul_relrank | null |
finrank_bot_mul_relfinrank (h : A ≤ B) : finrank F A * relfinrank A B = finrank F B := by
simpa using congr(toNat $(rank_bot_mul_relrank h))
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | finrank_bot_mul_relfinrank | null |
relrank_dvd_rank_top_of_le (h : A ≤ B) : relrank A B ∣ Module.rank A E :=
dvd_of_mul_right_eq _ (relrank_mul_rank_top h)
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_dvd_rank_top_of_le | null |
relfinrank_dvd_finrank_top_of_le (h : A ≤ B) : relfinrank A B ∣ finrank A E :=
dvd_of_mul_right_eq _ (relfinrank_mul_finrank_top h) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_dvd_finrank_top_of_le | null |
relrank_dvd_rank_bot : relrank A B ∣ Module.rank F B :=
inf_relrank_right A B ▸ dvd_of_mul_left_eq _ (rank_bot_mul_relrank inf_le_right) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_dvd_rank_bot | null |
relfinrank_dvd_finrank_bot : relfinrank A B ∣ finrank F B :=
inf_relfinrank_right A B ▸ dvd_of_mul_left_eq _ (finrank_bot_mul_relfinrank inf_le_right)
variable {A B C} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_dvd_finrank_bot | null |
relrank_mul_relrank (h1 : A ≤ B) (h2 : B ≤ C) :
relrank A B * relrank B C = relrank A C :=
Subfield.relrank_mul_relrank h1 h2
variable {A B C} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_mul_relrank | null |
relfinrank_mul_relfinrank (h1 : A ≤ B) (h2 : B ≤ C) :
relfinrank A B * relfinrank B C = relfinrank A C := by
simpa using congr(toNat $(relrank_mul_relrank h1 h2)) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_mul_relfinrank | null |
relrank_inf_mul_relrank : A.relrank (B ⊓ C) * B.relrank C = (A ⊓ B).relrank C :=
Subfield.relrank_inf_mul_relrank A.toSubfield B.toSubfield C.toSubfield | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_inf_mul_relrank | null |
relfinrank_inf_mul_relfinrank :
A.relfinrank (B ⊓ C) * B.relfinrank C = (A ⊓ B).relfinrank C := by
simpa using congr(toNat $(relrank_inf_mul_relrank A B C))
variable {B C} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_inf_mul_relfinrank | null |
relrank_mul_relrank_eq_inf_relrank (h : B ≤ C) :
relrank A B * relrank B C = (A ⊓ B).relrank C := by
simpa only [inf_of_le_left h] using relrank_inf_mul_relrank A B C
variable {B C} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_mul_relrank_eq_inf_relrank | null |
relfinrank_mul_relfinrank_eq_inf_relfinrank (h : B ≤ C) :
relfinrank A B * relfinrank B C = (A ⊓ B).relfinrank C := by
simpa using congr(toNat $(relrank_mul_relrank_eq_inf_relrank A h))
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_mul_relfinrank_eq_inf_relfinrank | null |
relrank_inf_mul_relrank_of_le (h : A ≤ B) :
A.relrank (B ⊓ C) * B.relrank C = A.relrank C := by
simpa only [inf_of_le_left h] using relrank_inf_mul_relrank A B C
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_inf_mul_relrank_of_le | null |
relfinrank_inf_mul_relfinrank_of_le (h : A ≤ B) :
A.relfinrank (B ⊓ C) * B.relfinrank C = A.relfinrank C := by
simpa using congr(toNat $(relrank_inf_mul_relrank_of_le C h))
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_inf_mul_relfinrank_of_le | null |
relrank_top_left : relrank ⊤ A = 1 := relrank_eq_one_of_le le_top
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_top_left | null |
relfinrank_top_left : relfinrank ⊤ A = 1 := relfinrank_eq_one_of_le le_top
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_top_left | null |
relrank_top_right : relrank A ⊤ = Module.rank A E := by
rw [← relrank_mul_rank_top (show A ≤ ⊤ from le_top), IntermediateField.rank_top, mul_one]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_top_right | null |
relfinrank_top_right : relfinrank A ⊤ = finrank A E := by
simp [relfinrank_eq_toNat_relrank, finrank]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_top_right | null |
relrank_bot_left : relrank ⊥ A = Module.rank F A := by
rw [← rank_bot_mul_relrank (show ⊥ ≤ A from bot_le), IntermediateField.rank_bot, one_mul]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_bot_left | null |
relfinrank_bot_left : relfinrank ⊥ A = finrank F A := by
simp [relfinrank_eq_toNat_relrank, finrank]
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_bot_left | null |
relrank_bot_right : relrank A ⊥ = 1 := relrank_eq_one_of_le bot_le
@[simp] | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_bot_right | null |
relfinrank_bot_right : relfinrank A ⊥ = 1 := relfinrank_eq_one_of_le bot_le
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_bot_right | null |
relrank_dvd_of_le_left (h : A ≤ B) : B.relrank C ∣ A.relrank C :=
dvd_of_mul_left_eq _ (relrank_inf_mul_relrank_of_le C h)
variable {A B} in | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relrank_dvd_of_le_left | null |
relfinrank_dvd_of_le_left (h : A ≤ B) : B.relfinrank C ∣ A.relfinrank C :=
dvd_of_mul_left_eq _ (relfinrank_inf_mul_relfinrank_of_le C h) | theorem | FieldTheory | [
"Mathlib.FieldTheory.IntermediateField.Adjoin.Basic"
] | Mathlib/FieldTheory/Relrank.lean | relfinrank_dvd_of_le_left | null |
@[stacks 09H1 "first part"]
Separable (f : R[X]) : Prop :=
IsCoprime f (derivative f) | def | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable | A polynomial is separable iff it is coprime with its derivative. |
separable_def (f : R[X]) : f.Separable ↔ IsCoprime f (derivative f) :=
Iff.rfl | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_def | null |
separable_def' (f : R[X]) : f.Separable ↔ ∃ a b : R[X], a * f + b * (derivative f) = 1 :=
Iff.rfl | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_def' | null |
not_separable_zero [Nontrivial R] : ¬Separable (0 : R[X]) := by
rintro ⟨x, y, h⟩
simp only [derivative_zero, mul_zero, add_zero, zero_ne_one] at h | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | not_separable_zero | null |
Separable.ne_zero [Nontrivial R] {f : R[X]} (h : f.Separable) : f ≠ 0 :=
(not_separable_zero <| · ▸ h)
@[simp] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.ne_zero | null |
separable_one : (1 : R[X]).Separable :=
isCoprime_one_left
@[nontriviality] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_one | null |
separable_of_subsingleton [Subsingleton R] (f : R[X]) : f.Separable := by
simp [Separable, IsCoprime, eq_iff_true_of_subsingleton] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_of_subsingleton | null |
separable_X_add_C (a : R) : (X + C a).Separable := by
rw [separable_def, derivative_add, derivative_X, derivative_C, add_zero]
exact isCoprime_one_right | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_X_add_C | null |
separable_X : (X : R[X]).Separable := by
rw [separable_def, derivative_X]
exact isCoprime_one_right | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_X | null |
separable_C (r : R) : (C r).Separable ↔ IsUnit r := by
rw [separable_def, derivative_C, isCoprime_zero_right, isUnit_C] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_C | null |
Separable.of_mul_left {f g : R[X]} (h : (f * g).Separable) : f.Separable := by
have := h.of_mul_left_left; rw [derivative_mul] at this
exact IsCoprime.of_mul_right_left (IsCoprime.of_add_mul_left_right this) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.of_mul_left | null |
Separable.of_mul_right {f g : R[X]} (h : (f * g).Separable) : g.Separable := by
rw [mul_comm] at h
exact h.of_mul_left | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.of_mul_right | null |
Separable.of_dvd {f g : R[X]} (hf : f.Separable) (hfg : g ∣ f) : g.Separable := by
rcases hfg with ⟨f', rfl⟩
exact Separable.of_mul_left hf | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.of_dvd | null |
separable_gcd_left {F : Type*} [Field F] [DecidableEq F[X]]
{f : F[X]} (hf : f.Separable) (g : F[X]) :
(EuclideanDomain.gcd f g).Separable :=
Separable.of_dvd hf (EuclideanDomain.gcd_dvd_left f g) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_gcd_left | null |
separable_gcd_right {F : Type*} [Field F] [DecidableEq F[X]]
{g : F[X]} (f : F[X]) (hg : g.Separable) :
(EuclideanDomain.gcd f g).Separable :=
Separable.of_dvd hg (EuclideanDomain.gcd_dvd_right f g) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_gcd_right | null |
Separable.isCoprime {f g : R[X]} (h : (f * g).Separable) : IsCoprime f g := by
have := h.of_mul_left_left; rw [derivative_mul] at this
exact IsCoprime.of_mul_right_right (IsCoprime.of_add_mul_left_right this) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.isCoprime | null |
Separable.of_pow' {f : R[X]} :
∀ {n : ℕ} (_h : (f ^ n).Separable), IsUnit f ∨ f.Separable ∧ n = 1 ∨ n = 0
| 0 => fun _h => Or.inr <| Or.inr rfl
| 1 => fun h => Or.inr <| Or.inl ⟨pow_one f ▸ h, rfl⟩
| n + 2 => fun h => by
rw [pow_succ, pow_succ] at h
exact Or.inl (isCoprime_self.1 h.isCoprime.of_mul_left_right) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.of_pow' | null |
Separable.of_pow {f : R[X]} (hf : ¬IsUnit f) {n : ℕ} (hn : n ≠ 0)
(hfs : (f ^ n).Separable) : f.Separable ∧ n = 1 :=
(hfs.of_pow'.resolve_left hf).resolve_right hn | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.of_pow | null |
Separable.map {p : R[X]} (h : p.Separable) {f : R →+* S} : (p.map f).Separable :=
let ⟨a, b, H⟩ := h
⟨a.map f, b.map f, by
rw [derivative_map, ← Polynomial.map_mul, ← Polynomial.map_mul, ← Polynomial.map_add, H,
Polynomial.map_one]⟩ | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.map | null |
_root_.Associated.separable {f g : R[X]}
(ha : Associated f g) (h : f.Separable) : g.Separable := by
obtain ⟨⟨u, v, h1, h2⟩, ha⟩ := ha
obtain ⟨a, b, h⟩ := h
refine ⟨a * v + b * derivative v, b * v, ?_⟩
replace h := congr($h * $(h1))
have h3 := congr(derivative $(h1))
simp only [← ha, derivative_mul, derivative_one] at h3 ⊢
calc
_ = (a * f + b * derivative f) * (u * v)
+ (b * f) * (derivative u * v + u * derivative v) := by ring1
_ = 1 := by rw [h, h3]; ring1 | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | _root_.Associated.separable | null |
_root_.Associated.separable_iff {f g : R[X]}
(ha : Associated f g) : f.Separable ↔ g.Separable := ⟨ha.separable, ha.symm.separable⟩ | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | _root_.Associated.separable_iff | null |
Separable.mul_unit {f g : R[X]} (hf : f.Separable) (hg : IsUnit g) : (f * g).Separable :=
(associated_mul_unit_right f g hg).separable hf | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.mul_unit | null |
Separable.unit_mul {f g : R[X]} (hf : IsUnit f) (hg : g.Separable) : (f * g).Separable :=
(associated_unit_mul_right g f hf).separable hg | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.unit_mul | null |
Separable.eval₂_derivative_ne_zero [Nontrivial S] (f : R →+* S) {p : R[X]}
(h : p.Separable) {x : S} (hx : p.eval₂ f x = 0) :
(derivative p).eval₂ f x ≠ 0 := by
intro hx'
obtain ⟨a, b, e⟩ := h
apply_fun Polynomial.eval₂ f x at e
simp only [eval₂_add, eval₂_mul, hx, mul_zero, hx', add_zero, eval₂_one, zero_ne_one] at e | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.eval₂_derivative_ne_zero | null |
Separable.aeval_derivative_ne_zero [Nontrivial S] [Algebra R S] {p : R[X]}
(h : p.Separable) {x : S} (hx : aeval x p = 0) :
aeval x (derivative p) ≠ 0 :=
h.eval₂_derivative_ne_zero (algebraMap R S) hx
variable (p q : ℕ) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.aeval_derivative_ne_zero | null |
isUnit_of_self_mul_dvd_separable {p q : R[X]} (hp : p.Separable) (hq : q * q ∣ p) :
IsUnit q := by
obtain ⟨p, rfl⟩ := hq
apply isCoprime_self.mp
have : IsCoprime (q * (q * p))
(q * (derivative q * p + derivative q * p + q * derivative p)) := by
simp only [← mul_assoc, mul_add]
dsimp only [Separable] at hp
convert hp using 1
rw [derivative_mul, derivative_mul]
ring
exact IsCoprime.of_mul_right_left (IsCoprime.of_mul_left_left this) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | isUnit_of_self_mul_dvd_separable | null |
emultiplicity_le_one_of_separable {p q : R[X]} (hq : ¬IsUnit q) (hsep : Separable p) :
emultiplicity q p ≤ 1 := by
contrapose! hq
apply isUnit_of_self_mul_dvd_separable hsep
rw [← sq]
apply pow_dvd_of_le_emultiplicity
exact Order.add_one_le_of_lt hq | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | emultiplicity_le_one_of_separable | null |
Separable.squarefree {p : R[X]} (hsep : Separable p) : Squarefree p := by
classical
rw [squarefree_iff_emultiplicity_le_one p]
exact fun f => or_iff_not_imp_right.mpr fun hunit => emultiplicity_le_one_of_separable hunit hsep | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.squarefree | A separable polynomial is square-free.
See `PerfectField.separable_iff_squarefree` for the converse when the coefficients are a perfect
field. |
separable_X_sub_C {x : R} : Separable (X - C x) := by
simpa only [sub_eq_add_neg, C_neg] using separable_X_add_C (-x) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_X_sub_C | null |
Separable.mul {f g : R[X]} (hf : f.Separable) (hg : g.Separable) (h : IsCoprime f g) :
(f * g).Separable := by
rw [separable_def, derivative_mul]
exact
((hf.mul_right h).add_mul_left_right _).mul_left ((h.symm.mul_right hg).mul_add_right_right _) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.mul | null |
separable_prod' {ι : Sort _} {f : ι → R[X]} {s : Finset ι} :
(∀ x ∈ s, ∀ y ∈ s, x ≠ y → IsCoprime (f x) (f y)) →
(∀ x ∈ s, (f x).Separable) → (∏ x ∈ s, f x).Separable := by
classical
exact Finset.induction_on s (fun _ _ => separable_one) fun a s has ih h1 h2 => by
simp_rw [Finset.forall_mem_insert, forall_and] at h1 h2; rw [prod_insert has]
exact
h2.1.mul (ih h1.2.2 h2.2)
(IsCoprime.prod_right fun i his => h1.1.2 i his <| Ne.symm <| ne_of_mem_of_not_mem his has)
open scoped Function in -- required for scoped `on` notation | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_prod' | null |
separable_prod {ι : Sort _} [Fintype ι] {f : ι → R[X]} (h1 : Pairwise (IsCoprime on f))
(h2 : ∀ x, (f x).Separable) : (∏ x, f x).Separable :=
separable_prod' (fun _x _hx _y _hy hxy => h1 hxy) fun x _hx => h2 x | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_prod | null |
Separable.inj_of_prod_X_sub_C [Nontrivial R] {ι : Sort _} {f : ι → R} {s : Finset ι}
(hfs : (∏ i ∈ s, (X - C (f i))).Separable) {x y : ι} (hx : x ∈ s) (hy : y ∈ s)
(hfxy : f x = f y) : x = y := by
classical
by_contra hxy
rw [← insert_erase hx, prod_insert (notMem_erase _ _), ←
insert_erase (mem_erase_of_ne_of_mem (Ne.symm hxy) hy), prod_insert (notMem_erase _ _), ←
mul_assoc, hfxy, ← sq] at hfs
cases (hfs.of_mul_left.of_pow (not_isUnit_X_sub_C _) two_ne_zero).2 | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.inj_of_prod_X_sub_C | null |
Separable.injective_of_prod_X_sub_C [Nontrivial R] {ι : Sort _} [Fintype ι] {f : ι → R}
(hfs : (∏ i, (X - C (f i))).Separable) : Function.Injective f := fun _x _y hfxy =>
hfs.inj_of_prod_X_sub_C (mem_univ _) (mem_univ _) hfxy | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | Separable.injective_of_prod_X_sub_C | null |
nodup_of_separable_prod [Nontrivial R] {s : Multiset R}
(hs : Separable (Multiset.map (fun a => X - C a) s).prod) : s.Nodup := by
rw [Multiset.nodup_iff_ne_cons_cons]
rintro a t rfl
refine not_isUnit_X_sub_C a (isUnit_of_self_mul_dvd_separable hs ?_)
simpa only [Multiset.map_cons, Multiset.prod_cons] using mul_dvd_mul_left _ (dvd_mul_right _ _) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | nodup_of_separable_prod | null |
separable_X_pow_sub_C_unit {n : ℕ} (u : Rˣ) (hn : IsUnit (n : R)) :
Separable (X ^ n - C (u : R)) := by
nontriviality R
rcases n.eq_zero_or_pos with (rfl | hpos)
· simp at hn
apply (separable_def' (X ^ n - C (u : R))).2
obtain ⟨n', hn'⟩ := hn.exists_left_inv
refine ⟨-C ↑u⁻¹, C (↑u⁻¹ : R) * C n' * X, ?_⟩
rw [derivative_sub, derivative_C, sub_zero, derivative_pow X n, derivative_X, mul_one]
calc
-C ↑u⁻¹ * (X ^ n - C ↑u) + C ↑u⁻¹ * C n' * X * (↑n * X ^ (n - 1)) =
C (↑u⁻¹ * ↑u) - C ↑u⁻¹ * X ^ n + C ↑u⁻¹ * C (n' * ↑n) * (X * X ^ (n - 1)) := by
simp only [C.map_mul, C_eq_natCast]
ring
_ = 1 := by
simp only [Units.inv_mul, hn', C.map_one, mul_one, ← pow_succ',
Nat.sub_add_cancel (show 1 ≤ n from hpos), sub_add_cancel] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_X_pow_sub_C_unit | If `IsUnit n` in a `CommRing R`, then `X ^ n - u` is separable for any unit `u`. |
separable_C_mul_X_pow_add_C_mul_X_add_C
{n : ℕ} (a b c : R) (hn : (n : R) = 0) (hb : IsUnit b) :
(C a * X ^ n + C b * X + C c).Separable := by
set f := C a * X ^ n + C b * X + C c
obtain ⟨e, hb⟩ := hb.exists_left_inv
refine ⟨-derivative f, f + C e, ?_⟩
have hderiv : derivative f = C b := by
simp [hn, f, map_add derivative, derivative_C, derivative_X_pow]
rw [hderiv, right_distrib, ← add_assoc, neg_mul, mul_comm, neg_add_cancel, zero_add,
← map_mul, hb, map_one] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_C_mul_X_pow_add_C_mul_X_add_C | If `n = 0` in `R` and `b` is a unit, then `a * X ^ n + b * X + c` is separable. |
separable_C_mul_X_pow_add_C_mul_X_add_C'
(p n : ℕ) (a b c : R) [CharP R p] (hn : p ∣ n) (hb : IsUnit b) :
(C a * X ^ n + C b * X + C c).Separable :=
separable_C_mul_X_pow_add_C_mul_X_add_C a b c ((CharP.cast_eq_zero_iff R p n).2 hn) hb | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_C_mul_X_pow_add_C_mul_X_add_C' | If `R` is of characteristic `p`, `p ∣ n` and `b` is a unit,
then `a * X ^ n + b * X + c` is separable. |
rootMultiplicity_le_one_of_separable [Nontrivial R] {p : R[X]} (hsep : Separable p)
(x : R) : rootMultiplicity x p ≤ 1 := by
classical
by_cases hp : p = 0
· simp [hp]
rw [rootMultiplicity_eq_multiplicity, if_neg hp, ← Nat.cast_le (α := ℕ∞),
Nat.cast_one, ← (finiteMultiplicity_X_sub_C x hp).emultiplicity_eq_multiplicity]
apply emultiplicity_le_one_of_separable (not_isUnit_X_sub_C _) hsep | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | rootMultiplicity_le_one_of_separable | null |
count_roots_le_one [DecidableEq R] {p : R[X]} (hsep : Separable p) (x : R) :
p.roots.count x ≤ 1 := by
rw [count_roots p]
exact rootMultiplicity_le_one_of_separable hsep x | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | count_roots_le_one | null |
nodup_roots {p : R[X]} (hsep : Separable p) : p.roots.Nodup := by
classical
exact Multiset.nodup_iff_count_le_one.mpr (count_roots_le_one hsep) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | nodup_roots | null |
separable_iff_derivative_ne_zero {f : F[X]} (hf : Irreducible f) :
f.Separable ↔ derivative f ≠ 0 :=
⟨fun h1 h2 => hf.not_isUnit <| isCoprime_zero_right.1 <| h2 ▸ h1, fun h =>
EuclideanDomain.isCoprime_of_dvd (mt And.right h) fun g hg1 _hg2 ⟨p, hg3⟩ hg4 =>
let ⟨u, hu⟩ := (hf.isUnit_or_isUnit hg3).resolve_left hg1
have : f ∣ derivative f := by
conv_lhs => rw [hg3, ← hu]
rwa [Units.mul_right_dvd]
not_lt_of_ge (natDegree_le_of_dvd this h) <|
natDegree_derivative_lt <| mt derivative_of_natDegree_zero h⟩
attribute [local instance] Ideal.Quotient.field in | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_iff_derivative_ne_zero | null |
separable_map {S} [CommRing S] [Nontrivial S] (f : F →+* S) {p : F[X]} :
(p.map f).Separable ↔ p.Separable := by
refine ⟨fun H ↦ ?_, fun H ↦ H.map⟩
obtain ⟨m, hm⟩ := Ideal.exists_maximal S
have := Separable.map H (f := Ideal.Quotient.mk m)
rwa [map_map, separable_def, derivative_map, isCoprime_map] at this | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_map | null |
separable_prod_X_sub_C_iff' {ι : Sort _} {f : ι → F} {s : Finset ι} :
(∏ i ∈ s, (X - C (f i))).Separable ↔ ∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y :=
⟨fun hfs _ hx _ hy hfxy => hfs.inj_of_prod_X_sub_C hx hy hfxy, fun H => by
rw [← prod_attach]
exact
separable_prod'
(fun x _hx y _hy hxy =>
@pairwise_coprime_X_sub_C _ _ { x // x ∈ s } (fun x => f x)
(fun x y hxy => Subtype.eq <| H x.1 x.2 y.1 y.2 hxy) _ _ hxy)
fun _ _ => separable_X_sub_C⟩ | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_prod_X_sub_C_iff' | null |
separable_prod_X_sub_C_iff {ι : Sort _} [Fintype ι] {f : ι → F} :
(∏ i, (X - C (f i))).Separable ↔ Function.Injective f :=
separable_prod_X_sub_C_iff'.trans <| by simp_rw [mem_univ, true_imp_iff, Function.Injective] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_prod_X_sub_C_iff | null |
separable_or {f : F[X]} (hf : Irreducible f) :
f.Separable ∨ ¬f.Separable ∧ ∃ g : F[X], Irreducible g ∧ expand F p g = f := by
classical
exact if H : derivative f = 0 then by
rcases p.eq_zero_or_pos with (rfl | hp)
· haveI := CharP.charP_to_charZero F
have := natDegree_eq_zero_of_derivative_eq_zero H
have := (natDegree_pos_iff_degree_pos.mpr <| degree_pos_of_irreducible hf).ne'
contradiction
haveI := isLocalHom_expand F hp
exact
Or.inr
⟨by rw [separable_iff_derivative_ne_zero hf, Classical.not_not, H], contract p f,
Irreducible.of_map (by rwa [← expand_contract p H hp.ne'] at hf),
expand_contract p H hp.ne'⟩
else Or.inl <| (separable_iff_derivative_ne_zero hf).2 H | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_or | null |
exists_separable_of_irreducible {f : F[X]} (hf : Irreducible f) (hp : p ≠ 0) :
∃ (n : ℕ) (g : F[X]), g.Separable ∧ expand F (p ^ n) g = f := by
replace hp : p.Prime := (CharP.char_is_prime_or_zero F p).resolve_right hp
induction hn : f.natDegree using Nat.strong_induction_on generalizing f with | _ N ih
rcases separable_or p hf with (h | ⟨h1, g, hg, hgf⟩)
· refine ⟨0, f, h, ?_⟩
rw [pow_zero, expand_one]
· rcases N with - | N
· rw [natDegree_eq_zero_iff_degree_le_zero, degree_le_zero_iff] at hn
rw [hn, separable_C, isUnit_iff_ne_zero, Classical.not_not] at h1
have hf0 : f ≠ 0 := hf.ne_zero
rw [h1, C_0] at hn
exact absurd hn hf0
have hg1 : g.natDegree * p = N.succ := by rwa [← natDegree_expand, hgf]
have hg2 : g.natDegree ≠ 0 := by
intro this
rw [this, zero_mul] at hg1
cases hg1
have hg3 : g.natDegree < N.succ := by
rw [← mul_one g.natDegree, ← hg1]
exact Nat.mul_lt_mul_of_pos_left hp.one_lt hg2.bot_lt
rcases ih _ hg3 hg rfl with ⟨n, g, hg4, rfl⟩
refine ⟨n + 1, g, hg4, ?_⟩
rw [← hgf, expand_expand, pow_succ'] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | exists_separable_of_irreducible | null |
isUnit_or_eq_zero_of_separable_expand {f : F[X]} (n : ℕ) (hp : 0 < p)
(hf : (expand F (p ^ n) f).Separable) : IsUnit f ∨ n = 0 := by
rw [or_iff_not_imp_right]
rintro hn : n ≠ 0
have hf2 : derivative (expand F (p ^ n) f) = 0 := by
rw [derivative_expand, Nat.cast_pow, CharP.cast_eq_zero, zero_pow hn, zero_mul, mul_zero]
rw [separable_def, hf2, isCoprime_zero_right, isUnit_iff] at hf
rcases hf with ⟨r, hr, hrf⟩
rw [eq_comm, expand_eq_C (pow_pos hp _)] at hrf
rwa [hrf, isUnit_C] | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | isUnit_or_eq_zero_of_separable_expand | null |
unique_separable_of_irreducible {f : F[X]} (hf : Irreducible f) (hp : 0 < p) (n₁ : ℕ)
(g₁ : F[X]) (hg₁ : g₁.Separable) (hgf₁ : expand F (p ^ n₁) g₁ = f) (n₂ : ℕ) (g₂ : F[X])
(hg₂ : g₂.Separable) (hgf₂ : expand F (p ^ n₂) g₂ = f) : n₁ = n₂ ∧ g₁ = g₂ := by
revert g₁ g₂
wlog hn : n₁ ≤ n₂
· intro g₁ hg₁ Hg₁ g₂ hg₂ Hg₂
simpa only [eq_comm] using this p hf hp n₂ n₁ (le_of_not_ge hn) g₂ hg₂ Hg₂ g₁ hg₁ Hg₁
intro g₁ hg₁ hgf₁ g₂ hg₂ hgf₂
rw [le_iff_exists_add] at hn
rcases hn with ⟨k, rfl⟩
rw [← hgf₁, pow_add, expand_mul, expand_inj (pow_pos hp n₁)] at hgf₂
subst hgf₂
subst hgf₁
rcases isUnit_or_eq_zero_of_separable_expand p k hp hg₁ with (h | rfl)
· rw [isUnit_iff] at h
rcases h with ⟨r, hr, rfl⟩
simp_rw [expand_C] at hf
exact absurd (isUnit_C.2 hr) hf.1
· rw [add_zero, pow_zero, expand_one]
constructor <;> rfl | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | unique_separable_of_irreducible | null |
separable_X_pow_sub_C {n : ℕ} (a : F) (hn : (n : F) ≠ 0) (ha : a ≠ 0) :
Separable (X ^ n - C a) :=
separable_X_pow_sub_C_unit (Units.mk0 a ha) (IsUnit.mk0 (n : F) hn) | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_X_pow_sub_C | If `n ≠ 0` in `F`, then `X ^ n - a` is separable for any `a ≠ 0`. |
separable_X_pow_sub_C' (p n : ℕ) (a : F) [CharP F p] (hn : ¬p ∣ n) (ha : a ≠ 0) :
Separable (X ^ n - C a) :=
separable_X_pow_sub_C a (by rwa [← CharP.cast_eq_zero_iff F p n] at hn) ha | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | separable_X_pow_sub_C' | If `F` is of characteristic `p` and `p ∤ n`, then `X ^ n - a` is separable for any `a ≠ 0`. |
X_pow_sub_one_separable_iff {n : ℕ} : (X ^ n - 1 : F[X]).Separable ↔ (n : F) ≠ 0 := by
refine ⟨?_, fun h => separable_X_pow_sub_C_unit 1 (IsUnit.mk0 _ h)⟩
rw [separable_def', derivative_sub, derivative_X_pow, derivative_one, sub_zero]
rintro (h : IsCoprime _ _) hn'
rw [hn', C_0, zero_mul, isCoprime_zero_right] at h
exact not_isUnit_X_pow_sub_one F n h | theorem | FieldTheory | [
"Mathlib.Algebra.Polynomial.Expand",
"Mathlib.Algebra.Polynomial.Splits",
"Mathlib.Algebra.Squarefree.Basic",
"Mathlib.FieldTheory.IntermediateField.Basic",
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.Polynomial.Content",
"Mathlib.RingTheory.PowerBasis",
"Mathlib.Data.ENat.Lattice"
] | Mathlib/FieldTheory/Separable.lean | X_pow_sub_one_separable_iff | In a field `F`, `X ^ n - 1` is separable iff `↑n ≠ 0`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.