ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem not_decide_eq_true [h : Decidable p] : ((!decide p) = true) = ¬ p
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atBot_principal [Nonempty β] [SemilatticeInf β] {f : β → α} {s : Set α} :
    Tendsto f atBot (𝓟 s) ↔ ∃ N, ∀ n ≤ N, f n ∈ s
-- Mathlib/Logic/Relator.lean
protected lemma refl (hr : ∀ a : α, r₁₁ a a) :
    BiTotal r₁₁
-- Mathlib/Geometry/RingedSpace/OpenImmersion.lean
@[simp, reassoc]
theorem inv_naturality {U V : (Opens X)ᵒᵖ} (i : U ⟶ V) :
    X.presheaf.map i ≫ H.invApp (unop V) =
      invApp f (unop U) ≫ Y.presheaf.map (opensFunctor f |>.op.map i)
-- Mathlib/Analysis/Convex/Integral.lean
/-- If `E` is a strictly convex normed space and `f : α → E` is a function such that `‖f x‖ ≤ C`
a.e. on a set `t` of finite measure, then either this function is a.e. equal to its average value on
`t`, or the norm of its integral over `t` is strictly less than `(μ t).toReal * C`. -/
theorem ae_eq_const_or_norm_setIntegral_lt_of_norm_le_const [StrictConvexSpace ℝ E] (ht : μ t ≠ ∞)
    (h_le : ∀ᵐ x ∂μ.restrict t, ‖f x‖ ≤ C) :
    f =ᵐ[μ.restrict t] const α (⨍ x in t, f x ∂μ) ∨ ‖∫ x in t, f x ∂μ‖ < (μ t).toReal * C
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
@[simp]
theorem comp_right_eq_zero [IsIso g] : f ≫ g = 0 ↔ f = 0
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem LieAlgebra.non_trivial_center_of_isNilpotent [Nontrivial L] [IsNilpotent R L] :
    Nontrivial <| center R L
-- Mathlib/Algebra/Order/Monoid/Defs.lean
@[to_additive (attr := simp)]
theorem one_le_mul_self_iff : 1 ≤ a * a ↔ 1 ≤ a
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Balanced.dual : ∀ {t : Ordnode α}, Balanced t → Balanced (dual t)
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem supported_iInter {ι : Type*} (s : ι → Set α) :
    supported M R (⋂ i, s i) = ⨅ i, supported M R (s i)
-- Mathlib/Topology/ExtremallyDisconnected.lean
protected theorem CompactT2.projective_iff_extremallyDisconnected [CompactSpace A] [T2Space A] :
    Projective A ↔ ExtremallyDisconnected A
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
theorem strictAntiOn_arccos : StrictAntiOn arccos (Icc (-1) 1)
-- Mathlib/RingTheory/Artinian.lean
@[local instance] lemma subtype_isMaximal_finite : Finite {I : Ideal R | I.IsMaximal}
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[simp]
theorem cos_two_pi : cos (2 * π) = 1
-- Mathlib/Algebra/Homology/ShortComplex/ShortExact.lean
lemma shortExact_iff_unop (S : ShortComplex Cᵒᵖ) : S.ShortExact ↔ S.unop.ShortExact
-- Mathlib/Data/Finset/Sym.lean
theorem image_diag_union_image_offDiag :
    s.diag.image Sym2.mk ∪ s.offDiag.image Sym2.mk = s.sym2
-- Mathlib/Algebra/Periodic.lean
protected theorem Antiperiodic.eq [AddZeroClass α] [Neg β] (h : Antiperiodic f c) : f c = -f 0
-- Mathlib/Topology/Semicontinuous.lean
theorem lowerSemicontinuousWithinAt_tsum {f : ι → α → ℝ≥0∞}
    (h : ∀ i, LowerSemicontinuousWithinAt (f i) s x) :
    LowerSemicontinuousWithinAt (fun x' => ∑' i, f i x') s x
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- A dependent version of `affineSpan_induction`. -/
@[elab_as_elim]
theorem affineSpan_induction' {s : Set P} {p : ∀ x, x ∈ affineSpan k s → Prop}
    (mem : ∀ (y) (hys : y ∈ s), p y (subset_affineSpan k _ hys))
    (smul_vsub_vadd :
      ∀ (c : k) (u hu v hv w hw),
        p u hu →
          p v hv → p w hw → p (c • (u -ᵥ v) +ᵥ w) (AffineSubspace.smul_vsub_vadd_mem _ _ hu hv hw))
    {x : P} (h : x ∈ affineSpan k s) : p x h
-- Mathlib/GroupTheory/Perm/Fin.lean
@[simp]
theorem Equiv.Perm.decomposeFin_symm_of_one {n : ℕ} (p : Fin (n + 1)) :
    Equiv.Perm.decomposeFin.symm (p, 1) = swap 0 p
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem add_lt_add {a b c d : Int} (h₁ : a < b) (h₂ : c < d) : a + c < b + d
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
theorem div_le_div_right₀ (hc : c ≠ 0) : a / c ≤ b / c ↔ a ≤ b
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem nndist_set_exists : ∃ C, ∀ x : α, nndist (f x) (g x) ≤ C
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem frobenius_zero : frobenius R p 0 = 0
-- Mathlib/Data/Finsupp/ToDFinsupp.lean
@[simp]
theorem toFinsupp_smul [Monoid R] [AddMonoid M] [DistribMulAction R M] [∀ m : M, Decidable (m ≠ 0)]
    (r : R) (f : Π₀ _ : ι, M) : (toFinsupp (r • f) : ι →₀ M) = r • toFinsupp f
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[simp]
theorem map_inf : (m₁ ⊓ m₂).map f = m₁.map f ⊓ m₂.map f
-- Mathlib/Algebra/Polynomial/Degree/Lemmas.lean
theorem natDegree_C_mul_le (a : R) (f : R[X]) : (C a * f).natDegree ≤ f.natDegree
-- Mathlib/RingTheory/PolynomialAlgebra.lean
@[simp]
theorem polyEquivTensor_apply (p : A[X]) :
    polyEquivTensor R A p =
      p.eval₂ (includeLeft : A →ₐ[R] A ⊗[R] R[X]) ((1 : A) ⊗ₜ[R] (X : R[X]))
-- Mathlib/Analysis/Convex/Between.lean
@[simp]
theorem wbtw_vsub_const_iff {x y z : P} (p : P) :
    Wbtw R (x -ᵥ p) (y -ᵥ p) (z -ᵥ p) ↔ Wbtw R x y z
-- Mathlib/Analysis/Normed/Module/Span.lean
@[simp]
theorem coe_toSpanNonzeroSingleton_symm {x : E} (h : x ≠ 0) :
    ⇑(toSpanNonzeroSingleton 𝕜 x h).symm = coord 𝕜 x h
-- Mathlib/FieldTheory/PolynomialGaloisGroup.lean
theorem restrict_surjective [Fact (p.Splits (algebraMap F E))] [Normal F E] :
    Function.Surjective (restrict p E)
-- Mathlib/LinearAlgebra/Matrix/ToLinearEquiv.lean
/-- This holds for all integral domains (see `Matrix.exists_mulVec_eq_zero_iff`),
not just fields, but it's easier to prove it for the field of fractions first. -/
theorem exists_mulVec_eq_zero_iff_aux {K : Type*} [DecidableEq n] [Field K] {M : Matrix n n K} :
    (∃ v ≠ 0, M *ᵥ v = 0) ↔ M.det = 0
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem inv_le_one_iff : a⁻¹ ≤ 1 ↔ a ≤ 0 ∨ 1 ≤ a
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
@[simp]
theorem _root_.IntervalIntegrable.log (hf : ContinuousOn f [[a, b]])
    (h : ∀ x : ℝ, x ∈ [[a, b]] → f x ≠ 0) :
    IntervalIntegrable (fun x => log (f x)) μ a b
-- Mathlib/Algebra/Group/Hom/Defs.lean
/-- Group homomorphisms preserve inverse. -/
@[to_additive "Additive group homomorphisms preserve negation."]
protected theorem map_inv [Group α] [DivisionMonoid β] (f : α →* β) (a : α) : f a⁻¹ = (f a)⁻¹
-- Mathlib/Topology/CompactOpen.lean
@[simp]
theorem continuousMapOfUnique_symm_apply [Unique X] (f : C(X, Y)) :
    continuousMapOfUnique.symm f = f default
-- Mathlib/LinearAlgebra/Quotient.lean
theorem subsingleton_quotient_iff_eq_top : Subsingleton (M ⧸ p) ↔ p = ⊤
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
@[simp]
theorem comp_neg (f : M →ₛₗ[σ₁₂] N₂) (g : N₂ →ₛₗ[σ₂₃] N₃) : g.comp (-f) = -g.comp f
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.const_mul_right' {g : α → R} {c : R} (hc : IsUnit c) (h : f =o[l] g) :
    f =o[l] fun x => c * g x
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
/-- The coequalizer of `(f, g)`, where `f = g`, is an isomorphism. -/
theorem coequalizer.π_of_eq [HasCoequalizer f g] (h : f = g) : IsIso (coequalizer.π f g)
-- .lake/packages/batteries/Batteries/Data/Array/Lemmas.lean
theorem size_filter_le (p : α → Bool) (l : Array α) :
    (l.filter p).size ≤ l.size
-- Mathlib/Analysis/Complex/UpperHalfPlane/FunctionsBoundedAtInfty.lean
theorem zero_form_isBoundedAtImInfty {α : Type*} [NormedField α] :
    IsBoundedAtImInfty (0 : ℍ → α)
-- Mathlib/Data/Set/Image.lean
theorem WithBot.range_eq {α β} (f : WithBot α → β) :
    range f = insert (f ⊥) (range (f ∘ WithBot.some : α → β))
-- Mathlib/Order/Bounds/Basic.lean
/-- See also `Monotone.map_bddBelow`. -/
protected theorem BddBelow.image2 (h₀ : ∀ b, Monotone (swap f b)) (h₁ : ∀ a, Monotone (f a)) :
    BddBelow s → BddBelow t → BddBelow (image2 f s t)
-- Mathlib/Analysis/Analytic/CPolynomial.lean
/-- The terms of the formal multilinear series `p.changeOrigin` are continuously polynomial
as we vary the origin -/
theorem cPolynomialAt_changeOrigin_of_finite (p : FormalMultilinearSeries 𝕜 E F)
    {n : ℕ} (hn : ∀ (m : ℕ), n ≤ m → p m = 0) (k : ℕ) :
    CPolynomialAt 𝕜 (p.changeOrigin · k) 0
-- Mathlib/Analysis/ODE/PicardLindelof.lean
theorem proj_of_mem {t : ℝ} (ht : t ∈ Icc v.tMin v.tMax) : ↑(v.proj t) = t
-- Mathlib/GroupTheory/Coxeter/Basic.lean
theorem reindexGroupEquiv_symm_apply_simple (i : B) :
    (M.reindexGroupEquiv e).symm (M.simple i) = (M.reindex e).simple (e i)
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem differentiableAt_rpow_of_ne (p : ℝ × ℝ) (hp : p.1 ≠ 0) :
    DifferentiableAt ℝ (fun p : ℝ × ℝ => p.1 ^ p.2) p
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_univ_pi {ι : α → Type*} (t : (a : α) → ι a → Set (π a)) :
    ⋃ x : (a : α) → ι a, pi univ (fun a => t a (x a)) = pi univ fun a => ⋃ j : ι a, t a j
-- Mathlib/Data/Multiset/Basic.lean
@[simp, norm_cast]
theorem coe_eq_singleton {l : List α} {a : α} : (l : Multiset α) = {a} ↔ l = [a]
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem getElem_map (f : α → β) {l} {n : Nat} {h : n < (map f l).length} :
    (map f l)[n] = f (l[n]'(length_map l f ▸ h))
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
theorem SameCycle.mem_support_iff {f} [DecidableEq α] [Fintype α] (h : SameCycle f x y) :
    x ∈ support f ↔ y ∈ support f
-- Mathlib/Analysis/SpecialFunctions/NonIntegrable.lean
/-- The function `fun x ↦ x⁻¹` is not integrable on any interval `[a, +∞)`. -/
theorem not_IntegrableOn_Ici_inv {a : ℝ} :
    ¬ IntegrableOn (fun x => x⁻¹) (Ici a)
-- Mathlib/Data/Bool/Basic.lean
theorem coe_sort_false : (false : Prop) = False
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem ceil_intCast {α : Type*} [LinearOrderedRing α] [FloorSemiring α] (z : ℤ) :
    ⌈(z : α)⌉₊ = z.toNat
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem map_iSup {ι : Sort*} (N : ι → LieSubmodule R L M) :
    (⨆ i, N i).map f = ⨆ i, (N i).map f
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_union_le (s s' : Set α) : μ.restrict (s ∪ s') ≤ μ.restrict s + μ.restrict s'
-- Mathlib/Algebra/MvPolynomial/Variables.lean
/-- If `f₁` and `f₂` are ring homs out of the polynomial ring and `p₁` and `p₂` are polynomials,
  then `f₁ p₁ = f₂ p₂` if `p₁ = p₂` and `f₁` and `f₂` are equal on `R` and on the variables
  of `p₁`.  -/
theorem hom_congr_vars {f₁ f₂ : MvPolynomial σ R →+* S} {p₁ p₂ : MvPolynomial σ R}
    (hC : f₁.comp C = f₂.comp C) (hv : ∀ i, i ∈ p₁.vars → i ∈ p₂.vars → f₁ (X i) = f₂ (X i))
    (hp : p₁ = p₂) : f₁ p₁ = f₂ p₂
-- Mathlib/Data/Ordmap/Ordset.lean
theorem raised_iff {n m} : Raised n m ↔ n ≤ m ∧ m ≤ n + 1
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
/-- There exists a non-null vector with respect to any quadratic form `Q` whose associated
bilinear form is non-zero, i.e. there exists `x` such that `Q x ≠ 0`. -/
theorem exists_quadraticForm_ne_zero {Q : QuadraticForm R M}
    -- Porting note: added implicit argument
    (hB₁ : associated' (R := R) Q ≠ 0) :
    ∃ x, Q x ≠ 0
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem equivOfEq_symm (S T : Subalgebra R A) (h : S = T) :
    (equivOfEq S T h).symm = equivOfEq T S h.symm
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem map_one_eq_bot : K.map (1 : G →* N) = ⊥
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp]
theorem sumCongr_mul {α β : Type*} (e : Perm α) (f : Perm β) (g : Perm α) (h : Perm β) :
    sumCongr e f * sumCongr g h = sumCongr (e * g) (f * h)
-- Mathlib/Order/PrimeIdeal.lean
/-- A pair of an `Order.Ideal` and an `Order.PFilter` which form a partition of `P`.
-/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure PrimePair (P : Type*) [Preorder P] where
  I : Ideal P
  F : PFilter P
  isCompl_I_F : IsCompl (I : Set P) F
-- Mathlib/CategoryTheory/Galois/Basic.lean
@[simp]
lemma fiberBinaryProductEquiv_symm_snd_apply {X Y : C} (x : F.obj X) (y : F.obj Y) :
    F.map prod.snd ((fiberBinaryProductEquiv F X Y).symm (x, y)) = y
-- Mathlib/Order/UpperLower/Basic.lean
nonrec lemma Iic_injective : Injective (Iic : α → LowerSet α)
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
@[simp]
theorem derivCLM_apply (f : 𝓢(ℝ, F)) (x : ℝ) : derivCLM 𝕜 f x = deriv f x
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If a function `f` tends to infinity along a filter,
then `f` divided by a negative constant tends to negative infinity. -/
lemma Tendsto.atTop_div_const_of_neg (hr : r < 0) (hf : Tendsto f l atTop) :
    Tendsto (fun x ↦ f x / r) l atBot
-- Mathlib/Analysis/Convex/Strong.lean
nonrec lemma StrongConvexOn.strictConvexOn (hf : StrongConvexOn s m f) (hm : 0 < m) :
    StrictConvexOn ℝ s f
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean
@[simp]
theorem DifferentiableAt.arctan (hc : DifferentiableAt ℝ f x) :
    DifferentiableAt ℝ (fun x => arctan (f x)) x
-- Mathlib/Topology/Homotopy/HomotopyGroup.lean
theorem equiv : Equivalence (@Homotopic N X _ x)
-- Mathlib/CategoryTheory/Products/Basic.lean
/-- The equivalence of categories between `(A ⥤ B) × (A ⥤ C)` and `A ⥤ (B × C)` -/
@[simps]
def functorProdFunctorEquiv : (A ⥤ B) × (A ⥤ C) ≌ A ⥤ B × C
-- Mathlib/Analysis/Matrix.lean
@[simp]
theorem frobenius_nnnorm_row (v : m → α) : ‖row ι v‖₊ = ‖(WithLp.equiv 2 _).symm v‖₊
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem and_left_comm : a ∧ b ∧ c ↔ b ∧ a ∧ c
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem aequiv_aequiv {U : Type*} [CommRing U] [Algebra R U] (h : IsAdjoinRoot S f)
    (h' : IsAdjoinRoot T f) (h'' : IsAdjoinRoot U f) (x) :
    (h'.aequiv h'') (h.aequiv h' x) = h.aequiv h'' x
-- Mathlib/GroupTheory/GroupAction/Hom.lean
protected theorem ext_iff  {f g : X →ₑ[φ] Y} :
    f = g ↔ ∀ x, f x = g x
-- Mathlib/Order/Interval/Set/Image.lean
lemma StrictMono.mapsTo_Ioc (h : StrictMono f) : MapsTo f (Ioc a b) (Ioc (f a) (f b))
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem upperClosure_image (f : α ≃o β) :
    upperClosure (f '' s) = UpperSet.map f (upperClosure s)
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[trans]
protected theorem trans (h1 : μ₁ ≪ μ₂) (h2 : μ₂ ≪ μ₃) : μ₁ ≪ μ₃
-- Mathlib/Computability/TuringMachine.lean
theorem stepAux_move (d : Dir) (q : Stmt'₁) (v : σ) (T : Tape Bool) :
    stepAux (moveₙ d q) v T = stepAux q v ((Tape.move d)^[n] T)
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
private theorem b_ne_one : b ≠ 1
-- Mathlib/CategoryTheory/Sites/CoversTop.lean
lemma ext (F : Sheaf J A) {c : Cone F.1} (hc : IsLimit c) {X : A} {f g : X ⟶ c.pt}
    (h : ∀ (i : I), f ≫ c.π.app (Opposite.op (Y i)) =
      g ≫ c.π.app (Opposite.op (Y i))) :
    f = g
-- Mathlib/CategoryTheory/Localization/Resolution.lean
lemma hasLeftResolutions_iff_op : Φ.HasLeftResolutions ↔ Φ.op.HasRightResolutions
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIcoMod_lt_right (a b : α) : toIcoMod hp a b < a + p
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
lemma sq_nonneg [IsRightCancelAdd α]
    [ZeroLEOneClass α] [ExistsAddOfLE α] [PosMulMono α] [CovariantClass α α (· + ·) (· < ·)]
    (a : α) : 0 ≤ a ^ 2
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma smul_lt_smul [PosSMulStrictMono α β] [SMulPosStrictMono α β] (ha : a₁ < a₂) (hb : b₁ < b₂)
    (h₁ : 0 < a₁) (h₂ : 0 < b₂) : a₁ • b₁ < a₂ • b₂
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma id_comp (C : VariableChange R) : comp id C = C
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem rev_addNat (k : Fin n) (m : Nat) : rev (addNat k m) = castAdd m (rev k)
-- Mathlib/Tactic/Abel.lean
lemma subst_into_smul_upcast {α} [AddCommGroup α]
    (l r tl zl tr t) (prl₁ : l = tl) (prl₂ : ↑tl = zl) (prr : r = tr)
    (prt : @smulg α _ zl tr = t) : smul l r = t
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
theorem WithSeminorms.hasBasis_zero_ball (hp : WithSeminorms p) :
    (𝓝 (0 : E)).HasBasis
    (fun sr : Finset ι × ℝ => 0 < sr.2) fun sr => (sr.1.sup p).ball 0 sr.2
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.set_index_subset (h : l.HasBasis p s) (ht : t ∈ l) : s (h.index t ht) ⊆ t
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem MeasurePreserving.lintegral_comp_emb {mb : MeasurableSpace β} {ν : Measure β} {g : α → β}
    (hg : MeasurePreserving g μ ν) (hge : MeasurableEmbedding g) (f : β → ℝ≥0∞) :
    ∫⁻ a, f (g a) ∂μ = ∫⁻ b, f b ∂ν
-- Mathlib/Topology/Inseparable.lean
lemma stableUnderGeneralization_iUnion {ι : Sort*} (S : ι → Set X)
    (H : ∀ i, StableUnderGeneralization (S i)) : StableUnderGeneralization (⋃ i, S i)
-- Mathlib/RingTheory/Polynomial/ScaleRoots.lean
theorem scaleRoots_eval₂_mul {p : S[X]} (f : S →+* R) (r : R) (s : S) :
    eval₂ f (f s * r) (scaleRoots p s) = f s ^ p.natDegree * eval₂ f r p
-- Mathlib/Data/Matrix/Notation.lean
@[simp]
theorem vecMulVec_empty (v : m' → α) (w : Fin 0 → α) : vecMulVec v w = of fun _ => ![]
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem coe_mk {toFun invFun left_inv right_inv map_mul map_add commutes} :
    ⇑(⟨⟨toFun, invFun, left_inv, right_inv⟩, map_mul, map_add, commutes⟩ : A₁ ≃ₐ[R] A₂) = toFun
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
lemma AffineIndependent.eq_zero_of_sum_eq_zero (hp : AffineIndependent k p)
    (hw₀ : ∑ i ∈ s, w i = 0) (hw₁ : ∑ i ∈ s, w i • p i = 0) : ∀ i ∈ s, w i = 0
-- Mathlib/LinearAlgebra/Matrix/Hermitian.lean
theorem IsHermitian.adjugate [Fintype m] [DecidableEq m] {A : Matrix m m α} (hA : A.IsHermitian) :
    A.adjugate.IsHermitian
-- Mathlib/NumberTheory/NumberField/Basic.lean
@[simp] lemma mk_sub_mk (x y : K) (hx hy) : (⟨x, hx⟩ : 𝓞 K) - ⟨y, hy⟩ = ⟨x - y, sub_mem hx hy⟩
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem self_mem_adjoin_singleton (x : A) : x ∈ adjoin R ({x} : Set A)
-- Mathlib/Algebra/MvPolynomial/Counit.lean
theorem counit_surjective : Surjective (counit R)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Pythagorean theorem, subtracting vectors, if-and-if vector inner product form using square
roots. -/
theorem norm_sub_eq_sqrt_iff_real_inner_eq_zero {x y : F} :
    ‖x - y‖ = √(‖x‖ * ‖x‖ + ‖y‖ * ‖y‖) ↔ ⟪x, y⟫_ℝ = 0
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem abs_zero : (0 : EReal).abs = 0
-- Mathlib/RingTheory/FiniteType.lean
/-- If a set `S` generates an additive monoid `M`, then the image of `M` generates, as algebra,
`R[M]`. -/
theorem mvPolynomial_aeval_of_surjective_of_closure [AddCommMonoid M] [CommSemiring R] {S : Set M}
    (hS : closure S = ⊤) :
    Function.Surjective
      (MvPolynomial.aeval fun s : S => of' R M ↑s : MvPolynomial S R → R[M])
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioi_subset_Ici_self : Ioi a ⊆ Ici a
-- Mathlib/SetTheory/Game/PGame.lean
theorem lf_of_le_mk {xl xr xL xR y} : mk xl xr xL xR ≤ y → ∀ i, xL i ⧏ y
-- Mathlib/Data/Set/Prod.lean
theorem Nonempty.snd : (s ×ˢ t).Nonempty → t.Nonempty
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[measurability]
protected theorem const_smul {𝕜} [TopologicalSpace 𝕜] [AddMonoid β] [Monoid 𝕜]
    [DistribMulAction 𝕜 β] [ContinuousSMul 𝕜 β] (hf : AEFinStronglyMeasurable f μ) (c : 𝕜) :
    AEFinStronglyMeasurable (c • f) μ
-- Mathlib/Data/Int/ModEq.lean
@[refl, simp]
protected theorem refl (a : ℤ) : a ≡ a [ZMOD n]
-- Mathlib/RingTheory/ClassGroup.lean
@[simp]
theorem FractionalIdeal.map_canonicalEquiv_mk0 [IsDedekindDomain R] (K' : Type*) [Field K']
    [Algebra R K'] [IsFractionRing R K'] (I : (Ideal R)⁰) :
    Units.map (↑(FractionalIdeal.canonicalEquiv R⁰ K K')) (FractionalIdeal.mk0 K I) =
      FractionalIdeal.mk0 K' I
-- Mathlib/Algebra/Module/Submodule/Pointwise.lean
@[simp]
theorem smul_le_self_of_tower {α : Type*} [Semiring α] [Module α R] [Module α M]
    [SMulCommClass α R M] [IsScalarTower α R M] (a : α) (S : Submodule R M) : a • S ≤ S
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
theorem Filter.HasBasis.equicontinuousAt_iff_left {p : κ → Prop} {s : κ → Set X}
    {F : ι → X → α} {x₀ : X} (hX : (𝓝 x₀).HasBasis p s) :
    EquicontinuousAt F x₀ ↔ ∀ U ∈ 𝓤 α, ∃ k, p k ∧ ∀ x ∈ s k, ∀ i, (F i x₀, F i x) ∈ U
-- Mathlib/Data/Set/Pointwise/Interval.lean
theorem image_neg_Icc : Neg.neg '' Icc a b = Icc (-b) (-a)
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
theorem continuousAt_rpow_of_ne (p : ℝ × ℝ) (hp : p.1 ≠ 0) :
    ContinuousAt (fun p : ℝ × ℝ => p.1 ^ p.2) p
-- Mathlib/Data/Set/Basic.lean
theorem eq_of_inclusion_surjective {s t : Set α} {h : s ⊆ t}
    (h_surj : Function.Surjective (inclusion h)) : s = t
-- Mathlib/Data/Matrix/Basic.lean
protected theorem map_add [Add α] [Add β] (f : α → β) (hf : ∀ a₁ a₂, f (a₁ + a₂) = f a₁ + f a₂)
    (M N : Matrix m n α) : (M + N).map f = M.map f + N.map f
-- Mathlib/Data/Int/Order/Units.lean
@[simp]
theorem units_coe_mul_self (u : ℤˣ) : (u * u : ℤ) = 1
-- Mathlib/NumberTheory/MulChar/Lemmas.lean
@[simp]
lemma star_apply [StarRing R'] (χ : MulChar R R') (a : R) : (star χ) a = star (χ a)
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nmul_lt_nmul_of_pos_left (h₁ : a < b) (h₂ : 0 < c) : c ⨳ a < c ⨳ b
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem IsPrime.prod_mem_iff_exists_mem {I : Ideal R} (hI : I.IsPrime) (s : Finset R) :
    s.prod (fun x ↦ x) ∈ I ↔ ∃ p ∈ s, p ∈ I
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem pNilradical_eq_bot {R : Type*} [CommSemiring R] {p : ℕ} (hp : ¬ 1 < p) :
    pNilradical R p = ⊥
-- Mathlib/Analysis/NormedSpace/MStructure.lean
theorem join [FaithfulSMul M X] {P Q : M} (h₁ : IsLprojection X P) (h₂ : IsLprojection X Q) :
    IsLprojection X (P + Q - P * Q)
-- Mathlib/Algebra/Order/Nonneg/Field.lean
@[simp, norm_cast]
protected theorem coe_inv (a : { x : α // 0 ≤ x }) : ((a⁻¹ : { x : α // 0 ≤ x }) : α) = (a : α)⁻¹
-- Mathlib/Data/Fintype/Basic.lean
theorem Fintype.univ_unit : @univ Unit _ = {()}
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem coe_trans_symm : ((e.trans e').symm : γ → α) = e.symm ∘ e'.symm
-- Mathlib/FieldTheory/Minpoly/MinpolyDiv.lean
lemma minpolyDiv_eq_zero (hx : ¬IsIntegral R x) : minpolyDiv R x = 0
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma NonUnitalStarAlgHom.ext_continuousMap [UniqueNonUnitalContinuousFunctionalCalculus R A]
    (a : A) (φ ψ : C(σₙ R a, R)₀ →⋆ₙₐ[R] A) (hφ : Continuous φ) (hψ : Continuous ψ)
    (h : φ ⟨.restrict (σₙ R a) <| .id R, rfl⟩ = ψ ⟨.restrict (σₙ R a) <| .id R, rfl⟩) :
    φ = ψ
-- Mathlib/Algebra/Star/Subalgebra.lean
@[simp]
theorem coe_map (S : StarSubalgebra R A) (f : A →⋆ₐ[R] B) : (S.map f : Set B) = f '' S
-- Mathlib/Algebra/Lie/Weights/Basic.lean
lemma map_posFittingComp_le :
    (posFittingComp R L M).map f ≤ posFittingComp R L M₂
-- Mathlib/Topology/MetricSpace/Dilation.lean
/-- Ratio of the composition `g.comp f` of two dilations is the product of their ratios. We assume
that the domain `α` of `f` is a nontrivial metric space, otherwise
`Dilation.ratio f = Dilation.ratio (g.comp f) = 1` but `Dilation.ratio g` may have any value.

See also `Dilation.ratio_comp'` for a version that works for more general spaces. -/
@[simp]
theorem ratio_comp [MetricSpace α] [Nontrivial α] [PseudoEMetricSpace β]
    [PseudoEMetricSpace γ] {g : β →ᵈ γ} {f : α →ᵈ β} : ratio (g.comp f) = ratio g * ratio f
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
/-- Conjugating preserves self-adjointness. -/
theorem conj_adjoint {T : E →L[𝕜] E} (hT : IsSelfAdjoint T) (S : E →L[𝕜] F) :
    IsSelfAdjoint (S ∘L T ∘L ContinuousLinearMap.adjoint S)
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
theorem eq_comp_δ_of_not_surjective' {n : ℕ} {Δ : SimplexCategory} (θ : Δ ⟶ mk (n + 1))
    (i : Fin (n + 2)) (hi : ∀ x, θ.toOrderHom x ≠ i) : ∃ θ' : Δ ⟶ mk n, θ = θ' ≫ δ i
-- Mathlib/Data/Set/Image.lean
theorem _root_.Nat.mem_range_succ (i : ℕ) : i ∈ range Nat.succ ↔ 0 < i
-- Mathlib/Data/Nat/Choose/Basic.lean
theorem choose_eq_zero_iff {n k : ℕ} : n.choose k = 0 ↔ n < k
-- Mathlib/Data/Finset/Lattice.lean
protected theorem Nonempty.sup_eq_top_iff {α : Type*} [LinearOrder α] [BoundedOrder α]
    {s : Finset ι} {f : ι → α} (hs : s.Nonempty) : s.sup f = ⊤ ↔ ∃ b ∈ s, f b = ⊤
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
@[simp]
theorem map_exp_comap_re_atTop : map exp (comap re atTop) = cobounded ℂ
-- Mathlib/NumberTheory/Pell.lean
/-- The `x`-coordinate of a fundamental solution is a lower bound for the `x`-coordinate
of any positive solution. -/
theorem x_le_x {a₁ : Solution₁ d} (h : IsFundamental a₁) {a : Solution₁ d} (hax : 1 < a.x) :
    a₁.x ≤ a.x