ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/LinearAlgebra/CliffordAlgebra/Inversion.lean

full_name: CliffordAlgebra.invertibleιOfInvertible
code: /-- If the quadratic form of a vector is invertible, then so is that vector. -/
def invertibleιOfInvertible (m : M) [Invertible (Q m)] : Invertible (ι Q m) 
goal: Invertible ((CliffordAlgebra.ι Q) m)

full_name: CliffordAlgebra.invOf_ι
code: /-- For a vector with invertible quadratic form, $v^{-1} = \frac{v}{Q(v)}$ -/
theorem invOf_ι (m : M) [Invertible (Q m)] [Invertible (ι Q m)] :
    ⅟ (ι Q m) = ι Q (⅟ (Q m) • m) 
goal: ⅟((CliffordAlgebra.ι Q) m) = (CliffordAlgebra.ι Q) (⅟(Q m) • m)

full_name: CliffordAlgebra.isUnit_ι_of_isUnit
code: theorem isUnit_ι_of_isUnit {m : M} (h : IsUnit (Q m)) : IsUnit (ι Q m) 
goal: IsUnit ((CliffordAlgebra.ι Q) m)

full_name: CliffordAlgebra.ι_mul_ι_mul_invOf_ι
code: /-- $aba^{-1}$ is a vector. -/
theorem ι_mul_ι_mul_invOf_ι (a b : M) [Invertible (ι Q a)] [Invertible (Q a)] :
    ι Q a * ι Q b * ⅟ (ι Q a) = ι Q ((⅟ (Q a) * QuadraticMap.polar Q a b) • a - b) 
goal: (CliffordAlgebra.ι Q) a * (CliffordAlgebra.ι Q) b * ⅟((CliffordAlgebra.ι Q) a) =
  (CliffordAlgebra.ι Q) ((⅟(Q a) * QuadraticMap.polar (⇑Q) a b) • a - b)

full_name: CliffordAlgebra.invOf_ι_mul_ι_mul_ι
code: /-- $a^{-1}ba$ is a vector. -/
theorem invOf_ι_mul_ι_mul_ι (a b : M) [Invertible (ι Q a)] [Invertible (Q a)] :
    ⅟ (ι Q a) * ι Q b * ι Q a = ι Q ((⅟ (Q a) * QuadraticMap.polar Q a b) • a - b) 
goal: ⅟((CliffordAlgebra.ι Q) a) * (CliffordAlgebra.ι Q) b * (CliffordAlgebra.ι Q) a =
  (CliffordAlgebra.ι Q) ((⅟(Q a) * QuadraticMap.polar (⇑Q) a b) • a - b)

full_name: CliffordAlgebra.invertibleOfInvertibleι
code: /-- Over a ring where `2` is invertible, `Q m` is invertible whenever `ι Q m`. -/
def invertibleOfInvertibleι (m : M) [Invertible (ι Q m)] : Invertible (Q m) 
goal: Invertible (Q m)

full_name: CliffordAlgebra.isUnit_of_isUnit_ι
code: theorem isUnit_of_isUnit_ι {m : M} (h : IsUnit (ι Q m)) : IsUnit (Q m) 
goal: IsUnit (Q m)

full_name: CliffordAlgebra.isUnit_ι_iff
code: @[simp] theorem isUnit_ι_iff {m : M} : IsUnit (ι Q m) ↔ IsUnit (Q m) 
goal: IsUnit ((CliffordAlgebra.ι Q) m) ↔ IsUnit (Q m)
File: Mathlib/LinearAlgebra/Coevaluation.lean

full_name: coevaluation
code: /-- The coevaluation map is a linear map from a field `K` to a finite dimensional
  vector space `V`. -/
def coevaluation : K →ₗ[K] V ⊗[K] Module.Dual K V 
goal: K →ₗ[K] TensorProduct K V (Module.Dual K V)

full_name: coevaluation_apply_one
code: theorem coevaluation_apply_one :
    (coevaluation K V) (1 : K) =
      let bV := Basis.ofVectorSpace K V
      ∑ i : Basis.ofVectorSpaceIndex K V, bV i ⊗ₜ[K] bV.coord i 
goal: (coevaluation K V) 1 =
  let bV := Basis.ofVectorSpace K V;
  ∑ i : ↑(Basis.ofVectorSpaceIndex K V), bV i ⊗ₜ[K] bV.coord i

full_name: contractLeft_assoc_coevaluation
code: /-- This lemma corresponds to one of the coherence laws for duals in rigid categories, see
  `CategoryTheory.Monoidal.Rigid`. -/
theorem contractLeft_assoc_coevaluation :
    (contractLeft K V).rTensor _ ∘ₗ
        (TensorProduct.assoc K _ _ _).symm.toLinearMap ∘ₗ
          (coevaluation K V).lTensor (Module.Dual K V) =
      (TensorProduct.lid K _).symm.toLinearMap ∘ₗ (TensorProduct.rid K _).toLinearMap 
goal: LinearMap.rTensor (Module.Dual K V) (contractLeft K V) ∘ₗ
    ↑(TensorProduct.assoc K (Module.Dual K V) V (Module.Dual K V)).symm ∘ₗ
      LinearMap.lTensor (Module.Dual K V) (coevaluation K V) =
  ↑(TensorProduct.lid K (Module.Dual K V)).symm ∘ₗ ↑(TensorProduct.rid K (Module.Dual K V))

full_name: contractLeft_assoc_coevaluation'
code: /-- This lemma corresponds to one of the coherence laws for duals in rigid categories, see
  `CategoryTheory.Monoidal.Rigid`. -/
theorem contractLeft_assoc_coevaluation' :
    (contractLeft K V).lTensor _ ∘ₗ
        (TensorProduct.assoc K _ _ _).toLinearMap ∘ₗ (coevaluation K V).rTensor V =
      (TensorProduct.rid K _).symm.toLinearMap ∘ₗ (TensorProduct.lid K _).toLinearMap 
goal: LinearMap.lTensor V (contractLeft K V) ∘ₗ
    ↑(TensorProduct.assoc K V (Module.Dual K V) V) ∘ₗ LinearMap.rTensor V (coevaluation K V) =
  ↑(TensorProduct.rid K V).symm ∘ₗ ↑(TensorProduct.lid K V)
File: Mathlib/LinearAlgebra/QuadraticForm/Complex.lean

full_name: QuadraticForm.isometryEquivSumSquares
code: /-- The isometry between a weighted sum of squares on the complex numbers and the
sum of squares, i.e. `weightedSumSquares` with weights 1 or 0. -/
noncomputable def isometryEquivSumSquares (w' : ι → ℂ) :
    IsometryEquiv (weightedSumSquares ℂ w')
      (weightedSumSquares ℂ (fun i => if w' i = 0 then 0 else 1 : ι → ℂ)) 
goal: (QuadraticMap.weightedSumSquares ℂ w').IsometryEquiv
  (QuadraticMap.weightedSumSquares ℂ fun i => if w' i = 0 then 0 else 1)

full_name: QuadraticForm.isometryEquivSumSquaresUnits
code: /-- The isometry between a weighted sum of squares on the complex numbers and the
sum of squares, i.e. `weightedSumSquares` with weight `fun (i : ι) => 1`. -/
noncomputable def isometryEquivSumSquaresUnits (w : ι → Units ℂ) :
    IsometryEquiv (weightedSumSquares ℂ w) (weightedSumSquares ℂ (1 : ι → ℂ)) 
goal: (QuadraticMap.weightedSumSquares ℂ w).IsometryEquiv (QuadraticMap.weightedSumSquares ℂ 1)

full_name: QuadraticForm.equivalent_sum_squares
code: /-- A nondegenerate quadratic form on the complex numbers is equivalent to
the sum of squares, i.e. `weightedSumSquares` with weight `fun (i : ι) => 1`. -/
theorem equivalent_sum_squares {M : Type*} [AddCommGroup M] [Module ℂ M] [FiniteDimensional ℂ M]
    (Q : QuadraticForm ℂ M) (hQ : (associated (R := ℂ) Q).SeparatingLeft) :
    Equivalent Q (weightedSumSquares ℂ (1 : Fin (FiniteDimensional.finrank ℂ M) → ℂ)) 
goal: QuadraticMap.Equivalent Q (QuadraticMap.weightedSumSquares ℂ 1)

full_name: QuadraticForm.complex_equivalent
code: /-- All nondegenerate quadratic forms on the complex numbers are equivalent. -/
theorem complex_equivalent {M : Type*} [AddCommGroup M] [Module ℂ M] [FiniteDimensional ℂ M]
    (Q₁ Q₂ : QuadraticForm ℂ M) (hQ₁ : (associated (R := ℂ) Q₁).SeparatingLeft)
    (hQ₂ : (associated (R := ℂ) Q₂).SeparatingLeft) : Equivalent Q₁ Q₂ 
goal: QuadraticMap.Equivalent Q₁ Q₂
File: Mathlib/LinearAlgebra/QuadraticForm/Basis.lean

full_name: QuadraticMap.toBilin
code: /-- Given an ordered basis, produce a bilinear form associated with the quadratic form.

Unlike `QuadraticMap.associated`, this is not symmetric; however, as a result it can be used even
in characteristic two. When considered as a matrix, the form is triangular. -/
noncomputable def toBilin (Q : QuadraticMap R M N) (bm : Basis ι R M) : LinearMap.BilinMap R M N 
goal: LinearMap.BilinMap R M N

full_name: QuadraticMap.toBilin_apply
code: theorem toBilin_apply (Q : QuadraticMap R M N) (bm : Basis ι R M) (i j : ι) :
    Q.toBilin bm (bm i) (bm j) =
      if i = j then Q (bm i) else if i < j then polar Q (bm i) (bm j) else 0 
goal: ((Q.toBilin bm) (bm i)) (bm j) = if i = j then Q (bm i) else if i < j then QuadraticMap.polar (⇑Q) (bm i) (bm j) else 0

full_name: QuadraticMap.toQuadraticMap_toBilin
code: theorem toQuadraticMap_toBilin (Q : QuadraticMap R M N) (bm : Basis ι R M) :
    (Q.toBilin bm).toQuadraticMap = Q 
goal: (Q.toBilin bm).toQuadraticMap = Q

full_name: LinearMap.BilinMap.toQuadraticMap_surjective
code: /-- From a free module, every quadratic map can be built from a bilinear form.

See `BilinMap.not_forall_toQuadraticMap_surjective` for a counterexample when the module is
not free. -/
theorem _root_.LinearMap.BilinMap.toQuadraticMap_surjective [Module.Free R M] :
    Function.Surjective (LinearMap.BilinMap.toQuadraticMap : LinearMap.BilinMap R M N → _) 
goal: Function.Surjective LinearMap.BilinMap.toQuadraticMap
File: Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat/Symmetric.lean

full_name: QuadraticModuleCat.instBraidedCategory
code: instance : BraidedCategory (QuadraticModuleCat.{u} R) 
goal: CategoryTheory.BraidedCategory (QuadraticModuleCat R)

full_name: QuadraticModuleCat.toModuleCatBraidedFunctor_toMonoidalFunctor
code: /-- `forget₂ (QuadraticModuleCat R) (ModuleCat R)` as a braided functor. -/
@[simps toMonoidalFunctor]
def toModuleCatBraidedFunctor : BraidedFunctor (QuadraticModuleCat.{u} R) (ModuleCat.{u} R) 
goal: (QuadraticModuleCat.toModuleCatBraidedFunctor R).toMonoidalFunctor = QuadraticModuleCat.toModuleCatMonoidalFunctor R

full_name: QuadraticModuleCat.toModuleCatBraidedFunctor
code: /-- `forget₂ (QuadraticModuleCat R) (ModuleCat R)` as a braided functor. -/
@[simps toMonoidalFunctor]
def toModuleCatBraidedFunctor : BraidedFunctor (QuadraticModuleCat.{u} R) (ModuleCat.{u} R) 
goal: CategoryTheory.BraidedFunctor (QuadraticModuleCat R) (ModuleCat R)

full_name: QuadraticModuleCat.instFaithfulModuleCatToModuleCatBraidedFunctor
code: instance : (toModuleCatBraidedFunctor R).Faithful 
goal: (QuadraticModuleCat.toModuleCatBraidedFunctor R).Faithful

full_name: QuadraticModuleCat.instSymmetricCategory
code: instance instSymmetricCategory : SymmetricCategory (QuadraticModuleCat.{u} R) 
goal: CategoryTheory.SymmetricCategory (QuadraticModuleCat R)
File: Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat/Monoidal.lean

full_name: QuadraticModuleCat.instMonoidalCategory.tensorObj
code: /-- Auxiliary definition used to build `QuadraticModuleCat.instMonoidalCategory`. -/
@[simps! form]
noncomputable abbrev tensorObj (X Y : QuadraticModuleCat.{u} R) : QuadraticModuleCat.{u} R 
goal: QuadraticModuleCat R

full_name: QuadraticModuleCat.instMonoidalCategory.tensorObj_form
code: /-- Auxiliary definition used to build `QuadraticModuleCat.instMonoidalCategory`. -/
@[simps! form]
noncomputable abbrev tensorObj (X Y : QuadraticModuleCat.{u} R) : QuadraticModuleCat.{u} R 
goal: (QuadraticModuleCat.instMonoidalCategory.tensorObj X Y).form = X.form.tmul Y.form

full_name: QuadraticModuleCat.instMonoidalCategory.tensorHom
code: /-- Auxiliary definition used to build `QuadraticModuleCat.instMonoidalCategory`.

We want this up front so that we can re-use it to define `whiskerLeft` and `whiskerRight`. -/
noncomputable abbrev tensorHom {W X Y Z : QuadraticModuleCat.{u} R} (f : W ⟶ X) (g : Y ⟶ Z) :
    tensorObj W Y ⟶ tensorObj X Z 
goal: QuadraticModuleCat.instMonoidalCategory.tensorObj W Y ⟶ QuadraticModuleCat.instMonoidalCategory.tensorObj X Z

full_name: QuadraticModuleCat.instMonoidalCategoryStruct
code: instance : MonoidalCategoryStruct (QuadraticModuleCat.{u} R) 
goal: CategoryTheory.MonoidalCategoryStruct (QuadraticModuleCat R)

full_name: QuadraticModuleCat.toModuleCat_tensor
code: @[simp] theorem toModuleCat_tensor (X Y : QuadraticModuleCat.{u} R) :
    (X ⊗ Y).toModuleCat = X.toModuleCat ⊗ Y.toModuleCat 
goal: (X ⊗ Y).toModuleCat = X.toModuleCat ⊗ Y.toModuleCat

full_name: QuadraticModuleCat.forget₂_map_associator_hom
code: theorem forget₂_map_associator_hom (X Y Z : QuadraticModuleCat.{u} R) :
    (forget₂ (QuadraticModuleCat R) (ModuleCat R)).map (α_ X Y Z).hom =
      (α_ X.toModuleCat Y.toModuleCat Z.toModuleCat).hom 
goal: (CategoryTheory.forget₂ (QuadraticModuleCat R) (ModuleCat R)).map (α_ X Y Z).hom =
  (α_ X.toModuleCat Y.toModuleCat Z.toModuleCat).hom

full_name: QuadraticModuleCat.forget₂_map_associator_inv
code: theorem forget₂_map_associator_inv (X Y Z : QuadraticModuleCat.{u} R) :
    (forget₂ (QuadraticModuleCat R) (ModuleCat R)).map (α_ X Y Z).inv =
      (α_ X.toModuleCat Y.toModuleCat Z.toModuleCat).inv 
goal: (CategoryTheory.forget₂ (QuadraticModuleCat R) (ModuleCat R)).map (α_ X Y Z).inv =
  (α_ X.toModuleCat Y.toModuleCat Z.toModuleCat).inv

full_name: QuadraticModuleCat.instMonoidalCategory
code: noncomputable instance instMonoidalCategory : MonoidalCategory (QuadraticModuleCat.{u} R) 
goal: CategoryTheory.MonoidalCategory (QuadraticModuleCat R)

full_name: QuadraticModuleCat.toModuleCatMonoidalFunctor
code: /-- `forget₂ (QuadraticModuleCat R) (ModuleCat R)` as a monoidal functor. -/
def toModuleCatMonoidalFunctor : MonoidalFunctor (QuadraticModuleCat.{u} R) (ModuleCat.{u} R) 
goal: CategoryTheory.MonoidalFunctor (QuadraticModuleCat R) (ModuleCat R)

full_name: QuadraticModuleCat.instFaithfulModuleCatToModuleCatMonoidalFunctor
code: instance : (toModuleCatMonoidalFunctor R).Faithful 
goal: (QuadraticModuleCat.toModuleCatMonoidalFunctor R).Faithful
File: Mathlib/LinearAlgebra/AffineSpace/Basic.lean

full_name: Affine._aux_Mathlib_LinearAlgebra_AffineSpace_Basic___macroRules_Affine_termAffineSpace_1
code: @[inherit_doc] scoped[Affine] notation "AffineSpace" => AddTorsor
goal: Lean.Macro

full_name: Affine._aux_Mathlib_LinearAlgebra_AffineSpace_Basic___unexpand_AddTorsor_1
code: @[inherit_doc] scoped[Affine] notation "AffineSpace" => AddTorsor
goal: Lean.PrettyPrinter.Unexpander
File: Mathlib/LinearAlgebra/Multilinear/FiniteDimensional.lean

full_name: _private.Mathlib.LinearAlgebra.Multilinear.FiniteDimensional.0.MultilinearMap.free_and_finite_fin
code: private theorem free_and_finite_fin (n : ℕ) (N : Fin n → Type*) [∀ i, AddCommGroup (N i)]
    [∀ i, Module R (N i)] [∀ i, Module.Finite R (N i)] [∀ i, Module.Free R (N i)] :
    Module.Free R (MultilinearMap R N M₂) ∧ Module.Finite R (MultilinearMap R N M₂) 
goal: Module.Free R (MultilinearMap R N M₂) ∧ Module.Finite R (MultilinearMap R N M₂)

full_name: _private.Mathlib.LinearAlgebra.Multilinear.FiniteDimensional.0.MultilinearMap.free_and_finite
code: private theorem free_and_finite :
    Module.Free R (MultilinearMap R M₁ M₂) ∧ Module.Finite R (MultilinearMap R M₁ M₂) 
goal: Module.Free R (MultilinearMap R M₁ M₂) ∧ Module.Finite R (MultilinearMap R M₁ M₂)

full_name: Module.Finite.multilinearMap
code: instance _root_.Module.Finite.multilinearMap : Module.Finite R (MultilinearMap R M₁ M₂) 
goal: Module.Finite R (MultilinearMap R M₁ M₂)

full_name: Module.Free.multilinearMap
code: instance _root_.Module.Free.multilinearMap : Module.Free R (MultilinearMap R M₁ M₂) 
goal: Module.Free R (MultilinearMap R M₁ M₂)
File: Mathlib/LinearAlgebra/Multilinear/Basis.lean

full_name: Basis.ext_multilinear_fin
code: /-- Two multilinear maps indexed by `Fin n` are equal if they are equal when all arguments are
basis vectors. -/
theorem Basis.ext_multilinear_fin {f g : MultilinearMap R M M₂} {ι₁ : Fin n → Type*}
    (e : ∀ i, Basis (ι₁ i) R (M i))
    (h : ∀ v : ∀ i, ι₁ i, (f fun i => e i (v i)) = g fun i => e i (v i)) : f = g 
goal: f = g

full_name: Basis.ext_multilinear
code: /-- Two multilinear maps indexed by a `Fintype` are equal if they are equal when all arguments
are basis vectors. Unlike `Basis.ext_multilinear_fin`, this only uses a single basis; a
dependently-typed version would still be true, but the proof would need a dependently-typed
version of `dom_dom_congr`. -/
theorem Basis.ext_multilinear [Finite ι] {f g : MultilinearMap R (fun _ : ι => M₂) M₃} {ι₁ : Type*}
    (e : Basis ι₁ R M₂) (h : ∀ v : ι → ι₁, (f fun i => e (v i)) = g fun i => e (v i)) : f = g 
goal: f = g
File: Mathlib/LinearAlgebra/AffineSpace/MidpointZero.lean

full_name: lineMap_inv_two
code: theorem lineMap_inv_two {R : Type*} {V P : Type*} [DivisionRing R] [CharZero R] [AddCommGroup V]
    [Module R V] [AddTorsor V P] (a b : P) : lineMap a b (2⁻¹ : R) = midpoint R a b 
goal: (AffineMap.lineMap a b) 2⁻¹ = midpoint R a b

full_name: lineMap_one_half
code: theorem lineMap_one_half {R : Type*} {V P : Type*} [DivisionRing R] [CharZero R] [AddCommGroup V]
    [Module R V] [AddTorsor V P] (a b : P) : lineMap a b (1 / 2 : R) = midpoint R a b 
goal: (AffineMap.lineMap a b) (1 / 2) = midpoint R a b

full_name: homothety_invOf_two
code: theorem homothety_invOf_two {R : Type*} {V P : Type*} [CommRing R] [Invertible (2 : R)]
    [AddCommGroup V] [Module R V] [AddTorsor V P] (a b : P) :
    homothety a (⅟ 2 : R) b = midpoint R a b 
goal: (AffineMap.homothety a ⅟2) b = midpoint R a b

full_name: homothety_inv_two
code: theorem homothety_inv_two {k : Type*} {V P : Type*} [Field k] [CharZero k] [AddCommGroup V]
    [Module k V] [AddTorsor V P] (a b : P) : homothety a (2⁻¹ : k) b = midpoint k a b 
goal: (AffineMap.homothety a 2⁻¹) b = midpoint k a b

full_name: homothety_one_half
code: theorem homothety_one_half {k : Type*} {V P : Type*} [Field k] [CharZero k] [AddCommGroup V]
    [Module k V] [AddTorsor V P] (a b : P) : homothety a (1 / 2 : k) b = midpoint k a b 
goal: (AffineMap.homothety a (1 / 2)) b = midpoint k a b

full_name: pi_midpoint_apply
code: @[simp]
theorem pi_midpoint_apply {k ι : Type*} {V : ι → Type*} {P : ι → Type*} [Field k]
    [Invertible (2 : k)] [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)]
    [∀ i, AddTorsor (V i) (P i)] (f g : ∀ i, P i) (i : ι) :
    midpoint k f g i = midpoint k (f i) (g i) 
goal: midpoint k f g i = midpoint k (f i) (g i)
File: Mathlib/LinearAlgebra/AffineSpace/Pointwise.lean

full_name: AffineSubspace.pointwiseAddAction
code: /-- The additive action on an affine subspace corresponding to applying the action to every element.

This is available as an instance in the `Pointwise` locale. -/
protected def pointwiseAddAction : AddAction V (AffineSubspace k P) 
goal: AddAction V (AffineSubspace k P)

full_name: AffineSubspace.pointwise_vadd_eq_map
code: theorem pointwise_vadd_eq_map (v : V) (s : AffineSubspace k P) :
    v +ᵥ s = s.map (AffineEquiv.constVAdd k P v) 
goal: v +ᵥ s = AffineSubspace.map (↑(AffineEquiv.constVAdd k P v)) s

full_name: AffineSubspace.coe_pointwise_vadd
code: @[simp]
theorem coe_pointwise_vadd (v : V) (s : AffineSubspace k P) :
    ((v +ᵥ s : AffineSubspace k P) : Set P) = v +ᵥ (s : Set P) 
goal: ↑(v +ᵥ s) = v +ᵥ ↑s

full_name: AffineSubspace.vadd_mem_pointwise_vadd_iff
code: theorem vadd_mem_pointwise_vadd_iff {v : V} {s : AffineSubspace k P} {p : P} :
    v +ᵥ p ∈ v +ᵥ s ↔ p ∈ s 
goal: v +ᵥ p ∈ v +ᵥ s ↔ p ∈ s

full_name: AffineSubspace.pointwise_vadd_bot
code: @[simp] theorem pointwise_vadd_bot (v : V) : v +ᵥ (⊥ : AffineSubspace k P) = ⊥ 
goal: v +ᵥ ⊥ = ⊥

full_name: AffineSubspace.pointwise_vadd_top
code: @[simp] lemma pointwise_vadd_top (v : V) : v +ᵥ (⊤ : AffineSubspace k P) = ⊤ 
goal: v +ᵥ ⊤ = ⊤

full_name: AffineSubspace.pointwise_vadd_direction
code: theorem pointwise_vadd_direction (v : V) (s : AffineSubspace k P) :
    (v +ᵥ s).direction = s.direction 
goal: (v +ᵥ s).direction = s.direction

full_name: AffineSubspace.pointwise_vadd_span
code: theorem pointwise_vadd_span (v : V) (s : Set P) : v +ᵥ affineSpan k s = affineSpan k (v +ᵥ s) 
goal: v +ᵥ affineSpan k s = affineSpan k (v +ᵥ s)

full_name: AffineSubspace.map_pointwise_vadd
code: theorem map_pointwise_vadd (f : P₁ →ᵃ[k] P₂) (v : V₁) (s : AffineSubspace k P₁) :
    (v +ᵥ s).map f = f.linear v +ᵥ s.map f 
goal: AffineSubspace.map f (v +ᵥ s) = f.linear v +ᵥ AffineSubspace.map f s
File: Mathlib/LinearAlgebra/AffineSpace/Restrict.lean

full_name: AffineSubspace.nonempty_map
code: theorem AffineSubspace.nonempty_map {E : AffineSubspace k P₁} [Ene : Nonempty E] {φ : P₁ →ᵃ[k] P₂} :
    Nonempty (E.map φ) 
goal: Nonempty ↥(AffineSubspace.map φ E)

full_name: AffineMap.restrict
code: /-- Restrict domain and codomain of an affine map to the given subspaces. -/
def AffineMap.restrict (φ : P₁ →ᵃ[k] P₂) {E : AffineSubspace k P₁} {F : AffineSubspace k P₂}
    [Nonempty E] [Nonempty F] (hEF : E.map φ ≤ F) : E →ᵃ[k] F 
goal: ↥E →ᵃ[k] ↥F

full_name: AffineMap.restrict.coe_apply
code: theorem AffineMap.restrict.coe_apply (φ : P₁ →ᵃ[k] P₂) {E : AffineSubspace k P₁}
    {F : AffineSubspace k P₂} [Nonempty E] [Nonempty F] (hEF : E.map φ ≤ F) (x : E) :
    ↑(φ.restrict hEF x) = φ x 
goal: ↑((φ.restrict hEF) x) = φ ↑x

full_name: AffineMap.restrict.linear_aux
code: theorem AffineMap.restrict.linear_aux {φ : P₁ →ᵃ[k] P₂} {E : AffineSubspace k P₁}
    {F : AffineSubspace k P₂} (hEF : E.map φ ≤ F) : E.direction ≤ F.direction.comap φ.linear 
goal: E.direction ≤ Submodule.comap φ.linear F.direction

full_name: AffineMap.restrict.linear
code: theorem AffineMap.restrict.linear (φ : P₁ →ᵃ[k] P₂) {E : AffineSubspace k P₁}
    {F : AffineSubspace k P₂} [Nonempty E] [Nonempty F] (hEF : E.map φ ≤ F) :
    (φ.restrict hEF).linear = φ.linear.restrict (AffineMap.restrict.linear_aux hEF) 
goal: (φ.restrict hEF).linear = φ.linear.restrict ⋯

full_name: AffineMap.restrict.injective
code: theorem AffineMap.restrict.injective {φ : P₁ →ᵃ[k] P₂} (hφ : Function.Injective φ)
    {E : AffineSubspace k P₁} {F : AffineSubspace k P₂} [Nonempty E] [Nonempty F]
    (hEF : E.map φ ≤ F) : Function.Injective (AffineMap.restrict φ hEF) 
goal: Function.Injective ⇑(φ.restrict hEF)

full_name: AffineMap.restrict.surjective
code: theorem AffineMap.restrict.surjective (φ : P₁ →ᵃ[k] P₂) {E : AffineSubspace k P₁}
    {F : AffineSubspace k P₂} [Nonempty E] [Nonempty F] (h : E.map φ = F) :
    Function.Surjective (AffineMap.restrict φ (le_of_eq h)) 
goal: Function.Surjective ⇑(φ.restrict ⋯)

full_name: AffineMap.restrict.bijective
code: theorem AffineMap.restrict.bijective {E : AffineSubspace k P₁} [Nonempty E] {φ : P₁ →ᵃ[k] P₂}
    (hφ : Function.Injective φ) : Function.Bijective (φ.restrict (le_refl (E.map φ))) 
goal: Function.Bijective ⇑(φ.restrict ⋯)
File: Mathlib/LinearAlgebra/Charpoly/Basic.lean

full_name: LinearMap.charpoly
code: /-- The characteristic polynomial of `f : M →ₗ[R] M`. -/
def charpoly : R[X] 
goal: R[X]

full_name: LinearMap.charpoly_def
code: theorem charpoly_def : f.charpoly = (toMatrix (chooseBasis R M) (chooseBasis R M) f).charpoly 
goal: f.charpoly = ((LinearMap.toMatrix (Module.Free.chooseBasis R M) (Module.Free.chooseBasis R M)) f).charpoly

full_name: LinearMap.charpoly_monic
code: theorem charpoly_monic : f.charpoly.Monic 
goal: f.charpoly.Monic

full_name: LinearMap.charpoly_natDegree
code: lemma charpoly_natDegree [StrongRankCondition R] : natDegree (charpoly f) = finrank R M 
goal: f.charpoly.natDegree = FiniteDimensional.finrank R M

full_name: LinearMap.aeval_self_charpoly
code: /-- The **Cayley-Hamilton Theorem**, that the characteristic polynomial of a linear map, applied
to the linear map itself, is zero.

See `Matrix.aeval_self_charpoly` for the equivalent statement about matrices. -/
theorem aeval_self_charpoly : aeval f f.charpoly = 0 
goal: (Polynomial.aeval f) f.charpoly = 0

full_name: LinearMap.isIntegral
code: theorem isIntegral : IsIntegral R f 
goal: IsIntegral R f

full_name: LinearMap.minpoly_dvd_charpoly
code: theorem minpoly_dvd_charpoly {K : Type u} {M : Type v} [Field K] [AddCommGroup M] [Module K M]
    [FiniteDimensional K M] (f : M →ₗ[K] M) : minpoly K f ∣ f.charpoly 
goal: minpoly K f ∣ f.charpoly

full_name: LinearMap.aeval_eq_aeval_mod_charpoly
code: /-- Any endomorphism polynomial `p` is equivalent under evaluation to `p %ₘ f.charpoly`; that is,
`p` is equivalent to a polynomial with degree less than the dimension of the module. -/
theorem aeval_eq_aeval_mod_charpoly (p : R[X]) : aeval f p = aeval f (p %ₘ f.charpoly) 
goal: (Polynomial.aeval f) p = (Polynomial.aeval f) (p %ₘ f.charpoly)

full_name: LinearMap.pow_eq_aeval_mod_charpoly
code: /-- Any endomorphism power can be computed as the sum of endomorphism powers less than the
dimension of the module. -/
theorem pow_eq_aeval_mod_charpoly (k : ℕ) : f ^ k = aeval f (X ^ k %ₘ f.charpoly) 
goal: f ^ k = (Polynomial.aeval f) (Polynomial.X ^ k %ₘ f.charpoly)

full_name: LinearMap.minpoly_coeff_zero_of_injective
code: theorem minpoly_coeff_zero_of_injective (hf : Function.Injective f) :
    (minpoly R f).coeff 0 ≠ 0 
goal: (minpoly R f).coeff 0 ≠ 0