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 ⌀ |
|---|---|---|---|---|---|---|
basisOfBasisLeft_repr_apply (H : A.LinearDisjoint B)
(H' : A.toSubalgebra ⊔ B.toSubalgebra = ⊤) {ι : Type*} (b : Basis ι F A) (x : A) (i : ι) :
algebraMap B E ((H.basisOfBasisLeft H' b).repr x i) = algebraMap F E (b.repr x i) :=
(linearDisjoint_iff'.mp H).basisOfBasisLeft_repr_apply H' b x i | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | basisOfBasisLeft_repr_apply | null |
of_basis_right {ι : Type*} (b : Basis ι F B)
(H : LinearIndependent A (B.val ∘ b)) : A.LinearDisjoint B :=
linearDisjoint_iff'.2 (.of_basis_right _ _ b H) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | of_basis_right | If there exists an `F`-basis of `B` which remains linearly independent over `A`, then
`A` and `B` are linearly disjoint. |
linearIndependent_right' (H : A.LinearDisjoint L) {ι : Type*} {b : ι → L}
(hb : LinearIndependent F b) : LinearIndependent A (algebraMap L E ∘ b) := by
apply Subalgebra.LinearDisjoint.linearIndependent_right_of_flat H <| hb.map' _
(AlgEquiv.ofInjectiveField (IsScalarTower.toAlgHom F L E)).toLinearEquiv.ker | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | linearIndependent_right' | If `A` and `L` are linearly disjoint, then any `F`-linearly independent family on `L` remains
linearly independent over `A`. |
of_basis_right' {ι : Type*} (b : Basis ι F L)
(H : LinearIndependent A (algebraMap L E ∘ b)) : A.LinearDisjoint L :=
Subalgebra.LinearDisjoint.of_basis_right _ _
(b.map (AlgEquiv.ofInjectiveField (IsScalarTower.toAlgHom F L E)).toLinearEquiv) H | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | of_basis_right' | If there exists an `F`-basis of `L` which remains linearly independent over `A`, then
`A` and `L` are linearly disjoint. |
linearIndependent_mul (H : A.LinearDisjoint B) {κ ι : Type*} {a : κ → A} {b : ι → B}
(ha : LinearIndependent F a) (hb : LinearIndependent F b) :
LinearIndependent F fun (i : κ × ι) ↦ (a i.1).1 * (b i.2).1 :=
(linearDisjoint_iff'.1 H).linearIndependent_mul_of_flat_left ha hb | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | linearIndependent_mul | If `A` and `B` are linearly disjoint, then for any `F`-linearly independent families
`{ u_i }`, `{ v_j }` of `A`, `B`, the products `{ u_i * v_j }`
are linearly independent over `F`. |
linearIndependent_mul' (H : A.LinearDisjoint L) {κ ι : Type*} {a : κ → A} {b : ι → L}
(ha : LinearIndependent F a) (hb : LinearIndependent F b) :
LinearIndependent F fun (i : κ × ι) ↦ (a i.1).1 * algebraMap L E (b i.2) := by
apply Subalgebra.LinearDisjoint.linearIndependent_mul_of_flat_left H ha <| hb.map' _
(AlgEquiv.ofInjectiveField (IsScalarTower.toAlgHom F L E)).toLinearEquiv.ker | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | linearIndependent_mul' | If `A` and `L` are linearly disjoint, then for any `F`-linearly independent families
`{ u_i }`, `{ v_j }` of `A`, `L`, the products `{ u_i * v_j }`
are linearly independent over `F`. |
of_basis_mul {κ ι : Type*} (a : Basis κ F A) (b : Basis ι F B)
(H : LinearIndependent F fun (i : κ × ι) ↦ (a i.1).1 * (b i.2).1) : A.LinearDisjoint B :=
linearDisjoint_iff'.2 (.of_basis_mul _ _ a b H) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | of_basis_mul | If there are `F`-bases `{ u_i }`, `{ v_j }` of `A`, `B`, such that the products
`{ u_i * v_j }` are linearly independent over `F`, then `A` and `B` are linearly disjoint. |
of_basis_mul' {κ ι : Type*} (a : Basis κ F A) (b : Basis ι F L)
(H : LinearIndependent F fun (i : κ × ι) ↦ (a i.1).1 * algebraMap L E (b i.2)) :
A.LinearDisjoint L :=
Subalgebra.LinearDisjoint.of_basis_mul _ _ a
(b.map (AlgEquiv.ofInjectiveField (IsScalarTower.toAlgHom F L E)).toLinearEquiv) H | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | of_basis_mul' | If there are `F`-bases `{ u_i }`, `{ v_j }` of `A`, `L`, such that the products
`{ u_i * v_j }` are linearly independent over `F`, then `A` and `L` are linearly disjoint. |
of_le_left {A' : IntermediateField F E} (H : A.LinearDisjoint L)
(h : A' ≤ A) : A'.LinearDisjoint L :=
Subalgebra.LinearDisjoint.of_le_left_of_flat H h | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | of_le_left | null |
of_le_right {B' : IntermediateField F E} (H : A.LinearDisjoint B)
(h : B' ≤ B) : A.LinearDisjoint B' :=
linearDisjoint_iff'.2 ((linearDisjoint_iff'.1 H).of_le_right_of_flat h) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | of_le_right | null |
of_le_right' (H : A.LinearDisjoint L) (L' : Type*) [Field L']
[Algebra F L'] [Algebra L' L] [IsScalarTower F L' L]
[Algebra L' E] [IsScalarTower F L' E] [IsScalarTower L' L E] : A.LinearDisjoint L' := by
refine Subalgebra.LinearDisjoint.of_le_right_of_flat H ?_
convert AlgHom.range_comp_le_range (IsScalarTower.toAlgHom F L' L) (IsScalarTower.toAlgHom F L E)
ext; exact IsScalarTower.algebraMap_apply L' L E _ | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | of_le_right' | Similar to `IntermediateField.LinearDisjoint.of_le_right` but this is for abstract fields. |
of_le {A' B' : IntermediateField F E} (H : A.LinearDisjoint B)
(hA : A' ≤ A) (hB : B' ≤ B) : A'.LinearDisjoint B' :=
H.of_le_left hA |>.of_le_right hB | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | of_le | If `A` and `B` are linearly disjoint, `A'` and `B'` are contained in `A` and `B`,
respectively, then `A'` and `B'` are also linearly disjoint. |
of_le' {A' : IntermediateField F E} (H : A.LinearDisjoint L)
(hA : A' ≤ A) (L' : Type*) [Field L']
[Algebra F L'] [Algebra L' L] [IsScalarTower F L' L]
[Algebra L' E] [IsScalarTower F L' E] [IsScalarTower L' L E] : A'.LinearDisjoint L' :=
H.of_le_left hA |>.of_le_right' L' | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | of_le' | Similar to `IntermediateField.LinearDisjoint.of_le` but this is for abstract fields. |
inf_eq_bot (H : A.LinearDisjoint B) :
A ⊓ B = ⊥ := toSubalgebra_injective (linearDisjoint_iff'.1 H).inf_eq_bot | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | inf_eq_bot | If `A` and `B` are linearly disjoint over `F`, then their intersection is equal to `F`. |
eq_bot_of_self (H : A.LinearDisjoint A) : A = ⊥ :=
inf_idem A ▸ H.inf_eq_bot | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | eq_bot_of_self | If `A` and `A` itself are linearly disjoint over `F`, then it is equal to `F`. |
rank_sup (H : A.LinearDisjoint B) :
Module.rank F ↥(A ⊔ B) = Module.rank F A * Module.rank F B :=
have h := le_sup_toSubalgebra A B
(rank_sup_le A B).antisymm <|
(linearDisjoint_iff'.1 H).rank_sup_of_free.ge.trans <|
(Subalgebra.inclusion h).toLinearMap.rank_le_of_injective (Subalgebra.inclusion_injective h) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | rank_sup | If `A` and `B` are linearly disjoint over `F`, then the
rank of `A ⊔ B` is equal to the product of that of `A` and `B`. |
finrank_sup (H : A.LinearDisjoint B) : finrank F ↥(A ⊔ B) = finrank F A * finrank F B := by
simpa only [map_mul] using congr(Cardinal.toNat $(H.rank_sup)) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | finrank_sup | If `A` and `B` are linearly disjoint over `F`, then the `Module.finrank` of
`A ⊔ B` is equal to the product of that of `A` and `B`. |
of_finrank_sup [FiniteDimensional F A] [FiniteDimensional F B]
(H : finrank F ↥(A ⊔ B) = finrank F A * finrank F B) : A.LinearDisjoint B :=
linearDisjoint_iff'.2 <| .of_finrank_sup_of_free (by rwa [← sup_toSubalgebra_of_left]) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | of_finrank_sup | If `A` and `B` are finite extensions of `F`,
such that rank of `A ⊔ B` is equal to the product of the rank of `A` and `B`,
then `A` and `B` are linearly disjoint. |
finrank_left_eq_finrank [Module.Finite F A] (h₁ : A.LinearDisjoint B) (h₂ : A ⊔ B = ⊤) :
finrank A E = finrank F B := by
have := h₁.finrank_sup
rwa [h₂, finrank_top', ← finrank_mul_finrank F A E, mul_right_inj' finrank_pos.ne'] at this | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | finrank_left_eq_finrank | If `A` and `B` are linearly disjoint over `F` and `A ⊔ B = E`, then the `Module.finrank` of
`E` over `A` is equal to the `Module.finrank` of `B` over `F`. |
finrank_right_eq_finrank [Module.Finite F B] (h₁ : A.LinearDisjoint B) (h₂ : A ⊔ B = ⊤) :
finrank B E = finrank F A :=
h₁.symm.finrank_left_eq_finrank (by rwa [sup_comm]) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | finrank_right_eq_finrank | If `A` and `B` are linearly disjoint over `F` and `A ⊔ B = E`, then the `Module.finrank` of
`E` over `B` is equal to the `Module.finrank` of `A` over `F`. |
adjoin_rank_eq_rank_left_of_isAlgebraic (H : A.LinearDisjoint L)
(halg : Algebra.IsAlgebraic F A ∨ Algebra.IsAlgebraic F L) :
Module.rank L (adjoin L (A : Set E)) = Module.rank F A := by
refine Eq.trans ?_ (Subalgebra.LinearDisjoint.adjoin_rank_eq_rank_left H)
set L' := (IsScalarTower.toAlgHom F L E).range
let i : L ≃ₐ[F] L' := AlgEquiv.ofInjectiveField (IsScalarTower.toAlgHom F L E)
have heq : (adjoin L (A : Set E)).toSubalgebra.toSubsemiring =
(Algebra.adjoin L' (A : Set E)).toSubsemiring := by
rw [adjoin_toSubalgebra_of_isAlgebraic _ _ halg.symm, Algebra.adjoin_toSubsemiring,
Algebra.adjoin_toSubsemiring]
congr 2
ext x
simp only [Set.mem_range, Subtype.exists]
exact ⟨fun ⟨y, h⟩ ↦ ⟨x, ⟨y, h⟩, rfl⟩, fun ⟨a, ⟨y, h1⟩, h2⟩ ↦ ⟨y, h1.trans h2⟩⟩
refine rank_eq_of_equiv_equiv i (RingEquiv.subsemiringCongr heq).toAddEquiv
i.bijective fun a ⟨x, hx⟩ ↦ ?_
ext
simp_rw [Algebra.smul_def]
rfl | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | adjoin_rank_eq_rank_left_of_isAlgebraic | If `A` and `L` are linearly disjoint over `F`, one of them is algebraic,
then `[L(A) : L] = [A : F]`. |
adjoin_rank_eq_rank_left_of_isAlgebraic_left (H : A.LinearDisjoint L)
[Algebra.IsAlgebraic F A] : Module.rank L (adjoin L (A : Set E)) = Module.rank F A :=
H.adjoin_rank_eq_rank_left_of_isAlgebraic (.inl ‹_›) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | adjoin_rank_eq_rank_left_of_isAlgebraic_left | null |
adjoin_rank_eq_rank_left_of_isAlgebraic_right (H : A.LinearDisjoint L)
[Algebra.IsAlgebraic F L] : Module.rank L (adjoin L (A : Set E)) = Module.rank F A :=
H.adjoin_rank_eq_rank_left_of_isAlgebraic (.inr ‹_›) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | adjoin_rank_eq_rank_left_of_isAlgebraic_right | null |
lift_adjoin_rank_eq_lift_rank_right_of_isAlgebraic (H : A.LinearDisjoint L)
(halg : Algebra.IsAlgebraic F A ∨ Algebra.IsAlgebraic F L) :
Cardinal.lift.{w} (Module.rank A (extendScalars
(show A ≤ (adjoin L (A : Set E)).restrictScalars F from subset_adjoin L (A : Set E)))) =
Cardinal.lift.{v} (Module.rank F L) := by
rw [(AlgEquiv.ofInjectiveField (IsScalarTower.toAlgHom F L E)).toLinearEquiv.lift_rank_eq,
Cardinal.lift_inj, ← Subalgebra.LinearDisjoint.adjoin_rank_eq_rank_right H]
set L' := (IsScalarTower.toAlgHom F L E).range
have heq : (adjoin L (A : Set E)).toSubalgebra.toSubsemiring =
(Algebra.adjoin A (L' : Set E)).toSubsemiring := by
rw [adjoin_toSubalgebra_of_isAlgebraic _ _ halg.symm, Algebra.adjoin_toSubsemiring,
Algebra.adjoin_toSubsemiring, Set.union_comm]
congr 2
ext x
simp
refine rank_eq_of_equiv_equiv (RingHom.id A) (RingEquiv.subsemiringCongr heq).toAddEquiv
Function.bijective_id fun ⟨a, ha⟩ ⟨x, hx⟩ ↦ ?_
ext
simp_rw [Algebra.smul_def]
rfl | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | lift_adjoin_rank_eq_lift_rank_right_of_isAlgebraic | If `A` and `L` are linearly disjoint over `F`, one of them is algebraic,
then `[L(A) : A] = [L : F]`. Note that in Lean `L(A)` is not naturally an `A`-algebra,
so this result is stated in a cumbersome way. |
lift_adjoin_rank_eq_lift_rank_right_of_isAlgebraic_left (H : A.LinearDisjoint L)
[Algebra.IsAlgebraic F A] :
Cardinal.lift.{w} (Module.rank A (extendScalars
(show A ≤ (adjoin L (A : Set E)).restrictScalars F from subset_adjoin L (A : Set E)))) =
Cardinal.lift.{v} (Module.rank F L) :=
H.lift_adjoin_rank_eq_lift_rank_right_of_isAlgebraic (.inl ‹_›) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | lift_adjoin_rank_eq_lift_rank_right_of_isAlgebraic_left | null |
lift_adjoin_rank_eq_lift_rank_right_of_isAlgebraic_right (H : A.LinearDisjoint L)
[Algebra.IsAlgebraic F L] :
Cardinal.lift.{w} (Module.rank A (extendScalars
(show A ≤ (adjoin L (A : Set E)).restrictScalars F from subset_adjoin L (A : Set E)))) =
Cardinal.lift.{v} (Module.rank F L) :=
H.lift_adjoin_rank_eq_lift_rank_right_of_isAlgebraic (.inr ‹_›) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | lift_adjoin_rank_eq_lift_rank_right_of_isAlgebraic_right | null |
lift_rank_right_mul_lift_adjoin_rank_eq_of_isAlgebraic (H : A.LinearDisjoint L)
(halg : Algebra.IsAlgebraic F A ∨ Algebra.IsAlgebraic F L) :
Cardinal.lift.{v} (Module.rank F L) * Cardinal.lift.{w} (Module.rank (adjoin L (A : Set E)) E) =
Cardinal.lift.{w} (Module.rank A E) := by
rw [← H.lift_adjoin_rank_eq_lift_rank_right_of_isAlgebraic halg, ← Cardinal.lift_mul,
Cardinal.lift_inj]
exact rank_mul_rank A (extendScalars
(show A ≤ (adjoin L (A : Set E)).restrictScalars F from subset_adjoin L (A : Set E))) E | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | lift_rank_right_mul_lift_adjoin_rank_eq_of_isAlgebraic | If `A` is an intermediate field of `E / F`, `L` is an abstract field between `E / F`,
such that they are linearly disjoint over `F`, and one of them is algebraic, then
`[L : F] * [E : L(A)] = [E : A]`. |
lift_rank_right_mul_lift_adjoin_rank_eq_of_isAlgebraic_left (H : A.LinearDisjoint L)
[Algebra.IsAlgebraic F A] :
Cardinal.lift.{v} (Module.rank F L) * Cardinal.lift.{w} (Module.rank (adjoin L (A : Set E)) E) =
Cardinal.lift.{w} (Module.rank A E) :=
H.lift_rank_right_mul_lift_adjoin_rank_eq_of_isAlgebraic (.inl ‹_›) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | lift_rank_right_mul_lift_adjoin_rank_eq_of_isAlgebraic_left | null |
lift_rank_right_mul_lift_adjoin_rank_eq_of_isAlgebraic_right (H : A.LinearDisjoint L)
[Algebra.IsAlgebraic F L] :
Cardinal.lift.{v} (Module.rank F L) * Cardinal.lift.{w} (Module.rank (adjoin L (A : Set E)) E) =
Cardinal.lift.{w} (Module.rank A E) :=
H.lift_rank_right_mul_lift_adjoin_rank_eq_of_isAlgebraic (.inr ‹_›) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | lift_rank_right_mul_lift_adjoin_rank_eq_of_isAlgebraic_right | null |
adjoin_rank_eq_rank_right_of_isAlgebraic (H : A.LinearDisjoint L)
(halg : Algebra.IsAlgebraic F A ∨ Algebra.IsAlgebraic F L) :
Module.rank A (extendScalars (show A ≤ (adjoin L (A : Set E)).restrictScalars F from
subset_adjoin L (A : Set E))) = Module.rank F L := by
simpa only [Cardinal.lift_id] using H.lift_adjoin_rank_eq_lift_rank_right_of_isAlgebraic halg | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | adjoin_rank_eq_rank_right_of_isAlgebraic | The same-universe version of
`IntermediateField.LinearDisjoint.lift_adjoin_rank_eq_lift_rank_right_of_isAlgebraic`. |
adjoin_rank_eq_rank_right_of_isAlgebraic_left (H : A.LinearDisjoint L)
[Algebra.IsAlgebraic F A] :
Module.rank A (extendScalars (show A ≤ (adjoin L (A : Set E)).restrictScalars F from
subset_adjoin L (A : Set E))) = Module.rank F L :=
H.adjoin_rank_eq_rank_right_of_isAlgebraic (.inl ‹_›) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | adjoin_rank_eq_rank_right_of_isAlgebraic_left | null |
adjoin_rank_eq_rank_right_of_isAlgebraic_right (H : A.LinearDisjoint L)
[Algebra.IsAlgebraic F L] :
Module.rank A (extendScalars (show A ≤ (adjoin L (A : Set E)).restrictScalars F from
subset_adjoin L (A : Set E))) = Module.rank F L :=
H.adjoin_rank_eq_rank_right_of_isAlgebraic (.inr ‹_›) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | adjoin_rank_eq_rank_right_of_isAlgebraic_right | null |
rank_right_mul_adjoin_rank_eq_of_isAlgebraic (H : A.LinearDisjoint L)
(halg : Algebra.IsAlgebraic F A ∨ Algebra.IsAlgebraic F L) :
Module.rank F L * Module.rank (adjoin L (A : Set E)) E = Module.rank A E := by
simpa only [Cardinal.lift_id] using H.lift_rank_right_mul_lift_adjoin_rank_eq_of_isAlgebraic halg | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | rank_right_mul_adjoin_rank_eq_of_isAlgebraic | The same-universe version of
`IntermediateField.LinearDisjoint.lift_rank_right_mul_lift_adjoin_rank_eq_of_isAlgebraic`. |
rank_right_mul_adjoin_rank_eq_of_isAlgebraic_left (H : A.LinearDisjoint L)
[Algebra.IsAlgebraic F A] :
Module.rank F L * Module.rank (adjoin L (A : Set E)) E = Module.rank A E :=
H.rank_right_mul_adjoin_rank_eq_of_isAlgebraic (.inl ‹_›) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | rank_right_mul_adjoin_rank_eq_of_isAlgebraic_left | null |
rank_right_mul_adjoin_rank_eq_of_isAlgebraic_right (H : A.LinearDisjoint L)
[Algebra.IsAlgebraic F L] :
Module.rank F L * Module.rank (adjoin L (A : Set E)) E = Module.rank A E :=
H.rank_right_mul_adjoin_rank_eq_of_isAlgebraic (.inr ‹_›) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | rank_right_mul_adjoin_rank_eq_of_isAlgebraic_right | null |
of_finrank_coprime (H : (finrank F A).Coprime (finrank F L)) : A.LinearDisjoint L :=
letI : Field (AlgHom.range (IsScalarTower.toAlgHom F L E)) :=
inferInstanceAs <| Field (AlgHom.fieldRange (IsScalarTower.toAlgHom F L E))
letI : Field A.toSubalgebra := inferInstanceAs <| Field A
Subalgebra.LinearDisjoint.of_finrank_coprime_of_free <| by
rwa [(AlgEquiv.ofInjectiveField (IsScalarTower.toAlgHom F L E)).toLinearEquiv.finrank_eq] at H | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | of_finrank_coprime | If `A` and `L` have coprime degree over `F`, then they are linearly disjoint. |
isDomain (H : A.LinearDisjoint L) : IsDomain (A ⊗[F] L) :=
have : IsDomain (A ⊗[F] _) := Subalgebra.LinearDisjoint.isDomain H
(Algebra.TensorProduct.congr (AlgEquiv.refl : A ≃ₐ[F] A)
(AlgEquiv.ofInjective (IsScalarTower.toAlgHom F L E) (RingHom.injective _))).toMulEquiv.isDomain | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | isDomain | If `A` and `L` are linearly disjoint over `F`, then `A ⊗[F] L` is a domain. |
isDomain' {A B : Type*} [Field A] [Algebra F A] [Field B] [Algebra F B]
{fa : A →ₐ[F] E} {fb : B →ₐ[F] E} (H : fa.fieldRange.LinearDisjoint fb.fieldRange) :
IsDomain (A ⊗[F] B) := by
simp_rw [linearDisjoint_iff', AlgHom.fieldRange_toSubalgebra] at H
exact H.isDomain_of_injective fa.injective fb.injective | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | isDomain' | If `A` and `B` are field extensions of `F`, there exists a field extension `E` of `F` that
`A` and `B` embed into with linearly disjoint images, then `A ⊗[F] B` is a domain. |
of_isField (H : IsField (A ⊗[F] L)) : A.LinearDisjoint L := by
apply Subalgebra.LinearDisjoint.of_isField
haveI : SMulCommClass F A A := SMulCommClass.of_commMonoid F A A
haveI : SMulCommClass F A.toSubalgebra A.toSubalgebra := ‹SMulCommClass F A A›
letI : Mul (A ⊗[F] L) := Algebra.TensorProduct.instMul
letI : Mul (A.toSubalgebra ⊗[F] (IsScalarTower.toAlgHom F L E).range) :=
Algebra.TensorProduct.instMul
exact Algebra.TensorProduct.congr (AlgEquiv.refl : A ≃ₐ[F] A)
(AlgEquiv.ofInjective (IsScalarTower.toAlgHom F L E) (RingHom.injective _))
|>.symm.toMulEquiv.isField H | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | of_isField | If `A ⊗[F] L` is a field, then `A` and `L` are linearly disjoint over `F`. |
of_isField' {A : Type v} [Field A] {B : Type w} [Field B]
[Algebra F A] [Algebra F B] (H : IsField (A ⊗[F] B))
{K : Type*} [Field K] [Algebra F K] (fa : A →ₐ[F] K) (fb : B →ₐ[F] K) :
fa.fieldRange.LinearDisjoint fb.fieldRange := by
rw [linearDisjoint_iff']
apply Subalgebra.LinearDisjoint.of_isField
exact Algebra.TensorProduct.congr (AlgEquiv.ofInjective fa fa.injective)
(AlgEquiv.ofInjective fb fb.injective) |>.symm.toMulEquiv.isField H
variable (F) in | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | of_isField' | If `A` and `B` are field extensions of `F`, such that `A ⊗[F] B` is a field, then for any
field extension of `F` that `A` and `B` embed into, their images are linearly disjoint. |
exists_field_of_isDomain (A : Type v) [Field A] (B : Type w) [Field B]
[Algebra F A] [Algebra F B] [IsDomain (A ⊗[F] B)] :
∃ (K : Type (max v w)) (_ : Field K) (_ : Algebra F K) (fa : A →ₐ[F] K) (fb : B →ₐ[F] K),
fa.fieldRange.LinearDisjoint fb.fieldRange :=
have ⟨K, inst1, inst2, fa, fb, _, _, H⟩ :=
Subalgebra.LinearDisjoint.exists_field_of_isDomain_of_injective F A B
(RingHom.injective _) (RingHom.injective _)
⟨K, inst1, inst2, fa, fb, linearDisjoint_iff'.2 H⟩
variable (F) in | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | exists_field_of_isDomain | If `A` and `B` are field extensions of `F`, such that `A ⊗[F] B` is a domain, then there exists
a field extension of `F` that `A` and `B` embed into with linearly disjoint images. |
isField_of_forall (A : Type v) [Field A] (B : Type w) [Field B]
[Algebra F A] [Algebra F B]
(H : ∀ (K : Type (max v w)) [Field K] [Algebra F K],
∀ (fa : A →ₐ[F] K) (fb : B →ₐ[F] K), fa.fieldRange.LinearDisjoint fb.fieldRange) :
IsField (A ⊗[F] B) := by
obtain ⟨M, hM⟩ := Ideal.exists_maximal (A ⊗[F] B)
apply not_imp_not.1 (Ring.ne_bot_of_isMaximal_of_not_isField hM)
let K : Type (max v w) := A ⊗[F] B ⧸ M
letI : Field K := Ideal.Quotient.field _
let i := IsScalarTower.toAlgHom F (A ⊗[F] B) K
let fa := i.comp (Algebra.TensorProduct.includeLeft : A →ₐ[F] _)
let fb := i.comp (Algebra.TensorProduct.includeRight : B →ₐ[F] _)
replace H := H K fa fb
simp_rw [linearDisjoint_iff', AlgHom.fieldRange_toSubalgebra,
Subalgebra.linearDisjoint_iff_injective] at H
have hi : i = (fa.range.mulMap fb.range).comp (Algebra.TensorProduct.congr
(AlgEquiv.ofInjective fa fa.injective) (AlgEquiv.ofInjective fb fb.injective)) := by
ext <;> simp [fa, fb]
replace H : Function.Injective i := by simpa only
[hi, AlgHom.coe_comp, AlgHom.coe_coe, EquivLike.injective_comp, fa, this, K, fb]
change Function.Injective (Ideal.Quotient.mk M) at H
rwa [RingHom.injective_iff_ker_eq_bot, Ideal.mk_ker] at H
variable (F E) in | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | isField_of_forall | If for any field extension `K` of `F` that `A` and `B` embed into, their images are
linearly disjoint, then `A ⊗[F] B` is a field. (In the proof we choose `K` to be the quotient
of `A ⊗[F] B` by a maximal ideal.) |
_root_.Algebra.TensorProduct.isField_of_isAlgebraic
(K : Type*) [Field K] [Algebra F K] [IsDomain (E ⊗[F] K)]
(halg : Algebra.IsAlgebraic F E ∨ Algebra.IsAlgebraic F K) : IsField (E ⊗[F] K) :=
have ⟨L, _, _, fa, fb, hfa, hfb, H⟩ :=
Subalgebra.LinearDisjoint.exists_field_of_isDomain_of_injective F E K
(RingHom.injective _) (RingHom.injective _)
let f : E ⊗[F] K ≃ₐ[F] ↥(fa.fieldRange ⊔ fb.fieldRange) :=
Algebra.TensorProduct.congr (AlgEquiv.ofInjective fa hfa) (AlgEquiv.ofInjective fb hfb)
|>.trans (Subalgebra.LinearDisjoint.mulMap H)
|>.trans (Subalgebra.equivOfEq _ _
(sup_toSubalgebra_of_isAlgebraic fa.fieldRange fb.fieldRange <| by
rwa [(AlgEquiv.ofInjective fa hfa).isAlgebraic_iff,
(AlgEquiv.ofInjective fb hfb).isAlgebraic_iff] at halg).symm)
f.toMulEquiv.isField (Field.toIsField _) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | _root_.Algebra.TensorProduct.isField_of_isAlgebraic | If `E` and `K` are field extensions of `F`, one of them is algebraic, such that
`E ⊗[F] K` is a domain, then `E ⊗[F] K` is also a field. It is a corollary of
`Subalgebra.LinearDisjoint.exists_field_of_isDomain_of_injective` and
`IntermediateField.sup_toSubalgebra_of_isAlgebraic`.
See `Algebra.TensorProduct.isAlgebraic_of_isField` for its converse (in an earlier file). |
isField_of_isAlgebraic (H : A.LinearDisjoint L)
(halg : Algebra.IsAlgebraic F A ∨ Algebra.IsAlgebraic F L) : IsField (A ⊗[F] L) :=
have := H.isDomain
Algebra.TensorProduct.isField_of_isAlgebraic F A L halg | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | isField_of_isAlgebraic | If `A` and `L` are linearly disjoint over `F` and one of them is algebraic,
then `A ⊗[F] L` is a field. |
isField_of_isAlgebraic' {A B : Type*} [Field A] [Algebra F A] [Field B] [Algebra F B]
{fa : A →ₐ[F] E} {fb : B →ₐ[F] E} (H : fa.fieldRange.LinearDisjoint fb.fieldRange)
(halg : Algebra.IsAlgebraic F A ∨ Algebra.IsAlgebraic F B) : IsField (A ⊗[F] B) :=
have := H.isDomain'
Algebra.TensorProduct.isField_of_isAlgebraic F A B halg | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | isField_of_isAlgebraic' | If `A` and `B` are field extensions of `F`, one of them is algebraic, such that there exists a
field `E` that `A` and `B` embeds into with linearly disjoint images, then `A ⊗[F] B`
is a field. |
algEquiv_of_isAlgebraic (H : A.LinearDisjoint L)
{E' : Type*} [Field E'] [Algebra F E']
(B : IntermediateField F E')
(L' : Type*) [Field L'] [Algebra F L'] [Algebra L' E'] [IsScalarTower F L' E']
(f1 : A ≃ₐ[F] B) (f2 : L ≃ₐ[F] L')
(halg : Algebra.IsAlgebraic F A ∨ Algebra.IsAlgebraic F L) :
B.LinearDisjoint L' :=
.of_isField ((Algebra.TensorProduct.congr f1 f2).symm.toMulEquiv.isField
(H.isField_of_isAlgebraic halg)) | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | algEquiv_of_isAlgebraic | If `A` and `L` are linearly disjoint, one of them is algebraic, then for any `B` and `L'`
isomorphic to `A` and `L` respectively, `B` and `L'` are also linearly disjoint. |
trace_algebraMap [FiniteDimensional F E] (h₁ : A.LinearDisjoint B) (h₂ : A ⊔ B = ⊤)
(x : B) :
Algebra.trace A E (algebraMap B E x) = algebraMap F A (Algebra.trace F B x) := by
rw [linearDisjoint_iff'] at h₁
refine h₁.trace_algebraMap ?_ x
simpa [sup_toSubalgebra_of_isAlgebraic_right] using congr_arg toSubalgebra h₂ | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | trace_algebraMap | If `A` and `B` are linearly disjoint, then `trace` and `algebraMap` commutes. |
norm_algebraMap [FiniteDimensional F E] (h₁ : A.LinearDisjoint B) (h₂ : A ⊔ B = ⊤)
(x : B) :
Algebra.norm A (algebraMap B E x) = algebraMap F A (Algebra.norm F x) := by
rw [linearDisjoint_iff'] at h₁
refine h₁.norm_algebraMap ?_ x
simpa [sup_toSubalgebra_of_isAlgebraic_right] using congr_arg toSubalgebra h₂ | theorem | FieldTheory | [
"Mathlib.RingTheory.AlgebraicIndependent.RankAndCardinality",
"Mathlib.RingTheory.LinearDisjoint"
] | Mathlib/FieldTheory/LinearDisjoint.lean | norm_algebraMap | If `A` and `B` are linearly disjoint, then `norm` and `algebraMap` commutes. |
private noncomputable normalizedTraceAux (a : K) : F :=
(Module.finrank F F⟮a⟯ : F)⁻¹ • trace F F⟮a⟯ (AdjoinSimple.gen F a) | def | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTraceAux | null |
private normalizedTraceAux_def (a : K) : normalizedTraceAux F K a =
(Module.finrank F F⟮a⟯ : F)⁻¹ • trace F F⟮a⟯ (AdjoinSimple.gen F a) := rfl | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTraceAux_def | null |
private normalizedTraceAux_map {E : Type*} [Field E] [Algebra F E] (f : E →ₐ[F] K) (a : E) :
normalizedTraceAux F K (f a) = normalizedTraceAux F E a := by
let e := (F⟮a⟯.equivMap f).trans (equivOfEq <| Set.image_singleton ▸ adjoin_map F {a} f)
simp_rw [normalizedTraceAux, ← LinearEquiv.finrank_eq e.toLinearEquiv]
congr
exact trace_eq_of_algEquiv e <| AdjoinSimple.gen F a | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTraceAux_map | null |
private normalizedTraceAux_intermediateField {E : IntermediateField F K} (a : E) :
normalizedTraceAux F K a = normalizedTraceAux F E a :=
normalizedTraceAux_map F K E.val a
variable [CharZero F]
variable {K} in | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTraceAux_intermediateField | null |
private normalizedTraceAux_eq_of_fininteDimensional [FiniteDimensional F K] (a : K) :
normalizedTraceAux F K a = (Module.finrank F K : F)⁻¹ • trace F K a := by
have h := (Nat.cast_ne_zero (R := F)).mpr <|
Nat.pos_iff_ne_zero.mp <| Module.finrank_pos (R := F⟮a⟯) (M := K)
rw [smul_eq_mul, mul_comm, ← div_eq_mul_inv, trace_eq_trace_adjoin F a,
← Module.finrank_mul_finrank F F⟮a⟯ K, nsmul_eq_mul, Nat.cast_mul, mul_comm,
mul_div_mul_right _ _ h, div_eq_mul_inv, mul_comm, ← smul_eq_mul, normalizedTraceAux_def]
variable [Algebra.IsIntegral F K] | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTraceAux_eq_of_fininteDimensional | null |
noncomputable normalizedTrace : K →ₗ[F] F where
toFun := normalizedTraceAux F K
map_add' a b := by
let E := F⟮a⟯ ⊔ F⟮b⟯
have : FiniteDimensional F F⟮a⟯ := adjoin.finiteDimensional (IsIntegral.isIntegral a)
have : FiniteDimensional F F⟮b⟯ := adjoin.finiteDimensional (IsIntegral.isIntegral b)
have ha : a ∈ E := (le_sup_left : F⟮a⟯ ≤ E) <| mem_adjoin_simple_self F a
have hb : b ∈ E := (le_sup_right : F⟮b⟯ ≤ E) <| mem_adjoin_simple_self F b
have hab : a + b ∈ E := IntermediateField.add_mem E ha hb
let a' : E := ⟨a, ha⟩
let b' : E := ⟨b, hb⟩
let ab' : E := ⟨a + b, hab⟩
rw [normalizedTraceAux_intermediateField F K a',
normalizedTraceAux_intermediateField F K b',
normalizedTraceAux_intermediateField F K ab',
normalizedTraceAux_eq_of_fininteDimensional F a',
normalizedTraceAux_eq_of_fininteDimensional F b',
normalizedTraceAux_eq_of_fininteDimensional F ab',
← smul_add, ← map_add, AddMemClass.mk_add_mk]
map_smul' m a := by
dsimp only [AddHom.toFun_eq_coe, AddHom.coe_mk, RingHom.id_apply]
let E := F⟮a⟯
have : FiniteDimensional F F⟮a⟯ := adjoin.finiteDimensional (IsIntegral.isIntegral a)
have ha : a ∈ E := mem_adjoin_simple_self F a
have hma : m • a ∈ E := smul_mem E ha
let a' : E := ⟨a, ha⟩
let ma' : E := ⟨m • a, hma⟩
rw [normalizedTraceAux_intermediateField F K a',
normalizedTraceAux_intermediateField F K ma',
normalizedTraceAux_eq_of_fininteDimensional F a',
normalizedTraceAux_eq_of_fininteDimensional F ma',
smul_comm, ← map_smul _ m, SetLike.mk_smul_mk] | def | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace | The normalized trace map from an algebraic extension `K` to the base field `F`. |
normalizedTrace_def (a : K) : normalizedTrace F K a =
(Module.finrank F F⟮a⟯ : F)⁻¹ • trace F F⟮a⟯ (AdjoinSimple.gen F a) :=
rfl
variable {K} in | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_def | null |
normalizedTrace_minpoly (a : K) :
normalizedTrace F K a = ((minpoly F a).natDegree : F)⁻¹ • -(minpoly F a).nextCoeff :=
have ha : IsIntegral F a := IsIntegral.isIntegral a
IntermediateField.adjoin.finrank ha ▸ trace_adjoinSimpleGen ha ▸ normalizedTrace_def F K a
variable {F} in | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_minpoly | Normalized trace defined purely in terms of the degree and the next coefficient of the minimal
polynomial. Could be an alternative definition but it is harder to work with linearity. |
normalizedTrace_self_apply (a : F) : normalizedTrace F F a = a := by
dsimp [normalizedTrace]
rw [normalizedTraceAux_eq_of_fininteDimensional F a, Module.finrank_self F,
Nat.cast_one, inv_one, one_smul, trace_self_apply]
@[simp] | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_self_apply | null |
normalizedTrace_self : normalizedTrace F F = LinearMap.id :=
LinearMap.ext normalizedTrace_self_apply
variable {K} in | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_self | null |
normalizedTrace_eq_of_fininteDimensional_apply [FiniteDimensional F K] (a : K) :
normalizedTrace F K a = (Module.finrank F K : F)⁻¹ • trace F K a :=
normalizedTraceAux_eq_of_fininteDimensional F a | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_eq_of_fininteDimensional_apply | null |
normalizedTrace_eq_of_fininteDimensional [FiniteDimensional F K] :
normalizedTrace F K = (Module.finrank F K : F)⁻¹ • trace F K :=
LinearMap.ext <| normalizedTrace_eq_of_fininteDimensional_apply F | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_eq_of_fininteDimensional | null |
@[simp]
normalizedTrace_map {E : Type*} [Field E] [Algebra F E] [Algebra.IsIntegral F E]
(f : E →ₐ[F] K) (a : E) : normalizedTrace F K (f a) = normalizedTrace F E a :=
normalizedTraceAux_map F K f a | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_map | The normalized trace transfers via (injective) maps. |
normalizedTrace_intermediateField {E : IntermediateField F K} (a : E) :
normalizedTrace F K a = normalizedTrace F E a :=
normalizedTraceAux_intermediateField F K a | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_intermediateField | The normalized trace transfers via restriction to a subextension. |
@[simp]
normalizedTrace_algebraMap_apply (a : E) :
normalizedTrace F K (algebraMap E K a) = normalizedTrace F E a :=
normalizedTrace_map F K (IsScalarTower.toAlgHom F E K) a
@[simp] | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_algebraMap_apply | null |
normalizedTrace_algebraMap :
normalizedTrace F K ∘ₗ Algebra.linearMap E K = normalizedTrace F E :=
LinearMap.ext <| normalizedTrace_algebraMap_apply F E K
omit [Algebra.IsIntegral F E] in | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_algebraMap | null |
normalizedTrace_algebraMap_of_lifts [CharZero E] [Algebra.IsIntegral E K] (a : K)
(h : minpoly E a ∈ Polynomial.lifts (algebraMap F E)) :
algebraMap F E (normalizedTrace F K a) = normalizedTrace E K a := by
have ha : IsIntegral F a := IsIntegral.isIntegral a
simp [normalizedTrace_minpoly F a, normalizedTrace_minpoly E a,
← minpoly.map_algebraMap ha h,
(minpoly F a).natDegree_map,
(minpoly F a).nextCoeff_map (algebraMap F E).injective,
map_mul, map_neg]
/- An auxiliary result to prove `normalizedTrace_trans_apply`. It differs from
`normalizedTrace_trans_apply` only by the extra assumption about finiteness of `E` over `F`. -/ | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_algebraMap_of_lifts | If all the coefficients of `minpoly E a` are in `F`, then the normalized trace of `a` from `K`
to `E` equals the normalized trace of `a` from `K` to `F`. |
private normalizedTrace_trans_apply_aux [FiniteDimensional F E] [Algebra.IsIntegral E K]
[CharZero E] (a : K) :
normalizedTrace F E (normalizedTrace E K a) = normalizedTrace F K a := by
have : FiniteDimensional E E⟮a⟯ :=
IntermediateField.adjoin.finiteDimensional (IsIntegral.isIntegral a)
rw [normalizedTrace_def E K, inv_natCast_smul_eq (R := E) (S := F), map_smul,
normalizedTrace_eq_of_fininteDimensional F E, LinearMap.smul_apply, ← smul_assoc,
smul_eq_mul (a := _⁻¹), ← mul_inv, trace_trace, mul_comm,
← Nat.cast_mul, Module.finrank_mul_finrank, eq_comm]
let E' := E⟮a⟯.restrictScalars F
have : FiniteDimensional F E' := Module.Finite.trans E E⟮a⟯
have h_finrank_eq : Module.finrank F E⟮a⟯ = Module.finrank F E' := rfl
have h_trace_eq : trace F E⟮a⟯ (AdjoinSimple.gen E a) = trace F E' (AdjoinSimple.gen E a : E') :=
rfl
let a' : E' := AdjoinSimple.gen E a
rw [h_finrank_eq, h_trace_eq, ← normalizedTrace_eq_of_fininteDimensional_apply F,
← normalizedTrace_intermediateField F K a']
congr | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_trans_apply_aux | null |
normalizedTrace_trans_apply [Algebra.IsIntegral E K] [CharZero E] (a : K) :
normalizedTrace F E (normalizedTrace E K a) = normalizedTrace F K a :=
let S : Set E := (minpoly E a).coeffs
let E₀ := IntermediateField.adjoin F S
have : FiniteDimensional F E₀ := IntermediateField.finiteDimensional_adjoin
fun x _ ↦ Algebra.IsIntegral.isIntegral x
have : Algebra.IsIntegral E₀ E := IsIntegral.tower_top F
have : Algebra.IsIntegral E₀ K := IsIntegral.trans E
have hsub : S ⊆ (algebraMap E₀ E).range :=
Subalgebra.range_algebraMap E₀.toSubalgebra ▸ IntermediateField.subset_adjoin F S
have hlifts := (Polynomial.lifts_iff_coeffs_subset_range _).mpr hsub
(normalizedTrace_trans_apply_aux F E₀ K _ ▸
normalizedTrace_algebraMap_apply F E₀ E _ ▸
congrArg (normalizedTrace F E) (normalizedTrace_algebraMap_of_lifts E₀ E K a hlifts)).symm
@[simp] | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_trans_apply | For a tower `K / E / F` of algebraic extensions, the normalized trace from `K` to `E` composed
with the normalized trace from `E` to `F` equals the normalized trace from `K` to `F`. |
normalizedTrace_trans [Algebra.IsIntegral E K] [CharZero E] :
normalizedTrace F E ∘ₗ normalizedTrace E K = normalizedTrace F K :=
LinearMap.ext <| normalizedTrace_trans_apply F E K | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_trans | null |
normalizedTrace_algebraMap_apply_eq_self (a : F) :
normalizedTrace F K (algebraMap F K a) = a := by simp | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_algebraMap_apply_eq_self | null |
normalizedTrace_algebraMap_eq_id :
normalizedTrace F K ∘ₗ Algebra.linearMap F K = LinearMap.id :=
LinearMap.ext <| normalizedTrace_algebraMap_apply_eq_self F K | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_algebraMap_eq_id | The normalized trace map is a left inverse of the algebra map. |
@[simp]
normalizedTrace_comp_algHom {E : Type*} [Field E] [Algebra F E] [Algebra.IsIntegral F E]
(f : E →ₐ[F] K) : normalizedTrace F K ∘ₗ f = normalizedTrace F E :=
LinearMap.ext <| normalizedTrace_map F K f | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_comp_algHom | The normalized trace commutes with (injective) maps. |
normalizedTrace_surjective : Function.Surjective (normalizedTrace F K) :=
fun a ↦ ⟨algebraMap F K a, normalizedTrace_algebraMap_apply_eq_self F K a⟩ | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_surjective | null |
normalizedTrace_ne_zero : normalizedTrace F K ≠ 0 :=
let ⟨a, ha⟩ := normalizedTrace_surjective F K 1
DFunLike.ne_iff.mpr <| ⟨a, ha ▸ one_ne_zero⟩ | theorem | FieldTheory | [
"Mathlib.RingTheory.Trace.Basic"
] | Mathlib/FieldTheory/NormalizedTrace.lean | normalizedTrace_ne_zero | The normalized trace map is non-trivial. |
PerfectRing (R : Type*) (p : ℕ) [CommSemiring R] [ExpChar R p] : Prop where
/-- A ring is perfect if the Frobenius map is bijective. -/
bijective_frobenius : Bijective <| frobenius R p | class | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | PerfectRing | A perfect ring of characteristic `p` (prime) in the sense of Serre.
NB: This is not related to the concept with the same name introduced by Bass (related to projective
covers of modules). |
PerfectRing.ofSurjective (R : Type*) (p : ℕ) [CommRing R] [ExpChar R p]
[IsReduced R] (h : Surjective <| frobenius R p) : PerfectRing R p :=
⟨frobenius_inj R p, h⟩ | lemma | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | PerfectRing.ofSurjective | For a reduced ring, surjectivity of the Frobenius map is a sufficient condition for perfection. |
PerfectRing.ofFiniteOfIsReduced (R : Type*) [CommRing R] [ExpChar R p]
[Finite R] [IsReduced R] : PerfectRing R p :=
ofSurjective _ _ <| Finite.surjective_of_injective (frobenius_inj R p)
variable [PerfectRing R p]
@[simp] | instance | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | PerfectRing.ofFiniteOfIsReduced | null |
bijective_frobenius : Bijective (frobenius R p) := PerfectRing.bijective_frobenius | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | bijective_frobenius | null |
bijective_iterateFrobenius : Bijective (iterateFrobenius R p n) :=
coe_iterateFrobenius R p n ▸ (bijective_frobenius R p).iterate n
@[simp] | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | bijective_iterateFrobenius | null |
injective_frobenius : Injective (frobenius R p) := (bijective_frobenius R p).1
@[simp] | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | injective_frobenius | null |
surjective_frobenius : Surjective (frobenius R p) := (bijective_frobenius R p).2 | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | surjective_frobenius | null |
@[simps! apply]
noncomputable frobeniusEquiv : R ≃+* R :=
RingEquiv.ofBijective (frobenius R p) PerfectRing.bijective_frobenius
@[simp] | def | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | frobeniusEquiv | The Frobenius automorphism for a perfect ring. |
coe_frobeniusEquiv : ⇑(frobeniusEquiv R p) = frobenius R p := rfl | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | coe_frobeniusEquiv | null |
frobeniusEquiv_def (x : R) : frobeniusEquiv R p x = x ^ p := rfl | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | frobeniusEquiv_def | null |
@[simps! apply]
noncomputable iterateFrobeniusEquiv : R ≃+* R :=
RingEquiv.ofBijective (iterateFrobenius R p n) (bijective_iterateFrobenius R p n)
@[simp] | def | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | iterateFrobeniusEquiv | The iterated Frobenius automorphism for a perfect ring. |
coe_iterateFrobeniusEquiv : ⇑(iterateFrobeniusEquiv R p n) = iterateFrobenius R p n := rfl | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | coe_iterateFrobeniusEquiv | null |
iterateFrobeniusEquiv_def (x : R) : iterateFrobeniusEquiv R p n x = x ^ p ^ n := rfl | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | iterateFrobeniusEquiv_def | null |
iterateFrobeniusEquiv_add_apply (x : R) : iterateFrobeniusEquiv R p (m + n) x =
iterateFrobeniusEquiv R p m (iterateFrobeniusEquiv R p n x) :=
iterateFrobenius_add_apply R p m n x | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | iterateFrobeniusEquiv_add_apply | null |
iterateFrobeniusEquiv_add : iterateFrobeniusEquiv R p (m + n) =
(iterateFrobeniusEquiv R p n).trans (iterateFrobeniusEquiv R p m) :=
RingEquiv.ext (iterateFrobeniusEquiv_add_apply R p m n) | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | iterateFrobeniusEquiv_add | null |
iterateFrobeniusEquiv_symm_add_apply (x : R) : (iterateFrobeniusEquiv R p (m + n)).symm x =
(iterateFrobeniusEquiv R p m).symm ((iterateFrobeniusEquiv R p n).symm x) :=
(iterateFrobeniusEquiv R p (m + n)).injective <| by rw [RingEquiv.apply_symm_apply, add_comm,
iterateFrobeniusEquiv_add_apply, RingEquiv.apply_symm_apply, RingEquiv.apply_symm_apply] | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | iterateFrobeniusEquiv_symm_add_apply | null |
iterateFrobeniusEquiv_symm_add : (iterateFrobeniusEquiv R p (m + n)).symm =
(iterateFrobeniusEquiv R p n).symm.trans (iterateFrobeniusEquiv R p m).symm :=
RingEquiv.ext (iterateFrobeniusEquiv_symm_add_apply R p m n) | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | iterateFrobeniusEquiv_symm_add | null |
iterateFrobeniusEquiv_zero_apply (x : R) : iterateFrobeniusEquiv R p 0 x = x := by
rw [iterateFrobeniusEquiv_def, pow_zero, pow_one] | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | iterateFrobeniusEquiv_zero_apply | null |
iterateFrobeniusEquiv_one_apply (x : R) : iterateFrobeniusEquiv R p 1 x = x ^ p := by
rw [iterateFrobeniusEquiv_def, pow_one]
@[simp] | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | iterateFrobeniusEquiv_one_apply | null |
iterateFrobeniusEquiv_zero : iterateFrobeniusEquiv R p 0 = RingEquiv.refl R :=
RingEquiv.ext (iterateFrobeniusEquiv_zero_apply R p)
@[simp] | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | iterateFrobeniusEquiv_zero | null |
iterateFrobeniusEquiv_one : iterateFrobeniusEquiv R p 1 = frobeniusEquiv R p :=
RingEquiv.ext (iterateFrobeniusEquiv_one_apply R p) | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | iterateFrobeniusEquiv_one | null |
iterateFrobeniusEquiv_eq_pow : iterateFrobeniusEquiv R p n = frobeniusEquiv R p ^ n :=
DFunLike.ext' <| show _ = ⇑(RingAut.toPerm _ _) by
rw [map_pow, Equiv.Perm.coe_pow]; exact (pow_iterate p n).symm | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | iterateFrobeniusEquiv_eq_pow | null |
iterateFrobeniusEquiv_symm :
(iterateFrobeniusEquiv R p n).symm = (frobeniusEquiv R p).symm ^ n := by
rw [iterateFrobeniusEquiv_eq_pow]; exact (inv_pow _ _).symm
@[simp] | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | iterateFrobeniusEquiv_symm | null |
frobeniusEquiv_symm_apply_frobenius (x : R) :
(frobeniusEquiv R p).symm (frobenius R p x) = x :=
leftInverse_surjInv PerfectRing.bijective_frobenius x
@[simp] | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | frobeniusEquiv_symm_apply_frobenius | null |
frobenius_apply_frobeniusEquiv_symm (x : R) :
frobenius R p ((frobeniusEquiv R p).symm x) = x :=
surjInv_eq _ _
@[simp] | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | frobenius_apply_frobeniusEquiv_symm | null |
frobenius_comp_frobeniusEquiv_symm :
(frobenius R p).comp (frobeniusEquiv R p).symm = RingHom.id R := by
ext; simp
@[simp] | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | frobenius_comp_frobeniusEquiv_symm | null |
frobeniusEquiv_symm_comp_frobenius :
((frobeniusEquiv R p).symm : R →+* R).comp (frobenius R p) = RingHom.id R := by
ext; simp
@[simp] | theorem | FieldTheory | [
"Mathlib.Algebra.CharP.Basic",
"Mathlib.Algebra.CharP.Reduced",
"Mathlib.FieldTheory.KummerPolynomial",
"Mathlib.FieldTheory.Separable"
] | Mathlib/FieldTheory/Perfect.lean | frobeniusEquiv_symm_comp_frobenius | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.