mathlib documentation

data.pi

Instances and theorems on pi types #

This file provides basic definitions and notation instances for Pi types.

Instances of more sophisticated classes are defined in pi.lean files elsewhere.

1, 0, +, *, -, ⁻¹, and / are defined pointwise.

@[instance]
def pi.has_zero {I : Type u} {f : I → Type v₁} [Π (i : I), has_zero (f i)] :
has_zero (Π (i : I), f i)
Equations
@[instance]
def pi.has_one {I : Type u} {f : I → Type v₁} [Π (i : I), has_one (f i)] :
has_one (Π (i : I), f i)
Equations
@[simp]
theorem pi.zero_apply {I : Type u} {f : I → Type v₁} (i : I) [Π (i : I), has_zero (f i)] :
0 i = 0
@[simp]
theorem pi.one_apply {I : Type u} {f : I → Type v₁} (i : I) [Π (i : I), has_one (f i)] :
1 i = 1
theorem pi.one_def {I : Type u} {f : I → Type v₁} [Π (i : I), has_one (f i)] :
1 = λ (i : I), 1
theorem pi.zero_def {I : Type u} {f : I → Type v₁} [Π (i : I), has_zero (f i)] :
0 = λ (i : I), 0
@[instance]
def pi.has_mul {I : Type u} {f : I → Type v₁} [Π (i : I), has_mul (f i)] :
has_mul (Π (i : I), f i)
Equations
@[instance]
def pi.has_add {I : Type u} {f : I → Type v₁} [Π (i : I), has_add (f i)] :
has_add (Π (i : I), f i)
Equations
@[simp]
theorem pi.add_apply {I : Type u} {f : I → Type v₁} (x y : Π (i : I), f i) (i : I) [Π (i : I), has_add (f i)] :
(x + y) i = x i + y i
@[simp]
theorem pi.mul_apply {I : Type u} {f : I → Type v₁} (x y : Π (i : I), f i) (i : I) [Π (i : I), has_mul (f i)] :
(x * y) i = (x i) * y i
theorem pi.mul_def {I : Type u} {f : I → Type v₁} (x y : Π (i : I), f i) [Π (i : I), has_mul (f i)] :
x * y = λ (i : I), (x i) * y i
theorem pi.add_def {I : Type u} {f : I → Type v₁} (x y : Π (i : I), f i) [Π (i : I), has_add (f i)] :
x + y = λ (i : I), x i + y i
@[instance]
def pi.has_inv {I : Type u} {f : I → Type v₁} [Π (i : I), has_inv (f i)] :
has_inv (Π (i : I), f i)
Equations
@[instance]
def pi.has_neg {I : Type u} {f : I → Type v₁} [Π (i : I), has_neg (f i)] :
has_neg (Π (i : I), f i)
Equations
@[simp]
theorem pi.neg_apply {I : Type u} {f : I → Type v₁} (x : Π (i : I), f i) (i : I) [Π (i : I), has_neg (f i)] :
(-x) i = -x i
@[simp]
theorem pi.inv_apply {I : Type u} {f : I → Type v₁} (x : Π (i : I), f i) (i : I) [Π (i : I), has_inv (f i)] :
x⁻¹ i = (x i)⁻¹
theorem pi.neg_def {I : Type u} {f : I → Type v₁} (x : Π (i : I), f i) [Π (i : I), has_neg (f i)] :
-x = λ (i : I), -x i
theorem pi.inv_def {I : Type u} {f : I → Type v₁} (x : Π (i : I), f i) [Π (i : I), has_inv (f i)] :
x⁻¹ = λ (i : I), (x i)⁻¹
@[instance]
def pi.has_sub {I : Type u} {f : I → Type v₁} [Π (i : I), has_sub (f i)] :
has_sub (Π (i : I), f i)
Equations
@[instance]
def pi.has_div {I : Type u} {f : I → Type v₁} [Π (i : I), has_div (f i)] :
has_div (Π (i : I), f i)
Equations
@[simp]
theorem pi.div_apply {I : Type u} {f : I → Type v₁} (x y : Π (i : I), f i) (i : I) [Π (i : I), has_div (f i)] :
(x / y) i = x i / y i
@[simp]
theorem pi.sub_apply {I : Type u} {f : I → Type v₁} (x y : Π (i : I), f i) (i : I) [Π (i : I), has_sub (f i)] :
(x - y) i = x i - y i
theorem pi.div_def {I : Type u} {f : I → Type v₁} (x y : Π (i : I), f i) [Π (i : I), has_div (f i)] :
x / y = λ (i : I), x i / y i
theorem pi.sub_def {I : Type u} {f : I → Type v₁} (x y : Π (i : I), f i) [Π (i : I), has_sub (f i)] :
x - y = λ (i : I), x i - y i
def pi.single {I : Type u} {f : I → Type v₁} [decidable_eq I] [Π (i : I), has_zero (f i)] (i : I) (x : f i) (i_1 : I) :
f i_1

The function supported at i, with value x there.

Equations
@[simp]
theorem pi.single_eq_same {I : Type u} {f : I → Type v₁} [decidable_eq I] [Π (i : I), has_zero (f i)] (i : I) (x : f i) :
pi.single i x i = x
@[simp]
theorem pi.single_eq_of_ne {I : Type u} {f : I → Type v₁} [decidable_eq I] [Π (i : I), has_zero (f i)] {i i' : I} (h : i' i) (x : f i) :
pi.single i x i' = 0
@[simp]
theorem pi.single_eq_of_ne' {I : Type u} {f : I → Type v₁} [decidable_eq I] [Π (i : I), has_zero (f i)] {i i' : I} (h : i i') (x : f i) :
pi.single i x i' = 0

Abbreviation for single_eq_of_ne h.symm, for ease of use by simp.

@[simp]
theorem pi.single_zero {I : Type u} {f : I → Type v₁} [decidable_eq I] [Π (i : I), has_zero (f i)] (i : I) :
pi.single i 0 = 0
theorem pi.single_apply {I : Type u} [decidable_eq I] {β : Type u_1} [has_zero β] (i : I) (x : β) (i' : I) :
pi.single i x i' = ite (i' = i) x 0

On non-dependent functions, pi.single can be expressed as an ite

theorem pi.single_comm {I : Type u} [decidable_eq I] {β : Type u_1} [has_zero β] (i : I) (x : β) (i' : I) :
pi.single i x i' = pi.single i' x i

On non-dependent functions, pi.single is symmetric in the two indices.

theorem pi.apply_single {I : Type u} {f : I → Type v₁} {g : I → Type v₂} [decidable_eq I] [Π (i : I), has_zero (f i)] [Π (i : I), has_zero (g i)] (f' : Π (i : I), f ig i) (hf' : ∀ (i : I), f' i 0 = 0) (i : I) (x : f i) (j : I) :
f' j (pi.single i x j) = pi.single i (f' i x) j
theorem pi.apply_single₂ {I : Type u} {f : I → Type v₁} {g : I → Type v₂} {h : I → Type v₃} [decidable_eq I] [Π (i : I), has_zero (f i)] [Π (i : I), has_zero (g i)] [Π (i : I), has_zero (h i)] (f' : Π (i : I), f ig ih i) (hf' : ∀ (i : I), f' i 0 0 = 0) (i : I) (x : f i) (y : g i) (j : I) :
f' j (pi.single i x j) (pi.single i y j) = pi.single i (f' i x y) j
theorem pi.single_op {I : Type u} {f : I → Type v₁} [decidable_eq I] [Π (i : I), has_zero (f i)] {g : I → Type u_1} [Π (i : I), has_zero (g i)] (op : Π (i : I), f ig i) (h : ∀ (i : I), op i 0 = 0) (i : I) (x : f i) :
pi.single i (op i x) = λ (j : I), op j (pi.single i x j)
theorem pi.single_op₂ {I : Type u} {f : I → Type v₁} [decidable_eq I] [Π (i : I), has_zero (f i)] {g₁ : I → Type u_1} {g₂ : I → Type u_2} [Π (i : I), has_zero (g₁ i)] [Π (i : I), has_zero (g₂ i)] (op : Π (i : I), g₁ ig₂ if i) (h : ∀ (i : I), op i 0 0 = 0) (i : I) (x₁ : g₁ i) (x₂ : g₂ i) :
pi.single i (op i x₁ x₂) = λ (j : I), op j (pi.single i x₁ j) (pi.single i x₂ j)
theorem pi.single_injective {I : Type u} (f : I → Type v₁) [decidable_eq I] [Π (i : I), has_zero (f i)] (i : I) :
theorem function.extend_one {α : Type u_1} {β : Type u_2} {γ : Type u_3} [has_one γ] (f : α → β) :
theorem function.extend_zero {α : Type u_1} {β : Type u_2} {γ : Type u_3} [has_zero γ] (f : α → β) :
theorem function.extend_add {α : Type u_1} {β : Type u_2} {γ : Type u_3} [has_add γ] (f : α → β) (g₁ g₂ : α → γ) (e₁ e₂ : β → γ) :
function.extend f (g₁ + g₂) (e₁ + e₂) = function.extend f g₁ e₁ + function.extend f g₂ e₂
theorem function.extend_mul {α : Type u_1} {β : Type u_2} {γ : Type u_3} [has_mul γ] (f : α → β) (g₁ g₂ : α → γ) (e₁ e₂ : β → γ) :
function.extend f (g₁ * g₂) (e₁ * e₂) = (function.extend f g₁ e₁) * function.extend f g₂ e₂
theorem function.extend_neg {α : Type u_1} {β : Type u_2} {γ : Type u_3} [has_neg γ] (f : α → β) (g : α → γ) (e : β → γ) :
theorem function.extend_inv {α : Type u_1} {β : Type u_2} {γ : Type u_3} [has_inv γ] (f : α → β) (g : α → γ) (e : β → γ) :
theorem function.extend_div {α : Type u_1} {β : Type u_2} {γ : Type u_3} [has_div γ] (f : α → β) (g₁ g₂ : α → γ) (e₁ e₂ : β → γ) :
function.extend f (g₁ / g₂) (e₁ / e₂) = function.extend f g₁ e₁ / function.extend f g₂ e₂
theorem function.extend_sub {α : Type u_1} {β : Type u_2} {γ : Type u_3} [has_sub γ] (f : α → β) (g₁ g₂ : α → γ) (e₁ e₂ : β → γ) :
function.extend f (g₁ - g₂) (e₁ - e₂) = function.extend f g₁ e₁ - function.extend f g₂ e₂
theorem subsingleton.pi_single_eq {I : Type u} {α : Type u_1} [decidable_eq I] [subsingleton I] [has_zero α] (i : I) (x : α) :
pi.single i x = λ (_x : I), x