| import Mathlib.LinearAlgebra.Prod |
| import Mathlib.Tactic.Module |
| import Mathlib.Algebra.CharP.Two |
|
|
| namespace OAI |
|
|
| namespace ArExplicit |
|
|
| variable {k V : Type*} [Field k] [AddCommGroup V] [Module k V] |
|
|
| def twoActionMap (a b : k) : (V × V) →ₗ[k] (V × V) := |
| (a • LinearMap.fst k V V + LinearMap.snd k V V).prod |
| (b • LinearMap.fst k V V + LinearMap.snd k V V) |
|
|
| @[simp] theorem twoActionMap_apply (a b : k) (x y : V) : |
| twoActionMap a b (x, y) = (a • x + y, b • x + y) := rfl |
|
|
| private def twoActionInverse (a b : k) (p : V × V) : V × V := |
| let g := (a - b)⁻¹ • (p.1 - p.2) |
| (g, p.1 - a • g) |
|
|
| private theorem twoActionInverse_left (a b : k) (hab : a ≠ b) (p : V × V) : |
| twoActionInverse a b (twoActionMap a b p) = p := by |
| rcases p with ⟨x, y⟩ |
| have hd : a - b ≠ 0 := sub_ne_zero.mpr hab |
| have hsub : (a • x + y) - (b • x + y) = (a - b) • x := by module |
| have hx : (a - b)⁻¹ • ((a • x + y) - (b • x + y)) = x := by |
| rw [hsub, smul_smul, inv_mul_cancel₀ hd, one_smul] |
| change (_, _) = (x, y) |
| simp only [twoActionMap_apply, hx] |
| congr 1 |
| module |
|
|
| private theorem twoActionInverse_right (a b : k) (hab : a ≠ b) (p : V × V) : |
| twoActionMap a b (twoActionInverse a b p) = p := by |
| rcases p with ⟨u, v⟩ |
| have hd : a - b ≠ 0 := sub_ne_zero.mpr hab |
| let g : V := (a - b)⁻¹ • (u - v) |
| have hg : (a - b) • g = u - v := by |
| dsimp [g] |
| rw [smul_smul, mul_inv_cancel₀ hd, one_smul] |
| change (a • g + (u - a • g), b • g + (u - a • g)) = (u, v) |
| apply Prod.ext |
| · module |
| · calc |
| b • g + (u - a • g) = u - (a - b) • g := by module |
| _ = v := by rw [hg] |
|
|
| def twoActionEquiv (a b : k) (hab : a ≠ b) : (V × V) ≃ₗ[k] (V × V) where |
| toLinearMap := twoActionMap a b |
| invFun := twoActionInverse a b |
| left_inv := twoActionInverse_left a b hab |
| right_inv := twoActionInverse_right a b hab |
|
|
| theorem twoActionMap_bijective (a b : k) (hab : a ≠ b) : |
| Function.Bijective (twoActionMap a b : (V × V) → V × V) := |
| (twoActionEquiv a b hab).bijective |
| |
| def degreeZeroMap : (V × V) →ₗ[k] V := |
| LinearMap.fst k V V + LinearMap.snd k V V |
|
|
| theorem degreeZeroMap_surjective : |
| Function.Surjective (degreeZeroMap (k := k) : (V × V) → V) := by |
| intro v |
| exact ⟨(v, 0), add_zero v⟩ |
|
|
| theorem degreeZeroMap_kernel [CharP k 2] (x y : V) : |
| degreeZeroMap (k := k) (x, y) = 0 ↔ x = y := by |
| change x + y = 0 ↔ x = y |
| rw [add_eq_zero_iff_eq_neg] |
| have hy : -y = y := by |
| have htwo : (2 : k) = 0 := CharP.cast_eq_zero k 2 |
| have : y + y = 0 := by rw [← two_smul k y, htwo, zero_smul] |
| exact neg_eq_iff_add_eq_zero.mpr this |
| rw [hy] |
|
|
| theorem twoActionMap_same_not_injective [Nontrivial V] (a : k) : |
| ¬ Function.Injective (twoActionMap a a : (V × V) → V × V) := by |
| obtain ⟨x, hx⟩ := exists_ne (0 : V) |
| intro hinj |
| have h : twoActionMap a a (x, -(a • x)) = twoActionMap a a (0, 0) := by |
| simp |
| have he := congrArg Prod.fst (hinj h) |
| exact hx he |
|
|
| end ArExplicit |
|
|
| end OAI |
|
|
