Module docstring
{"# Zero and One instances on M × N
In this file we define 0 and 1 on M × N as the pair (0, 0) and (1, 1) respectively.
We also prove trivial simp lemmas:
"}
{"# Zero and One instances on M × N
In this file we define 0 and 1 on M × N as the pair (0, 0) and (1, 1) respectively.
We also prove trivial simp lemmas:
"}
Prod.instOne
instance
: One (M × N)
@[to_additive]
instance instOne : One (M × N) :=
⟨(1, 1)⟩
Prod.fst_one
theorem
: (1 : M × N).1 = 1
@[to_additive (attr := simp)]
theorem fst_one : (1 : M × N).1 = 1 :=
rfl
Prod.snd_one
theorem
: (1 : M × N).2 = 1
@[to_additive (attr := simp)]
theorem snd_one : (1 : M × N).2 = 1 :=
rfl
Prod.one_eq_mk
theorem
: (1 : M × N) = (1, 1)
@[to_additive]
theorem one_eq_mk : (1 : M × N) = (1, 1) :=
rfl
Prod.mk_one_one
theorem
: ((1 : M), (1 : N)) = 1
@[to_additive (attr := simp)]
theorem mk_one_one : ((1 : M), (1 : N)) = 1 := rfl
Prod.mk_eq_one
theorem
{x : M} {y : N} : (x, y) = 1 ↔ x = 1 ∧ y = 1
@[to_additive (attr := simp)]
theorem mk_eq_one {x : M} {y : N} : (x, y)(x, y) = 1 ↔ x = 1 ∧ y = 1 := mk_inj
Prod.swap_one
theorem
: (1 : M × N).swap = 1
@[to_additive (attr := simp)]
theorem swap_one : (1 : M × N).swap = 1 :=
rfl
Prod.instMul
instance
: Mul (M × N)
@[to_additive]
instance instMul : Mul (M × N) :=
⟨fun p q => ⟨p.1 * q.1, p.2 * q.2⟩⟩
Prod.fst_mul
theorem
(p q : M × N) : (p * q).1 = p.1 * q.1
Prod.snd_mul
theorem
(p q : M × N) : (p * q).2 = p.2 * q.2
Prod.mk_mul_mk
theorem
(a₁ a₂ : M) (b₁ b₂ : N) : (a₁, b₁) * (a₂, b₂) = (a₁ * a₂, b₁ * b₂)
@[to_additive (attr := simp)]
theorem mk_mul_mk (a₁ a₂ : M) (b₁ b₂ : N) : (a₁, b₁) * (a₂, b₂) = (a₁ * a₂, b₁ * b₂) := rfl
Prod.swap_mul
theorem
(p q : M × N) : (p * q).swap = p.swap * q.swap
Prod.mul_def
theorem
(p q : M × N) : p * q = (p.1 * q.1, p.2 * q.2)
@[to_additive]
theorem mul_def (p q : M × N) : p * q = (p.1 * q.1, p.2 * q.2) := rfl
Prod.instInv
instance
: Inv (G × H)
@[to_additive]
instance instInv : Inv (G × H) :=
⟨fun p => (p.1⁻¹, p.2⁻¹)⟩
Prod.fst_inv
theorem
(p : G × H) : p⁻¹.1 = p.1⁻¹
Prod.snd_inv
theorem
(p : G × H) : p⁻¹.2 = p.2⁻¹
Prod.inv_mk
theorem
(a : G) (b : H) : (a, b)⁻¹ = (a⁻¹, b⁻¹)
@[to_additive (attr := simp)]
theorem inv_mk (a : G) (b : H) : (a, b)(a, b)⁻¹ = (a⁻¹, b⁻¹) := rfl
Prod.swap_inv
theorem
(p : G × H) : p⁻¹.swap = p.swap⁻¹
Prod.instDiv
instance
: Div (G × H)
@[to_additive]
instance instDiv : Div (G × H) :=
⟨fun p q => ⟨p.1 / q.1, p.2 / q.2⟩⟩
Prod.fst_div
theorem
(a b : G × H) : (a / b).1 = a.1 / b.1
Prod.snd_div
theorem
(a b : G × H) : (a / b).2 = a.2 / b.2
Prod.mk_div_mk
theorem
(x₁ x₂ : G) (y₁ y₂ : H) : (x₁, y₁) / (x₂, y₂) = (x₁ / x₂, y₁ / y₂)
@[to_additive (attr := simp)]
theorem mk_div_mk (x₁ x₂ : G) (y₁ y₂ : H) : (x₁, y₁) / (x₂, y₂) = (x₁ / x₂, y₁ / y₂) := rfl
Prod.swap_div
theorem
(a b : G × H) : (a / b).swap = a.swap / b.swap
Prod.div_def
theorem
(a b : G × H) : a / b = (a.1 / b.1, a.2 / b.2)
@[to_additive] lemma div_def (a b : G × H) : a / b = (a.1 / b.1, a.2 / b.2) := rfl
Prod.instSMul
instance
: SMul M (α × β)
@[to_additive]
instance instSMul : SMul M (α × β) where smul a p := (a • p.1, a • p.2)
Prod.smul_fst
theorem
(a : M) (x : α × β) : (a • x).1 = a • x.1
Prod.smul_snd
theorem
(a : M) (x : α × β) : (a • x).2 = a • x.2
Prod.smul_mk
theorem
(a : M) (b : α) (c : β) : a • (b, c) = (a • b, a • c)
@[to_additive (attr := simp)]
lemma smul_mk (a : M) (b : α) (c : β) : a • (b, c) = (a • b, a • c) := rfl
Prod.smul_def
theorem
(a : M) (x : α × β) : a • x = (a • x.1, a • x.2)
@[to_additive]
lemma smul_def (a : M) (x : α × β) : a • x = (a • x.1, a • x.2) := rfl
Prod.smul_swap
theorem
(a : M) (x : α × β) : (a • x).swap = a • x.swap
Prod.instPow
instance
: Pow (α × β) E
@[to_additive existing instSMul]
instance instPow : Pow (α × β) E where pow p c := (p.1 ^ c, p.2 ^ c)
Prod.pow_fst
theorem
(p : α × β) (c : E) : (p ^ c).fst = p.fst ^ c
Prod.pow_snd
theorem
(p : α × β) (c : E) : (p ^ c).snd = p.snd ^ c
Prod.pow_mk
theorem
(a : α) (b : β) (c : E) : Prod.mk a b ^ c = Prod.mk (a ^ c) (b ^ c)
Prod.pow_def
theorem
(p : α × β) (c : E) : p ^ c = (p.1 ^ c, p.2 ^ c)
@[to_additive existing (reorder := 6 7) smul_def]
lemma pow_def (p : α × β) (c : E) : p ^ c = (p.1 ^ c, p.2 ^ c) := rfl
Prod.pow_swap
theorem
(p : α × β) (c : E) : (p ^ c).swap = p.swap ^ c