ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem toIsometryEquiv_refl : (refl 𝕜 P).toIsometryEquiv = IsometryEquiv.refl P
-- Mathlib/Data/List/MinMax.lean
theorem le_minimum_of_forall_le {b : WithTop α} (h : ∀ a ∈ l, b ≤ a) : b ≤ l.minimum
-- Mathlib/Topology/MetricSpace/Thickening.lean
@[simp]
theorem cthickening_closure : cthickening δ (closure s) = cthickening δ s
-- Mathlib/Data/Matrix/Basic.lean
lemma neg_vecMul_neg [Fintype m] (v : m → α) (A : Matrix m n α) : (-v) ᵥ* (-A) = v ᵥ* A
-- Mathlib/Data/Fin/Basic.lean
theorem castPred_eq_iff_eq_castSucc (i : Fin (n + 1)) (hi : i ≠ last _) (j : Fin n) :
    castPred i hi = j ↔ i = castSucc j
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem le_of_mul_le_of_one_le_nonneg_right [MulPosMono α] (h : a * b ≤ c) (ha : 1 ≤ a)
    (hb : 0 ≤ b) : b ≤ c
-- Mathlib/Topology/LocallyConstant/Basic.lean
theorem locallyConstant_eq_of_fiber_zero_eq {X : Type*} [TopologicalSpace X]
    (f g : LocallyConstant X (Fin 2)) (h : f ⁻¹' ({0} : Set (Fin 2)) = g ⁻¹' {0}) : f = g
-- Mathlib/Topology/ContinuousFunction/Ideals.lean
theorem setOfIdeal_eq_compl_singleton (I : Ideal C(X, 𝕜)) [hI : I.IsMaximal] :
    ∃ x : X, setOfIdeal I = {x}ᶜ
-- Mathlib/Algebra/Order/CauSeq/BigOperators.lean
lemma of_abv (hf : IsCauSeq abs fun m ↦ ∑ n ∈ range m, abv (f n)) :
    IsCauSeq abv fun m ↦ ∑ n ∈ range m, f n
-- Mathlib/LinearAlgebra/Matrix/DotProduct.lean
theorem dotProduct_eq_zero (v : n → R) (h : ∀ w, dotProduct v w = 0) : v = 0
-- Mathlib/Algebra/Module/Equiv/Basic.lean
@[simp]
theorem funCongrLeft_apply (e : m ≃ n) (x : n → M) : funCongrLeft R M e x = funLeft R M e x
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
theorem tprod_congr_set_coe (f : β → α) {s t : Set β} (h : s = t) :
    ∏' x : s, f x = ∏' x : t, f x
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] lemma _root_.EquivLike.self_comp_coe_symm {F} [EquivLike F α β] (e : F) :
    e ∘ (e : α ≃ β).symm = id
-- Mathlib/GroupTheory/GroupAction/Quotient.lean
/-- A typeclass for when an `AddAction β α` descends to the quotient `α ⧸ H`. -/
class _root_.AddAction.QuotientAction {α : Type u} (β : Type v) [AddGroup α] [AddMonoid β]
  [AddAction β α] (H : AddSubgroup α) : Prop where
  /-- The action fulfils a normality condition on summands that lie in `H`.
    This ensures that the action descends to an action on the quotient `α ⧸ H`. -/
  inv_mul_mem : ∀ (b : β) {a a' : α}, -a + a' ∈ H → -(b +ᵥ a) + (b +ᵥ a') ∈ H
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem conjTranspose_zero [AddMonoid α] [StarAddMonoid α] : (0 : Matrix m n α)ᴴ = 0
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem diag_preimage_prod (s t : Set α) : (fun x => (x, x)) ⁻¹' s ×ˢ t = s ∩ t
-- .lake/packages/lean4/src/lean/Init/Data/Option/Basic.lean
@[simp] theorem none_bind (f : α → Option β) : none.bind f = none
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem sub_self (a : Ordinal) : a - a = 0
-- Mathlib/Logic/Basic.lean
theorem BAll.imp_right (H : ∀ x h, P x h → Q x h) (h₁ : ∀ x h, P x h) (x h) : Q x h
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_mul_const_Iio (a : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Iio a = Iio (a / c)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem emod_eq_of_lt {a b : Int} (H1 : 0 ≤ a) (H2 : a < b) : a % b = a
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
@[reassoc (attr := simp)]
lemma liftCycles_comp_cyclesMap {A : C} (k : A ⟶ K.X i) (j : ι) (hj : c.next i = j)
    (hk : k ≫ K.d i j = 0) (φ : K ⟶ L) :
    K.liftCycles k j hj hk ≫ cyclesMap φ i = L.liftCycles (k ≫ φ.f i) j hj
      (by rw [assoc, φ.comm, reassoc_of% hk, zero_comp])
-- Mathlib/Logic/Equiv/TransferInstance.lean
@[simp]
theorem algEquiv_apply (e : α ≃ β) [Semiring β] [Algebra R β] (a : α) : (algEquiv R e) a = e a
-- Mathlib/Data/Set/Defs.lean
@[simp]
theorem mem_image (f : α → β) (s : Set α) (y : β) : y ∈ f '' s ↔ ∃ x ∈ s, f x = y
-- Mathlib/Algebra/Ring/Int.lean
lemma two_mul_ediv_two_add_one_of_odd : Odd n → 2 * (n / 2) + 1 = n
-- Mathlib/Logic/Function/Basic.lean
theorem RightInverse.comp_eq_id {f : α → β} {g : β → α} (h : RightInverse f g) : g ∘ f = id
-- Mathlib/Data/Rat/BigOperators.lean
@[simp, norm_cast]
theorem cast_sum (s : Finset ι) (f : ι → ℚ) : ∑ i ∈ s, f i = ∑ i ∈ s, (f i : α)
-- Mathlib/Data/Setoid/Basic.lean
/-- Given a map f from α to β, the kernel of f is the unique equivalence relation on α whose
    induced map from the quotient of α to β is injective. -/
theorem ker_eq_lift_of_injective {r : Setoid α} (f : α → β) (H : ∀ x y, r.Rel x y → f x = f y)
    (h : Injective (Quotient.lift f H)) : ker f = r
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
@[to_additive]
theorem contMDiffWithinAt_one [One M'] : ContMDiffWithinAt I I' n (1 : M → M') s x
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem coe_toAddSubgroup : (s.toAddSubgroup : Set K) = s
-- Mathlib/MeasureTheory/Covering/Differentiation.lean
/-- Given an arbitrary set `s`, then `μ (s ∩ a) / μ a` converges to `1` when `a` shrinks to a
typical point of `s` along a Vitali family. This shows that almost every point of `s` is a
Lebesgue density point for `s`. A stronger version for measurable sets is given
in `ae_tendsto_measure_inter_div_of_measurableSet`. -/
theorem ae_tendsto_measure_inter_div (s : Set α) :
    ∀ᵐ x ∂μ.restrict s, Tendsto (fun a => μ (s ∩ a) / μ a) (v.filterAt x) (𝓝 1)
-- Mathlib/Algebra/Homology/ComplexShape.lean
lemma prev_eq_self' (c : ComplexShape ι) (j : ι) (hj : ∀ i, ¬ c.Rel i j) :
    c.prev j = j
-- Mathlib/Algebra/Homology/ImageToKernel.lean
@[simp]
lemma imageToKernel_arrow_apply [ConcreteCategory V] (w : f ≫ g = 0)
    (x : (forget V).obj (Subobject.underlying.obj (imageSubobject f))) :
    (kernelSubobject g).arrow (imageToKernel f g w x) =
      (imageSubobject f).arrow x
-- Mathlib/RingTheory/Jacobson.lean
/-- If `R` is a Jacobson ring, and `P` is a maximal ideal of `R[X]`,
  then `R → R[X]/P` is an integral map. -/
theorem quotient_mk_comp_C_isIntegral_of_jacobson :
    ((Quotient.mk P).comp C : R →+* R[X] ⧸ P).IsIntegral
-- Mathlib/Analysis/SpecificLimits/Basic.lean
theorem tendsto_nat_floor_atTop {α : Type*} [LinearOrderedSemiring α] [FloorSemiring α] :
    Tendsto (fun x : α ↦ ⌊x⌋₊) atTop atTop
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem ContDiffOn.contDiffAt (h : ContDiffOn 𝕜 n f s) (hx : s ∈ 𝓝 x) :
    ContDiffAt 𝕜 n f x
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem filter_apply [∀ i, Zero (β i)] (p : ι → Prop) [DecidablePred p] (i : ι) (f : Π₀ i, β i) :
    f.filter p i = if p i then f i else 0
-- Mathlib/LinearAlgebra/Determinant.lean
/-- The determinant of an endomorphism independent of basis.

If there is no finite basis on `M`, the result is `1` instead.
-/
protected irreducible_def det : (M →ₗ[A] M) →* A
-- Mathlib/RingTheory/MvPolynomial/Symmetric.lean
theorem support_esymm'' (n : ℕ) [DecidableEq σ] [Nontrivial R] :
    (esymm σ R n).support =
      (powersetCard n (univ : Finset σ)).biUnion fun t =>
        (Finsupp.single (∑ i ∈ t, Finsupp.single i 1) (1 : R)).support
-- Mathlib/Analysis/Convex/Function.lean
theorem concaveOn_iff_div {f : E → β} :
    ConcaveOn 𝕜 s f ↔
      Convex 𝕜 s ∧ ∀ ⦃x⦄, x ∈ s → ∀ ⦃y⦄, y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → 0 < a + b →
        (a / (a + b)) • f x + (b / (a + b)) • f y ≤ f ((a / (a + b)) • x + (b / (a + b)) • y)
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
@[simp]
theorem preimage_symm (f : P₁ ≃ᵃL[k] P₂) (s : Set P₁) : f.symm ⁻¹' s = f '' s
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem Ioo_ae_eq_Icc : Ioo a b =ᵐ[μ] Icc a b
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem principal_neBot_iff {s : Set α} : NeBot (𝓟 s) ↔ s.Nonempty
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
lemma isClique_empty : G.IsClique ∅
-- Mathlib/Data/Prod/Basic.lean
@[simp]
theorem mk.eta : ∀ {p : α × β}, (p.1, p.2) = p
-- Mathlib/Analysis/Seminorm.lean
@[simp]
theorem ball_eq_emptyset (p : Seminorm 𝕜 E) {x : E} {r : ℝ} (hr : r ≤ 0) : p.ball x r = ∅
-- Mathlib/Analysis/Seminorm.lean
theorem closedBall_add_closedBall_subset (p : Seminorm 𝕜 E) (r₁ r₂ : ℝ) (x₁ x₂ : E) :
    p.closedBall (x₁ : E) r₁ + p.closedBall (x₂ : E) r₂ ⊆ p.closedBall (x₁ + x₂) (r₁ + r₂)
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
/-- If `μ` is an s-finite measure, then for any function `f`
there exists a measurable function `g ≤ f`
that has the same Lebesgue integral over every set.

For the integral over the whole space, the statement is true without extra assumptions,
see `exists_measurable_le_lintegral_eq`.
See also `MeasureTheory.Measure.restrict_toMeasurable_of_sFinite` for a similar result. -/
theorem exists_measurable_le_forall_setLIntegral_eq [SFinite μ] (f : α → ℝ≥0∞) :
    ∃ g : α → ℝ≥0∞, Measurable g ∧ g ≤ f ∧ ∀ s, ∫⁻ a in s, f a ∂μ = ∫⁻ a in s, g a ∂μ
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
@[reassoc]
theorem gluedLiftPullbackMap_snd (i j : 𝒰.J) :
    gluedLiftPullbackMap 𝒰 f g s i j ≫ pullback.snd _ _ = pullback.snd _ _ ≫ pullback.snd _ _
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem take_cons_succ : (a::as).take (i+1) = a :: as.take i
-- Mathlib/Algebra/GroupWithZero/Action/Defs.lean
@[simp]
theorem smul_zero (a : M) : a • (0 : A) = 0
-- Mathlib/NumberTheory/LSeries/Linearity.lean
lemma LSeries.term_add (f g : ℕ → ℂ) (s : ℂ) : term (f + g) s = term f s + term g s
-- Mathlib/Data/List/GetD.lean
theorem getD_append_right (l l' : List α) (d : α) (n : ℕ) (h : l.length ≤ n) :
    (l ++ l').getD n d = l'.getD (n - l.length) d
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem open_target (he : e ∈ c.atlas) : IsOpen e.target
-- Mathlib/Analysis/Complex/UnitDisc/Basic.lean
@[simp]
theorem coe_conj (z : 𝔻) : (z.conj : ℂ) = conj' ↑z
-- Mathlib/RingTheory/Polynomial/Dickson.lean
@[simp]
theorem dickson_zero : dickson k a 0 = 3 - k
-- Mathlib/Logic/Basic.lean
theorem imp_or' {a : Sort*} {b c : Prop} : a → b ∨ c ↔ (a → b) ∨ (a → c)
-- Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean
@[simp]
theorem isOrtho_smul_right {x y : M₄} {a : R₄} (ha : a ≠ 0) :
    IsOrtho G x (a • y) ↔ IsOrtho G x y
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem compl_sup_eq_top : xᶜ ⊔ x = ⊤
-- Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean
/-- `x^n`, `n : ℕ` is strictly convex on `[0, +∞)` for all `n` greater than `2`. -/
theorem strictConvexOn_pow {n : ℕ} (hn : 2 ≤ n) : StrictConvexOn ℝ (Ici 0) fun x : ℝ => x ^ n
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
/-- If a set has the unique differentiability property at a point x, then the image of this set
under a map with onto derivative has also the unique differentiability property at the image point.
-/
theorem HasFDerivWithinAt.uniqueDiffWithinAt {x : E} (h : HasFDerivWithinAt f f' s x)
    (hs : UniqueDiffWithinAt 𝕜 s x) (h' : DenseRange f') : UniqueDiffWithinAt 𝕜 (f '' s) (f x)
-- Mathlib/Data/Set/Lattice.lean
theorem _root_.Antitone.iInter_nat_add {f : ℕ → Set α} (hf : Antitone f) (k : ℕ) :
    ⋂ n, f (n + k) = ⋂ n, f n
-- Mathlib/Tactic/CC/Lemmas.lean
theorem imp_eq_of_eq_false_right {a b : Prop} (h : b = False) : (a → b) = Not a
-- Mathlib/Topology/Compactness/Compact.lean
/-- The complement to a compact set belongs to a filter `f` if it belongs to each filter
`𝓝 x ⊓ f`, `x ∈ s`. -/
theorem IsCompact.compl_mem_sets (hs : IsCompact s) {f : Filter X} (hf : ∀ x ∈ s, sᶜ ∈ 𝓝 x ⊓ f) :
    sᶜ ∈ f
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
theorem coeFn_pow (f : α →ₘ[μ] γ) (n : ℕ) : ⇑(f ^ n) =ᵐ[μ] (⇑f) ^ n
-- Mathlib/Order/Interval/Set/OrdConnectedComponent.lean
theorem mem_ordConnectedComponent_comm :
    y ∈ ordConnectedComponent s x ↔ x ∈ ordConnectedComponent s y
-- Mathlib/Tactic/Ring/Basic.lean
theorem neg_zero {R} [Ring R] : -(0 : R) = 0
-- Mathlib/Analysis/MeanInequalities.lean
/-- **Minkowski inequality**: the `L_p` seminorm of the infinite sum of two vectors is less than or
equal to the infinite sum of the `L_p`-seminorms of the summands, if these infinite sums both
exist. A version for `NNReal`-valued functions. For an alternative version, convenient if the
infinite sums are not already expressed as `p`-th powers, see `Lp_add_le_tsum_of_nonneg`.  -/
theorem Lp_add_le_hasSum {f g : ι → ℝ≥0} {A B : ℝ≥0} {p : ℝ} (hp : 1 ≤ p)
    (hf : HasSum (fun i => f i ^ p) (A ^ p)) (hg : HasSum (fun i => g i ^ p) (B ^ p)) :
    ∃ C, C ≤ A + B ∧ HasSum (fun i => (f i + g i) ^ p) (C ^ p)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem getElem?_replicate_of_lt {n : Nat} {m : Nat} (h : m < n) : (replicate n a)[m]? = some a
-- Mathlib/RingTheory/Derivation/Basic.lean
theorem leibniz_inv (a : K) : D a⁻¹ = -a⁻¹ ^ 2 • D a
-- Mathlib/Data/Nat/Bitwise.lean
@[simp]
theorem bit_false : bit false = (2 * ·)
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Ico_filter_lt_of_right_le [DecidablePred (· < c)] (hbc : b ≤ c) :
    (Ico a b).filter (· < c) = Ico a b
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
lemma map_truncatedSup (e : α ≃o β) (s : Finset α) (a : α) :
    e (truncatedSup s a) = truncatedSup (s.map e.toEquiv.toEmbedding) (e a)
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
@[simp]
theorem zero_smul' [Zero R] [SMulWithZero R V] {x : HahnModule Γ' R V} :
    (0 : HahnSeries Γ R) • x = 0
-- Mathlib/RingTheory/DedekindDomain/Different.lean
lemma mem_dual {x} :
    x ∈ dual A K I ↔ ∀ a ∈ I, traceForm K L x a ∈ (algebraMap A K).range
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem Bool.not_not (b : Bool) : (!!b) = b
-- Mathlib/Data/Nat/PartENat.lean
@[simp]
theorem ofNat_lt_top (x : ℕ) [x.AtLeastTwo] : (no_index (OfNat.ofNat x : PartENat)) < ⊤
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem mem_iInf_iff {f : ι → UpperSet α} : (a ∈ ⨅ i, f i) ↔ ∃ i, a ∈ f i
-- Mathlib/Topology/Homotopy/Basic.lean
theorem symm_trans (F : HomotopyRel f₀ f₁ S) (G : HomotopyRel f₁ f₂ S) :
    (F.trans G).symm = G.symm.trans F.symm
-- Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean
theorem stream_eq_none_of_fr_eq_zero {ifp_n : IntFractPair K}
    (stream_nth_eq : IntFractPair.stream v n = some ifp_n) (nth_fr_eq_zero : ifp_n.fr = 0) :
    IntFractPair.stream v (n + 1) = none
-- Mathlib/Algebra/Module/Equiv/Defs.lean
/-- The two paths coercion can take to an `AddMonoidHom` are equivalent -/
theorem toAddMonoidHom_commutes : e.toLinearMap.toAddMonoidHom = e.toAddEquiv.toAddMonoidHom
-- Mathlib/Data/Matroid/Basic.lean
theorem Indep.basis_of_forall_insert (hI : M.Indep I) (hIX : I ⊆ X)
    (he : ∀ e ∈ X \ I, M.Dep (insert e I)) : M.Basis I X
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem toTopologicalSpace_iInf {ι : Sort*} {u : ι → UniformSpace α} :
    (iInf u).toTopologicalSpace = ⨅ i, (u i).toTopologicalSpace
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
theorem one_def : (1 : E ≃ₗᵢ[R] E) = refl _ _
-- Mathlib/Analysis/Calculus/FDeriv/Bilinear.lean
protected theorem IsBoundedBilinearMap.fderivWithin (h : IsBoundedBilinearMap 𝕜 b) (p : E × F)
    (hxs : UniqueDiffWithinAt 𝕜 u p) : fderivWithin 𝕜 b u p = h.deriv p
-- Mathlib/RingTheory/Polynomial/Hermite/Basic.lean
theorem coeff_hermite_succ_succ (n k : ℕ) : coeff (hermite (n + 1)) (k + 1) =
    coeff (hermite n) k - (k + 2) * coeff (hermite n) (k + 2)
-- Mathlib/Data/Sym/Sym2/Order.lean
@[simp] theorem sup_mk [SemilatticeSup α] (a b : α) : s(a, b).sup = a ⊔ b
-- Mathlib/LinearAlgebra/Lagrange.lean
@[simp]
theorem basisDivisor_eq_zero_iff : basisDivisor x y = 0 ↔ x = y
-- Mathlib/Data/Int/Cast/Lemmas.lean
@[simp]
theorem intCast_def (n : ℤ) : (n : ∀ i, π i) = fun _ => ↑n
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
@[simp]
theorem int_sub_iff : LiouvilleWith p (m - x) ↔ LiouvilleWith p x
-- Mathlib/Order/WellFoundedSet.lean
@[simp]
protected theorem isWF [Preorder α] (s : Finset α) : Set.IsWF (↑s : Set α)
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem eq_of_xn_modEq_lem2 {n} (h : 2 * xn a1 n = xn a1 (n + 1)) : a = 2 ∧ n = 0
-- Mathlib/SetTheory/Cardinal/Finite.lean
theorem card_eq_one_iff_unique : Nat.card α = 1 ↔ Subsingleton α ∧ Nonempty α
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma div_div_cancel_left' (ha : a ≠ 0) : a / b / a = b⁻¹
-- Mathlib/Data/Num/Lemmas.lean
@[simp]
theorem gcd_to_nat : ∀ a b, (gcd a b : ℕ) = Nat.gcd a b
-- Mathlib/Analysis/Convex/Basic.lean
theorem convex_halfspace_ge {f : E → β} (h : IsLinearMap 𝕜 f) (r : β) : Convex 𝕜 { w | r ≤ f w }
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
@[simp]
theorem rightUnitor_hom_hom (X : Mon_ C) : (ρ_ X).hom.hom = (ρ_ X.X).hom
-- Mathlib/Algebra/Homology/ExactSequence.lean
@[reassoc]
lemma IsComplex.zero' (hS : S.IsComplex) (i j k : ℕ) (hij : i + 1 = j := by omega)
    (hjk : j + 1 = k := by omega) (hk : k ≤ n := by omega) :
    S.map' i j ≫ S.map' j k = 0
-- Mathlib/Deprecated/Subring.lean
@[elab_as_elim]
protected theorem InClosure.recOn {C : R → Prop} {x : R} (hx : x ∈ closure s) (h1 : C 1)
    (hneg1 : C (-1)) (hs : ∀ z ∈ s, ∀ n, C n → C (z * n)) (ha : ∀ {x y}, C x → C y → C (x + y)) :
    C x
-- Mathlib/Algebra/Module/LinearMap/End.lean
theorem coe_pow (f : M →ₗ[R] M) (n : ℕ) : ⇑(f ^ n) = f^[n]
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
@[simp]
theorem comap_comp {E : Type*} [Groupoid E] (ψ : D ⥤ E) : comap (φ ⋙ ψ) = comap φ ∘ comap ψ
-- Mathlib/RingTheory/IsTensorProduct.lean
theorem IsTensorProduct.inductionOn (h : IsTensorProduct f) {C : M → Prop} (m : M) (h0 : C 0)
    (htmul : ∀ x y, C (f x y)) (hadd : ∀ x y, C x → C y → C (x + y)) : C m
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem coe_toHomeomorph (h : M ≃ₘ^n⟮I, J⟯ N) : ⇑h.toHomeomorph = h
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem tan_zero : tan 0 = 0
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
theorem DirectSum.coeLinearMap_eq_finsum [DecidableEq M]
    (x : DirectSum M fun i : M => ↥(weightedHomogeneousSubmodule R w i)) :
    (DirectSum.coeLinearMap fun i : M => weightedHomogeneousSubmodule R w i) x =
      finsum fun m => x m
-- Mathlib/Order/Category/PartOrd.lean
/-- The equivalence between `PartOrd` and itself induced by `OrderDual` both ways. -/
@[simps functor inverse]
def dualEquiv : PartOrd ≌ PartOrd
-- Mathlib/Data/Matrix/DMatrix.lean
@[simp]
theorem sub_apply [∀ i j, Sub (α i j)] (M N : DMatrix m n α) (i j) : (M - N) i j = M i j - N i j
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem le_ediv_of_mul_le {a b c : Int} (H1 : 0 < c) (H2 : a * c ≤ b) : a ≤ b / c
-- Mathlib/Order/CompleteLattice.lean
theorem sInf_pair {a b : α} : sInf {a, b} = a ⊓ b
-- Mathlib/Data/Finset/Lattice.lean
theorem set_biUnion_singleton (a : α) (s : α → Set β) : ⋃ x ∈ ({a} : Finset α), s x = s a
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem decide_iff_dist (p q : Prop) [dpq : Decidable (p ↔ q)] [dp : Decidable p] [dq : Decidable q] :
    decide (p ↔ q) = (decide p == decide q)
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem isRadical_bot_of_noZeroDivisors {R} [CommSemiring R] [NoZeroDivisors R] :
    (⊥ : Ideal R).IsRadical
-- Mathlib/Algebra/Module/Equiv/Basic.lean
@[simp]
theorem funCongrLeft_id : funCongrLeft R M (Equiv.refl n) = LinearEquiv.refl R (n → M)
-- Mathlib/Order/Filter/Germ/Basic.lean
@[elab_as_elim]
theorem inductionOn₂ (f : Germ l β) (g : Germ l γ) {p : Germ l β → Germ l γ → Prop}
    (h : ∀ (f : α → β) (g : α → γ), p f g) : p f g
-- Mathlib/Order/Filter/Germ/Basic.lean
theorem coe_nonneg [LE β] [Zero β] {f : α → β} : 0 ≤ (f : Germ l β) ↔ ∀ᶠ x in l, 0 ≤ f x
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
/-- `sinh` is bijective, both injective and surjective. -/
theorem sinh_bijective : Bijective sinh
-- Mathlib/Algebra/Quaternion.lean
@[simp] nonrec theorem sub_self_re : a - ↑a.re = a.im
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNorm_indicator_eq_restrict {f : α → E} {s : Set α} (hs : MeasurableSet s) :
    eLpNorm (s.indicator f) p μ = eLpNorm f p (μ.restrict s)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
lemma ΨSq_ne_zero [NoZeroDivisors R] {n : ℤ} (h : (n : R) ≠ 0) : W.ΨSq n ≠ 0
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem OrthogonalFamily.inner_sum (l₁ l₂ : ∀ i, G i) (s : Finset ι) :
    ⟪∑ i ∈ s, V i (l₁ i), ∑ j ∈ s, V j (l₂ j)⟫ = ∑ i ∈ s, ⟪l₁ i, l₂ i⟫
-- Mathlib/Data/Seq/Seq.lean
theorem map_id : ∀ s : Seq1 α, map id s = s
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ico_insert_right (h : a ≤ b) : insert b (Ico a b) = Icc a b
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
theorem trim_eq_trim_iff {m₁ m₂ : OuterMeasure α} :
    m₁.trim = m₂.trim ↔ ∀ s, MeasurableSet s → m₁ s = m₂ s
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem DifferentiableAt.rpow (hf : DifferentiableAt ℝ f x) (hg : DifferentiableAt ℝ g x)
    (h : f x ≠ 0) : DifferentiableAt ℝ (fun x => f x ^ g x) x
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem tendsto_nhds_iff {α : Type*} {l : Filter α} {f : α → Z} {z : Z} (hz : z ∈ e.source) :
    Tendsto f l (𝓝 z) ↔
      Tendsto (proj ∘ f) l (𝓝 (proj z)) ∧ Tendsto (fun x ↦ (e (f x)).2) l (𝓝 (e z).2)
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem zeroLocus_sup_ideal (I J : Ideal A) :
    zeroLocus 𝒜 ((I ⊔ J : Ideal A) : Set A) = zeroLocus _ I ∩ zeroLocus _ J
-- Mathlib/LinearAlgebra/Matrix/DotProduct.lean
lemma self_mul_conjTranspose_mul_eq_zero (A : Matrix m n R) (B : Matrix m p R) :
    (A * Aᴴ) * B = 0 ↔ Aᴴ * B = 0
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp]
theorem Icc_erase_right (a b : α) : (Icc a b).erase b = Ico a b
-- Mathlib/Data/Prod/TProd.lean
theorem mk_preimage_tprod :
    ∀ (l : List ι) (t : ∀ i, Set (α i)), TProd.mk l ⁻¹' Set.tprod l t = { i | i ∈ l }.pi t
-- Mathlib/NumberTheory/Divisors.lean
theorem divisors_injective : Function.Injective divisors
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[simp]
theorem coe_copy (S : NonUnitalSubring R) (s : Set R) (hs : s = ↑S) : (S.copy s hs : Set R) = s
-- Mathlib/Algebra/Order/CauSeq/Completion.lean
theorem lim_mul_lim (f g : CauSeq β abv) : lim f * lim g = lim (f * g)
-- Mathlib/Algebra/Homology/HomotopyCategory/Shift.lean
@[simp]
lemma mapHomologicalComplex_commShiftIso_hom_app_f (K : CochainComplex C ℤ) (n i : ℤ) :
    (((F.mapHomologicalComplex (ComplexShape.up ℤ)).commShiftIso n).hom.app K).f i = 𝟙 _
-- Mathlib/Order/Interval/Set/ProjIcc.lean
theorem IccExtend_of_mem (f : Icc a b → β) (hx : x ∈ Icc a b) : IccExtend h f x = f ⟨x, hx⟩
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem mul_lt_mul_of_pos_left {n m k : Nat} (h : n < m) (hk : k > 0) : k * n < k * m
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
@[simp]
theorem homIso_hom (h : IsColimit t) {W : C} (f : ULift (t.pt ⟶ W)) :
    (IsColimit.homIso h W).hom f = (t.extend f.down).ι
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
theorem totalDegree_le_of_support_subset (h : p.support ⊆ q.support) :
    totalDegree p ≤ totalDegree q
-- Mathlib/CategoryTheory/Category/Preorder.lean
@[simp]
theorem Equivalence.toOrderIso_apply (e : X ≌ Y) (x : X) : e.toOrderIso x = e.functor.obj x
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem mk_add_moveRight_inr {xl xr yl yr} {xL xR yL yR} {i} :
    (mk xl xr xL xR + mk yl yr yL yR).moveRight (Sum.inr i) =
      mk xl xr xL xR + (mk yl yr yL yR).moveRight i
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
@[simp] lemma compl_truncatedInf (s : Finset α) (a : α) :
    (truncatedInf s a)ᶜ = truncatedSup sᶜˢ aᶜ
-- Mathlib/Algebra/Ring/Ext.lean
theorem toSemiring_injective :
    Function.Injective (@toSemiring R)
-- Mathlib/Data/PNat/Factors.lean
@[simp]
theorem coe_coePNatMonoidHom : (coePNatMonoidHom : PrimeMultiset → Multiset ℕ+) = Coe.coe
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
@[simp, norm_cast]
theorem coe_bot : ((⊥ : WithBot (Box ι)) : Set (ι → ℝ)) = ∅
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
@[simp]
theorem eLpNormEssSup_measure_zero {f : α → F} : eLpNormEssSup f (0 : Measure α) = 0
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem smul_left {R : Type*} [Semiring R] [DistribMulAction R M] [ContinuousConstSMul R M] (r : R)
    (h : v ⟂ᵥ w) : r • v ⟂ᵥ w
-- Mathlib/RingTheory/PowerSeries/Derivative.lean
@[simp] theorem derivative_inv' {R} [Field R] (f : R⟦X⟧) : d⁄dX R f⁻¹ = -f⁻¹ ^ 2 * d⁄dX R f
-- .lake/packages/lean4/src/lean/Init/Data/Option/Basic.lean
@[simp] theorem all_none : Option.all p none = true