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 ⌀ |
|---|---|---|---|---|---|---|
powers_zero : powers (0 : HahnSeries Γ R) = .single 0 1 := by
ext n
rw [powers_of_orderTop_pos (by simp)]
obtain rfl | ha := eq_or_ne n 0 <;> simp [*]
variable {x : HahnSeries Γ R} (hx : 0 < x.orderTop)
include hx in
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | powers_zero | null |
coe_powers : ⇑(powers x) = HPow.hPow x := by
ext1 n
simp [hx]
include hx in | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coe_powers | null |
embDomain_succ_smul_powers :
(x • powers x).embDomain ⟨Nat.succ, Nat.succ_injective⟩ =
powers x - ofFinsupp (Finsupp.single 0 1) := by
apply SummableFamily.ext
rintro (_ | n)
· simp [hx]
· -- FIXME: smul_eq_mul introduces type confusion between HahnModule and HahnSeries.
simp [embDomain_apply, of_symm_smul_of_eq_mul, powers_of_orderTop_pos hx, pow_succ',
-smul_eq_mul, -Algebra.id.smul_eq_mul]
include hx in | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | embDomain_succ_smul_powers | null |
one_sub_self_mul_hsum_powers : (1 - x) * (powers x).hsum = 1 := by
rw [← hsum_smul, sub_smul 1 x (powers x), one_smul, hsum_sub, ←
hsum_embDomain (x • powers x) ⟨Nat.succ, Nat.succ_injective⟩, embDomain_succ_smul_powers hx]
simp | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | one_sub_self_mul_hsum_powers | null |
one_minus_single_neg_mul {x y : HahnSeries Γ R} {r : R} (hr : r * x.leadingCoeff = 1)
(hxy : x = y + single x.order x.leadingCoeff) (oinv : Γ) (hxo : oinv + x.order = 0) :
1 - single oinv r * x = -(single oinv r * y) := by
nth_rw 1 [hxy]
rw [mul_add, single_mul_single, hr, hxo,
sub_add_eq_sub_sub_swap, sub_eq_neg_self, sub_eq_zero_of_eq single_zero_one.symm] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | one_minus_single_neg_mul | null |
unit_aux (x : HahnSeries Γ R) {r : R} (hr : r * x.leadingCoeff = 1)
(oinv : Γ) (hxo : oinv + x.order = 0) :
0 < (1 - single oinv r * x).orderTop := by
let y := (x - single x.order x.leadingCoeff)
by_cases hy : y = 0
· have hrx : (single oinv) r * x = 1 := by
rw [eq_of_sub_eq_zero hy, single_mul_single, hxo, hr, single_zero_one]
simp only [hrx, sub_self, orderTop_zero, WithTop.top_pos]
· have hr' : IsRegular r := IsUnit.isRegular <| isUnit_of_mul_eq_one r x.leadingCoeff hr
have hy' : 0 < (single oinv r * y).order := by
rw [(order_single_mul_of_isRegular hr' hy)]
refine pos_of_lt_add_right (a := x.order) ?_
rw [← add_assoc, add_comm x.order, hxo, zero_add]
exact order_lt_order_of_eq_add_single (sub_add_cancel x _).symm hy
rw [one_minus_single_neg_mul hr (sub_add_cancel x _).symm _ hxo, orderTop_neg]
exact zero_lt_orderTop_of_order hy' | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | unit_aux | null |
isUnit_of_isUnit_leadingCoeff_AddUnitOrder {x : HahnSeries Γ R} (hx : IsUnit x.leadingCoeff)
(hxo : IsAddUnit x.order) : IsUnit x := by
let ⟨⟨u, i, ui, iu⟩, h⟩ := hx
rw [Units.val_mk] at h
rw [h] at iu
have h' := SummableFamily.one_sub_self_mul_hsum_powers (unit_aux x iu _ hxo.addUnit.neg_add)
rw [sub_sub_cancel] at h'
exact isUnit_of_mul_isUnit_right (isUnit_of_mul_eq_one _ _ h') | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | isUnit_of_isUnit_leadingCoeff_AddUnitOrder | null |
isUnit_iff {x : HahnSeries Γ R} : IsUnit x ↔ IsUnit (x.leadingCoeff) := by
constructor
· rintro ⟨⟨u, i, ui, iu⟩, rfl⟩
refine
isUnit_of_mul_eq_one (u.leadingCoeff) (i.leadingCoeff)
((coeff_mul_order_add_order u i).symm.trans ?_)
rw [ui, coeff_one, if_pos]
rw [← order_mul (left_ne_zero_of_mul_eq_one ui) (right_ne_zero_of_mul_eq_one ui), ui, order_one]
· rintro ⟨⟨u, i, ui, iu⟩, hx⟩
rw [Units.val_mk] at hx
rw [hx] at iu
have h :=
SummableFamily.one_sub_self_mul_hsum_powers (unit_aux x iu _ (neg_add_cancel x.order))
rw [sub_sub_cancel] at h
exact isUnit_of_mul_isUnit_right (isUnit_of_mul_eq_one _ _ h) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | isUnit_iff | null |
@[simp]
inv_single (a : Γ) (r : R) : (single a r)⁻¹ = single (-a) r⁻¹ := by
obtain rfl | hr := eq_or_ne r 0
· simp [inv_def]
· simp [inv_def, hr]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | inv_single | null |
single_div_single (a b : Γ) (r s : R) :
single a r / single b s = single (a - b) (r / s) := by
rw [div_eq_mul_inv, sub_eq_add_neg, div_eq_mul_inv, inv_single, single_mul_single] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | single_div_single | null |
instField : Field (HahnSeries Γ R) where
inv_zero := by simp [inv_def]
mul_inv_cancel x x0 := by
have h :=
SummableFamily.one_sub_self_mul_hsum_powers
(unit_aux x (inv_mul_cancel₀ (leadingCoeff_ne_zero.mpr x0)) _ (neg_add_cancel x.order))
rw [sub_sub_cancel] at h
rw [inv_def, ← mul_assoc, mul_comm x, h]
nnqsmul := (· • ·)
qsmul := (· • ·)
nnqsmul_def q x := by ext; simp [← single_zero_nnratCast, NNRat.smul_def]
qsmul_def q x := by ext; simp [← single_zero_ratCast, Rat.smul_def]
nnratCast_def q := by
simp [← single_zero_nnratCast, ← single_zero_natCast, NNRat.cast_def]
ratCast_def q := by
simp [← single_zero_ratCast, ← single_zero_intCast, ← single_zero_natCast, Rat.cast_def] | instance | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | instField | null |
single_zero_ofScientific (m e s) :
single (0 : Γ) (OfScientific.ofScientific m e s : R) = OfScientific.ofScientific m e s := by
simpa using single_zero_ratCast (Γ := Γ) (R := R) (OfScientific.ofScientific m e s) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | single_zero_ofScientific | null |
addVal : AddValuation (HahnSeries Γ R) (WithTop Γ) :=
AddValuation.of orderTop orderTop_zero (orderTop_one) (fun _ _ => min_orderTop_le_orderTop_add)
fun x y => by
by_cases hx : x = 0; · simp [hx]
by_cases hy : y = 0; · simp [hy]
rw [← order_eq_orderTop_of_ne_zero hx, ← order_eq_orderTop_of_ne_zero hy,
← order_eq_orderTop_of_ne_zero (mul_ne_zero hx hy), ← WithTop.coe_add, WithTop.coe_eq_coe,
order_mul hx hy]
variable {Γ} {R} | def | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/HahnSeries/Valuation.lean | addVal | The additive valuation on `HahnSeries Γ R`, returning the smallest index at which
a Hahn Series has a nonzero coefficient, or `⊤` for the 0 series. |
addVal_apply {x : HahnSeries Γ R} :
addVal Γ R x = x.orderTop :=
AddValuation.of_apply _
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/HahnSeries/Valuation.lean | addVal_apply | null |
addVal_apply_of_ne {x : HahnSeries Γ R} (hx : x ≠ 0) : addVal Γ R x = x.order :=
addVal_apply.trans (order_eq_orderTop_of_ne_zero hx).symm | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/HahnSeries/Valuation.lean | addVal_apply_of_ne | null |
addVal_le_of_coeff_ne_zero {x : HahnSeries Γ R} {g : Γ} (h : x.coeff g ≠ 0) :
addVal Γ R x ≤ g :=
orderTop_le_of_coeff_ne_zero h | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.Valuation.Basic"
] | Mathlib/RingTheory/HahnSeries/Valuation.lean | addVal_le_of_coeff_ne_zero | null |
HopfAlgebraStruct (R : Type u) (A : Type v) [CommSemiring R] [Semiring A]
extends Bialgebra R A where
/-- The antipode of the Hopf algebra. -/
antipode (R) : A →ₗ[R] A | class | RingTheory | [
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/Basic.lean | HopfAlgebraStruct | Isolates the antipode of a Hopf algebra, to allow API to be constructed before proving the
Hopf algebra axioms. See `HopfAlgebra` for documentation. |
HopfAlgebra (R : Type u) (A : Type v) [CommSemiring R] [Semiring A] extends
HopfAlgebraStruct R A where
/-- One of the antipode axioms for a Hopf algebra. -/
mul_antipode_rTensor_comul :
LinearMap.mul' R A ∘ₗ antipode.rTensor A ∘ₗ comul = (Algebra.linearMap R A) ∘ₗ counit
/-- One of the antipode axioms for a Hopf algebra. -/
mul_antipode_lTensor_comul :
LinearMap.mul' R A ∘ₗ antipode.lTensor A ∘ₗ comul = (Algebra.linearMap R A) ∘ₗ counit | class | RingTheory | [
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/Basic.lean | HopfAlgebra | A Hopf algebra over a commutative (semi)ring `R` is a bialgebra over `R` equipped with an
`R`-linear endomorphism `antipode` satisfying the antipode axioms. |
@[simp]
mul_antipode_rTensor_comul_apply (a : A) :
LinearMap.mul' R A ((antipode R).rTensor A (Coalgebra.comul a)) =
algebraMap R A (Coalgebra.counit a) :=
LinearMap.congr_fun mul_antipode_rTensor_comul a
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/Basic.lean | mul_antipode_rTensor_comul_apply | null |
mul_antipode_lTensor_comul_apply (a : A) :
LinearMap.mul' R A ((antipode R).lTensor A (Coalgebra.comul a)) =
algebraMap R A (Coalgebra.counit a) :=
LinearMap.congr_fun mul_antipode_lTensor_comul a
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/Basic.lean | mul_antipode_lTensor_comul_apply | null |
antipode_one :
HopfAlgebra.antipode R (1 : A) = 1 := by
simpa [Algebra.TensorProduct.one_def] using mul_antipode_rTensor_comul_apply (R := R) (1 : A)
open Coalgebra | theorem | RingTheory | [
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/Basic.lean | antipode_one | null |
sum_antipode_mul_eq_algebraMap_counit (repr : Repr R a) :
∑ i ∈ repr.index, antipode R (repr.left i) * repr.right i =
algebraMap R A (counit a) := by
simpa [← repr.eq, map_sum] using congr($(mul_antipode_rTensor_comul (R := R)) a)
@[deprecated (since := "2025-05-29")]
alias sum_antipode_mul_eq := sum_antipode_mul_eq_algebraMap_counit | lemma | RingTheory | [
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/Basic.lean | sum_antipode_mul_eq_algebraMap_counit | null |
sum_mul_antipode_eq_algebraMap_counit (repr : Repr R a) :
∑ i ∈ repr.index, repr.left i * antipode R (repr.right i) =
algebraMap R A (counit a) := by
simpa [← repr.eq, map_sum] using congr($(mul_antipode_lTensor_comul (R := R)) a)
@[deprecated (since := "2025-05-29")]
alias sum_mul_antipode_eq := sum_mul_antipode_eq_algebraMap_counit | lemma | RingTheory | [
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/Basic.lean | sum_mul_antipode_eq_algebraMap_counit | null |
sum_antipode_mul_eq_smul (repr : Repr R a) :
∑ i ∈ repr.index, antipode R (repr.left i) * repr.right i =
counit (R := R) a • 1 := by
rw [sum_antipode_mul_eq_algebraMap_counit, Algebra.smul_def, mul_one] | lemma | RingTheory | [
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/Basic.lean | sum_antipode_mul_eq_smul | null |
sum_mul_antipode_eq_smul (repr : Repr R a) :
∑ i ∈ repr.index, repr.left i * antipode R (repr.right i) =
counit (R := R) a • 1 := by
rw [sum_mul_antipode_eq_algebraMap_counit, Algebra.smul_def, mul_one]
@[simp] lemma counit_antipode (a : A) : counit (R := R) (antipode R a) = counit a := by
calc
counit (antipode R a)
_ = counit (∑ i ∈ (ℛ R a).index, (ℛ R a).left i * antipode R ((ℛ R a).right i)) := by
simp_rw [map_sum, counit_mul, ← smul_eq_mul, ← map_smul, ← map_sum, sum_counit_smul]
_ = counit a := by simpa using congr(counit (R := R) $(sum_mul_antipode_eq_smul (ℛ R a)))
@[simp] lemma counit_comp_antipode : counit ∘ₗ antipode R = counit (A := A) := by
ext; exact counit_antipode _ | lemma | RingTheory | [
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/Basic.lean | sum_mul_antipode_eq_smul | null |
toHopfAlgebra : HopfAlgebra R R where
antipode := .id
mul_antipode_rTensor_comul := by ext; simp
mul_antipode_lTensor_comul := by ext; simp
@[simp] | instance | RingTheory | [
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/Basic.lean | toHopfAlgebra | Every commutative (semi)ring is a Hopf algebra over itself |
antipode_eq_id : antipode R (A := R) = .id := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/Basic.lean | antipode_eq_id | null |
instHopfAlgebraStruct : HopfAlgebraStruct R (MonoidAlgebra A G) where
antipode := Finsupp.lsum R fun g => Finsupp.lsingle g⁻¹ ∘ₗ antipode R
@[simp] | instance | RingTheory | [
"Mathlib.RingTheory.Bialgebra.MonoidAlgebra",
"Mathlib.RingTheory.HopfAlgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/MonoidAlgebra.lean | instHopfAlgebraStruct | null |
antipode_single (g : G) (a : A) :
antipode R (single g a) = single g⁻¹ (antipode R a) := by
simp [MonoidAlgebra, antipode]
open Coalgebra in | lemma | RingTheory | [
"Mathlib.RingTheory.Bialgebra.MonoidAlgebra",
"Mathlib.RingTheory.HopfAlgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/MonoidAlgebra.lean | antipode_single | null |
instHopfAlgebra : HopfAlgebra R (MonoidAlgebra A G) where
mul_antipode_rTensor_comul := by
ext a b : 2
simpa [← (ℛ R b).eq] using congr(lsingle (R := R) (1 : G)
$(sum_antipode_mul_eq_algebraMap_counit (ℛ R b)))
mul_antipode_lTensor_comul := by
ext a b : 2
simpa [← (ℛ R b).eq] using congr(lsingle (R := R) (1 : G)
$(sum_mul_antipode_eq_algebraMap_counit (ℛ R b))) | instance | RingTheory | [
"Mathlib.RingTheory.Bialgebra.MonoidAlgebra",
"Mathlib.RingTheory.HopfAlgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/MonoidAlgebra.lean | instHopfAlgebra | null |
instHopfAlgebraStruct : HopfAlgebraStruct R A[G] where
antipode := Finsupp.lsum R fun g => Finsupp.lsingle (-g) ∘ₗ antipode R
@[simp] | instance | RingTheory | [
"Mathlib.RingTheory.Bialgebra.MonoidAlgebra",
"Mathlib.RingTheory.HopfAlgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/MonoidAlgebra.lean | instHopfAlgebraStruct | null |
antipode_single (g : G) (a : A) :
antipode R (single g a) = single (-g) (antipode R a) := by
simp [AddMonoidAlgebra, antipode]
open Coalgebra in | lemma | RingTheory | [
"Mathlib.RingTheory.Bialgebra.MonoidAlgebra",
"Mathlib.RingTheory.HopfAlgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/MonoidAlgebra.lean | antipode_single | null |
instHopfAlgebra : HopfAlgebra R A[G] where
mul_antipode_rTensor_comul := by
ext a b : 2
simpa [← (ℛ R b).eq, single_mul_single] using congr(lsingle (R := R) (0 : G)
$(sum_antipode_mul_eq_algebraMap_counit (ℛ R b)))
mul_antipode_lTensor_comul := by
ext a b : 2
simpa [← (ℛ R b).eq, single_mul_single] using congr(lsingle (R := R) (0 : G)
$(sum_mul_antipode_eq_algebraMap_counit (ℛ R b))) | instance | RingTheory | [
"Mathlib.RingTheory.Bialgebra.MonoidAlgebra",
"Mathlib.RingTheory.HopfAlgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/MonoidAlgebra.lean | instHopfAlgebra | null |
instHopfAlgebra : HopfAlgebra R A[T;T⁻¹] :=
inferInstanceAs (HopfAlgebra R <| AddMonoidAlgebra A ℤ)
variable {R A}
@[simp] | instance | RingTheory | [
"Mathlib.RingTheory.Bialgebra.MonoidAlgebra",
"Mathlib.RingTheory.HopfAlgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/MonoidAlgebra.lean | instHopfAlgebra | null |
antipode_C (a : A) :
HopfAlgebra.antipode R (C a) = C (HopfAlgebra.antipode R a) := by
rw [← single_eq_C, AddMonoidAlgebra.antipode_single]
simp
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Bialgebra.MonoidAlgebra",
"Mathlib.RingTheory.HopfAlgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/MonoidAlgebra.lean | antipode_C | null |
antipode_T (n : ℤ) :
HopfAlgebra.antipode R (T n : A[T;T⁻¹]) = T (-n) := by
unfold T
rw [AddMonoidAlgebra.antipode_single]
simp only [HopfAlgebra.antipode_one, single_eq_C_mul_T, map_one, one_mul]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Bialgebra.MonoidAlgebra",
"Mathlib.RingTheory.HopfAlgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/MonoidAlgebra.lean | antipode_T | null |
antipode_C_mul_T (a : A) (n : ℤ) :
HopfAlgebra.antipode R (C a * T n) = C (HopfAlgebra.antipode R a) * T (-n) := by
simp [← single_eq_C_mul_T] | theorem | RingTheory | [
"Mathlib.RingTheory.Bialgebra.MonoidAlgebra",
"Mathlib.RingTheory.HopfAlgebra.Basic"
] | Mathlib/RingTheory/HopfAlgebra/MonoidAlgebra.lean | antipode_C_mul_T | null |
noncomputable HopfAlgebra.ofAlgHom {R A : Type*} [CommSemiring R] [CommSemiring A]
[Bialgebra R A] (antipode : A →ₐ[R] A)
(mul_antipode_rTensor_comul :
((Algebra.TensorProduct.lift antipode (.id R A) fun _ ↦ .all _).comp
(Bialgebra.comulAlgHom R A)) = (Algebra.ofId R A).comp (Bialgebra.counitAlgHom R A))
(mul_antipode_lTensor_comul :
(Algebra.TensorProduct.lift (.id R A) antipode fun _ _ ↦ .all _ _).comp
(Bialgebra.comulAlgHom R A) = (Algebra.ofId R A).comp (Bialgebra.counitAlgHom R A)) :
HopfAlgebra R A where
antipode := antipode
mul_antipode_rTensor_comul := by
rw [← Algebra.TensorProduct.lmul'_comp_map] at mul_antipode_rTensor_comul
exact congr(($mul_antipode_rTensor_comul).toLinearMap)
mul_antipode_lTensor_comul := by
rw [← Algebra.TensorProduct.lmul'_comp_map] at mul_antipode_lTensor_comul
exact congr(($mul_antipode_lTensor_comul).toLinearMap) | abbrev | RingTheory | [
"Mathlib.RingTheory.HopfAlgebra.Basic",
"Mathlib.RingTheory.Bialgebra.TensorProduct"
] | Mathlib/RingTheory/HopfAlgebra/TensorProduct.lean | HopfAlgebra.ofAlgHom | Upgrade a bialgebra to a Hopf algebra by specifying the antipode as an algebra map with
appropriate conditions. |
@[simp]
antipode_def :
antipode S (A := B ⊗[R] A) = AlgebraTensorModule.map (antipode S) (antipode R) := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.HopfAlgebra.Basic",
"Mathlib.RingTheory.Bialgebra.TensorProduct"
] | Mathlib/RingTheory/HopfAlgebra/TensorProduct.lean | antipode_def | null |
pi : Ideal (Π i, R i) where
carrier := { r | ∀ i, r i ∈ I i }
zero_mem' i := (I i).zero_mem
add_mem' ha hb i := (I i).add_mem (ha i) (hb i)
smul_mem' a _b hb i := (I i).mul_mem_left (a i) (hb i) | def | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | pi | `Πᵢ Iᵢ` as an ideal of `Πᵢ Rᵢ`. |
mem_pi (r : Π i, R i) : r ∈ pi I ↔ ∀ i, r i ∈ I i :=
Iff.rfl
@[simp] theorem pi_span {r : Π i, R i} : pi (span {r ·}) = span {r} := by
ext; simp_rw [mem_pi, mem_span_singleton', funext_iff, Classical.skolem, Pi.mul_def] | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | mem_pi | null |
single_mem_pi [DecidableEq ι] {i : ι} {r : R i} (hr : r ∈ I i) : Pi.single i r ∈ pi I := by
intro j
obtain rfl | ne := eq_or_ne i j
· simpa
· simp [ne]
@[simp] theorem pi_le_pi_iff : pi I ≤ pi J ↔ I ≤ J where
mp le i r hr := by classical simpa using le (single_mem_pi hr) i
mpr le r hr i := le i (hr i) | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | single_mem_pi | null |
add_pow_mem_of_pow_mem_of_le_of_commute {m n k : ℕ}
(ha : a ^ m ∈ I) (hb : b ^ n ∈ I) (hk : m + n ≤ k + 1)
(hab : Commute a b) :
(a + b) ^ k ∈ I := by
simp_rw [hab.add_pow, ← Nat.cast_comm]
apply I.sum_mem
intro c _
apply mul_mem_left
by_cases h : m ≤ c
· rw [hab.pow_pow]
exact I.mul_mem_left _ (I.pow_mem_of_pow_mem ha h)
· refine I.mul_mem_left _ (I.pow_mem_of_pow_mem hb ?_)
cutsat | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | add_pow_mem_of_pow_mem_of_le_of_commute | null |
add_pow_add_pred_mem_of_pow_mem_of_commute {m n : ℕ}
(ha : a ^ m ∈ I) (hb : b ^ n ∈ I) (hab : Commute a b) :
(a + b) ^ (m + n - 1) ∈ I :=
I.add_pow_mem_of_pow_mem_of_le_of_commute ha hb (by rw [← Nat.sub_le_iff_le_add]) hab | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | add_pow_add_pred_mem_of_pow_mem_of_commute | null |
add_pow_mem_of_pow_mem_of_le {m n k : ℕ}
(ha : a ^ m ∈ I) (hb : b ^ n ∈ I) (hk : m + n ≤ k + 1) :
(a + b) ^ k ∈ I :=
I.add_pow_mem_of_pow_mem_of_le_of_commute ha hb hk (Commute.all ..) | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | add_pow_mem_of_pow_mem_of_le | null |
add_pow_add_pred_mem_of_pow_mem {m n : ℕ}
(ha : a ^ m ∈ I) (hb : b ^ n ∈ I) :
(a + b) ^ (m + n - 1) ∈ I :=
I.add_pow_add_pred_mem_of_pow_mem_of_commute ha hb (Commute.all ..) | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | add_pow_add_pred_mem_of_pow_mem | null |
pow_multiset_sum_mem_span_pow [DecidableEq α] (s : Multiset α) (n : ℕ) :
s.sum ^ (Multiset.card s * n + 1) ∈
span ((s.map fun (x : α) ↦ x ^ (n + 1)).toFinset : Set α) := by
induction s using Multiset.induction_on with
| empty => simp
| cons a s hs => ?_
simp only [Finset.coe_insert, Multiset.map_cons, Multiset.toFinset_cons, Multiset.sum_cons,
Multiset.card_cons, add_pow]
refine Submodule.sum_mem _ ?_
intro c _hc
rw [mem_span_insert]
by_cases h : n + 1 ≤ c
· refine ⟨a ^ (c - (n + 1)) * s.sum ^ ((Multiset.card s + 1) * n + 1 - c) *
((Multiset.card s + 1) * n + 1).choose c, 0, Submodule.zero_mem _, ?_⟩
rw [mul_comm _ (a ^ (n + 1))]
simp_rw [← mul_assoc]
rw [← pow_add, add_zero, add_tsub_cancel_of_le h]
· use 0
simp_rw [zero_mul, zero_add]
refine ⟨_, ?_, rfl⟩
replace h : c ≤ n := Nat.lt_succ_iff.mp (not_le.mp h)
have : (Multiset.card s + 1) * n + 1 - c = Multiset.card s * n + 1 + (n - c) := by
rw [add_mul, one_mul, add_assoc, add_comm n 1, ← add_assoc, add_tsub_assoc_of_le h]
rw [this, pow_add]
simp_rw [mul_assoc, mul_comm (s.sum ^ (Multiset.card s * n + 1)), ← mul_assoc]
exact mul_mem_left _ _ hs | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | pow_multiset_sum_mem_span_pow | null |
sum_pow_mem_span_pow {ι} (s : Finset ι) (f : ι → α) (n : ℕ) :
(∑ i ∈ s, f i) ^ (s.card * n + 1) ∈ span ((fun i => f i ^ (n + 1)) '' s) := by
classical
simpa only [Multiset.card_map, Multiset.map_map, comp_apply, Multiset.toFinset_map,
Finset.coe_image, Finset.val_toFinset] using pow_multiset_sum_mem_span_pow (s.1.map f) n | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | sum_pow_mem_span_pow | null |
span_pow_eq_top (s : Set α) (hs : span s = ⊤) (n : ℕ) :
span ((fun (x : α) => x ^ n) '' s) = ⊤ := by
rw [eq_top_iff_one]
rcases n with - | n
· obtain rfl | ⟨x, hx⟩ := eq_empty_or_nonempty s
· rw [Set.image_empty, hs]
trivial
· exact subset_span ⟨_, hx, pow_zero _⟩
rw [eq_top_iff_one, span, Finsupp.mem_span_iff_linearCombination] at hs
rcases hs with ⟨f, hf⟩
simp only [Finsupp.linearCombination, Finsupp.coe_lsum, Finsupp.sum, LinearMap.coe_smulRight,
LinearMap.id_coe, id_eq, smul_eq_mul] at hf
have := sum_pow_mem_span_pow f.support (fun a => f a * a) n
rw [hf, one_pow] at this
refine span_le.mpr ?_ this
rintro _ hx
simp_rw [Set.mem_image] at hx
rcases hx with ⟨x, _, rfl⟩
have : span ({(x : α) ^ (n + 1)} : Set α) ≤ span ((fun x : α => x ^ (n + 1)) '' s) := by
rw [span_le, Set.singleton_subset_iff]
exact subset_span ⟨x, x.prop, rfl⟩
refine this ?_
rw [mul_pow, mem_span_singleton]
exact ⟨f x ^ (n + 1), mul_comm _ _⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | span_pow_eq_top | null |
span_range_pow_eq_top (s : Set α) (hs : span s = ⊤) (n : s → ℕ) :
span (Set.range fun x ↦ x.1 ^ n x) = ⊤ := by
have ⟨t, hts, mem⟩ := Submodule.mem_span_finite_of_mem_span ((eq_top_iff_one _).mp hs)
refine top_unique ((span_pow_eq_top _ ((eq_top_iff_one _).mpr mem) <|
t.attach.sup fun x ↦ n ⟨x, hts x.2⟩).ge.trans <| span_le.mpr ?_)
rintro _ ⟨x, hxt, rfl⟩
rw [← Nat.sub_add_cancel (Finset.le_sup <| t.mem_attach ⟨x, hxt⟩)]
simp_rw [pow_add]
exact mul_mem_left _ _ (subset_span ⟨_, rfl⟩) | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | span_range_pow_eq_top | null |
prod_mem {ι : Type*} {f : ι → α} {s : Finset ι}
(I : Ideal α) {i : ι} (hi : i ∈ s) (hfi : f i ∈ I) :
∏ i ∈ s, f i ∈ I := by
classical
rw [Finset.prod_eq_prod_diff_singleton_mul hi]
exact Ideal.mul_mem_left _ _ hfi | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | prod_mem | null |
equivFinTwo [DecidableEq (Ideal K)] : Ideal K ≃ Fin 2 where
toFun := fun I ↦ if I = ⊥ then 0 else 1
invFun := ![⊥, ⊤]
left_inv := fun I ↦ by rcases eq_bot_or_top I with rfl | rfl <;> simp
right_inv := fun i ↦ by fin_cases i <;> simp | def | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | equivFinTwo | A bijection between (left) ideals of a division ring and `{0, 1}`, sending `⊥` to `0`
and `⊤` to `1`. |
isSimpleOrder : IsSimpleOrder (Ideal K) :=
⟨eq_bot_or_top⟩ | instance | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | isSimpleOrder | Ideals of a `DivisionSemiring` are a simple order. Thanks to the way abbreviations work,
this automatically gives an `IsSimpleModule K` instance. |
exists_not_isUnit_of_not_isField [Nontrivial R] (hf : ¬IsField R) :
∃ (x : R) (_hx : x ≠ (0 : R)), ¬IsUnit x := by
have : ¬_ := fun h => hf ⟨exists_pair_ne R, mul_comm, h⟩
simp_rw [isUnit_iff_exists_inv]
push_neg at this ⊢
obtain ⟨x, hx, not_unit⟩ := this
exact ⟨x, hx, not_unit⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | exists_not_isUnit_of_not_isField | null |
not_isField_iff_exists_ideal_bot_lt_and_lt_top [Nontrivial R] :
¬IsField R ↔ ∃ I : Ideal R, ⊥ < I ∧ I < ⊤ := by
constructor
· intro h
obtain ⟨x, nz, nu⟩ := exists_not_isUnit_of_not_isField h
use Ideal.span {x}
rw [bot_lt_iff_ne_bot, lt_top_iff_ne_top]
exact ⟨mt Ideal.span_singleton_eq_bot.mp nz, mt Ideal.span_singleton_eq_top.mp nu⟩
· rintro ⟨I, bot_lt, lt_top⟩ hf
obtain ⟨x, mem, ne_zero⟩ := SetLike.exists_of_lt bot_lt
rw [Submodule.mem_bot] at ne_zero
obtain ⟨y, hy⟩ := hf.mul_inv_cancel ne_zero
rw [lt_top_iff_ne_top, Ne, Ideal.eq_top_iff_one, ← hy] at lt_top
exact lt_top (I.mul_mem_right _ mem) | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | not_isField_iff_exists_ideal_bot_lt_and_lt_top | null |
not_isField_iff_exists_prime [Nontrivial R] :
¬IsField R ↔ ∃ p : Ideal R, p ≠ ⊥ ∧ p.IsPrime :=
not_isField_iff_exists_ideal_bot_lt_and_lt_top.trans
⟨fun ⟨I, bot_lt, lt_top⟩ =>
let ⟨p, hp, le_p⟩ := I.exists_le_maximal (lt_top_iff_ne_top.mp lt_top)
⟨p, bot_lt_iff_ne_bot.mp (lt_of_lt_of_le bot_lt le_p), hp.isPrime⟩,
fun ⟨p, ne_bot, Prime⟩ => ⟨p, bot_lt_iff_ne_bot.mpr ne_bot, lt_top_iff_ne_top.mpr Prime.1⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | not_isField_iff_exists_prime | null |
isField_iff_isSimpleOrder_ideal : IsField R ↔ IsSimpleOrder (Ideal R) := by
cases subsingleton_or_nontrivial R
· exact
⟨fun h => (not_isField_of_subsingleton _ h).elim, fun h =>
(false_of_nontrivial_of_subsingleton <| Ideal R).elim⟩
rw [← not_iff_not, Ring.not_isField_iff_exists_ideal_bot_lt_and_lt_top, ← not_iff_not]
push_neg
simp_rw [lt_top_iff_ne_top, bot_lt_iff_ne_bot, ← or_iff_not_imp_left, not_ne_iff]
exact ⟨fun h => ⟨h⟩, fun h => h.2⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | isField_iff_isSimpleOrder_ideal | Also see `Ideal.isSimpleOrder` for the forward direction as an instance when `R` is a
division (semi)ring.
This result actually holds for all division semirings, but we lack the predicate to state it. |
ne_bot_of_isMaximal_of_not_isField [Nontrivial R] {M : Ideal R} (max : M.IsMaximal)
(not_field : ¬IsField R) : M ≠ ⊥ := by
rintro h
rw [h] at max
rcases max with ⟨⟨_h1, h2⟩⟩
obtain ⟨I, hIbot, hItop⟩ := not_isField_iff_exists_ideal_bot_lt_and_lt_top.mp not_field
exact ne_of_lt hItop (h2 I hIbot) | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | ne_bot_of_isMaximal_of_not_isField | When a ring is not a field, the maximal ideals are nontrivial. |
bot_lt_of_maximal (M : Ideal R) [hm : M.IsMaximal] (non_field : ¬IsField R) : ⊥ < M := by
rcases Ring.not_isField_iff_exists_ideal_bot_lt_and_lt_top.1 non_field with ⟨I, Ibot, Itop⟩
constructor; · simp
intro mle
apply lt_irrefl (⊤ : Ideal R)
have : M = ⊥ := eq_bot_iff.mpr mle
rw [← this] at Ibot
rwa [hm.1.2 I Ibot] at Itop | theorem | RingTheory | [
"Mathlib.Algebra.Field.IsField",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Nat.Choose.Sum",
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.Ideal.Maximal",
"Mathlib.Tactic.FinCases"
] | Mathlib/RingTheory/Ideal/Basic.lean | bot_lt_of_maximal | null |
noncomputable basisSpanSingleton (b : Basis ι R S) {x : S} (hx : x ≠ 0) :
Basis ι R (span ({x} : Set S)) :=
b.map <|
LinearEquiv.ofInjective (LinearMap.mulLeft R x) (mul_right_injective₀ hx) ≪≫ₗ
LinearEquiv.ofEq _ _
(by
ext
simp [mem_span_singleton', mul_comm]) ≪≫ₗ
(Submodule.restrictScalarsEquiv R S S (Ideal.span ({x} : Set S))).restrictScalars R
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.LinearAlgebra.Basis.Defs",
"Mathlib.LinearAlgebra.Basis.Submodule",
"Mathlib.RingTheory.Ideal.Span"
] | Mathlib/RingTheory/Ideal/Basis.lean | basisSpanSingleton | A basis on `S` gives a basis on `Ideal.span {x}`, by multiplying everything by `x`. |
basisSpanSingleton_apply (b : Basis ι R S) {x : S} (hx : x ≠ 0) (i : ι) :
(basisSpanSingleton b hx i : S) = x * b i := by
simp only [basisSpanSingleton, Basis.map_apply, LinearEquiv.trans_apply,
Submodule.restrictScalarsEquiv_apply, LinearEquiv.ofInjective_apply, LinearEquiv.coe_ofEq_apply,
LinearEquiv.restrictScalars_apply, LinearMap.mulLeft_apply]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.LinearAlgebra.Basis.Defs",
"Mathlib.LinearAlgebra.Basis.Submodule",
"Mathlib.RingTheory.Ideal.Span"
] | Mathlib/RingTheory/Ideal/Basis.lean | basisSpanSingleton_apply | null |
constr_basisSpanSingleton {N : Type*} [Semiring N] [Module N S] [SMulCommClass R N S]
(b : Basis ι R S) {x : S} (hx : x ≠ 0) :
(b.constr N).toFun (((↑) : _ → S) ∘ (basisSpanSingleton b hx)) = Algebra.lmul R S x :=
b.ext fun i => by simp | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.LinearAlgebra.Basis.Defs",
"Mathlib.LinearAlgebra.Basis.Submodule",
"Mathlib.RingTheory.Ideal.Span"
] | Mathlib/RingTheory/Ideal/Basis.lean | constr_basisSpanSingleton | null |
Basis.mem_ideal_iff {ι R S : Type*} [CommSemiring R] [Semiring S] [Algebra R S]
{I : Ideal S} (b : Basis ι R I) {x : S} :
x ∈ I ↔ ∃ c : ι →₀ R, x = Finsupp.sum c fun i x => x • (b i : S) :=
(b.map ((I.restrictScalarsEquiv R _ _).restrictScalars R).symm).mem_submodule_iff | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.LinearAlgebra.Basis.Defs",
"Mathlib.LinearAlgebra.Basis.Submodule",
"Mathlib.RingTheory.Ideal.Span"
] | Mathlib/RingTheory/Ideal/Basis.lean | Basis.mem_ideal_iff | If `I : Ideal S` has a basis over `R`,
`x ∈ I` iff it is a linear combination of basis vectors. |
Basis.mem_ideal_iff' {ι R S : Type*} [Fintype ι] [CommSemiring R] [Semiring S] [Algebra R S]
{I : Ideal S} (b : Basis ι R I) {x : S} : x ∈ I ↔ ∃ c : ι → R, x = ∑ i, c i • (b i : S) :=
(b.map ((I.restrictScalarsEquiv R _ _).restrictScalars R).symm).mem_submodule_iff' | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.LinearAlgebra.Basis.Defs",
"Mathlib.LinearAlgebra.Basis.Submodule",
"Mathlib.RingTheory.Ideal.Span"
] | Mathlib/RingTheory/Ideal/Basis.lean | Basis.mem_ideal_iff' | If `I : Ideal S` has a finite basis over `R`,
`x ∈ I` iff it is a linear combination of basis vectors. |
sum_mem (I : Ideal α) {ι : Type*} {t : Finset ι} {f : ι → α} :
(∀ c ∈ t, f c ∈ I) → (∑ i ∈ t, f i) ∈ I :=
Submodule.sum_mem I | theorem | RingTheory | [
"Mathlib.Algebra.Module.Submodule.Basic",
"Mathlib.RingTheory.Ideal.Defs"
] | Mathlib/RingTheory/Ideal/BigOperators.lean | sum_mem | null |
colon (N P : Submodule R M) : Ideal R where
carrier := {r : R | (r • P : Set M) ⊆ N}
add_mem' ha hb :=
(Set.add_smul_subset _ _ _).trans ((Set.add_subset_add ha hb).trans_eq (by simp))
zero_mem' := by simp [Set.zero_smul_set P.nonempty]
smul_mem' r := by
simp only [Set.mem_setOf_eq, smul_eq_mul, mul_smul, Set.smul_set_subset_iff]
intro x hx y hy
exact N.smul_mem _ (hx hy) | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.Pointwise.Set",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Colon.lean | colon | `N.colon P` is the ideal of all elements `r : R` such that `r • P ⊆ N`. |
mem_colon {r} : r ∈ N.colon P ↔ ∀ p ∈ P, r • p ∈ N := Set.smul_set_subset_iff | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Pointwise.Set",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Colon.lean | mem_colon | null |
@[simp]
colon_top {I : Ideal R} [I.IsTwoSided] : I.colon ⊤ = I := by
simp_rw [SetLike.ext_iff, mem_colon, smul_eq_mul]
exact fun x ↦ ⟨fun h ↦ mul_one x ▸ h 1 trivial, fun h _ _ ↦ I.mul_mem_right _ h⟩
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Pointwise.Set",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Colon.lean | colon_top | null |
colon_bot : colon ⊥ N = N.annihilator := by
simp_rw [SetLike.ext_iff, mem_colon, mem_annihilator, mem_bot, forall_const] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Pointwise.Set",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Colon.lean | colon_bot | null |
colon_mono (hn : N₁ ≤ N₂) (hp : P₁ ≤ P₂) : N₁.colon P₂ ≤ N₂.colon P₁ := fun _ hrnp =>
mem_colon.2 fun p₁ hp₁ => hn <| mem_colon.1 hrnp p₁ <| hp hp₁ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Pointwise.Set",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Colon.lean | colon_mono | null |
_root_.Ideal.le_colon {I J : Ideal R} [I.IsTwoSided] : I ≤ I.colon J := by
calc I = I.colon ⊤ := colon_top.symm
_ ≤ I.colon J := colon_mono (le_refl I) le_top | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Pointwise.Set",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Colon.lean | _root_.Ideal.le_colon | null |
mem_colon' {r} : r ∈ N.colon P ↔ P ≤ comap (r • (LinearMap.id : M →ₗ[R] M)) N :=
mem_colon | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Pointwise.Set",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Colon.lean | mem_colon' | null |
iInf_colon_iSup (ι₁ : Sort*) (f : ι₁ → Submodule R M) (ι₂ : Sort*)
(g : ι₂ → Submodule R M) : (⨅ i, f i).colon (⨆ j, g j) = ⨅ (i) (j), (f i).colon (g j) :=
le_antisymm (le_iInf fun _ => le_iInf fun _ => colon_mono (iInf_le _ _) (le_iSup _ _)) fun _ H =>
mem_colon'.2 <|
iSup_le fun j =>
map_le_iff_le_comap.1 <|
le_iInf fun i =>
map_le_iff_le_comap.2 <|
mem_colon'.1 <|
have := (mem_iInf _).1 H i
have := (mem_iInf _).1 this j
this
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Pointwise.Set",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Colon.lean | iInf_colon_iSup | null |
mem_colon_singleton {x : M} {r : R} : r ∈ N.colon (Submodule.span R {x}) ↔ r • x ∈ N :=
calc
r ∈ N.colon (Submodule.span R {x}) ↔ ∀ a : R, r • a • x ∈ N := by
simp [Submodule.mem_colon, Submodule.mem_span_singleton]
_ ↔ r • x ∈ N := by simp_rw [fun (a : R) ↦ smul_comm r a x]; exact SetLike.forall_smul_mem_iff
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Pointwise.Set",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Colon.lean | mem_colon_singleton | null |
_root_.Ideal.mem_colon_singleton {I : Ideal R} {x r : R} :
r ∈ I.colon (Ideal.span {x}) ↔ r * x ∈ I := by
simp only [← Ideal.submodule_span_eq, Submodule.mem_colon_singleton, smul_eq_mul] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Pointwise.Set",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Colon.lean | _root_.Ideal.mem_colon_singleton | null |
@[simp]
annihilator_map_mkQ_eq_colon : annihilator (P.map N.mkQ) = N.colon P := by
ext
rw [mem_annihilator, mem_colon]
exact ⟨fun H p hp ↦ (Quotient.mk_eq_zero N).1 (H (Quotient.mk p) (mem_map_of_mem hp)),
fun H _ ⟨p, hp, hpm⟩ ↦ hpm ▸ ((Quotient.mk_eq_zero N).2 <| H p hp)⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Ring.Action.Pointwise.Set",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Colon.lean | annihilator_map_mkQ_eq_colon | null |
annihilator_quotient : Module.annihilator R (M ⧸ N) = N.colon ⊤ := by
simp_rw [SetLike.ext_iff, Module.mem_annihilator, ← annihilator_map_mkQ_eq_colon, mem_annihilator,
map_top, LinearMap.range_eq_top.mpr (mkQ_surjective N), mem_top, forall_true_left,
forall_const] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Pointwise.Set",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Colon.lean | annihilator_quotient | null |
_root_.Ideal.annihilator_quotient {I : Ideal R} [I.IsTwoSided] :
Module.annihilator R (R ⧸ I) = I := by
rw [Submodule.annihilator_quotient, colon_top] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Pointwise.Set",
"Mathlib.LinearAlgebra.Quotient.Defs",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Colon.lean | _root_.Ideal.annihilator_quotient | null |
is a quotient module of `I`, but the alternative definition as an ideal of `R ⧸ I ^ 2` is
also given, and the two are `R`-equivalent as in `Ideal.cotangentEquivIdeal`.
Additional support is also given to the cotangent space `m ⧸ m ^ 2` of a local ring.
-/ | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | is | null |
Cotangent : Type _ := I ⧸ (I • ⊤ : Submodule R I)
deriving Inhabited, AddCommGroup, Module (R ⧸ I)
deriving instance Module S, IsScalarTower S S' for Cotangent I
variable [IsNoetherian R I] in deriving instance IsNoetherian R for Cotangent I | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | Cotangent | `I ⧸ I ^ 2` as a quotient of `I`. |
@[simps! -isSimp apply]
toCotangent : I →ₗ[R] I.Cotangent := Submodule.mkQ _ | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | toCotangent | The quotient map from `I` to `I ⧸ I ^ 2`. |
map_toCotangent_ker : (LinearMap.ker I.toCotangent).map I.subtype = I ^ 2 := by
rw [Ideal.toCotangent, Submodule.ker_mkQ, pow_two, Submodule.map_smul'' I ⊤ (Submodule.subtype I),
Algebra.id.smul_eq_mul, Submodule.map_subtype_top] | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | map_toCotangent_ker | null |
mem_toCotangent_ker {x : I} : x ∈ LinearMap.ker I.toCotangent ↔ (x : R) ∈ I ^ 2 := by
rw [← I.map_toCotangent_ker]
simp | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | mem_toCotangent_ker | null |
toCotangent_eq {x y : I} : I.toCotangent x = I.toCotangent y ↔ (x - y : R) ∈ I ^ 2 := by
rw [← sub_eq_zero]
exact I.mem_toCotangent_ker | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | toCotangent_eq | null |
toCotangent_eq_zero (x : I) : I.toCotangent x = 0 ↔ (x : R) ∈ I ^ 2 := I.mem_toCotangent_ker | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | toCotangent_eq_zero | null |
toCotangent_surjective : Function.Surjective I.toCotangent := Submodule.mkQ_surjective _ | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | toCotangent_surjective | null |
toCotangent_range : LinearMap.range I.toCotangent = ⊤ := Submodule.range_mkQ _ | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | toCotangent_range | null |
cotangent_subsingleton_iff : Subsingleton I.Cotangent ↔ IsIdempotentElem I := by
constructor
· intro H
refine (pow_two I).symm.trans (le_antisymm (Ideal.pow_le_self two_ne_zero) ?_)
exact fun x hx => (I.toCotangent_eq_zero ⟨x, hx⟩).mp (Subsingleton.elim _ _)
· exact fun e =>
⟨fun x y =>
Quotient.inductionOn₂' x y fun x y =>
I.toCotangent_eq.mpr <| ((pow_two I).trans e).symm ▸ I.sub_mem x.prop y.prop⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | cotangent_subsingleton_iff | null |
cotangentToQuotientSquare : I.Cotangent →ₗ[R] R ⧸ I ^ 2 :=
Submodule.mapQ (I • ⊤) (I ^ 2) I.subtype
(by
rw [← Submodule.map_le_iff_le_comap, Submodule.map_smul'', Submodule.map_top,
Submodule.range_subtype, smul_eq_mul, pow_two] ) | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | cotangentToQuotientSquare | The inclusion map `I ⧸ I ^ 2` to `R ⧸ I ^ 2`. |
to_quotient_square_comp_toCotangent :
I.cotangentToQuotientSquare.comp I.toCotangent = (I ^ 2).mkQ.comp (Submodule.subtype I) :=
LinearMap.ext fun _ => rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | to_quotient_square_comp_toCotangent | null |
toCotangent_to_quotient_square (x : I) :
I.cotangentToQuotientSquare (I.toCotangent x) = (I ^ 2).mkQ x := rfl | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | toCotangent_to_quotient_square | null |
Cotangent.smul_eq_zero_of_mem {I : Ideal R}
{x} (hx : x ∈ I) (m : I.Cotangent) : x • m = 0 := by
obtain ⟨m, rfl⟩ := Ideal.toCotangent_surjective _ m
rw [← map_smul, Ideal.toCotangent_eq_zero, pow_two]
exact Ideal.mul_mem_mul hx m.2 | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | Cotangent.smul_eq_zero_of_mem | null |
isTorsionBySet_cotangent :
Module.IsTorsionBySet R I.Cotangent I :=
fun m x ↦ m.smul_eq_zero_of_mem x.2 | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | isTorsionBySet_cotangent | null |
cotangentIdeal (I : Ideal R) : Ideal (R ⧸ I ^ 2) :=
Submodule.map (Quotient.mk (I ^ 2)|>.toSemilinearMap) I | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | cotangentIdeal | `I ⧸ I ^ 2` as an ideal of `R ⧸ I ^ 2`. |
cotangentIdeal_square (I : Ideal R) : I.cotangentIdeal ^ 2 = ⊥ := by
rw [eq_bot_iff, pow_two I.cotangentIdeal, ← smul_eq_mul]
intro x hx
refine Submodule.smul_induction_on hx ?_ ?_
· rintro _ ⟨x, hx, rfl⟩ _ ⟨y, hy, rfl⟩; apply (Submodule.Quotient.eq _).mpr _
rw [sub_zero, pow_two]; exact Ideal.mul_mem_mul hx hy
· intro x y hx hy; exact add_mem hx hy | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | cotangentIdeal_square | null |
mk_mem_cotangentIdeal {I : Ideal R} {x : R} :
Quotient.mk (I ^ 2) x ∈ I.cotangentIdeal ↔ x ∈ I := by
refine ⟨fun ⟨y, hy, e⟩ ↦ ?_, fun h ↦ ⟨x, h, rfl⟩⟩
simpa using sub_mem hy (Ideal.pow_le_self two_ne_zero
((Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp e)) | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | mk_mem_cotangentIdeal | null |
comap_cotangentIdeal (I : Ideal R) :
I.cotangentIdeal.comap (Quotient.mk (I ^ 2)) = I :=
Ideal.ext fun _ ↦ mk_mem_cotangentIdeal | lemma | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | comap_cotangentIdeal | null |
range_cotangentToQuotientSquare :
LinearMap.range I.cotangentToQuotientSquare = I.cotangentIdeal.restrictScalars R := by
trans LinearMap.range (I.cotangentToQuotientSquare.comp I.toCotangent)
· rw [LinearMap.range_comp, I.toCotangent_range, Submodule.map_top]
· rw [to_quotient_square_comp_toCotangent, LinearMap.range_comp, I.range_subtype]; ext; rfl | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | range_cotangentToQuotientSquare | null |
noncomputable cotangentEquivIdeal : I.Cotangent ≃ₗ[R] I.cotangentIdeal := by
refine
{ LinearMap.codRestrict (I.cotangentIdeal.restrictScalars R) I.cotangentToQuotientSquare
fun x => by rw [← range_cotangentToQuotientSquare]; exact LinearMap.mem_range_self _ _,
Equiv.ofBijective _ ⟨?_, ?_⟩ with }
· rintro x y e
replace e := congr_arg Subtype.val e
obtain ⟨x, rfl⟩ := I.toCotangent_surjective x
obtain ⟨y, rfl⟩ := I.toCotangent_surjective y
rw [I.toCotangent_eq]
dsimp only [toCotangent_to_quotient_square, Submodule.mkQ_apply] at e
rwa [Submodule.Quotient.eq] at e
· rintro ⟨_, x, hx, rfl⟩
exact ⟨I.toCotangent ⟨x, hx⟩, Subtype.ext rfl⟩
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | cotangentEquivIdeal | The equivalence of the two definitions of `I / I ^ 2`, either as the quotient of `I` or the
ideal of `R / I ^ 2`. |
cotangentEquivIdeal_apply (x : I.Cotangent) :
↑(I.cotangentEquivIdeal x) = I.cotangentToQuotientSquare x := rfl | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Ring.Idempotent",
"Mathlib.LinearAlgebra.Dimension.Finite",
"Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition",
"Mathlib.LinearAlgebra.FiniteDimensional.Defs",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Ideal.Operations",
"Mathlib.... | Mathlib/RingTheory/Ideal/Cotangent.lean | cotangentEquivIdeal_apply | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.