ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- LinearIndependent.option
theorem LinearIndependent.option (hv : LinearIndependent K v)
    (hx : x ∉ Submodule.span K (range v)) :
    LinearIndependent K (fun o => Option.casesOn' o x v : Option ι → V) 
Arguments: {ι : Type u'} {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {v : ι → V} {x : V} (hv : LinearIndependent K v) (hx : x ∉ Submodule.span K (Set.range v))
Goal: LinearIndependent K fun o => o.casesOn' x v
-- linearIndependent_option
theorem linearIndependent_option {v : Option ι → V} : LinearIndependent K v ↔
    LinearIndependent K (v ∘ (↑) : ι → V) ∧
      v none ∉ Submodule.span K (range (v ∘ (↑) : ι → V)) 
Arguments: {ι : Type u'} {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {v : Option ι → V}
Goal: LinearIndependent K v ↔ LinearIndependent K (v ∘ some) ∧ v none ∉ Submodule.span K (Set.range (v ∘ some))
-- linearIndependent_insert'
theorem linearIndependent_insert' {ι} {s : Set ι} {a : ι} {f : ι → V} (has : a ∉ s) :
    (LinearIndependent K fun x : ↥(insert a s) => f x) ↔
      (LinearIndependent K fun x : s => f x) ∧ f a ∉ Submodule.span K (f '' s) 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {ι : Type u_8} {s : Set ι} {a : ι} {f : ι → V} (has : a ∉ s)
Goal: (LinearIndependent K fun (x : ↑(insert a s)) => f ↑x) ↔
  (LinearIndependent K fun (x : ↑s) => f ↑x) ∧ f a ∉ Submodule.span K (f '' s)
-- linearIndependent_insert
theorem linearIndependent_insert (hxs : x ∉ s) :
    (LinearIndependent K fun b : ↥(insert x s) => (b : V)) ↔
      (LinearIndependent K fun b : s => (b : V)) ∧ x ∉ Submodule.span K s 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {s : Set V} {x : V} (hxs : x ∉ s)
Goal: (LinearIndependent K fun (b : ↑(insert x s)) => ↑b) ↔ (LinearIndependent K fun (b : ↑s) => ↑b) ∧ x ∉ Submodule.span K s
-- linearIndependent_pair
theorem linearIndependent_pair {x y : V} (hx : x ≠ 0) (hy : ∀ a : K, a • x ≠ y) :
    LinearIndependent K ((↑) : ({x, y} : Set V) → V) 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {x y : V} (hx : x ≠ 0) (hy : ∀ (a : K), a • x ≠ y)
Goal: LinearIndependent (ι := { x_1 // x_1 ∈ {x, y} }) K Subtype.val
-- LinearIndependent.pair_iff'
theorem LinearIndependent.pair_iff' {x y : V} (hx : x ≠ 0) :
    LinearIndependent K ![x, y] ↔ ∀ a : K, a • x ≠ y 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {x y : V} (hx : x ≠ 0)
Goal: LinearIndependent K ![x, y] ↔ ∀ (a : K), a • x ≠ y
-- linearIndependent_fin_cons
theorem linearIndependent_fin_cons {n} {v : Fin n → V} :
    LinearIndependent K (Fin.cons x v : Fin (n + 1) → V) ↔
      LinearIndependent K v ∧ x ∉ Submodule.span K (range v) 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {x : V} {n : ℕ} {v : Fin n → V}
Goal: LinearIndependent K (Fin.cons x v) ↔ LinearIndependent K v ∧ x ∉ Submodule.span K (Set.range v)
-- linearIndependent_fin_snoc
theorem linearIndependent_fin_snoc {n} {v : Fin n → V} :
    LinearIndependent K (Fin.snoc v x : Fin (n + 1) → V) ↔
      LinearIndependent K v ∧ x ∉ Submodule.span K (range v) 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {x : V} {n : ℕ} {v : Fin n → V}
Goal: LinearIndependent K (Fin.snoc v x) ↔ LinearIndependent K v ∧ x ∉ Submodule.span K (Set.range v)
-- LinearIndependent.fin_cons
theorem LinearIndependent.fin_cons {n} {v : Fin n → V} (hv : LinearIndependent K v)
    (hx : x ∉ Submodule.span K (range v)) : LinearIndependent K (Fin.cons x v : Fin (n + 1) → V) 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {x : V} {n : ℕ} {v : Fin n → V} (hv : LinearIndependent K v) (hx : x ∉ Submodule.span K (Set.range v))
Goal: LinearIndependent K (Fin.cons x v)
-- linearIndependent_fin_succ
theorem linearIndependent_fin_succ {n} {v : Fin (n + 1) → V} :
    LinearIndependent K v ↔
      LinearIndependent K (Fin.tail v) ∧ v 0 ∉ Submodule.span K (range <| Fin.tail v) 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {n : ℕ} {v : Fin (n + 1) → V}
Goal: LinearIndependent K v ↔ LinearIndependent K (Fin.tail v) ∧ v 0 ∉ Submodule.span K (Set.range (Fin.tail v))
-- linearIndependent_fin_succ'
theorem linearIndependent_fin_succ' {n} {v : Fin (n + 1) → V} : LinearIndependent K v ↔
    LinearIndependent K (Fin.init v) ∧ v (Fin.last _) ∉ Submodule.span K (range <| Fin.init v) 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {n : ℕ} {v : Fin (n + 1) → V}
Goal: LinearIndependent K v ↔ LinearIndependent K (Fin.init v) ∧ v (Fin.last n) ∉ Submodule.span K (Set.range (Fin.init v))
-- linearIndependent_fin2
theorem linearIndependent_fin2 {f : Fin 2 → V} :
    LinearIndependent K f ↔ f 1 ≠ 0 ∧ ∀ a : K, a • f 1 ≠ f 0 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {f : Fin 2 → V}
Goal: LinearIndependent K f ↔ f 1 ≠ 0 ∧ ∀ (a : K), a • f 1 ≠ f 0
-- exists_linearIndependent_extension
theorem exists_linearIndependent_extension (hs : LinearIndependent K ((↑) : s → V)) (hst : s ⊆ t) :
    ∃ b ⊆ t, s ⊆ b ∧ t ⊆ span K b ∧ LinearIndependent K ((↑) : b → V) 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {s t : Set V} (hs : LinearIndependent (ι := { x // x ∈ s }) K Subtype.val) (hst : s ⊆ t)
Goal: ∃ b ⊆ t, s ⊆ b ∧ t ⊆ ↑(Submodule.span K b) ∧ LinearIndependent (ι := { x // x ∈ b }) K Subtype.val
-- exists_linearIndependent
theorem exists_linearIndependent :
    ∃ b ⊆ t, span K b = span K t ∧ LinearIndependent K ((↑) : b → V) 
Arguments: (K : Type u_3) {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] (t : Set V)
Goal: ∃ b ⊆ t, Submodule.span K b = Submodule.span K t ∧ LinearIndependent (ι := { x // x ∈ b }) K Subtype.val
-- LinearIndependent.extend_subset
theorem LinearIndependent.extend_subset (hs : LinearIndependent K (fun x => x : s → V))
    (hst : s ⊆ t) : hs.extend hst ⊆ t 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {s t : Set V} (hs : LinearIndependent K fun (x : ↑s) => ↑x) (hst : s ⊆ t)
Goal: hs.extend hst ⊆ t
-- LinearIndependent.subset_extend
theorem LinearIndependent.subset_extend (hs : LinearIndependent K (fun x => x : s → V))
    (hst : s ⊆ t) : s ⊆ hs.extend hst 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {s t : Set V} (hs : LinearIndependent K fun (x : ↑s) => ↑x) (hst : s ⊆ t)
Goal: s ⊆ hs.extend hst
-- LinearIndependent.subset_span_extend
theorem LinearIndependent.subset_span_extend (hs : LinearIndependent K (fun x => x : s → V))
    (hst : s ⊆ t) : t ⊆ span K (hs.extend hst) 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {s t : Set V} (hs : LinearIndependent K fun (x : ↑s) => ↑x) (hst : s ⊆ t)
Goal: t ⊆ ↑(Submodule.span K (hs.extend hst))
-- LinearIndependent.linearIndependent_extend
theorem LinearIndependent.linearIndependent_extend (hs : LinearIndependent K (fun x => x : s → V))
    (hst : s ⊆ t) : LinearIndependent K ((↑) : hs.extend hst → V) 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {s t : Set V} (hs : LinearIndependent K fun (x : ↑s) => ↑x) (hst : s ⊆ t)
Goal: LinearIndependent (ι := { x // x ∈ hs.extend hst }) K Subtype.val
-- exists_of_linearIndependent_of_finite_span
theorem exists_of_linearIndependent_of_finite_span {t : Finset V}
    (hs : LinearIndependent K (fun x => x : s → V)) (hst : s ⊆ (span K ↑t : Submodule K V)) :
    ∃ t' : Finset V, ↑t' ⊆ s ∪ ↑t ∧ s ⊆ ↑t' ∧ t'.card = t.card 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {s : Set V} {t : Finset V} (hs : LinearIndependent K fun (x : ↑s) => ↑x) (hst : s ⊆ ↑(Submodule.span K ↑t))
Goal: ∃ t', ↑t' ⊆ s ∪ ↑t ∧ s ⊆ ↑t' ∧ t'.card = t.card
-- exists_finite_card_le_of_finite_of_linearIndependent_of_span
theorem exists_finite_card_le_of_finite_of_linearIndependent_of_span (ht : t.Finite)
    (hs : LinearIndependent K (fun x => x : s → V)) (hst : s ⊆ span K t) :
    ∃ h : s.Finite, h.toFinset.card ≤ ht.toFinset.card 
Arguments: {K : Type u_3} {V : Type u} [DivisionRing K] [AddCommGroup V] [Module K V] {s t : Set V} (ht : t.Finite) (hs : LinearIndependent K fun (x : ↑s) => ↑x) (hst : s ⊆ ↑(Submodule.span K t))
Goal: ∃ (h : s.Finite), h.toFinset.card ≤ ht.toFinset.card
-- Submodule.mulMap_tmul
@[simp]
theorem mulMap_tmul (m : M) (n : N) : mulMap M N (m ⊗ₜ[R] n) = m.1 * n.1 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] (M N : Submodule R S) (m : ↥M) (n : ↥N)
Goal: (M.mulMap N) (m ⊗ₜ[R] n) = ↑m * ↑n
-- Submodule.mulMap_op
theorem mulMap_op :
    mulMap (equivOpposite.symm (MulOpposite.op M)) (equivOpposite.symm (MulOpposite.op N)) =
    (MulOpposite.opLinearEquiv R).toLinearMap ∘ₗ mulMap N M ∘ₗ
    (TensorProduct.congr
      (LinearEquiv.ofSubmodule' (MulOpposite.opLinearEquiv R).symm M)
      (LinearEquiv.ofSubmodule' (MulOpposite.opLinearEquiv R).symm N) ≪≫ₗ
    TensorProduct.comm R M N).toLinearMap 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] (M N : Submodule R S)
Goal: (Submodule.equivOpposite.symm (MulOpposite.op M)).mulMap (Submodule.equivOpposite.symm (MulOpposite.op N)) =
  ↑(MulOpposite.opLinearEquiv R) ∘ₗ
    N.mulMap M ∘ₗ
      ↑(TensorProduct.congr ((MulOpposite.opLinearEquiv R).symm.ofSubmodule' M)
            ((MulOpposite.opLinearEquiv R).symm.ofSubmodule' N) ≪≫ₗ
          TensorProduct.comm R ↥M ↥N)
-- Submodule.mulMap_comm_of_commute
theorem mulMap_comm_of_commute (hc : ∀ (m : M) (n : N), Commute m.1 n.1) :
    mulMap N M = mulMap M N ∘ₗ TensorProduct.comm R N M 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] (M N : Submodule R S) (hc : ∀ (m : ↥M) (n : ↥N), Commute ↑m ↑n)
Goal: N.mulMap M = M.mulMap N ∘ₗ ↑(TensorProduct.comm R ↥N ↥M)
-- Submodule.mulMap_comp_rTensor
theorem mulMap_comp_rTensor {M' : Submodule R S} (hM : M' ≤ M) :
    mulMap M N ∘ₗ (inclusion hM).rTensor N = mulMap M' N 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {M : Submodule R S} (N : Submodule R S) {M' : Submodule R S} (hM : M' ≤ M)
Goal: M.mulMap N ∘ₗ LinearMap.rTensor (↥N) (Submodule.inclusion hM) = M'.mulMap N
-- Submodule.mulMap_comp_lTensor
theorem mulMap_comp_lTensor {N' : Submodule R S} (hN : N' ≤ N) :
    mulMap M N ∘ₗ (inclusion hN).lTensor M = mulMap M N' 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] (M : Submodule R S) {N N' : Submodule R S} (hN : N' ≤ N)
Goal: M.mulMap N ∘ₗ LinearMap.lTensor (↥M) (Submodule.inclusion hN) = M.mulMap N'
-- Submodule.mulMap_comp_map_inclusion
theorem mulMap_comp_map_inclusion {M' N' : Submodule R S} (hM : M' ≤ M) (hN : N' ≤ N) :
    mulMap M N ∘ₗ TensorProduct.map (inclusion hM) (inclusion hN) = mulMap M' N' 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {M N M' N' : Submodule R S} (hM : M' ≤ M) (hN : N' ≤ N)
Goal: M.mulMap N ∘ₗ TensorProduct.map (Submodule.inclusion hM) (Submodule.inclusion hN) = M'.mulMap N'
-- Submodule.mulMap_eq_mul'_comp_mapIncl
theorem mulMap_eq_mul'_comp_mapIncl : mulMap M N = .mul' R S ∘ₗ TensorProduct.mapIncl M N 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] (M N : Submodule R S)
Goal: M.mulMap N = LinearMap.mul' R S ∘ₗ TensorProduct.mapIncl M N
-- Submodule.mulMap_range
theorem mulMap_range : LinearMap.range (mulMap M N) = M * N 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] (M N : Submodule R S)
Goal: LinearMap.range (M.mulMap N) = M * N
-- Submodule.val_mulMap'_tmul
@[simp]
theorem val_mulMap'_tmul (m : M) (n : N) : (mulMap' M N (m ⊗ₜ[R] n) : S) = m.1 * n.1 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {M N : Submodule R S} (m : ↥M) (n : ↥N)
Goal: ↑((M.mulMap' N) (m ⊗ₜ[R] n)) = ↑m * ↑n
-- Submodule.mulMap'_surjective
theorem mulMap'_surjective : Function.Surjective (mulMap' M N) 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] (M N : Submodule R S)
Goal: Function.Surjective ⇑(M.mulMap' N)
-- Submodule.lTensorOne'_tmul
@[simp]
theorem lTensorOne'_tmul (y : R) (n : N) :
    N.lTensorOne' (algebraMap R _ y ⊗ₜ[R] n) = y • n 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {N : Submodule R S} (y : R) (n : ↥N)
Goal: N.lTensorOne' ((algebraMap R ↥⊥) y ⊗ₜ[R] n) = y • n
-- Submodule.lTensorOne'_one_tmul
@[simp]
theorem lTensorOne'_one_tmul (n : N) : N.lTensorOne' (1 ⊗ₜ[R] n) = n 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {N : Submodule R S} (n : ↥N)
Goal: N.lTensorOne' (1 ⊗ₜ[R] n) = n
-- Submodule.lTensorOne_tmul
@[simp]
theorem lTensorOne_tmul (y : R) (n : N) : N.lTensorOne (algebraMap R _ y ⊗ₜ[R] n) = y • n 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {N : Submodule R S} (y : R) (n : ↥N)
Goal: N.lTensorOne ((algebraMap R ↥⊥) y ⊗ₜ[R] n) = y • n
-- Submodule.lTensorOne_one_tmul
@[simp]
theorem lTensorOne_one_tmul (n : N) : N.lTensorOne (1 ⊗ₜ[R] n) = n 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {N : Submodule R S} (n : ↥N)
Goal: N.lTensorOne (1 ⊗ₜ[R] n) = n
-- Submodule.lTensorOne_symm_apply
@[simp]
theorem lTensorOne_symm_apply (n : N) : N.lTensorOne.symm n = 1 ⊗ₜ[R] n 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {N : Submodule R S} (n : ↥N)
Goal: N.lTensorOne.symm n = 1 ⊗ₜ[R] n
-- Submodule.mulMap_one_left_eq
theorem mulMap_one_left_eq : mulMap 1 N = N.subtype ∘ₗ N.lTensorOne.toLinearMap 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] (N : Submodule R S)
Goal: Submodule.mulMap 1 N = N.subtype ∘ₗ ↑N.lTensorOne
-- Submodule.rTensorOne'_tmul
@[simp]
theorem rTensorOne'_tmul (y : R) (m : M) :
    M.rTensorOne' (m ⊗ₜ[R] algebraMap R _ y) = y • m 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {M : Submodule R S} (y : R) (m : ↥M)
Goal: M.rTensorOne' (m ⊗ₜ[R] (algebraMap R ↥⊥) y) = y • m
-- Submodule.rTensorOne'_tmul_one
@[simp]
theorem rTensorOne'_tmul_one (m : M) : M.rTensorOne' (m ⊗ₜ[R] 1) = m 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {M : Submodule R S} (m : ↥M)
Goal: M.rTensorOne' (m ⊗ₜ[R] 1) = m
-- Submodule.rTensorOne_tmul
@[simp]
theorem rTensorOne_tmul (y : R) (m : M) : M.rTensorOne (m ⊗ₜ[R] algebraMap R _ y) = y • m 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {M : Submodule R S} (y : R) (m : ↥M)
Goal: M.rTensorOne (m ⊗ₜ[R] (algebraMap R ↥⊥) y) = y • m
-- Submodule.rTensorOne_tmul_one
@[simp]
theorem rTensorOne_tmul_one (m : M) : M.rTensorOne (m ⊗ₜ[R] 1) = m 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {M : Submodule R S} (m : ↥M)
Goal: M.rTensorOne (m ⊗ₜ[R] 1) = m
-- Submodule.rTensorOne_symm_apply
@[simp]
theorem rTensorOne_symm_apply (m : M) : M.rTensorOne.symm m = m ⊗ₜ[R] 1 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {M : Submodule R S} (m : ↥M)
Goal: M.rTensorOne.symm m = m ⊗ₜ[R] 1
-- Submodule.mulMap_one_right_eq
theorem mulMap_one_right_eq : mulMap M 1 = M.subtype ∘ₗ M.rTensorOne.toLinearMap 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] (M : Submodule R S)
Goal: M.mulMap 1 = M.subtype ∘ₗ ↑M.rTensorOne
-- Submodule.comm_trans_lTensorOne
@[simp]
theorem comm_trans_lTensorOne :
    (TensorProduct.comm R _ _).trans M.lTensorOne = M.rTensorOne 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] (M : Submodule R S)
Goal: TensorProduct.comm R ↥M ↥⊥ ≪≫ₗ M.lTensorOne = M.rTensorOne
-- Submodule.comm_trans_rTensorOne
@[simp]
theorem comm_trans_rTensorOne :
    (TensorProduct.comm R _ _).trans M.rTensorOne = M.lTensorOne 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] (M : Submodule R S)
Goal: TensorProduct.comm R ↥⊥ ↥M ≪≫ₗ M.rTensorOne = M.lTensorOne
-- Submodule.mulLeftMap_eq_mulMap_comp
theorem mulLeftMap_eq_mulMap_comp {ι : Type*} [DecidableEq ι] (m : ι → M) :
    mulLeftMap N m = mulMap M N ∘ₗ LinearMap.rTensor N (Finsupp.total ι M R m) ∘ₗ
      (TensorProduct.finsuppScalarLeft R N ι).symm.toLinearMap 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {M : Submodule R S} (N : Submodule R S) {ι : Type u_1} [DecidableEq ι] (m : ι → ↥M)
Goal: Submodule.mulLeftMap N m =
  M.mulMap N ∘ₗ LinearMap.rTensor (↥N) (Finsupp.total ι (↥M) R m) ∘ₗ ↑(TensorProduct.finsuppScalarLeft R (↥N) ι).symm
-- Submodule.mulRightMap_eq_mulMap_comp
theorem mulRightMap_eq_mulMap_comp {ι : Type*} [DecidableEq ι] (n : ι → N) :
    mulRightMap M n = mulMap M N ∘ₗ LinearMap.lTensor M (Finsupp.total ι N R n) ∘ₗ
      (TensorProduct.finsuppScalarRight R M ι).symm.toLinearMap 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] (M : Submodule R S) {N : Submodule R S} {ι : Type u_1} [DecidableEq ι] (n : ι → ↥N)
Goal: M.mulRightMap n =
  M.mulMap N ∘ₗ LinearMap.lTensor (↥M) (Finsupp.total ι (↥N) R n) ∘ₗ ↑(TensorProduct.finsuppScalarRight R (↥M) ι).symm
-- Submodule.mulMap_comm
theorem mulMap_comm : mulMap N M = (mulMap M N).comp (TensorProduct.comm R N M).toLinearMap 
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [CommSemiring S] [Algebra R S] (M N : Submodule R S)
Goal: N.mulMap M = M.mulMap N ∘ₗ ↑(TensorProduct.comm R ↥N ↥M)
-- QuadraticMap.map_add
protected theorem map_add (f : M → N) (x y : M) :
    f (x + y) = f x + f y + polar f x y 
Arguments: {M : Type u_4} {N : Type u_5} [AddCommGroup M] [AddCommGroup N] (f : M → N) (x y : M)
Goal: f (x + y) = f x + f y + QuadraticMap.polar f x y
-- QuadraticMap.polar_add
theorem polar_add (f g : M → N) (x y : M) : polar (f + g) x y = polar f x y + polar g x y 
Arguments: {M : Type u_4} {N : Type u_5} [AddCommGroup M] [AddCommGroup N] (f g : M → N) (x y : M)
Goal: QuadraticMap.polar (f + g) x y = QuadraticMap.polar f x y + QuadraticMap.polar g x y
-- QuadraticMap.polar_neg
theorem polar_neg (f : M → N) (x y : M) : polar (-f) x y = -polar f x y 
Arguments: {M : Type u_4} {N : Type u_5} [AddCommGroup M] [AddCommGroup N] (f : M → N) (x y : M)
Goal: QuadraticMap.polar (-f) x y = -QuadraticMap.polar f x y
-- QuadraticMap.polar_smul
theorem polar_smul [Monoid S] [DistribMulAction S N] (f : M → N) (s : S) (x y : M) :
    polar (s • f) x y = s • polar f x y 
Arguments: {S : Type u_1} {M : Type u_4} {N : Type u_5} [AddCommGroup M] [AddCommGroup N] [Monoid S] [DistribMulAction S N] (f : M → N) (s : S) (x y : M)
Goal: QuadraticMap.polar (s • f) x y = s • QuadraticMap.polar f x y
-- QuadraticMap.polar_comm
theorem polar_comm (f : M → N) (x y : M) : polar f x y = polar f y x 
Arguments: {M : Type u_4} {N : Type u_5} [AddCommGroup M] [AddCommGroup N] (f : M → N) (x y : M)
Goal: QuadraticMap.polar f x y = QuadraticMap.polar f y x
-- QuadraticMap.polar_add_left_iff
theorem polar_add_left_iff {f : M → N} {x x' y : M} :
    polar f (x + x') y = polar f x y + polar f x' y ↔
      f (x + x' + y) + (f x + f x' + f y) = f (x + x') + f (x' + y) + f (y + x) 
Arguments: {M : Type u_4} {N : Type u_5} [AddCommGroup M] [AddCommGroup N] {f : M → N} {x x' y : M}
Goal: QuadraticMap.polar f (x + x') y = QuadraticMap.polar f x y + QuadraticMap.polar f x' y ↔
  f (x + x' + y) + (f x + f x' + f y) = f (x + x') + f (x' + y) + f (y + x)
-- QuadraticMap.polar_comp
theorem polar_comp {F : Type*} [CommRing S] [FunLike F N S] [AddMonoidHomClass F N S]
    (f : M → N) (g : F) (x y : M) :
    polar (g ∘ f) x y = g (polar f x y) 
Arguments: {S : Type u_1} {M : Type u_4} {N : Type u_5} [AddCommGroup M] [AddCommGroup N] {F : Type u_8} [CommRing S] [FunLike F N S] [AddMonoidHomClass F N S] (f : M → N) (g : F) (x y : M)
Goal: QuadraticMap.polar (⇑g ∘ f) x y = g (QuadraticMap.polar f x y)
-- QuadraticMap.toFun_smul
structure QuadraticMap (R : Type u) (M : Type v) (N : Type w) [CommSemiring R] [AddCommMonoid M]
    [Module R M] [AddCommMonoid N] [Module R N] where
  toFun : M → N
  toFun_smul : ∀ (a : R) (x : M), toFun (a • x) = (a * a) • toFun x
  exists_companion' : ∃ B : BilinMap R M N, ∀ x y, toFun (x + y) = toFun x + toFun y + B x y
Arguments: {R : Type u} {M : Type v} {N : Type w} [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N] (self : QuadraticMap R M N) (a : R) (x : M)
Goal: self.toFun (a • x) = (a * a) • self.toFun x
-- QuadraticMap.exists_companion'
structure QuadraticMap (R : Type u) (M : Type v) (N : Type w) [CommSemiring R] [AddCommMonoid M]
    [Module R M] [AddCommMonoid N] [Module R N] where
  toFun : M → N
  toFun_smul : ∀ (a : R) (x : M), toFun (a • x) = (a * a) • toFun x
  exists_companion' : ∃ B : BilinMap R M N, ∀ x y, toFun (x + y) = toFun x + toFun y + B x y
Arguments: {R : Type u} {M : Type v} {N : Type w} [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N] (self : QuadraticMap R M N)
Goal: ∃ B, ∀ (x y : M), self.toFun (x + y) = self.toFun x + self.toFun y + (B x) y
-- QuadraticMap.toFun_eq_coe
@[simp]
theorem toFun_eq_coe : Q.toFun = ⇑Q 
Arguments: {R : Type u_3} {M : Type u_4} {N : Type u_5} [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N] (Q : QuadraticMap R M N)
Goal: Q.toFun = ⇑Q
-- QuadraticMap.ext
@[ext]
theorem ext (H : ∀ x : M, Q x = Q' x) : Q = Q' 
Arguments: {R : Type u_3} {M : Type u_4} {N : Type u_5} [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N] {Q Q' : QuadraticMap R M N} (H : ∀ (x : M), Q x = Q' x)
Goal: Q = Q'
-- QuadraticMap.congr_fun
theorem congr_fun (h : Q = Q') (x : M) : Q x = Q' x 
Arguments: {R : Type u_3} {M : Type u_4} {N : Type u_5} [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N] {Q Q' : QuadraticMap R M N} (h : Q = Q') (x : M)
Goal: Q x = Q' x
-- QuadraticMap.ext_iff
theorem ext_iff : Q = Q' ↔ ∀ x, Q x = Q' x 
Arguments: {R : Type u_3} {M : Type u_4} {N : Type u_5} [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N] {Q Q' : QuadraticMap R M N}
Goal: Q = Q' ↔ ∀ (x : M), Q x = Q' x
-- QuadraticMap.coe_copy
@[simp]
theorem coe_copy (Q : QuadraticMap R M N) (Q' : M → N) (h : Q' = ⇑Q) : ⇑(Q.copy Q' h) = Q' 
Arguments: {R : Type u_3} {M : Type u_4} {N : Type u_5} [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N] (Q : QuadraticMap R M N) (Q' : M → N) (h : Q' = ⇑Q)
Goal: ⇑(Q.copy Q' h) = Q'
-- QuadraticMap.copy_eq
theorem copy_eq (Q : QuadraticMap R M N) (Q' : M → N) (h : Q' = ⇑Q) : Q.copy Q' h = Q 
Arguments: {R : Type u_3} {M : Type u_4} {N : Type u_5} [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N] (Q : QuadraticMap R M N) (Q' : M → N) (h : Q' = ⇑Q)
Goal: Q.copy Q' h = Q
-- QuadraticMap.map_smul
theorem map_smul (a : R) (x : M) : Q (a • x) = (a * a) • Q x 
Arguments: {R : Type u_3} {M : Type u_4} {N : Type u_5} [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N] (Q : QuadraticMap R M N) (a : R) (x : M)
Goal: Q (a • x) = (a * a) • Q x
-- QuadraticMap.exists_companion
theorem exists_companion : ∃ B : BilinMap R M N, ∀ x y, Q (x + y) = Q x + Q y + B x y 
Arguments: {R : Type u_3} {M : Type u_4} {N : Type u_5} [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N] (Q : QuadraticMap R M N)
Goal: ∃ B, ∀ (x y : M), Q (x + y) = Q x + Q y + (B x) y
-- QuadraticMap.map_add_add_add_map
theorem map_add_add_add_map (x y z : M) :
    Q (x + y + z) + (Q x + Q y + Q z) = Q (x + y) + Q (y + z) + Q (z + x) 
Arguments: {R : Type u_3} {M : Type u_4} {N : Type u_5} [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N] (Q : QuadraticMap R M N) (x y z : M)
Goal: Q (x + y + z) + (Q x + Q y + Q z) = Q (x + y) + Q (y + z) + Q (z + x)
-- QuadraticMap.map_add_self
theorem map_add_self (x : M) : Q (x + x) = 4 • Q x 
Arguments: {R : Type u_3} {M : Type u_4} {N : Type u_5} [CommSemiring R] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N] (Q : QuadraticMap R M N) (x : M)
Goal: Q (x + x) = 4 • Q x