ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Fintype.piFinset_inv
@[to_additive (attr := simp)]
lemma piFinset_inv [∀ i, Inv (α i)] (s : ∀ i, Finset (α i)) :
    piFinset (fun i ↦ (s i)⁻¹) = (piFinset s)⁻¹ 
Arguments: {ι : Type u_5} {α : ι → Type u_6} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] [(i : ι) → Inv (α i)] (s : (i : ι) → Finset (α i))
Goal: (Fintype.piFinset fun i => (s i)⁻¹) = (Fintype.piFinset s)⁻¹
-- Fintype.piFinset_vadd
@[to_additive]
lemma piFinset_smul [∀ i, SMul (α i) (β i)] (s : ∀ i, Finset (α i)) (t : ∀ i, Finset (β i)) :
    piFinset (fun i ↦ s i • t i) = piFinset s • piFinset t 
Arguments: {ι : Type u_5} {α : ι → Type u_6} {β : ι → Type u_7} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (β i)] [(i : ι) → VAdd (α i) (β i)] (s : (i : ι) → Finset (α i)) (t : (i : ι) → Finset (β i))
Goal: (Fintype.piFinset fun i => s i +ᵥ t i) = Fintype.piFinset s +ᵥ Fintype.piFinset t
-- Fintype.piFinset_smul
@[to_additive]
lemma piFinset_smul [∀ i, SMul (α i) (β i)] (s : ∀ i, Finset (α i)) (t : ∀ i, Finset (β i)) :
    piFinset (fun i ↦ s i • t i) = piFinset s • piFinset t 
Arguments: {ι : Type u_5} {α : ι → Type u_6} {β : ι → Type u_7} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (β i)] [(i : ι) → SMul (α i) (β i)] (s : (i : ι) → Finset (α i)) (t : (i : ι) → Finset (β i))
Goal: (Fintype.piFinset fun i => s i • t i) = Fintype.piFinset s • Fintype.piFinset t
-- Fintype.piFinset_vadd_finset
@[to_additive]
lemma piFinset_smul_finset [∀ i, SMul (α i) (β i)] (a : ∀ i, α i) (s : ∀ i, Finset (β i)) :
    piFinset (fun i ↦ a i • s i) = a • piFinset s 
Arguments: {ι : Type u_5} {α : ι → Type u_6} {β : ι → Type u_7} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (β i)] [(i : ι) → VAdd (α i) (β i)] (a : (i : ι) → α i) (s : (i : ι) → Finset (β i))
Goal: (Fintype.piFinset fun i => a i +ᵥ s i) = a +ᵥ Fintype.piFinset s
-- Fintype.piFinset_smul_finset
@[to_additive]
lemma piFinset_smul_finset [∀ i, SMul (α i) (β i)] (a : ∀ i, α i) (s : ∀ i, Finset (β i)) :
    piFinset (fun i ↦ a i • s i) = a • piFinset s 
Arguments: {ι : Type u_5} {α : ι → Type u_6} {β : ι → Type u_7} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (β i)] [(i : ι) → SMul (α i) (β i)] (a : (i : ι) → α i) (s : (i : ι) → Finset (β i))
Goal: (Fintype.piFinset fun i => a i • s i) = a • Fintype.piFinset s
-- Set.toFinset_one
@[to_additive (attr := simp)]
theorem toFinset_one : (1 : Set α).toFinset = 1 
Arguments: {α : Type u_2} [One α]
Goal: Set.toFinset 1 = 1
-- Set.toFinset_zero
@[to_additive (attr := simp)]
theorem toFinset_one : (1 : Set α).toFinset = 1 
Arguments: {α : Type u_2} [Zero α]
Goal: Set.toFinset 0 = 0
-- Set.Finite.toFinset_one
@[to_additive (attr := simp high)]
theorem Finite.toFinset_one (h : (1 : Set α).Finite := finite_one) : h.toFinset = 1 
Arguments: {α : Type u_2} [One α] (h : Set.Finite 1 := ⋯)
Goal: Set.Finite.toFinset h = 1
-- Set.Finite.toFinset_zero
@[to_additive (attr := simp high)]
theorem Finite.toFinset_one (h : (1 : Set α).Finite := finite_one) : h.toFinset = 1 
Arguments: {α : Type u_2} [Zero α] (h : Set.Finite 0 := ⋯)
Goal: Set.Finite.toFinset h = 0
-- Set.toFinset_mul
@[to_additive (attr := simp)]
theorem toFinset_mul (s t : Set α) [Fintype s] [Fintype t] [Fintype ↑(s * t)] :
    (s * t).toFinset = s.toFinset * t.toFinset 
Arguments: {α : Type u_2} [DecidableEq α] [Mul α] (s t : Set α) [Fintype ↑s] [Fintype ↑t] [Fintype ↑(s * t)]
Goal: (s * t).toFinset = s.toFinset * t.toFinset
-- Set.toFinset_add
@[to_additive (attr := simp)]
theorem toFinset_mul (s t : Set α) [Fintype s] [Fintype t] [Fintype ↑(s * t)] :
    (s * t).toFinset = s.toFinset * t.toFinset 
Arguments: {α : Type u_2} [DecidableEq α] [Add α] (s t : Set α) [Fintype ↑s] [Fintype ↑t] [Fintype ↑(s + t)]
Goal: (s + t).toFinset = s.toFinset + t.toFinset
-- Set.Finite.toFinset_add
@[to_additive]
theorem Finite.toFinset_mul (hs : s.Finite) (ht : t.Finite) (hf := hs.mul ht) :
    hf.toFinset = hs.toFinset * ht.toFinset 
Arguments: {α : Type u_2} [DecidableEq α] [Add α] {s t : Set α} (hs : s.Finite) (ht : t.Finite) (hf : (s + t).Finite := ⋯)
Goal: Set.Finite.toFinset hf = hs.toFinset + ht.toFinset
-- Set.Finite.toFinset_mul
@[to_additive]
theorem Finite.toFinset_mul (hs : s.Finite) (ht : t.Finite) (hf := hs.mul ht) :
    hf.toFinset = hs.toFinset * ht.toFinset 
Arguments: {α : Type u_2} [DecidableEq α] [Mul α] {s t : Set α} (hs : s.Finite) (ht : t.Finite) (hf : (s * t).Finite := ⋯)
Goal: Set.Finite.toFinset hf = hs.toFinset * ht.toFinset
-- Set.toFinset_vadd
@[to_additive (attr := simp)]
theorem toFinset_smul (s : Set α) (t : Set β) [Fintype s] [Fintype t] [Fintype ↑(s • t)] :
    (s • t).toFinset = s.toFinset • t.toFinset 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] [DecidableEq β] (s : Set α) (t : Set β) [Fintype ↑s] [Fintype ↑t] [Fintype ↑(s +ᵥ t)]
Goal: (s +ᵥ t).toFinset = s.toFinset +ᵥ t.toFinset
-- Set.toFinset_smul
@[to_additive (attr := simp)]
theorem toFinset_smul (s : Set α) (t : Set β) [Fintype s] [Fintype t] [Fintype ↑(s • t)] :
    (s • t).toFinset = s.toFinset • t.toFinset 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] [DecidableEq β] (s : Set α) (t : Set β) [Fintype ↑s] [Fintype ↑t] [Fintype ↑(s • t)]
Goal: (s • t).toFinset = s.toFinset • t.toFinset
-- Set.Finite.toFinset_vadd
@[to_additive]
theorem Finite.toFinset_smul (hs : s.Finite) (ht : t.Finite) (hf := hs.smul ht) :
    hf.toFinset = hs.toFinset • ht.toFinset 
Arguments: {α : Type u_2} {β : Type u_3} [VAdd α β] [DecidableEq β] {s : Set α} {t : Set β} (hs : s.Finite) (ht : t.Finite) (hf : (s +ᵥ t).Finite := ⋯)
Goal: Set.Finite.toFinset hf = hs.toFinset +ᵥ ht.toFinset
-- Set.Finite.toFinset_smul
@[to_additive]
theorem Finite.toFinset_smul (hs : s.Finite) (ht : t.Finite) (hf := hs.smul ht) :
    hf.toFinset = hs.toFinset • ht.toFinset 
Arguments: {α : Type u_2} {β : Type u_3} [SMul α β] [DecidableEq β] {s : Set α} {t : Set β} (hs : s.Finite) (ht : t.Finite) (hf : (s • t).Finite := ⋯)
Goal: Set.Finite.toFinset hf = hs.toFinset • ht.toFinset
-- Set.toFinset_vadd_set
@[to_additive (attr := simp)]
theorem toFinset_smul_set (a : α) (s : Set β) [Fintype s] [Fintype ↑(a • s)] :
    (a • s).toFinset = a • s.toFinset 
Arguments: {α : Type u_2} {β : Type u_3} [DecidableEq β] [VAdd α β] (a : α) (s : Set β) [Fintype ↑s] [Fintype ↑(a +ᵥ s)]
Goal: (a +ᵥ s).toFinset = a +ᵥ s.toFinset
-- Set.toFinset_smul_set
@[to_additive (attr := simp)]
theorem toFinset_smul_set (a : α) (s : Set β) [Fintype s] [Fintype ↑(a • s)] :
    (a • s).toFinset = a • s.toFinset 
Arguments: {α : Type u_2} {β : Type u_3} [DecidableEq β] [SMul α β] (a : α) (s : Set β) [Fintype ↑s] [Fintype ↑(a • s)]
Goal: (a • s).toFinset = a • s.toFinset
-- Set.Finite.toFinset_vadd_set
@[to_additive]
theorem Finite.toFinset_smul_set (hs : s.Finite) (hf : (a • s).Finite := hs.smul_set) :
    hf.toFinset = a • hs.toFinset 
Arguments: {α : Type u_2} {β : Type u_3} [DecidableEq β] [VAdd α β] {a : α} {s : Set β} (hs : s.Finite) (hf : (a +ᵥ s).Finite := ⋯)
Goal: Set.Finite.toFinset hf = a +ᵥ hs.toFinset
-- Set.Finite.toFinset_smul_set
@[to_additive]
theorem Finite.toFinset_smul_set (hs : s.Finite) (hf : (a • s).Finite := hs.smul_set) :
    hf.toFinset = a • hs.toFinset 
Arguments: {α : Type u_2} {β : Type u_3} [DecidableEq β] [SMul α β] {a : α} {s : Set β} (hs : s.Finite) (hf : (a • s).Finite := ⋯)
Goal: Set.Finite.toFinset hf = a • hs.toFinset
-- Set.toFinset_vsub
@[simp]
theorem toFinset_vsub (s t : Set β) [Fintype s] [Fintype t] [Fintype ↑(s -ᵥ t)] :
    (s -ᵥ t : Set α).toFinset = s.toFinset -ᵥ t.toFinset 
Arguments: {α : Type u_2} {β : Type u_3} [DecidableEq α] [VSub α β] (s t : Set β) [Fintype ↑s] [Fintype ↑t] [Fintype ↑(s -ᵥ t)]
Goal: (s -ᵥ t).toFinset = s.toFinset -ᵥ t.toFinset
-- Set.Finite.toFinset_vsub
theorem Finite.toFinset_vsub (hs : s.Finite) (ht : t.Finite) (hf := hs.vsub ht) :
    hf.toFinset = hs.toFinset -ᵥ ht.toFinset 
Arguments: {α : Type u_2} {β : Type u_3} [DecidableEq α] [VSub α β] {s t : Set β} (hs : s.Finite) (ht : t.Finite) (hf : (s -ᵥ t).Finite := ⋯)
Goal: Set.Finite.toFinset hf = hs.toFinset -ᵥ ht.toFinset
-- Set.card_vadd_set
@[to_additive (attr := simp)]
lemma card_smul_set (a : α) (s : Set β) : Nat.card ↥(a • s) = Nat.card s 
Arguments: {α : Type u_2} {β : Type u_3} [AddGroup α] [AddAction α β] (a : α) (s : Set β)
Goal: Nat.card ↑(a +ᵥ s) = Nat.card ↑s
-- Set.card_smul_set
@[to_additive (attr := simp)]
lemma card_smul_set (a : α) (s : Set β) : Nat.card ↥(a • s) = Nat.card s 
Arguments: {α : Type u_2} {β : Type u_3} [Group α] [MulAction α β] (a : α) (s : Set β)
Goal: Nat.card ↑(a • s) = Nat.card ↑s
-- Set.card_add_le
@[to_additive]
lemma card_mul_le : Nat.card (s * t) ≤ Nat.card s * Nat.card t 
Arguments: {α : Type u_2} [Add α] [IsCancelAdd α] {s t : Set α}
Goal: Nat.card ↑(s + t) ≤ Nat.card ↑s * Nat.card ↑t
-- Set.card_mul_le
@[to_additive]
lemma card_mul_le : Nat.card (s * t) ≤ Nat.card s * Nat.card t 
Arguments: {α : Type u_2} [Mul α] [IsCancelMul α] {s t : Set α}
Goal: Nat.card ↑(s * t) ≤ Nat.card ↑s * Nat.card ↑t
-- Set.card_inv
@[to_additive (attr := simp)]
lemma card_inv (s : Set α) : Nat.card ↥(s⁻¹) = Nat.card s 
Arguments: {α : Type u_2} [InvolutiveInv α] (s : Set α)
Goal: Nat.card ↑s⁻¹ = Nat.card ↑s
-- Set.card_neg
@[to_additive (attr := simp)]
lemma card_inv (s : Set α) : Nat.card ↥(s⁻¹) = Nat.card s 
Arguments: {α : Type u_2} [InvolutiveNeg α] (s : Set α)
Goal: Nat.card ↑(-s) = Nat.card ↑s
-- Set.card_sub_le
@[to_additive]
lemma card_div_le : Nat.card (s / t) ≤ Nat.card s * Nat.card t 
Arguments: {α : Type u_2} [AddGroup α] {s t : Set α}
Goal: Nat.card ↑(s - t) ≤ Nat.card ↑s * Nat.card ↑t
-- Set.card_div_le
@[to_additive]
lemma card_div_le : Nat.card (s / t) ≤ Nat.card s * Nat.card t 
Arguments: {α : Type u_2} [Group α] {s t : Set α}
Goal: Nat.card ↑(s / t) ≤ Nat.card ↑s * Nat.card ↑t
-- Matrix.empty_eq
theorem empty_eq (v : Fin 0 → α) : v = ![] 
Arguments: {α : Type u} (v : Fin 0 → α)
Goal: v = ![]
-- Matrix.head_fin_const
@[simp]
theorem head_fin_const (a : α) : (vecHead fun _ : Fin (n + 1) => a) = a 
Arguments: {α : Type u} {n : ℕ} (a : α)
Goal: (Matrix.vecHead fun x => a) = a
-- Matrix.cons_val_zero
@[simp]
theorem cons_val_zero (x : α) (u : Fin m → α) : vecCons x u 0 = x 
Arguments: {α : Type u} {m : ℕ} (x : α) (u : Fin m → α)
Goal: Matrix.vecCons x u 0 = x
-- Matrix.cons_val_zero'
theorem cons_val_zero' (h : 0 < m.succ) (x : α) (u : Fin m → α) : vecCons x u ⟨0, h⟩ = x 
Arguments: {α : Type u} {m : ℕ} (h : 0 < m.succ) (x : α) (u : Fin m → α)
Goal: Matrix.vecCons x u ⟨0, h⟩ = x
-- Matrix.cons_val_succ
@[simp]
theorem cons_val_succ (x : α) (u : Fin m → α) (i : Fin m) : vecCons x u i.succ = u i 
Arguments: {α : Type u} {m : ℕ} (x : α) (u : Fin m → α) (i : Fin m)
Goal: Matrix.vecCons x u i.succ = u i
-- Matrix.cons_val_succ'
@[simp]
theorem cons_val_succ' {i : ℕ} (h : i.succ < m.succ) (x : α) (u : Fin m → α) :
    vecCons x u ⟨i.succ, h⟩ = u ⟨i, Nat.lt_of_succ_lt_succ h⟩ 
Arguments: {α : Type u} {m i : ℕ} (h : i.succ < m.succ) (x : α) (u : Fin m → α)
Goal: Matrix.vecCons x u ⟨i.succ, h⟩ = u ⟨i, ⋯⟩
-- Matrix.head_cons
@[simp]
theorem head_cons (x : α) (u : Fin m → α) : vecHead (vecCons x u) = x 
Arguments: {α : Type u} {m : ℕ} (x : α) (u : Fin m → α)
Goal: Matrix.vecHead (Matrix.vecCons x u) = x
-- Matrix.tail_cons
@[simp]
theorem tail_cons (x : α) (u : Fin m → α) : vecTail (vecCons x u) = u 
Arguments: {α : Type u} {m : ℕ} (x : α) (u : Fin m → α)
Goal: Matrix.vecTail (Matrix.vecCons x u) = u
-- Matrix.empty_val'
@[simp]
theorem empty_val' {n' : Type*} (j : n') : (fun i => (![] : Fin 0 → n' → α) i j) = ![] 
Arguments: {α : Type u} {n' : Type u_4} (j : n')
Goal: (fun i => ![] i j) = ![]
-- Matrix.cons_head_tail
@[simp]
theorem cons_head_tail (u : Fin m.succ → α) : vecCons (vecHead u) (vecTail u) = u 
Arguments: {α : Type u} {m : ℕ} (u : Fin m.succ → α)
Goal: Matrix.vecCons (Matrix.vecHead u) (Matrix.vecTail u) = u
-- Matrix.range_cons
@[simp]
theorem range_cons (x : α) (u : Fin n → α) : Set.range (vecCons x u) = {x} ∪ Set.range u 
Arguments: {α : Type u} {n : ℕ} (x : α) (u : Fin n → α)
Goal: Set.range (Matrix.vecCons x u) = {x} ∪ Set.range u
-- Matrix.range_empty
@[simp]
theorem range_empty (u : Fin 0 → α) : Set.range u = ∅ 
Arguments: {α : Type u} (u : Fin 0 → α)
Goal: Set.range u = ∅
-- Matrix.range_cons_empty
theorem range_cons_empty (x : α) (u : Fin 0 → α) : Set.range (Matrix.vecCons x u) = {x} 
Arguments: {α : Type u} (x : α) (u : Fin 0 → α)
Goal: Set.range (Matrix.vecCons x u) = {x}
-- Matrix.range_cons_cons_empty
theorem range_cons_cons_empty (x y : α) (u : Fin 0 → α) :
    Set.range (vecCons x <| vecCons y u) = {x, y} 
Arguments: {α : Type u} (x y : α) (u : Fin 0 → α)
Goal: Set.range (Matrix.vecCons x (Matrix.vecCons y u)) = {x, y}
-- Matrix.vecCons_const
@[simp]
theorem vecCons_const (a : α) : (vecCons a fun _ : Fin n => a) = fun _ => a 
Arguments: {α : Type u} {n : ℕ} (a : α)
Goal: (Matrix.vecCons a fun x => a) = fun x => a
-- Matrix.vec_single_eq_const
theorem vec_single_eq_const (a : α) : ![a] = fun _ => a 
Arguments: {α : Type u} (a : α)
Goal: ![a] = fun x => a
-- Matrix.cons_val_one
@[simp]
theorem cons_val_one (x : α) (u : Fin m.succ → α) : vecCons x u 1 = vecHead u 
Arguments: {α : Type u} {m : ℕ} (x : α) (u : Fin m.succ → α)
Goal: Matrix.vecCons x u 1 = Matrix.vecHead u
-- Matrix.cons_val_two
@[simp]
theorem cons_val_two (x : α) (u : Fin m.succ.succ → α) : vecCons x u 2 = vecHead (vecTail u) 
Arguments: {α : Type u} {m : ℕ} (x : α) (u : Fin m.succ.succ → α)
Goal: Matrix.vecCons x u 2 = Matrix.vecHead (Matrix.vecTail u)
-- Matrix.cons_val_three
@[simp]
lemma cons_val_three (x : α) (u : Fin m.succ.succ.succ → α) :
    vecCons x u 3 = vecHead (vecTail (vecTail u)) 
Arguments: {α : Type u} {m : ℕ} (x : α) (u : Fin m.succ.succ.succ → α)
Goal: Matrix.vecCons x u 3 = Matrix.vecHead (Matrix.vecTail (Matrix.vecTail u))
-- Matrix.cons_val_four
@[simp]
lemma cons_val_four (x : α) (u : Fin m.succ.succ.succ.succ → α) :
    vecCons x u 4 = vecHead (vecTail (vecTail (vecTail u))) 
Arguments: {α : Type u} {m : ℕ} (x : α) (u : Fin m.succ.succ.succ.succ → α)
Goal: Matrix.vecCons x u 4 = Matrix.vecHead (Matrix.vecTail (Matrix.vecTail (Matrix.vecTail u)))
-- Matrix.cons_val_fin_one
@[simp]
theorem cons_val_fin_one (x : α) (u : Fin 0 → α) : ∀ (i : Fin 1), vecCons x u i = x 
Arguments: {α : Type u} (x : α) (u : Fin 0 → α) (i : Fin 1)
Goal: Matrix.vecCons x u i = x
-- Matrix.cons_fin_one
theorem cons_fin_one (x : α) (u : Fin 0 → α) : vecCons x u = fun _ => x 
Arguments: {α : Type u} (x : α) (u : Fin 0 → α)
Goal: Matrix.vecCons x u = fun x_1 => x
-- Matrix.vecAppend_eq_ite
theorem vecAppend_eq_ite {α : Type*} {o : ℕ} (ho : o = m + n) (u : Fin m → α) (v : Fin n → α) :
    vecAppend ho u v = fun i : Fin o =>
      if h : (i : ℕ) < m then u ⟨i, h⟩ else v ⟨(i : ℕ) - m, by omega⟩ 
Arguments: {m n : ℕ} {α : Type u_4} {o : ℕ} (ho : o = m + n) (u : Fin m → α) (v : Fin n → α)
Goal: Matrix.vecAppend ho u v = fun i => if h : ↑i < m then u ⟨↑i, h⟩ else v ⟨↑i - m, ⋯⟩
-- Matrix.vecAppend_apply_zero
@[simp]
theorem vecAppend_apply_zero {α : Type*} {o : ℕ} (ho : o + 1 = m + 1 + n) (u : Fin (m + 1) → α)
    (v : Fin n → α) : vecAppend ho u v 0 = u 0 
Arguments: {m n : ℕ} {α : Type u_4} {o : ℕ} (ho : o + 1 = m + 1 + n) (u : Fin (m + 1) → α) (v : Fin n → α)
Goal: Matrix.vecAppend ho u v 0 = u 0
-- Matrix.empty_vecAppend
@[simp]
theorem empty_vecAppend (v : Fin n → α) : vecAppend n.zero_add.symm ![] v = v 
Arguments: {α : Type u} {n : ℕ} (v : Fin n → α)
Goal: Matrix.vecAppend ⋯ ![] v = v
-- Matrix.cons_vecAppend
@[simp]
theorem cons_vecAppend (ho : o + 1 = m + 1 + n) (x : α) (u : Fin m → α) (v : Fin n → α) :
    vecAppend ho (vecCons x u) v = vecCons x (vecAppend (by omega) u v) 
Arguments: {α : Type u} {m n o : ℕ} (ho : o + 1 = m + 1 + n) (x : α) (u : Fin m → α) (v : Fin n → α)
Goal: Matrix.vecAppend ho (Matrix.vecCons x u) v = Matrix.vecCons x (Matrix.vecAppend ⋯ u v)
-- Matrix.vecAlt0_vecAppend
theorem vecAlt0_vecAppend (v : Fin n → α) :
    vecAlt0 rfl (vecAppend rfl v v) = v ∘ (fun n ↦ n + n) 
Arguments: {α : Type u} {n : ℕ} (v : Fin n → α)
Goal: Matrix.vecAlt0 ⋯ (Matrix.vecAppend ⋯ v v) = v ∘ fun n_1 => n_1 + n_1
-- Matrix.vecAlt1_vecAppend
theorem vecAlt1_vecAppend (v : Fin (n + 1) → α) :
    vecAlt1 rfl (vecAppend rfl v v) = v ∘ (fun n ↦ (n + n) + 1) 
Arguments: {α : Type u} {n : ℕ} (v : Fin (n + 1) → α)
Goal: Matrix.vecAlt1 ⋯ (Matrix.vecAppend ⋯ v v) = v ∘ fun n_1 => n_1 + n_1 + 1
-- Matrix.vecHead_vecAlt0
@[simp]
theorem vecHead_vecAlt0 (hm : m + 2 = n + 1 + (n + 1)) (v : Fin (m + 2) → α) :
    vecHead (vecAlt0 hm v) = v 0 
Arguments: {α : Type u} {m n : ℕ} (hm : m + 2 = n + 1 + (n + 1)) (v : Fin (m + 2) → α)
Goal: Matrix.vecHead (Matrix.vecAlt0 hm v) = v 0
-- Matrix.vecHead_vecAlt1
@[simp]
theorem vecHead_vecAlt1 (hm : m + 2 = n + 1 + (n + 1)) (v : Fin (m + 2) → α) :
    vecHead (vecAlt1 hm v) = v 1 
Arguments: {α : Type u} {m n : ℕ} (hm : m + 2 = n + 1 + (n + 1)) (v : Fin (m + 2) → α)
Goal: Matrix.vecHead (Matrix.vecAlt1 hm v) = v 1
-- Matrix.cons_vec_bit0_eq_alt0
@[simp]
theorem cons_vec_bit0_eq_alt0 (x : α) (u : Fin n → α) (i : Fin (n + 1)) :
    vecCons x u (i + i) = vecAlt0 rfl (vecAppend rfl (vecCons x u) (vecCons x u)) i 
Arguments: {α : Type u} {n : ℕ} (x : α) (u : Fin n → α) (i : Fin (n + 1))
Goal: Matrix.vecCons x u (i + i) = Matrix.vecAlt0 ⋯ (Matrix.vecAppend ⋯ (Matrix.vecCons x u) (Matrix.vecCons x u)) i
-- Matrix.cons_vec_bit1_eq_alt1
@[simp]
theorem cons_vec_bit1_eq_alt1 (x : α) (u : Fin n → α) (i : Fin (n + 1)) :
    vecCons x u ((i + i) + 1) = vecAlt1 rfl (vecAppend rfl (vecCons x u) (vecCons x u)) i 
Arguments: {α : Type u} {n : ℕ} (x : α) (u : Fin n → α) (i : Fin (n + 1))
Goal: Matrix.vecCons x u (i + i + 1) = Matrix.vecAlt1 ⋯ (Matrix.vecAppend ⋯ (Matrix.vecCons x u) (Matrix.vecCons x u)) i
-- Matrix.cons_vecAlt0
@[simp]
theorem cons_vecAlt0 (h : m + 1 + 1 = n + 1 + (n + 1)) (x y : α) (u : Fin m → α) :
    vecAlt0 h (vecCons x (vecCons y u)) = vecCons x (vecAlt0 (by omega) u) 
Arguments: {α : Type u} {m n : ℕ} (h : m + 1 + 1 = n + 1 + (n + 1)) (x y : α) (u : Fin m → α)
Goal: Matrix.vecAlt0 h (Matrix.vecCons x (Matrix.vecCons y u)) = Matrix.vecCons x (Matrix.vecAlt0 ⋯ u)
-- Matrix.empty_vecAlt0
@[simp]
theorem empty_vecAlt0 (α) {h} : vecAlt0 h (![] : Fin 0 → α) = ![] 
Arguments: (α : Type u_4) {h : 0 = 0 + 0}
Goal: Matrix.vecAlt0 h ![] = ![]
-- Matrix.cons_vecAlt1
@[simp]
theorem cons_vecAlt1 (h : m + 1 + 1 = n + 1 + (n + 1)) (x y : α) (u : Fin m → α) :
    vecAlt1 h (vecCons x (vecCons y u)) = vecCons y (vecAlt1 (by omega) u) 
Arguments: {α : Type u} {m n : ℕ} (h : m + 1 + 1 = n + 1 + (n + 1)) (x y : α) (u : Fin m → α)
Goal: Matrix.vecAlt1 h (Matrix.vecCons x (Matrix.vecCons y u)) = Matrix.vecCons y (Matrix.vecAlt1 ⋯ u)
-- Matrix.empty_vecAlt1
@[simp]
theorem empty_vecAlt1 (α) {h} : vecAlt1 h (![] : Fin 0 → α) = ![] 
Arguments: (α : Type u_4) {h : 0 = 0 + 0}
Goal: Matrix.vecAlt1 h ![] = ![]
-- Matrix.const_fin1_eq
lemma const_fin1_eq (x : α) : (fun _ : Fin 1 => x) = ![x] 
Arguments: {α : Type u} (x : α)
Goal: (fun x_1 => x) = ![x]
-- Matrix.ext_iff
theorem ext_iff : (∀ i j, M i j = N i j) ↔ M = N 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} {M N : Matrix m n α}
Goal: (∀ (i : m) (j : n), M i j = N i j) ↔ M = N
-- Matrix.ext
@[ext]
theorem ext : (∀ i j, M i j = N i j) → M = N 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} {M N : Matrix m n α}
Goal: (∀ (i : m) (j : n), M i j = N i j) → M = N
-- Matrix.of_apply
@[simp]
theorem of_apply (f : m → n → α) (i j) : of f i j = f i j 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} (f : m → n → α) (i : m) (j : n)
Goal: Matrix.of f i j = f i j
-- Matrix.of_symm_apply
@[simp]
theorem of_symm_apply (f : Matrix m n α) (i j) : of.symm f i j = f i j 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} (f : Matrix m n α) (i : m) (j : n)
Goal: Matrix.of.symm f i j = f i j
-- Matrix.map_apply
@[simp]
theorem map_apply {M : Matrix m n α} {f : α → β} {i : m} {j : n} : M.map f i j = f (M i j) 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} {β : Type w} {M : Matrix m n α} {f : α → β} {i : m} {j : n}
Goal: M.map f i j = f (M i j)
-- Matrix.map_id
@[simp]
theorem map_id (M : Matrix m n α) : M.map id = M 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} (M : Matrix m n α)
Goal: M.map id = M
-- Matrix.map_id'
@[simp]
theorem map_id' (M : Matrix m n α) : M.map (·) = M 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} (M : Matrix m n α)
Goal: (M.map fun x => x) = M
-- Matrix.map_map
@[simp]
theorem map_map {M : Matrix m n α} {β γ : Type*} {f : α → β} {g : β → γ} :
    (M.map f).map g = M.map (g ∘ f) 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} {M : Matrix m n α} {β : Type u_10} {γ : Type u_11} {f : α → β} {g : β → γ}
Goal: (M.map f).map g = M.map (g ∘ f)
-- Matrix.map_injective
theorem map_injective {f : α → β} (hf : Function.Injective f) :
    Function.Injective fun M : Matrix m n α => M.map f 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} {β : Type w} {f : α → β} (hf : Function.Injective f)
Goal: Function.Injective fun M => M.map f
-- Matrix.transpose_apply
@[simp]
theorem transpose_apply (M : Matrix m n α) (i j) : transpose M i j = M j i 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} (M : Matrix m n α) (i : n) (j : m)
Goal: Mᵀ i j = M j i
-- Matrix.zero_apply
@[simp, nolint simpNF]
theorem zero_apply [Zero α] (i : m) (j : n) : (0 : Matrix m n α) i j = 0 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} [Zero α] (i : m) (j : n)
Goal: 0 i j = 0
-- Matrix.add_apply
@[simp]
theorem add_apply [Add α] (A B : Matrix m n α) (i : m) (j : n) :
    (A + B) i j = (A i j) + (B i j) 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} [Add α] (A B : Matrix m n α) (i : m) (j : n)
Goal: (A + B) i j = A i j + B i j
-- Matrix.smul_apply
@[simp]
theorem smul_apply [SMul β α] (r : β) (A : Matrix m n α) (i : m) (j : n) :
    (r • A) i j = r • (A i j) 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} {β : Type w} [SMul β α] (r : β) (A : Matrix m n α) (i : m) (j : n)
Goal: (r • A) i j = r • A i j
-- Matrix.sub_apply
@[simp]
theorem sub_apply [Sub α] (A B : Matrix m n α) (i : m) (j : n) :
    (A - B) i j = (A i j) - (B i j) 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} [Sub α] (A B : Matrix m n α) (i : m) (j : n)
Goal: (A - B) i j = A i j - B i j
-- Matrix.neg_apply
@[simp]
theorem neg_apply [Neg α] (A : Matrix m n α) (i : m) (j : n) :
    (-A) i j = -(A i j) 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} [Neg α] (A : Matrix m n α) (i : m) (j : n)
Goal: (-A) i j = -A i j
-- Matrix.of_zero
@[simp]
theorem of_zero [Zero α] : of (0 : m → n → α) = 0 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} [Zero α]
Goal: Matrix.of 0 = 0
-- Matrix.of_add_of
@[simp]
theorem of_add_of [Add α] (f g : m → n → α) : of f + of g = of (f + g) 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} [Add α] (f g : m → n → α)
Goal: Matrix.of f + Matrix.of g = Matrix.of (f + g)
-- Matrix.of_sub_of
@[simp]
theorem of_sub_of [Sub α] (f g : m → n → α) : of f - of g = of (f - g) 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} [Sub α] (f g : m → n → α)
Goal: Matrix.of f - Matrix.of g = Matrix.of (f - g)
-- Matrix.neg_of
@[simp]
theorem neg_of [Neg α] (f : m → n → α) : -of f = of (-f) 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} [Neg α] (f : m → n → α)
Goal: -Matrix.of f = Matrix.of (-f)
-- Matrix.smul_of
@[simp]
theorem smul_of [SMul R α] (r : R) (f : m → n → α) : r • of f = of (r • f) 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_7} {α : Type v} [SMul R α] (r : R) (f : m → n → α)
Goal: r • Matrix.of f = Matrix.of (r • f)
-- Matrix.map_zero
@[simp]
protected theorem map_zero [Zero α] [Zero β] (f : α → β) (h : f 0 = 0) :
    (0 : Matrix m n α).map f = 0 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} {β : Type w} [Zero α] [Zero β] (f : α → β) (h : f 0 = 0)
Goal: Matrix.map 0 f = 0
-- Matrix.map_add
protected theorem map_add [Add α] [Add β] (f : α → β) (hf : ∀ a₁ a₂, f (a₁ + a₂) = f a₁ + f a₂)
    (M N : Matrix m n α) : (M + N).map f = M.map f + N.map f 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type v} {β : Type w} [Add α] [Add β] (f : α → β) (hf : ∀ (a₁ a₂ : α), f (a₁ + a₂) = f a₁ + f a₂) (M N : Matrix m n α)
Goal: (M + N).map f = M.map f + N.map f