ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Matrix.kroneckerTMul_diagonal
theorem kroneckerTMul_diagonal [DecidableEq n] (A : Matrix l m α) (b : n → α) :
    A ⊗ₖₜ[R] diagonal b = blockDiagonal fun i => A.map fun a => a ⊗ₜ[R] b i 
Arguments: (R : Type u_1) {α : Type u_2} {l : Type u_8} {m : Type u_9} {n : Type u_10} [CommSemiring R] [AddCommMonoid α] [Module R α] [DecidableEq n] (A : Matrix l m α) (b : n → α)
Goal: Matrix.kroneckerMap (TensorProduct.tmul R) A (Matrix.diagonal b) =
  Matrix.blockDiagonal fun i => A.map fun a => a ⊗ₜ[R] b i
-- Matrix.diagonal_kroneckerTMul
theorem diagonal_kroneckerTMul [DecidableEq l] (a : l → α) (B : Matrix m n α) :
    diagonal a ⊗ₖₜ[R] B =
      Matrix.reindex (Equiv.prodComm _ _) (Equiv.prodComm _ _)
        (blockDiagonal fun i => B.map fun b => a i ⊗ₜ[R] b) 
Arguments: (R : Type u_1) {α : Type u_2} {l : Type u_8} {m : Type u_9} {n : Type u_10} [CommSemiring R] [AddCommMonoid α] [Module R α] [DecidableEq l] (a : l → α) (B : Matrix m n α)
Goal: Matrix.kroneckerMap (TensorProduct.tmul R) (Matrix.diagonal a) B =
  (Matrix.reindex (Equiv.prodComm m l) (Equiv.prodComm n l)) (Matrix.blockDiagonal fun i => B.map fun b => a i ⊗ₜ[R] b)
-- Matrix.kroneckerTMul_assoc
theorem kroneckerTMul_assoc (A : Matrix l m α) (B : Matrix n p β) (C : Matrix q r γ) :
    reindex (Equiv.prodAssoc l n q) (Equiv.prodAssoc m p r)
        (((A ⊗ₖₜ[R] B) ⊗ₖₜ[R] C).map (TensorProduct.assoc R α β γ)) =
      A ⊗ₖₜ[R] B ⊗ₖₜ[R] C 
Arguments: (R : Type u_1) {α : Type u_2} {β : Type u_4} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10} {p : Type u_11} {q : Type u_12} {r : Type u_13} [CommSemiring R] [AddCommMonoid α] [AddCommMonoid β] [AddCommMonoid γ] [Module R α] [Module R β] [Module R γ] (A : Matrix l m α) (B : Matrix n p β) (C : Matrix q r γ)
Goal: (Matrix.reindex (Equiv.prodAssoc l n q) (Equiv.prodAssoc m p r))
    ((Matrix.kroneckerMap (TensorProduct.tmul R) (Matrix.kroneckerMap (TensorProduct.tmul R) A B) C).map
      ⇑(TensorProduct.assoc R α β γ)) =
  Matrix.kroneckerMap (TensorProduct.tmul R) A (Matrix.kroneckerMap (TensorProduct.tmul R) B C)
-- Matrix.kroneckerTMul_assoc'
@[simp]
theorem kroneckerTMul_assoc' (A : Matrix l m α) (B : Matrix n p β) (C : Matrix q r γ) :
    submatrix (((A ⊗ₖₜ[R] B) ⊗ₖₜ[R] C).map (TensorProduct.assoc R α β γ))
      (Equiv.prodAssoc l n q).symm (Equiv.prodAssoc m p r).symm = A ⊗ₖₜ[R] B ⊗ₖₜ[R] C 
Arguments: (R : Type u_1) {α : Type u_2} {β : Type u_4} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10} {p : Type u_11} {q : Type u_12} {r : Type u_13} [CommSemiring R] [AddCommMonoid α] [AddCommMonoid β] [AddCommMonoid γ] [Module R α] [Module R β] [Module R γ] (A : Matrix l m α) (B : Matrix n p β) (C : Matrix q r γ)
Goal: ((Matrix.kroneckerMap (TensorProduct.tmul R) (Matrix.kroneckerMap (TensorProduct.tmul R) A B) C).map
        ⇑(TensorProduct.assoc R α β γ)).submatrix
    ⇑(Equiv.prodAssoc l n q).symm ⇑(Equiv.prodAssoc m p r).symm =
  Matrix.kroneckerMap (TensorProduct.tmul R) A (Matrix.kroneckerMap (TensorProduct.tmul R) B C)
-- Matrix.trace_kroneckerTMul
theorem trace_kroneckerTMul [Fintype m] [Fintype n] (A : Matrix m m α) (B : Matrix n n β) :
    trace (A ⊗ₖₜ[R] B) = trace A ⊗ₜ[R] trace B 
Arguments: (R : Type u_1) {α : Type u_2} {β : Type u_4} {m : Type u_9} {n : Type u_10} [CommSemiring R] [AddCommMonoid α] [AddCommMonoid β] [Module R α] [Module R β] [Fintype m] [Fintype n] (A : Matrix m m α) (B : Matrix n n β)
Goal: (Matrix.kroneckerMap (TensorProduct.tmul R) A B).trace = A.trace ⊗ₜ[R] B.trace
-- Matrix.one_kroneckerTMul_one
@[simp]
theorem one_kroneckerTMul_one [DecidableEq m] [DecidableEq n] :
    (1 : Matrix m m α) ⊗ₖₜ[R] (1 : Matrix n n α) = 1 
Arguments: (R : Type u_1) {α : Type u_2} {m : Type u_9} {n : Type u_10} [CommSemiring R] [Semiring α] [Algebra R α] [DecidableEq m] [DecidableEq n]
Goal: Matrix.kroneckerMap (TensorProduct.tmul R) 1 1 = 1
-- Matrix.mul_kroneckerTMul_mul
theorem mul_kroneckerTMul_mul [Fintype m] [Fintype m'] (A : Matrix l m α) (B : Matrix m n α)
    (A' : Matrix l' m' β) (B' : Matrix m' n' β) :
    (A * B) ⊗ₖₜ[R] (A' * B') = A ⊗ₖₜ[R] A' * B ⊗ₖₜ[R] B' 
Arguments: (R : Type u_1) {α : Type u_2} {β : Type u_4} {l : Type u_8} {m : Type u_9} {n : Type u_10} {l' : Type u_14} {m' : Type u_15} {n' : Type u_16} [CommSemiring R] [Semiring α] [Semiring β] [Algebra R α] [Algebra R β] [Fintype m] [Fintype m'] (A : Matrix l m α) (B : Matrix m n α) (A' : Matrix l' m' β) (B' : Matrix m' n' β)
Goal: Matrix.kroneckerMap (TensorProduct.tmul R) (A * B) (A' * B') =
  Matrix.kroneckerMap (TensorProduct.tmul R) A A' * Matrix.kroneckerMap (TensorProduct.tmul R) B B'
-- Matrix.det_kroneckerTMul
theorem det_kroneckerTMul [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n]
    (A : Matrix m m α) (B : Matrix n n β) :
    det (A ⊗ₖₜ[R] B) = (det A ^ Fintype.card n) ⊗ₜ[R] (det B ^ Fintype.card m) 
Arguments: (R : Type u_1) {α : Type u_2} {β : Type u_4} {m : Type u_9} {n : Type u_10} [CommRing R] [CommRing α] [CommRing β] [Algebra R α] [Algebra R β] [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n] (A : Matrix m m α) (B : Matrix n n β)
Goal: (Matrix.kroneckerMap (TensorProduct.tmul R) A B).det = (A.det ^ Fintype.card n) ⊗ₜ[R] (B.det ^ Fintype.card m)
-- Finset.sup_univ_eq_iSup
theorem sup_univ_eq_iSup [CompleteLattice β] (f : α → β) : Finset.univ.sup f = iSup f 
Arguments: {α : Type u_2} {β : Type u_3} [Fintype α] [CompleteLattice β] (f : α → β)
Goal: Finset.univ.sup f = iSup f
-- Finset.inf_univ_eq_iInf
theorem inf_univ_eq_iInf [CompleteLattice β] (f : α → β) : Finset.univ.inf f = iInf f 
Arguments: {α : Type u_2} {β : Type u_3} [Fintype α] [CompleteLattice β] (f : α → β)
Goal: Finset.univ.inf f = iInf f
-- Finset.fold_inf_univ
@[simp]
theorem fold_inf_univ [SemilatticeInf α] [OrderBot α] (a : α) :
    -- Porting note: added `haveI`
    haveI : Std.Commutative (α := α) (· ⊓ ·) := inferInstance
    (Finset.univ.fold (· ⊓ ·) a fun x => x) = ⊥ 
Arguments: {α : Type u_2} [Fintype α] [SemilatticeInf α] [OrderBot α] (a : α)
Goal: Finset.fold (fun x x_1 => x ⊓ x_1) a (fun x => x) Finset.univ = ⊥
-- Finset.fold_sup_univ
@[simp]
theorem fold_sup_univ [SemilatticeSup α] [OrderTop α] (a : α) :
    -- Porting note: added `haveI`
    haveI : Std.Commutative (α := α) (· ⊔ ·) := inferInstance
    (Finset.univ.fold (· ⊔ ·) a fun x => x) = ⊤ 
Arguments: {α : Type u_2} [Fintype α] [SemilatticeSup α] [OrderTop α] (a : α)
Goal: Finset.fold (fun x x_1 => x ⊔ x_1) a (fun x => x) Finset.univ = ⊤
-- Finset.mem_inf
lemma mem_inf [DecidableEq α] {s : Finset ι} {f : ι → Finset α} {a : α} :
    a ∈ s.inf f ↔ ∀ i ∈ s, a ∈ f i 
Arguments: {ι : Type u_1} {α : Type u_2} [Fintype α] [DecidableEq α] {s : Finset ι} {f : ι → Finset α} {a : α}
Goal: a ∈ s.inf f ↔ ∀ i ∈ s, a ∈ f i
-- Finite.exists_max
theorem Finite.exists_max [Finite α] [Nonempty α] [LinearOrder β] (f : α → β) :
    ∃ x₀ : α, ∀ x, f x ≤ f x₀ 
Arguments: {α : Type u_2} {β : Type u_3} [Finite α] [Nonempty α] [LinearOrder β] (f : α → β)
Goal: ∃ x₀, ∀ (x : α), f x ≤ f x₀
-- Finite.exists_min
theorem Finite.exists_min [Finite α] [Nonempty α] [LinearOrder β] (f : α → β) :
    ∃ x₀ : α, ∀ x, f x₀ ≤ f x 
Arguments: {α : Type u_2} {β : Type u_3} [Finite α] [Nonempty α] [LinearOrder β] (f : α → β)
Goal: ∃ x₀, ∀ (x : α), f x₀ ≤ f x
-- MvQPF.abs_repr
class MvQPF {n : ℕ} (F : TypeVec.{u} n → Type*) extends MvFunctor F where
  P : MvPFunctor.{u} n
  abs : ∀ {α}, P α → F α
  repr : ∀ {α}, F α → P α
  abs_repr : ∀ {α} (x : F α), abs (repr x) = x
  abs_map : ∀ {α β} (f : α ⟹ β) (p : P α), abs (f <$$> p) = f <$$> abs p
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [self : MvQPF F] {α : TypeVec.{u} n} (x : F α)
Goal: MvQPF.abs (MvQPF.repr x) = x
-- MvQPF.abs_map
class MvQPF {n : ℕ} (F : TypeVec.{u} n → Type*) extends MvFunctor F where
  P : MvPFunctor.{u} n
  abs : ∀ {α}, P α → F α
  repr : ∀ {α}, F α → P α
  abs_repr : ∀ {α} (x : F α), abs (repr x) = x
  abs_map : ∀ {α β} (f : α ⟹ β) (p : P α), abs (f <$$> p) = f <$$> abs p
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [self : MvQPF F] {α β : TypeVec.{u} n} (f : α ⟹ β) (p : ↑(MvQPF.P F) α)
Goal: MvQPF.abs (f <$$> p) = f <$$> MvQPF.abs p
-- MvQPF.id_map
protected theorem id_map {α : TypeVec n} (x : F α) : TypeVec.id <$$> x = x 
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [q : MvQPF F] {α : TypeVec.{u} n} (x : F α)
Goal: TypeVec.id <$$> x = x
-- MvQPF.comp_map
@[simp]
theorem comp_map {α β γ : TypeVec n} (f : α ⟹ β) (g : β ⟹ γ) (x : F α) :
    (g ⊚ f) <$$> x = g <$$> f <$$> x 
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [q : MvQPF F] {α β γ : TypeVec.{u} n} (f : α ⟹ β) (g : β ⟹ γ) (x : F α)
Goal: (g ⊚ f) <$$> x = g <$$> f <$$> x
-- MvQPF.liftP_iff
theorem liftP_iff {α : TypeVec n} (p : ∀ ⦃i⦄, α i → Prop) (x : F α) :
    LiftP p x ↔ ∃ a f, x = abs ⟨a, f⟩ ∧ ∀ i j, p (f i j) 
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [q : MvQPF F] {α : TypeVec.{u} n} (p : ⦃i : Fin2 n⦄ → α i → Prop) (x : F α)
Goal: MvFunctor.LiftP p x ↔ ∃ a f, x = MvQPF.abs ⟨a, f⟩ ∧ ∀ (i : Fin2 n) (j : (MvQPF.P F).B a i), p (f i j)
-- MvQPF.liftR_iff
theorem liftR_iff {α : TypeVec n} (r : ∀ /- ⦃i⦄ -/ {i}, α i → α i → Prop) (x y : F α) :
    LiftR r x y ↔ ∃ a f₀ f₁, x = abs ⟨a, f₀⟩ ∧ y = abs ⟨a, f₁⟩ ∧ ∀ i j, r (f₀ i j) (f₁ i j) 
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [q : MvQPF F] {α : TypeVec.{u} n} (r : {i : Fin2 n} → α i → α i → Prop) (x y : F α)
Goal: MvFunctor.LiftR (fun {i} => r) x y ↔
  ∃ a f₀ f₁, x = MvQPF.abs ⟨a, f₀⟩ ∧ y = MvQPF.abs ⟨a, f₁⟩ ∧ ∀ (i : Fin2 n) (j : (MvQPF.P F).B a i), r (f₀ i j) (f₁ i j)
-- MvQPF.mem_supp
theorem mem_supp {α : TypeVec n} (x : F α) (i) (u : α i) :
    u ∈ supp x i ↔ ∀ a f, abs ⟨a, f⟩ = x → u ∈ f i '' univ 
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [q : MvQPF F] {α : TypeVec.{u} n} (x : F α) (i : Fin2 n) (u : α i)
Goal: u ∈ MvFunctor.supp x i ↔ ∀ (a : (MvQPF.P F).A) (f : (MvQPF.P F).B a ⟹ α), MvQPF.abs ⟨a, f⟩ = x → u ∈ f i '' Set.univ
-- MvQPF.supp_eq
theorem supp_eq {α : TypeVec n} {i} (x : F α) :
    supp x i = { u | ∀ a f, abs ⟨a, f⟩ = x → u ∈ f i '' univ } 
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [q : MvQPF F] {α : TypeVec.{u} n} {i : Fin2 n} (x : F α)
Goal: MvFunctor.supp x i = {u | ∀ (a : (MvQPF.P F).A) (f : (MvQPF.P F).B a ⟹ α), MvQPF.abs ⟨a, f⟩ = x → u ∈ f i '' Set.univ}
-- MvQPF.has_good_supp_iff
theorem has_good_supp_iff {α : TypeVec n} (x : F α) :
    (∀ p, LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i u) ↔
      ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ i a' f', abs ⟨a', f'⟩ = x → f i '' univ ⊆ f' i '' univ 
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [q : MvQPF F] {α : TypeVec.{u} n} (x : F α)
Goal: (∀ (p : (i : Fin2 n) → α i → Prop), MvFunctor.LiftP p x ↔ ∀ (i : Fin2 n), ∀ u ∈ MvFunctor.supp x i, p i u) ↔
  ∃ a f,
    MvQPF.abs ⟨a, f⟩ = x ∧
      ∀ (i : Fin2 n) (a' : (MvQPF.P F).A) (f' : (MvQPF.P F).B a' ⟹ α),
        MvQPF.abs ⟨a', f'⟩ = x → f i '' Set.univ ⊆ f' i '' Set.univ
-- MvQPF.supp_eq_of_isUniform
theorem supp_eq_of_isUniform (h : q.IsUniform) {α : TypeVec n} (a : q.P.A) (f : q.P.B a ⟹ α) :
    ∀ i, supp (abs ⟨a, f⟩) i = f i '' univ 
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [q : MvQPF F] (h : MvQPF.IsUniform) {α : TypeVec.{u} n} (a : (MvQPF.P F).A) (f : (MvQPF.P F).B a ⟹ α) (i : Fin2 n)
Goal: MvFunctor.supp (MvQPF.abs ⟨a, f⟩) i = f i '' Set.univ
-- MvQPF.liftP_iff_of_isUniform
theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
    LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i u 
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [q : MvQPF F] (h : MvQPF.IsUniform) {α : TypeVec.{u} n} (x : F α) (p : (i : Fin2 n) → α i → Prop)
Goal: MvFunctor.LiftP p x ↔ ∀ (i : Fin2 n), ∀ u ∈ MvFunctor.supp x i, p i u
-- MvQPF.supp_map
theorem supp_map (h : q.IsUniform) {α β : TypeVec n} (g : α ⟹ β) (x : F α) (i) :
    supp (g <$$> x) i = g i '' supp x i 
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [q : MvQPF F] (h : MvQPF.IsUniform) {α β : TypeVec.{u} n} (g : α ⟹ β) (x : F α) (i : Fin2 n)
Goal: MvFunctor.supp (g <$$> x) i = g i '' MvFunctor.supp x i
-- MvQPF.suppPreservation_iff_isUniform
theorem suppPreservation_iff_isUniform : q.SuppPreservation ↔ q.IsUniform 
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [q : MvQPF F]
Goal: MvQPF.SuppPreservation ↔ MvQPF.IsUniform
-- MvQPF.suppPreservation_iff_liftpPreservation
theorem suppPreservation_iff_liftpPreservation : q.SuppPreservation ↔ q.LiftPPreservation 
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [q : MvQPF F]
Goal: MvQPF.SuppPreservation ↔ MvQPF.LiftPPreservation
-- MvQPF.liftpPreservation_iff_uniform
theorem liftpPreservation_iff_uniform : q.LiftPPreservation ↔ q.IsUniform 
Arguments: {n : ℕ} {F : TypeVec.{u} n → Type u_1} [q : MvQPF F]
Goal: MvQPF.LiftPPreservation ↔ MvQPF.IsUniform
-- Fin.map_valEmbedding_univ
theorem map_valEmbedding_univ : (Finset.univ : Finset (Fin n)).map Fin.valEmbedding = Iio n 
Arguments: {n : ℕ}
Goal: Finset.map Fin.valEmbedding Finset.univ = Finset.Iio n
-- Fin.Ioi_zero_eq_map
@[simp]
theorem Ioi_zero_eq_map : Ioi (0 : Fin n.succ) = univ.map (Fin.succEmb _) 
Arguments: {n : ℕ}
Goal: Finset.Ioi 0 = Finset.map (Fin.succEmb n) Finset.univ
-- Fin.Iio_last_eq_map
@[simp]
theorem Iio_last_eq_map : Iio (Fin.last n) = Finset.univ.map Fin.castSuccEmb 
Arguments: {n : ℕ}
Goal: Finset.Iio (Fin.last n) = Finset.map Fin.castSuccEmb Finset.univ
-- Fin.Ioi_succ
@[simp]
theorem Ioi_succ (i : Fin n) : Ioi i.succ = (Ioi i).map (Fin.succEmb _) 
Arguments: {n : ℕ} (i : Fin n)
Goal: Finset.Ioi i.succ = Finset.map (Fin.succEmb n) (Finset.Ioi i)
-- Fin.Iio_castSucc
@[simp]
theorem Iio_castSucc (i : Fin n) : Iio (castSucc i) = (Iio i).map Fin.castSuccEmb 
Arguments: {n : ℕ} (i : Fin n)
Goal: Finset.Iio i.castSucc = Finset.map Fin.castSuccEmb (Finset.Iio i)
-- Fin.card_filter_univ_succ'
theorem card_filter_univ_succ' (p : Fin (n + 1) → Prop) [DecidablePred p] :
    (univ.filter p).card = ite (p 0) 1 0 + (univ.filter (p ∘ Fin.succ)).card 
Arguments: {n : ℕ} (p : Fin (n + 1) → Prop) [DecidablePred p]
Goal: (Finset.filter p Finset.univ).card = (if p 0 then 1 else 0) + (Finset.filter (p ∘ Fin.succ) Finset.univ).card
-- Fin.card_filter_univ_succ
theorem card_filter_univ_succ (p : Fin (n + 1) → Prop) [DecidablePred p] :
    (univ.filter p).card =
    if p 0 then (univ.filter (p ∘ Fin.succ)).card + 1 else (univ.filter (p ∘ Fin.succ)).card 
Arguments: {n : ℕ} (p : Fin (n + 1) → Prop) [DecidablePred p]
Goal: (Finset.filter p Finset.univ).card =
  if p 0 then (Finset.filter (p ∘ Fin.succ) Finset.univ).card + 1 else (Finset.filter (p ∘ Fin.succ) Finset.univ).card
-- Fin.card_filter_univ_eq_vector_get_eq_count
theorem card_filter_univ_eq_vector_get_eq_count [DecidableEq α] (a : α) (v : Vector α n) :
    (univ.filter fun i => a = v.get i).card = v.toList.count a 
Arguments: {α : Type u_1} {n : ℕ} [DecidableEq α] (a : α) (v : Mathlib.Vector α n)
Goal: (Finset.filter (fun i => a = v.get i) Finset.univ).card = List.count a v.toList
-- Matrix.cons_val'
@[simp]
theorem cons_val' (v : n' → α) (B : Fin m → n' → α) (i j) :
    vecCons v B i j = vecCons (v j) (fun i => B i j) i 
Arguments: {α : Type u} {m : ℕ} {n' : Type uₙ} (v : n' → α) (B : Fin m → n' → α) (i : Fin m.succ) (j : n')
Goal: Matrix.vecCons v B i j = Matrix.vecCons (v j) (fun i => B i j) i
-- Matrix.head_val'
@[simp]
theorem head_val' (B : Fin m.succ → n' → α) (j : n') : (vecHead fun i => B i j) = vecHead B j 
Arguments: {α : Type u} {m : ℕ} {n' : Type uₙ} (B : Fin m.succ → n' → α) (j : n')
Goal: (Matrix.vecHead fun i => B i j) = Matrix.vecHead B j
-- Matrix.tail_val'
@[simp]
theorem tail_val' (B : Fin m.succ → n' → α) (j : n') :
    (vecTail fun i => B i j) = fun i => vecTail B i j 
Arguments: {α : Type u} {m : ℕ} {n' : Type uₙ} (B : Fin m.succ → n' → α) (j : n')
Goal: (Matrix.vecTail fun i => B i j) = fun i => Matrix.vecTail B i j
-- Matrix.dotProduct_empty
@[simp]
theorem dotProduct_empty (v w : Fin 0 → α) : dotProduct v w = 0 
Arguments: {α : Type u} [AddCommMonoid α] [Mul α] (v w : Fin 0 → α)
Goal: Matrix.dotProduct v w = 0
-- Matrix.cons_dotProduct
@[simp]
theorem cons_dotProduct (x : α) (v : Fin n → α) (w : Fin n.succ → α) :
    dotProduct (vecCons x v) w = x * vecHead w + dotProduct v (vecTail w) 
Arguments: {α : Type u} {n : ℕ} [AddCommMonoid α] [Mul α] (x : α) (v : Fin n → α) (w : Fin n.succ → α)
Goal: Matrix.dotProduct (Matrix.vecCons x v) w = x * Matrix.vecHead w + Matrix.dotProduct v (Matrix.vecTail w)
-- Matrix.dotProduct_cons
@[simp]
theorem dotProduct_cons (v : Fin n.succ → α) (x : α) (w : Fin n → α) :
    dotProduct v (vecCons x w) = vecHead v * x + dotProduct (vecTail v) w 
Arguments: {α : Type u} {n : ℕ} [AddCommMonoid α] [Mul α] (v : Fin n.succ → α) (x : α) (w : Fin n → α)
Goal: Matrix.dotProduct v (Matrix.vecCons x w) = Matrix.vecHead v * x + Matrix.dotProduct (Matrix.vecTail v) w
-- Matrix.cons_dotProduct_cons
theorem cons_dotProduct_cons (x : α) (v : Fin n → α) (y : α) (w : Fin n → α) :
    dotProduct (vecCons x v) (vecCons y w) = x * y + dotProduct v w 
Arguments: {α : Type u} {n : ℕ} [AddCommMonoid α] [Mul α] (x : α) (v : Fin n → α) (y : α) (w : Fin n → α)
Goal: Matrix.dotProduct (Matrix.vecCons x v) (Matrix.vecCons y w) = x * y + Matrix.dotProduct v w
-- Matrix.col_empty
@[simp]
theorem col_empty (v : Fin 0 → α) : col ι v = vecEmpty 
Arguments: {α : Type u} {ι : Type u_1} (v : Fin 0 → α)
Goal: Matrix.col ι v = ![]
-- Matrix.col_cons
@[simp]
theorem col_cons (x : α) (u : Fin m → α) :
    col ι (vecCons x u) = of (vecCons (fun _ => x) (col ι u)) 
Arguments: {α : Type u} {m : ℕ} {ι : Type u_1} (x : α) (u : Fin m → α)
Goal: Matrix.col ι (Matrix.vecCons x u) = Matrix.of (Matrix.vecCons (fun x_1 => x) (Matrix.col ι u))
-- Matrix.row_empty
@[simp]
theorem row_empty : row ι (vecEmpty : Fin 0 → α) = of fun _ => vecEmpty 
Arguments: {α : Type u} {ι : Type u_1}
Goal: Matrix.row ι ![] = Matrix.of fun x => ![]
-- Matrix.row_cons
@[simp]
theorem row_cons (x : α) (u : Fin m → α) : row ι (vecCons x u) = of fun _ => vecCons x u 
Arguments: {α : Type u} {m : ℕ} {ι : Type u_1} (x : α) (u : Fin m → α)
Goal: Matrix.row ι (Matrix.vecCons x u) = Matrix.of fun x_1 => Matrix.vecCons x u
-- Matrix.transpose_empty_rows
@[simp]
theorem transpose_empty_rows (A : Matrix m' (Fin 0) α) : Aᵀ = of ![] 
Arguments: {α : Type u} {m' : Type uₘ} (A : Matrix m' (Fin 0) α)
Goal: A.transpose = Matrix.of ![]
-- Matrix.transpose_empty_cols
@[simp]
theorem transpose_empty_cols (A : Matrix (Fin 0) m' α) : Aᵀ = of fun _ => ![] 
Arguments: {α : Type u} {m' : Type uₘ} (A : Matrix (Fin 0) m' α)
Goal: A.transpose = Matrix.of fun x => ![]
-- Matrix.cons_transpose
@[simp]
theorem cons_transpose (v : n' → α) (A : Matrix (Fin m) n' α) :
    (of (vecCons v A))ᵀ = of fun i => vecCons (v i) (Aᵀ i) 
Arguments: {α : Type u} {m : ℕ} {n' : Type uₙ} (v : n' → α) (A : Matrix (Fin m) n' α)
Goal: (Matrix.of (Matrix.vecCons v A)).transpose = Matrix.of fun i => Matrix.vecCons (v i) (A.transpose i)
-- Matrix.head_transpose
@[simp]
theorem head_transpose (A : Matrix m' (Fin n.succ) α) :
    vecHead (of.symm Aᵀ) = vecHead ∘ of.symm A 
Arguments: {α : Type u} {n : ℕ} {m' : Type uₘ} (A : Matrix m' (Fin n.succ) α)
Goal: Matrix.vecHead (Matrix.of.symm A.transpose) = Matrix.vecHead ∘ Matrix.of.symm A
-- Matrix.tail_transpose
@[simp]
theorem tail_transpose (A : Matrix m' (Fin n.succ) α) : vecTail (of.symm Aᵀ) = (vecTail ∘ A)ᵀ 
Arguments: {α : Type u} {n : ℕ} {m' : Type uₘ} (A : Matrix m' (Fin n.succ) α)
Goal: Matrix.vecTail (Matrix.of.symm A.transpose) = Matrix.transpose (Matrix.vecTail ∘ A)
-- Matrix.empty_mul
@[simp]
theorem empty_mul [Fintype n'] (A : Matrix (Fin 0) n' α) (B : Matrix n' o' α) : A * B = of ![] 
Arguments: {α : Type u} {n' : Type uₙ} {o' : Type uₒ} [NonUnitalNonAssocSemiring α] [Fintype n'] (A : Matrix (Fin 0) n' α) (B : Matrix n' o' α)
Goal: A * B = Matrix.of ![]
-- Matrix.empty_mul_empty
@[simp]
theorem empty_mul_empty (A : Matrix m' (Fin 0) α) (B : Matrix (Fin 0) o' α) : A * B = 0 
Arguments: {α : Type u} {m' : Type uₘ} {o' : Type uₒ} [NonUnitalNonAssocSemiring α] (A : Matrix m' (Fin 0) α) (B : Matrix (Fin 0) o' α)
Goal: A * B = 0
-- Matrix.mul_empty
@[simp]
theorem mul_empty [Fintype n'] (A : Matrix m' n' α) (B : Matrix n' (Fin 0) α) :
    A * B = of fun _ => ![] 
Arguments: {α : Type u} {m' : Type uₘ} {n' : Type uₙ} [NonUnitalNonAssocSemiring α] [Fintype n'] (A : Matrix m' n' α) (B : Matrix n' (Fin 0) α)
Goal: A * B = Matrix.of fun x => ![]
-- Matrix.mul_val_succ
theorem mul_val_succ [Fintype n'] (A : Matrix (Fin m.succ) n' α) (B : Matrix n' o' α) (i : Fin m)
    (j : o') : (A * B) i.succ j = (of (vecTail (of.symm A)) * B) i j 
Arguments: {α : Type u} {m : ℕ} {n' : Type uₙ} {o' : Type uₒ} [NonUnitalNonAssocSemiring α] [Fintype n'] (A : Matrix (Fin m.succ) n' α) (B : Matrix n' o' α) (i : Fin m) (j : o')
Goal: (A * B) i.succ j = (Matrix.of (Matrix.vecTail (Matrix.of.symm A)) * B) i j
-- Matrix.cons_mul
@[simp]
theorem cons_mul [Fintype n'] (v : n' → α) (A : Fin m → n' → α) (B : Matrix n' o' α) :
    of (vecCons v A) * B = of (vecCons (v ᵥ* B) (of.symm (of A * B))) 
Arguments: {α : Type u} {m : ℕ} {n' : Type uₙ} {o' : Type uₒ} [NonUnitalNonAssocSemiring α] [Fintype n'] (v : n' → α) (A : Fin m → n' → α) (B : Matrix n' o' α)
Goal: Matrix.of (Matrix.vecCons v A) * B = Matrix.of (Matrix.vecCons (Matrix.vecMul v B) (Matrix.of.symm (Matrix.of A * B)))
-- Matrix.empty_vecMul
@[simp]
theorem empty_vecMul (v : Fin 0 → α) (B : Matrix (Fin 0) o' α) : v ᵥ* B = 0 
Arguments: {α : Type u} {o' : Type uₒ} [NonUnitalNonAssocSemiring α] (v : Fin 0 → α) (B : Matrix (Fin 0) o' α)
Goal: Matrix.vecMul v B = 0
-- Matrix.vecMul_empty
@[simp]
theorem vecMul_empty [Fintype n'] (v : n' → α) (B : Matrix n' (Fin 0) α) : v ᵥ* B = ![] 
Arguments: {α : Type u} {n' : Type uₙ} [NonUnitalNonAssocSemiring α] [Fintype n'] (v : n' → α) (B : Matrix n' (Fin 0) α)
Goal: Matrix.vecMul v B = ![]
-- Matrix.cons_vecMul
@[simp]
theorem cons_vecMul (x : α) (v : Fin n → α) (B : Fin n.succ → o' → α) :
    vecCons x v ᵥ* of B = x • vecHead B + v ᵥ* of (vecTail B) 
Arguments: {α : Type u} {n : ℕ} {o' : Type uₒ} [NonUnitalNonAssocSemiring α] (x : α) (v : Fin n → α) (B : Fin n.succ → o' → α)
Goal: Matrix.vecMul (Matrix.vecCons x v) (Matrix.of B) = x • Matrix.vecHead B + Matrix.vecMul v (Matrix.of (Matrix.vecTail B))
-- Matrix.vecMul_cons
@[simp]
theorem vecMul_cons (v : Fin n.succ → α) (w : o' → α) (B : Fin n → o' → α) :
    v ᵥ* of (vecCons w B) = vecHead v • w + vecTail v ᵥ* of B 
Arguments: {α : Type u} {n : ℕ} {o' : Type uₒ} [NonUnitalNonAssocSemiring α] (v : Fin n.succ → α) (w : o' → α) (B : Fin n → o' → α)
Goal: Matrix.vecMul v (Matrix.of (Matrix.vecCons w B)) = Matrix.vecHead v • w + Matrix.vecMul (Matrix.vecTail v) (Matrix.of B)
-- Matrix.cons_vecMul_cons
theorem cons_vecMul_cons (x : α) (v : Fin n → α) (w : o' → α) (B : Fin n → o' → α) :
    vecCons x v ᵥ* of (vecCons w B) = x • w + v ᵥ* of B 
Arguments: {α : Type u} {n : ℕ} {o' : Type uₒ} [NonUnitalNonAssocSemiring α] (x : α) (v : Fin n → α) (w : o' → α) (B : Fin n → o' → α)
Goal: Matrix.vecMul (Matrix.vecCons x v) (Matrix.of (Matrix.vecCons w B)) = x • w + Matrix.vecMul v (Matrix.of B)
-- Matrix.empty_mulVec
@[simp]
theorem empty_mulVec [Fintype n'] (A : Matrix (Fin 0) n' α) (v : n' → α) : A *ᵥ v = ![] 
Arguments: {α : Type u} {n' : Type uₙ} [NonUnitalNonAssocSemiring α] [Fintype n'] (A : Matrix (Fin 0) n' α) (v : n' → α)
Goal: A.mulVec v = ![]
-- Matrix.mulVec_empty
@[simp]
theorem mulVec_empty (A : Matrix m' (Fin 0) α) (v : Fin 0 → α) : A *ᵥ v = 0 
Arguments: {α : Type u} {m' : Type uₘ} [NonUnitalNonAssocSemiring α] (A : Matrix m' (Fin 0) α) (v : Fin 0 → α)
Goal: A.mulVec v = 0
-- Matrix.cons_mulVec
@[simp]
theorem cons_mulVec [Fintype n'] (v : n' → α) (A : Fin m → n' → α) (w : n' → α) :
    (of <| vecCons v A) *ᵥ w = vecCons (dotProduct v w) (of A *ᵥ w) 
Arguments: {α : Type u} {m : ℕ} {n' : Type uₙ} [NonUnitalNonAssocSemiring α] [Fintype n'] (v : n' → α) (A : Fin m → n' → α) (w : n' → α)
Goal: (Matrix.of (Matrix.vecCons v A)).mulVec w = Matrix.vecCons (Matrix.dotProduct v w) ((Matrix.of A).mulVec w)
-- Matrix.mulVec_cons
@[simp]
theorem mulVec_cons {α} [CommSemiring α] (A : m' → Fin n.succ → α) (x : α) (v : Fin n → α) :
    (of A) *ᵥ (vecCons x v) = x • vecHead ∘ A + (of (vecTail ∘ A)) *ᵥ v 
Arguments: {n : ℕ} {m' : Type uₘ} {α : Type u_1} [CommSemiring α] (A : m' → Fin n.succ → α) (x : α) (v : Fin n → α)
Goal: (Matrix.of A).mulVec (Matrix.vecCons x v) = x • Matrix.vecHead ∘ A + (Matrix.of (Matrix.vecTail ∘ A)).mulVec v