ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CliffordAlgebra.comp_ι_sq_scalar
@[simp]
theorem comp_ι_sq_scalar (g : CliffordAlgebra Q →ₐ[R] A) (m : M) :
    g (ι Q m) * g (ι Q m) = algebraMap _ _ (Q m) 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} {A : Type u_3} [Semiring A] [Algebra R A] (g : CliffordAlgebra Q →ₐ[R] A) (m : M)
Goal: g ((CliffordAlgebra.ι Q) m) * g ((CliffordAlgebra.ι Q) m) = (algebraMap R A) (Q m)
-- CliffordAlgebra.lift_symm_apply
@[simps symm_apply]
def lift :
    { f : M →ₗ[R] A // ∀ m, f m * f m = algebraMap _ _ (Q m) } ≃ (CliffordAlgebra Q →ₐ[R] A) 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] (Q : QuadraticForm R M) {A : Type u_3} [Semiring A] [Algebra R A] (F : CliffordAlgebra Q →ₐ[R] A)
Goal: (CliffordAlgebra.lift Q).symm F = ⟨F.toLinearMap ∘ₗ CliffordAlgebra.ι Q, ⋯⟩
-- CliffordAlgebra.ι_comp_lift
@[simp]
theorem ι_comp_lift (f : M →ₗ[R] A) (cond : ∀ m, f m * f m = algebraMap _ _ (Q m)) :
    (lift Q ⟨f, cond⟩).toLinearMap.comp (ι Q) = f 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} {A : Type u_3} [Semiring A] [Algebra R A] (f : M →ₗ[R] A) (cond : ∀ (m : M), f m * f m = (algebraMap R A) (Q m))
Goal: ((CliffordAlgebra.lift Q) ⟨f, cond⟩).toLinearMap ∘ₗ CliffordAlgebra.ι Q = f
-- CliffordAlgebra.lift_ι_apply
@[simp]
theorem lift_ι_apply (f : M →ₗ[R] A) (cond : ∀ m, f m * f m = algebraMap _ _ (Q m)) (x) :
    lift Q ⟨f, cond⟩ (ι Q x) = f x 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} {A : Type u_3} [Semiring A] [Algebra R A] (f : M →ₗ[R] A) (cond : ∀ (m : M), f m * f m = (algebraMap R A) (Q m)) (x : M)
Goal: ((CliffordAlgebra.lift Q) ⟨f, cond⟩) ((CliffordAlgebra.ι Q) x) = f x
-- CliffordAlgebra.lift_unique
@[simp]
theorem lift_unique (f : M →ₗ[R] A) (cond : ∀ m : M, f m * f m = algebraMap _ _ (Q m))
    (g : CliffordAlgebra Q →ₐ[R] A) : g.toLinearMap.comp (ι Q) = f ↔ g = lift Q ⟨f, cond⟩ 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} {A : Type u_3} [Semiring A] [Algebra R A] (f : M →ₗ[R] A) (cond : ∀ (m : M), f m * f m = (algebraMap R A) (Q m)) (g : CliffordAlgebra Q →ₐ[R] A)
Goal: g.toLinearMap ∘ₗ CliffordAlgebra.ι Q = f ↔ g = (CliffordAlgebra.lift Q) ⟨f, cond⟩
-- CliffordAlgebra.lift_comp_ι
@[simp]
theorem lift_comp_ι (g : CliffordAlgebra Q →ₐ[R] A) :
    lift Q ⟨g.toLinearMap.comp (ι Q), comp_ι_sq_scalar _⟩ = g 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} {A : Type u_3} [Semiring A] [Algebra R A] (g : CliffordAlgebra Q →ₐ[R] A)
Goal: (CliffordAlgebra.lift Q) ⟨g.toLinearMap ∘ₗ CliffordAlgebra.ι Q, ⋯⟩ = g
-- CliffordAlgebra.hom_ext
@[ext high]
theorem hom_ext {A : Type*} [Semiring A] [Algebra R A] {f g : CliffordAlgebra Q →ₐ[R] A} :
    f.toLinearMap.comp (ι Q) = g.toLinearMap.comp (ι Q) → f = g 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} {A : Type u_4} [Semiring A] [Algebra R A] {f g : CliffordAlgebra Q →ₐ[R] A}
Goal: f.toLinearMap ∘ₗ CliffordAlgebra.ι Q = g.toLinearMap ∘ₗ CliffordAlgebra.ι Q → f = g
-- CliffordAlgebra.induction
@[elab_as_elim]
theorem induction {C : CliffordAlgebra Q → Prop}
    (algebraMap : ∀ r, C (algebraMap R (CliffordAlgebra Q) r)) (ι : ∀ x, C (ι Q x))
    (mul : ∀ a b, C a → C b → C (a * b)) (add : ∀ a b, C a → C b → C (a + b))
    (a : CliffordAlgebra Q) : C a 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} {C : CliffordAlgebra Q → Prop} (algebraMap : ∀ (r : R), C ((algebraMap R (CliffordAlgebra Q)) r)) (ι : ∀ (x : M), C ((CliffordAlgebra.ι Q) x)) (mul : ∀ (a b : CliffordAlgebra Q), C a → C b → C (a * b)) (add : ∀ (a b : CliffordAlgebra Q), C a → C b → C (a + b)) (a : CliffordAlgebra Q)
Goal: C a
-- CliffordAlgebra.mul_add_swap_eq_polar_of_forall_mul_self_eq
theorem mul_add_swap_eq_polar_of_forall_mul_self_eq {A : Type*} [Ring A] [Algebra R A]
    (f : M →ₗ[R] A) (hf : ∀ x, f x * f x = algebraMap _ _ (Q x)) (a b : M) :
    f a * f b + f b * f a = algebraMap R _ (QuadraticMap.polar Q a b) 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} {A : Type u_4} [Ring A] [Algebra R A] (f : M →ₗ[R] A) (hf : ∀ (x : M), f x * f x = (algebraMap R A) (Q x)) (a b : M)
Goal: f a * f b + f b * f a = (algebraMap R A) (QuadraticMap.polar (⇑Q) a b)
-- CliffordAlgebra.forall_mul_self_eq_iff
theorem forall_mul_self_eq_iff {A : Type*} [Ring A] [Algebra R A] (h2 : IsUnit (2 : A))
    (f : M →ₗ[R] A) :
    (∀ x, f x * f x = algebraMap _ _ (Q x)) ↔
      (LinearMap.mul R A).compl₂ f ∘ₗ f + (LinearMap.mul R A).flip.compl₂ f ∘ₗ f =
        Q.polarBilin.compr₂ (Algebra.linearMap R A) 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} {A : Type u_4} [Ring A] [Algebra R A] (h2 : IsUnit 2) (f : M →ₗ[R] A)
Goal: (∀ (x : M), f x * f x = (algebraMap R A) (Q x)) ↔
  (LinearMap.mul R A).compl₂ f ∘ₗ f + (LinearMap.mul R A).flip.compl₂ f ∘ₗ f =
    LinearMap.compr₂ (QuadraticMap.polarBilin Q) (Algebra.linearMap R A)
-- CliffordAlgebra.ι_mul_ι_add_swap
theorem ι_mul_ι_add_swap (a b : M) :
    ι Q a * ι Q b + ι Q b * ι Q a = algebraMap R _ (QuadraticMap.polar Q a b) 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} (a b : M)
Goal: (CliffordAlgebra.ι Q) a * (CliffordAlgebra.ι Q) b + (CliffordAlgebra.ι Q) b * (CliffordAlgebra.ι Q) a =
  (algebraMap R (CliffordAlgebra Q)) (QuadraticMap.polar (⇑Q) a b)
-- CliffordAlgebra.ι_mul_ι_comm
theorem ι_mul_ι_comm (a b : M) :
    ι Q a * ι Q b = algebraMap R _ (QuadraticMap.polar Q a b) - ι Q b * ι Q a 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} (a b : M)
Goal: (CliffordAlgebra.ι Q) a * (CliffordAlgebra.ι Q) b =
  (algebraMap R (CliffordAlgebra Q)) (QuadraticMap.polar (⇑Q) a b) - (CliffordAlgebra.ι Q) b * (CliffordAlgebra.ι Q) a
-- CliffordAlgebra.ι_mul_ι_add_swap_of_isOrtho
@[simp] theorem ι_mul_ι_add_swap_of_isOrtho {a b : M} (h : Q.IsOrtho a b) :
    ι Q a * ι Q b + ι Q b * ι Q a = 0 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} {a b : M} (h : QuadraticMap.IsOrtho Q a b)
Goal: (CliffordAlgebra.ι Q) a * (CliffordAlgebra.ι Q) b + (CliffordAlgebra.ι Q) b * (CliffordAlgebra.ι Q) a = 0
-- CliffordAlgebra.ι_mul_ι_comm_of_isOrtho
theorem ι_mul_ι_comm_of_isOrtho {a b : M} (h : Q.IsOrtho a b) :
    ι Q a * ι Q b = -(ι Q b * ι Q a) 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} {a b : M} (h : QuadraticMap.IsOrtho Q a b)
Goal: (CliffordAlgebra.ι Q) a * (CliffordAlgebra.ι Q) b = -((CliffordAlgebra.ι Q) b * (CliffordAlgebra.ι Q) a)
-- CliffordAlgebra.mul_ι_mul_ι_of_isOrtho
theorem mul_ι_mul_ι_of_isOrtho (x : CliffordAlgebra Q) {a b : M} (h : Q.IsOrtho a b) :
    x * ι Q a * ι Q b = -(x * ι Q b * ι Q a) 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} (x : CliffordAlgebra Q) {a b : M} (h : QuadraticMap.IsOrtho Q a b)
Goal: x * (CliffordAlgebra.ι Q) a * (CliffordAlgebra.ι Q) b = -(x * (CliffordAlgebra.ι Q) b * (CliffordAlgebra.ι Q) a)
-- CliffordAlgebra.ι_mul_ι_mul_of_isOrtho
theorem ι_mul_ι_mul_of_isOrtho (x : CliffordAlgebra Q) {a b : M} (h : Q.IsOrtho a b) :
    ι Q a * (ι Q b * x) = -(ι Q b * (ι Q a * x)) 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} (x : CliffordAlgebra Q) {a b : M} (h : QuadraticMap.IsOrtho Q a b)
Goal: (CliffordAlgebra.ι Q) a * ((CliffordAlgebra.ι Q) b * x) = -((CliffordAlgebra.ι Q) b * ((CliffordAlgebra.ι Q) a * x))
-- CliffordAlgebra.ι_mul_ι_mul_ι
theorem ι_mul_ι_mul_ι (a b : M) :
    ι Q a * ι Q b * ι Q a = ι Q (QuadraticMap.polar Q a b • a - Q a • b) 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} (a b : M)
Goal: (CliffordAlgebra.ι Q) a * (CliffordAlgebra.ι Q) b * (CliffordAlgebra.ι Q) a =
  (CliffordAlgebra.ι Q) (QuadraticMap.polar (⇑Q) a b • a - Q a • b)
-- CliffordAlgebra.ι_range_map_lift
@[simp]
theorem ι_range_map_lift (f : M →ₗ[R] A) (cond : ∀ m, f m * f m = algebraMap _ _ (Q m)) :
    (ι Q).range.map (lift Q ⟨f, cond⟩).toLinearMap = LinearMap.range f 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} {A : Type u_3} [Semiring A] [Algebra R A] (f : M →ₗ[R] A) (cond : ∀ (m : M), f m * f m = (algebraMap R A) (Q m))
Goal: Submodule.map ((CliffordAlgebra.lift Q) ⟨f, cond⟩).toLinearMap (LinearMap.range (CliffordAlgebra.ι Q)) =
  LinearMap.range f
-- CliffordAlgebra.map_comp_ι
@[simp]
theorem map_comp_ι (f : Q₁ →qᵢ Q₂) :
    (map f).toLinearMap ∘ₗ ι Q₁ = ι Q₂ ∘ₗ f.toLinearMap 
Arguments: {R : Type u_1} [CommRing R] {M₁ : Type u_4} {M₂ : Type u_5} [AddCommGroup M₁] [AddCommGroup M₂] [Module R M₁] [Module R M₂] {Q₁ : QuadraticForm R M₁} {Q₂ : QuadraticForm R M₂} (f : Q₁ →qᵢ Q₂)
Goal: (CliffordAlgebra.map f).toLinearMap ∘ₗ CliffordAlgebra.ι Q₁ = CliffordAlgebra.ι Q₂ ∘ₗ f.toLinearMap
-- CliffordAlgebra.map_apply_ι
@[simp]
theorem map_apply_ι (f : Q₁ →qᵢ Q₂) (m : M₁) : map f (ι Q₁ m) = ι Q₂ (f m) 
Arguments: {R : Type u_1} [CommRing R] {M₁ : Type u_4} {M₂ : Type u_5} [AddCommGroup M₁] [AddCommGroup M₂] [Module R M₁] [Module R M₂] {Q₁ : QuadraticForm R M₁} {Q₂ : QuadraticForm R M₂} (f : Q₁ →qᵢ Q₂) (m : M₁)
Goal: (CliffordAlgebra.map f) ((CliffordAlgebra.ι Q₁) m) = (CliffordAlgebra.ι Q₂) (f m)
-- CliffordAlgebra.map_id
@[simp]
theorem map_id : map (QuadraticMap.Isometry.id Q₁) = AlgHom.id R (CliffordAlgebra Q₁) 
Arguments: {R : Type u_1} [CommRing R] {M₁ : Type u_4} [AddCommGroup M₁] [Module R M₁] (Q₁ : QuadraticForm R M₁)
Goal: CliffordAlgebra.map (QuadraticMap.Isometry.id Q₁) = AlgHom.id R (CliffordAlgebra Q₁)
-- CliffordAlgebra.map_comp_map
@[simp]
theorem map_comp_map (f : Q₂ →qᵢ Q₃) (g : Q₁ →qᵢ Q₂) :
    (map f).comp (map g) = map (f.comp g) 
Arguments: {R : Type u_1} [CommRing R] {M₁ : Type u_4} {M₂ : Type u_5} {M₃ : Type u_6} [AddCommGroup M₁] [AddCommGroup M₂] [AddCommGroup M₃] [Module R M₁] [Module R M₂] [Module R M₃] {Q₁ : QuadraticForm R M₁} {Q₂ : QuadraticForm R M₂} {Q₃ : QuadraticForm R M₃} (f : Q₂ →qᵢ Q₃) (g : Q₁ →qᵢ Q₂)
Goal: (CliffordAlgebra.map f).comp (CliffordAlgebra.map g) = CliffordAlgebra.map (f.comp g)
-- CliffordAlgebra.ι_range_map_map
@[simp]
theorem ι_range_map_map (f : Q₁ →qᵢ Q₂) :
    (ι Q₁).range.map (map f).toLinearMap = f.range.map (ι Q₂) 
Arguments: {R : Type u_1} [CommRing R] {M₁ : Type u_4} {M₂ : Type u_5} [AddCommGroup M₁] [AddCommGroup M₂] [Module R M₁] [Module R M₂] {Q₁ : QuadraticForm R M₁} {Q₂ : QuadraticForm R M₂} (f : Q₁ →qᵢ Q₂)
Goal: Submodule.map (CliffordAlgebra.map f).toLinearMap (LinearMap.range (CliffordAlgebra.ι Q₁)) =
  Submodule.map (CliffordAlgebra.ι Q₂) (LinearMap.range f.toLinearMap)
-- CliffordAlgebra.leftInverse_map_of_leftInverse
lemma leftInverse_map_of_leftInverse {Q₁ : QuadraticForm R M₁} {Q₂ : QuadraticForm R M₂}
    (f : Q₁ →qᵢ Q₂) (g : Q₂ →qᵢ Q₁) (h : LeftInverse g f) : LeftInverse (map g) (map f) 
Arguments: {R : Type u_1} [CommRing R] {M₁ : Type u_4} {M₂ : Type u_5} [AddCommGroup M₁] [AddCommGroup M₂] [Module R M₁] [Module R M₂] {Q₁ : QuadraticForm R M₁} {Q₂ : QuadraticForm R M₂} (f : Q₁ →qᵢ Q₂) (g : Q₂ →qᵢ Q₁) (h : Function.LeftInverse ⇑g ⇑f)
Goal: Function.LeftInverse ⇑(CliffordAlgebra.map g) ⇑(CliffordAlgebra.map f)
-- CliffordAlgebra.map_surjective
lemma map_surjective {Q₁ : QuadraticForm R M₁} {Q₂ : QuadraticForm R M₂} (f : Q₁ →qᵢ Q₂)
    (hf : Function.Surjective f) : Function.Surjective (CliffordAlgebra.map f) 
Arguments: {R : Type u_1} [CommRing R] {M₁ : Type u_4} {M₂ : Type u_5} [AddCommGroup M₁] [AddCommGroup M₂] [Module R M₁] [Module R M₂] {Q₁ : QuadraticForm R M₁} {Q₂ : QuadraticForm R M₂} (f : Q₁ →qᵢ Q₂) (hf : Function.Surjective ⇑f)
Goal: Function.Surjective ⇑(CliffordAlgebra.map f)
-- CliffordAlgebra.equivOfIsometry_apply
@[simps! apply]
def equivOfIsometry (e : Q₁.IsometryEquiv Q₂) : CliffordAlgebra Q₁ ≃ₐ[R] CliffordAlgebra Q₂ 
Arguments: {R : Type u_1} [CommRing R] {M₁ : Type u_4} {M₂ : Type u_5} [AddCommGroup M₁] [AddCommGroup M₂] [Module R M₁] [Module R M₂] {Q₁ : QuadraticForm R M₁} {Q₂ : QuadraticForm R M₂} (e : QuadraticMap.IsometryEquiv Q₁ Q₂) (a : CliffordAlgebra Q₁)
Goal: (CliffordAlgebra.equivOfIsometry e) a = (CliffordAlgebra.map e.toIsometry) a
-- CliffordAlgebra.equivOfIsometry_symm
@[simp]
theorem equivOfIsometry_symm (e : Q₁.IsometryEquiv Q₂) :
    (equivOfIsometry e).symm = equivOfIsometry e.symm 
Arguments: {R : Type u_1} [CommRing R] {M₁ : Type u_4} {M₂ : Type u_5} [AddCommGroup M₁] [AddCommGroup M₂] [Module R M₁] [Module R M₂] {Q₁ : QuadraticForm R M₁} {Q₂ : QuadraticForm R M₂} (e : QuadraticMap.IsometryEquiv Q₁ Q₂)
Goal: (CliffordAlgebra.equivOfIsometry e).symm = CliffordAlgebra.equivOfIsometry e.symm
-- CliffordAlgebra.equivOfIsometry_trans
@[simp]
theorem equivOfIsometry_trans (e₁₂ : Q₁.IsometryEquiv Q₂) (e₂₃ : Q₂.IsometryEquiv Q₃) :
    (equivOfIsometry e₁₂).trans (equivOfIsometry e₂₃) = equivOfIsometry (e₁₂.trans e₂₃) 
Arguments: {R : Type u_1} [CommRing R] {M₁ : Type u_4} {M₂ : Type u_5} {M₃ : Type u_6} [AddCommGroup M₁] [AddCommGroup M₂] [AddCommGroup M₃] [Module R M₁] [Module R M₂] [Module R M₃] {Q₁ : QuadraticForm R M₁} {Q₂ : QuadraticForm R M₂} {Q₃ : QuadraticForm R M₃} (e₁₂ : QuadraticMap.IsometryEquiv Q₁ Q₂) (e₂₃ : QuadraticMap.IsometryEquiv Q₂ Q₃)
Goal: (CliffordAlgebra.equivOfIsometry e₁₂).trans (CliffordAlgebra.equivOfIsometry e₂₃) =
  CliffordAlgebra.equivOfIsometry (e₁₂.trans e₂₃)
-- CliffordAlgebra.equivOfIsometry_refl
@[simp]
theorem equivOfIsometry_refl :
    (equivOfIsometry <| QuadraticMap.IsometryEquiv.refl Q₁) = AlgEquiv.refl 
Arguments: {R : Type u_1} [CommRing R] {M₁ : Type u_4} [AddCommGroup M₁] [Module R M₁] {Q₁ : QuadraticForm R M₁}
Goal: CliffordAlgebra.equivOfIsometry (QuadraticMap.IsometryEquiv.refl Q₁) = AlgEquiv.refl
-- TensorAlgebra.toClifford_ι
@[simp]
theorem toClifford_ι (m : M) : toClifford (TensorAlgebra.ι R m) = CliffordAlgebra.ι Q m 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_2} [AddCommGroup M] [Module R M] {Q : QuadraticForm R M} (m : M)
Goal: TensorAlgebra.toClifford ((TensorAlgebra.ι R) m) = (CliffordAlgebra.ι Q) m
-- QuadraticForm.equivalent_sign_ne_zero_weighted_sum_squared
theorem equivalent_sign_ne_zero_weighted_sum_squared {M : Type*} [AddCommGroup M] [Module ℝ M]
    [FiniteDimensional ℝ M] (Q : QuadraticForm ℝ M) (hQ : (associated (R := ℝ) Q).SeparatingLeft) :
    ∃ w : Fin (FiniteDimensional.finrank ℝ M) → SignType,
      (∀ i, w i ≠ 0) ∧ Equivalent Q (weightedSumSquares ℝ fun i ↦ (w i : ℝ)) 
Arguments: {M : Type u_2} [AddCommGroup M] [Module ℝ M] [FiniteDimensional ℝ M] (Q : QuadraticForm ℝ M) (hQ : LinearMap.SeparatingLeft (QuadraticMap.associated Q))
Goal: ∃ w,
  (∀ (i : Fin (FiniteDimensional.finrank ℝ M)), w i ≠ 0) ∧
    QuadraticMap.Equivalent Q (QuadraticMap.weightedSumSquares ℝ fun i => ↑(w i))
-- QuadraticForm.equivalent_one_neg_one_weighted_sum_squared
theorem equivalent_one_neg_one_weighted_sum_squared {M : Type*} [AddCommGroup M] [Module ℝ M]
    [FiniteDimensional ℝ M] (Q : QuadraticForm ℝ M) (hQ : (associated (R := ℝ) Q).SeparatingLeft) :
    ∃ w : Fin (FiniteDimensional.finrank ℝ M) → ℝ,
      (∀ i, w i = -1 ∨ w i = 1) ∧ Equivalent Q (weightedSumSquares ℝ w) 
Arguments: {M : Type u_2} [AddCommGroup M] [Module ℝ M] [FiniteDimensional ℝ M] (Q : QuadraticForm ℝ M) (hQ : LinearMap.SeparatingLeft (QuadraticMap.associated Q))
Goal: ∃ w,
  (∀ (i : Fin (FiniteDimensional.finrank ℝ M)), w i = -1 ∨ w i = 1) ∧
    QuadraticMap.Equivalent Q (QuadraticMap.weightedSumSquares ℝ w)
-- QuadraticForm.equivalent_signType_weighted_sum_squared
theorem equivalent_signType_weighted_sum_squared {M : Type*} [AddCommGroup M] [Module ℝ M]
    [FiniteDimensional ℝ M] (Q : QuadraticForm ℝ M) :
    ∃ w : Fin (FiniteDimensional.finrank ℝ M) → SignType,
      Equivalent Q (weightedSumSquares ℝ fun i ↦ (w i : ℝ)) 
Arguments: {M : Type u_2} [AddCommGroup M] [Module ℝ M] [FiniteDimensional ℝ M] (Q : QuadraticForm ℝ M)
Goal: ∃ w, QuadraticMap.Equivalent Q (QuadraticMap.weightedSumSquares ℝ fun i => ↑(w i))
-- QuadraticForm.equivalent_one_zero_neg_one_weighted_sum_squared
theorem equivalent_one_zero_neg_one_weighted_sum_squared {M : Type*} [AddCommGroup M] [Module ℝ M]
    [FiniteDimensional ℝ M] (Q : QuadraticForm ℝ M) :
    ∃ w : Fin (FiniteDimensional.finrank ℝ M) → ℝ,
      (∀ i, w i = -1 ∨ w i = 0 ∨ w i = 1) ∧ Equivalent Q (weightedSumSquares ℝ w) 
Arguments: {M : Type u_2} [AddCommGroup M] [Module ℝ M] [FiniteDimensional ℝ M] (Q : QuadraticForm ℝ M)
Goal: ∃ w,
  (∀ (i : Fin (FiniteDimensional.finrank ℝ M)), w i = -1 ∨ w i = 0 ∨ w i = 1) ∧
    QuadraticMap.Equivalent Q (QuadraticMap.weightedSumSquares ℝ w)
-- LinearMap.dualProd_apply_apply
@[simps!]
def dualProd : LinearMap.BilinForm R (Module.Dual R M × M) 
Arguments: (R : Type u_1) (M : Type u_2) [CommSemiring R] [AddCommMonoid M] [Module R M] (a : Module.Dual R M × M)
Goal: ∀ (a_1 : Module.Dual R M × M), ((LinearMap.dualProd R M) a) a_1 = a_1.1 a.2 + a.1 a_1.2
-- LinearMap.isSymm_dualProd
theorem isSymm_dualProd : (dualProd R M).IsSymm 
Arguments: (R : Type u_1) (M : Type u_2) [CommSemiring R] [AddCommMonoid M] [Module R M]
Goal: LinearMap.IsSymm (LinearMap.dualProd R M)
-- LinearMap.separatingLeft_dualProd
theorem separatingLeft_dualProd :
    (dualProd R M).SeparatingLeft ↔ Function.Injective (Module.Dual.eval R M) 
Arguments: (R : Type u_1) (M : Type u_2) [CommRing R] [AddCommGroup M] [Module R M]
Goal: LinearMap.SeparatingLeft (LinearMap.dualProd R M) ↔ Function.Injective ⇑(Module.Dual.eval R M)
-- QuadraticForm.dualProd_apply
@[simps]
def dualProd : QuadraticForm R (Module.Dual R M × M) 
Arguments: (R : Type u_1) (M : Type u_2) [CommSemiring R] [AddCommMonoid M] [Module R M] (p : Module.Dual R M × M)
Goal: (QuadraticForm.dualProd R M) p = p.1 p.2
-- LinearMap.dualProd.toQuadraticForm
@[simp]
theorem _root_.LinearMap.dualProd.toQuadraticForm :
    (LinearMap.dualProd R M).toQuadraticMap = 2 • dualProd R M 
Arguments: (R : Type u_1) (M : Type u_2) [CommSemiring R] [AddCommMonoid M] [Module R M]
Goal: LinearMap.BilinMap.toQuadraticMap (LinearMap.dualProd R M) = 2 • QuadraticForm.dualProd R M
-- QuadraticForm.dualProdIsometry_toFun
@[simps!]
def dualProdIsometry (f : M ≃ₗ[R] N) : (dualProd R M).IsometryEquiv (dualProd R N) 
Arguments: {R : Type u_1} {M : Type u_2} {N : Type u_3} [CommSemiring R] [AddCommMonoid M] [AddCommMonoid N] [Module R M] [Module R N] (f : M ≃ₗ[R] N)
Goal: ∀ (a : Module.Dual R M × M), (QuadraticForm.dualProdIsometry f) a = ((↑f.symm.dualMap).prodCongr ↑f) a
-- QuadraticForm.dualProdIsometry_invFun
@[simps!]
def dualProdIsometry (f : M ≃ₗ[R] N) : (dualProd R M).IsometryEquiv (dualProd R N) 
Arguments: {R : Type u_1} {M : Type u_2} {N : Type u_3} [CommSemiring R] [AddCommMonoid M] [AddCommMonoid N] [Module R M] [Module R N] (f : M ≃ₗ[R] N)
Goal: ∀ (a : Module.Dual R N × N), (QuadraticForm.dualProdIsometry f).invFun a = ((↑f.symm.dualMap).prodCongr ↑f).symm a
-- QuadraticForm.dualProdProdIsometry_invFun
@[simps!]
def dualProdProdIsometry :
    (dualProd R (M × N)).IsometryEquiv ((dualProd R M).prod (dualProd R N)) 
Arguments: {R : Type u_1} {M : Type u_2} {N : Type u_3} [CommSemiring R] [AddCommMonoid M] [AddCommMonoid N] [Module R M] [Module R N]
Goal: ∀ (a : (Module.Dual R M × M) × Module.Dual R N × N),
  QuadraticForm.dualProdProdIsometry.invFun a =
    ((Module.dualProdDualEquivDual R M N).symm.prod (LinearEquiv.refl R (M × N))).symm ((a.1.1, a.2.1), a.1.2, a.2.2)
-- QuadraticForm.dualProdProdIsometry_toFun
@[simps!]
def dualProdProdIsometry :
    (dualProd R (M × N)).IsometryEquiv ((dualProd R M).prod (dualProd R N)) 
Arguments: {R : Type u_1} {M : Type u_2} {N : Type u_3} [CommSemiring R] [AddCommMonoid M] [AddCommMonoid N] [Module R M] [Module R N]
Goal: ∀ (a : Module.Dual R (M × N) × M × N),
  QuadraticForm.dualProdProdIsometry a = ((a.1 ∘ₗ LinearMap.inl R M N, a.2.1), a.1 ∘ₗ LinearMap.inr R M N, a.2.2)
-- QuadraticForm.toDualProd_apply
@[simps!]
def toDualProd (Q : QuadraticForm R M) [Invertible (2 : R)] :
    (Q.prod <| -Q) →qᵢ QuadraticForm.dualProd R M 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (Q : QuadraticForm R M) [Invertible 2] (i : M × M)
Goal: Q.toDualProd i = ((QuadraticMap.associated Q) i.1 + (QuadraticMap.associated Q) i.2, i.1 - i.2)
-- QuadraticModuleCat.moduleCat_of_toModuleCat
@[simp] theorem moduleCat_of_toModuleCat (X : QuadraticModuleCat.{v} R) :
    ModuleCat.of R X.toModuleCat = X.toModuleCat 
Arguments: {R : Type u} [CommRing R] (X : QuadraticModuleCat R)
Goal: ModuleCat.of R ↑X.toModuleCat = X.toModuleCat
-- QuadraticModuleCat.of_form
@[simps form]
def of {X : Type v} [AddCommGroup X] [Module R X] (Q : QuadraticForm R X) :
    QuadraticModuleCat R 
Arguments: {R : Type u} [CommRing R] {X : Type v} [AddCommGroup X] [Module R X] (Q : QuadraticForm R X)
Goal: (QuadraticModuleCat.of Q).form = Q
-- QuadraticModuleCat.Hom.toIsometry_injective
lemma Hom.toIsometry_injective (V W : QuadraticModuleCat.{v} R) :
    Function.Injective (Hom.toIsometry : Hom V W → _) 
Arguments: {R : Type u} [CommRing R] (V W : QuadraticModuleCat R)
Goal: Function.Injective QuadraticModuleCat.Hom.toIsometry
-- QuadraticModuleCat.hom_ext
@[ext]
lemma hom_ext {M N : QuadraticModuleCat.{v} R} (f g : M ⟶ N) (h : f.toIsometry = g.toIsometry) :
    f = g 
Arguments: {R : Type u} [CommRing R] {M N : QuadraticModuleCat R} (f g : M ⟶ N) (h : f.toIsometry = g.toIsometry)
Goal: f = g
-- QuadraticModuleCat.toIsometry_comp
@[simp] theorem toIsometry_comp {M N U : QuadraticModuleCat.{v} R} (f : M ⟶ N) (g : N ⟶ U) :
    (f ≫ g).toIsometry = g.toIsometry.comp f.toIsometry 
Arguments: {R : Type u} [CommRing R] {M N U : QuadraticModuleCat R} (f : M ⟶ N) (g : N ⟶ U)
Goal: (f ≫ g).toIsometry = g.toIsometry.comp f.toIsometry
-- QuadraticModuleCat.toIsometry_id
@[simp] theorem toIsometry_id {M : QuadraticModuleCat.{v} R} :
    Hom.toIsometry (𝟙 M) = Isometry.id _ 
Arguments: {R : Type u} [CommRing R] {M : QuadraticModuleCat R}
Goal: (𝟙 M).toIsometry = QuadraticMap.Isometry.id M.form
-- QuadraticModuleCat.forget₂_obj
@[simp]
theorem forget₂_obj (X : QuadraticModuleCat R) :
    (forget₂ (QuadraticModuleCat R) (ModuleCat R)).obj X = ModuleCat.of R X 
Arguments: {R : Type u} [CommRing R] (X : QuadraticModuleCat R)
Goal: (CategoryTheory.forget₂ (QuadraticModuleCat R) (ModuleCat R)).obj X = ModuleCat.of R ↑X.toModuleCat
-- QuadraticModuleCat.forget₂_map
@[simp]
theorem forget₂_map (X Y : QuadraticModuleCat R) (f : X ⟶ Y) :
    (forget₂ (QuadraticModuleCat R) (ModuleCat R)).map f = f.toIsometry.toLinearMap 
Arguments: {R : Type u} [CommRing R] (X Y : QuadraticModuleCat R) (f : X ⟶ Y)
Goal: (CategoryTheory.forget₂ (QuadraticModuleCat R) (ModuleCat R)).map f = f.toIsometry.toLinearMap
-- QuadraticModuleCat.ofIso_hom_toIsometry
@[simps]
def ofIso (e : Q₁.IsometryEquiv Q₂) : QuadraticModuleCat.of Q₁ ≅ QuadraticModuleCat.of Q₂ 
Arguments: {R : Type u} [CommRing R] {X Y : Type v} [AddCommGroup X] [Module R X] [AddCommGroup Y] [Module R Y] {Q₁ : QuadraticForm R X} {Q₂ : QuadraticForm R Y} (e : QuadraticMap.IsometryEquiv Q₁ Q₂)
Goal: (QuadraticModuleCat.ofIso e).hom.toIsometry = e.toIsometry
-- QuadraticModuleCat.ofIso_inv_toIsometry
@[simps]
def ofIso (e : Q₁.IsometryEquiv Q₂) : QuadraticModuleCat.of Q₁ ≅ QuadraticModuleCat.of Q₂ 
Arguments: {R : Type u} [CommRing R] {X Y : Type v} [AddCommGroup X] [Module R X] [AddCommGroup Y] [Module R Y] {Q₁ : QuadraticForm R X} {Q₂ : QuadraticForm R Y} (e : QuadraticMap.IsometryEquiv Q₁ Q₂)
Goal: (QuadraticModuleCat.ofIso e).inv.toIsometry = e.symm.toIsometry
-- QuadraticModuleCat.ofIso_refl
@[simp] theorem ofIso_refl : ofIso (IsometryEquiv.refl Q₁) = .refl _ 
Arguments: {R : Type u} [CommRing R] {X : Type v} [AddCommGroup X] [Module R X] {Q₁ : QuadraticForm R X}
Goal: QuadraticModuleCat.ofIso (QuadraticMap.IsometryEquiv.refl Q₁) = CategoryTheory.Iso.refl (QuadraticModuleCat.of Q₁)