ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean
theorem map_alternatingFaceMapComplex {D : Type*} [Category D] [Preadditive D] (F : C ⥤ D)
    [F.Additive] :
    alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex _ =
      (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem bsup_le_blsub {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    bsup.{_, v} o f ≤ blsub.{_, v} o f
-- Mathlib/Data/NNReal/Basic.lean
@[simp]
theorem lt_inv_iff_mul_lt {r p : ℝ≥0} (h : p ≠ 0) : r < p⁻¹ ↔ r * p < 1
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
/-- `VectorMeasure.map` as a linear map. -/
@[simps]
def mapₗ (f : α → β) : VectorMeasure α M →ₗ[R] VectorMeasure β M
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem castSucc_lt_castSucc_iff {a b : Fin n} :
    Fin.castSucc a < Fin.castSucc b ↔ a < b
-- Mathlib/Computability/EpsilonNFA.lean
@[simp]
theorem evalFrom_singleton (S : Set σ) (a : α) : M.evalFrom S [a] = M.stepSet (M.εClosure S) a
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
@[fun_prop]
theorem Differentiable.differentiableAt (h : Differentiable 𝕜 f) : DifferentiableAt 𝕜 f x
-- Mathlib/Algebra/Group/Opposite.lean
@[to_additive]
nonrec theorem _root_.Commute.unop [Mul α] {x y : αᵐᵒᵖ} (h : Commute x y) :
    Commute (unop x) (unop y)
-- Mathlib/Data/Nat/Cast/Prod.lean
@[simp]
theorem fst_ofNat (n : ℕ) [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n : α × β)).1 = (OfNat.ofNat n : α)
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
theorem homogeneousSubmodule_mul [CommSemiring R] (m n : ℕ) :
    homogeneousSubmodule σ R m * homogeneousSubmodule σ R n ≤ homogeneousSubmodule σ R (m + n)
-- Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean
/-- The isomorphism `eB.functor ⋙ e'.inverse ⋙ e'.functor ≅ eB.functor` deduced
from the counit isomorphism of `e'`. -/
@[simps! hom_app]
def τ₀ : eB.functor ⋙ e'.inverse ⋙ e'.functor ≅ eB.functor
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
@[simp]
theorem mul_integral_comp_mul_add :
    (c * ∫ x in a..b, f (c * x + d)) = ∫ x in c * a + d..c * b + d, f x
-- Mathlib/Order/Partition/Finpartition.lean
/-- The empty finpartition. -/
@[simps]
protected def empty : Finpartition (⊥ : α)
-- Mathlib/Combinatorics/Pigeonhole.lean
/-- The strong pigeonhole principle for finitely many pigeons and pigeonholes.
There is a pigeonhole with at most as many pigeons as
the floor of the average number of pigeons across all pigeonholes.
("The minimum is at most the mean" specialized to integers.)

More formally, given a function `f` between finite types `α` and `β` and a number `n` such that
`card α < card β * n`, there exists an element `y : β` such that its preimage has less than `n`
elements. -/
theorem exists_card_fiber_lt_of_card_lt_mul (hn : card α < card β * n) :
    ∃ y : β, (univ.filter fun x => f x = y).card < n
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
theorem _root_.AlgHom.map_det [Algebra R S] {T : Type z} [CommRing T] [Algebra R T] (f : S →ₐ[R] T)
    (M : Matrix n n S) : f M.det = Matrix.det (f.mapMatrix M)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.eq_zero_imp (h : IsBigOWith c l f'' g'') : ∀ᶠ x in l, g'' x = 0 → f'' x = 0
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem span_singleton_eq_span_singleton {α : Type u} [CommRing α] [IsDomain α] {x y : α} :
    span ({x} : Set α) = span ({y} : Set α) ↔ Associated x y
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
@[simp]
theorem algebraMap_lift (x : S) : algebraMap A B (lift R A B x) = algebraMap S B x
-- Mathlib/Data/Finset/Pairwise.lean
theorem PairwiseDisjoint.attach (hs : (s : Set ι).PairwiseDisjoint f) :
    (s.attach : Set { x // x ∈ s }).PairwiseDisjoint (f ∘ Subtype.val)
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem mem_lp_const_smul (c : 𝕜) (f : lp E p) : c • (f : PreLp E) ∈ lp E p
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma smul_neg_iff_of_pos_left [PosSMulStrictMono α β] [PosSMulReflectLT α β] (ha : 0 < a) :
    a • b < 0 ↔ b < 0
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
@[simp]
lemma gluing_ι (j : 𝒰.J) :
    (gluing 𝒰 f g).ι j = Multicoequalizer.π (gluing 𝒰 f g).diagram j
-- Mathlib/Order/OmegaCompletePartialOrder.lean
/-- `Function.const` is a continuous function. -/
@[simps!]
def const (x : β) : α →𝒄 β
-- Mathlib/SetTheory/Game/PGame.lean
theorem lt_neg_iff {x y : PGame} : y < -x ↔ x < -y
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
lemma refl {X Y : C} (z : W.RightFraction X Y) : RightFractionRel z z
-- Mathlib/Topology/Instances/ENNReal.lean
@[gcongr]
protected theorem _root_.GCongr.ennreal_tsum_le_tsum (h : ∀ a, f a ≤ g a) : tsum f ≤ tsum g
-- Mathlib/Computability/Language.lean
theorem append_mem_mul : a ∈ l → b ∈ m → a ++ b ∈ l * m
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
theorem mem_support_bernoulli_iff : b ∈ (bernoulli p h).support ↔ cond b (p ≠ 0) (p ≠ 1)
-- Mathlib/RingTheory/AdicCompletion/Algebra.lean
theorem val_smul_eq_evalₐ_smul (n : ℕ) (r : AdicCompletion I R)
    (x : M ⧸ (I ^ n • ⊤ : Submodule R M)) : r.val n • x = evalₐ I n r • x
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem Iio_ae_eq_Iic : Iio a =ᵐ[μ] Iic a
-- Mathlib/Analysis/Complex/UnitDisc/Basic.lean
theorem normSq_lt_one (z : 𝔻) : normSq z < 1
-- Mathlib/Combinatorics/SetFamily/FourFunctions.lean
lemma collapse_eq (ha : a ∉ s) (𝒜 : Finset (Finset α)) (f : Finset α → β) :
    collapse 𝒜 a f s = (if s ∈ 𝒜 then f s else 0) +
      if insert a s ∈ 𝒜 then f (insert a s) else 0
-- Mathlib/Data/Fintype/Card.lean
theorem card_pos_iff : 0 < card α ↔ Nonempty α
-- Mathlib/Data/Num/Lemmas.lean
@[simp]
theorem pred'_succ' (n) : pred' (succ' n) = n
-- Mathlib/Data/Finset/Union.lean
@[simp] lemma biUnion_val (s : Finset α) (t : α → Finset β) :
    (s.biUnion t).1 = (s.1.bind fun a ↦ (t a).1).dedup
-- Mathlib/Topology/Instances/AddCircle.lean
theorem continuousAt_equivIco : ContinuousAt (equivIco p a) x
-- Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
theorem mdifferentiable_of_mem_atlas (h : e ∈ atlas H M) : e.MDifferentiable I I
-- Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean
@[simp]
theorem unitization_apply (x : Unitization ℕ s) : unitization s x = x.fst + x.snd
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
/--
The sign extension is a bitwise not, followed by a zero extend, followed by another bitwise not
when `msb = true`. The double bitwise not ensures that the high bits are '1',
and the lower bits are preserved. -/
theorem signExtend_eq_not_zeroExtend_not_of_msb_true {x : BitVec w} {v : Nat} (hmsb : x.msb = true) :
    x.signExtend v = ~~~((~~~x).zeroExtend v)
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
@[simp] lemma coe_recolorOfCardLE [Fintype α] [Fintype β] (hαβ : card α ≤ card β) :
    ⇑(G.recolorOfCardLE hαβ) =
      (Embedding.completeGraph (Embedding.nonempty_of_card_le hαβ).some).toHom.comp
-- Mathlib/Geometry/Manifold/LocalDiffeomorph.lean
theorem isLocalDiffeomorph_iff_isLocalDiffeomorphOn_univ {f : M → N} :
    IsLocalDiffeomorph I J n f ↔ IsLocalDiffeomorphOn I J n f Set.univ
-- Mathlib/Order/MinMax.lean
@[simp]
theorem min_eq_left_iff : min a b = a ↔ a ≤ b
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem smooth_iff_target :
    Smooth I I' f ↔
      Continuous f ∧
        ∀ y : M', SmoothOn I 𝓘(𝕜, E') (extChartAt I' y ∘ f) (f ⁻¹' (extChartAt I' y).source)
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
/-- The `setRed` function preserves the ordering invariants. -/
protected theorem Ordered.setRed {t : RBNode α} : (setRed t).Ordered cmp ↔ t.Ordered cmp
-- Mathlib/Order/Filter/Basic.lean
theorem comap_map {f : Filter α} {m : α → β} (h : Injective m) : comap m (map m f) = f
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem le_csInf_iff (hb : BddBelow s) (hs : s.Nonempty) : a ≤ sInf s ↔ ∀ b ∈ s, a ≤ b
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem System.Platform.numBits_eq : Or (Eq numBits 32) (Eq numBits 64)
-- Mathlib/Topology/AlexandrovDiscrete.lean
lemma exterior_mem_nhdsSet : exterior s ∈ 𝓝ˢ s
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem one_eq_closure : (1 : AddSubmonoid R) = closure {1}
-- Mathlib/CategoryTheory/Preadditive/InjectiveResolution.lean
lemma exact_succ (n : ℕ) :
    (ShortComplex.mk _ _ (I.cocomplex.d_comp_d n (n + 1) (n + 2))).Exact
-- Mathlib/Data/Real/Archimedean.lean
theorem sInf_le_sSup (s : Set ℝ) (h₁ : BddBelow s) (h₂ : BddAbove s) : sInf s ≤ sSup s
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem get_swap (a : Array α) (i j : Fin a.size) (k : Nat) (hk: k < a.size) :
    (a.swap i j)[k]'(by simp_all) = if k = i then a[j] else if k = j then a[i]  else a[k]
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem norm_compLp_sub_le (hg : LipschitzWith c g) (g0 : g 0 = 0) (f f' : Lp E p μ) :
    ‖hg.compLp g0 f - hg.compLp g0 f'‖ ≤ c * ‖f - f'‖
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
theorem differentiable_set_eq_D (hK : IsComplete K) :
    { x | DifferentiableWithinAt ℝ f (Ici x) x ∧ derivWithin f (Ici x) x ∈ K } = D f K
-- Mathlib/Algebra/Lie/Normalizer.lean
@[simp]
lemma mem_idealizer {x : L} : x ∈ N.idealizer ↔ ∀ m : M, ⁅x, m⁆ ∈ N
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem one_imJ : (1 : ℍ[R,c₁,c₂]).imJ = 0
-- Mathlib/Data/Matroid/Restrict.lean
theorem restrict_eq_restrict_iff (M M' : Matroid α) (X : Set α) :
    M ↾ X = M' ↾ X ↔ ∀ I, I ⊆ X → (M.Indep I ↔ M'.Indep I)
-- Mathlib/Algebra/Module/LocalizedModule.lean
/--
If `g` is a linear map `M → M''` such that all scalar multiplication by `s : S` is invertible and
`l` is another linear map `LocalizedModule S M ⟶ M''` such that `l ∘ mkLinearMap = g` then
`l = lift g`
-/
theorem lift_unique (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x))
    (l : LocalizedModule S M →ₗ[R] M'') (hl : l.comp (LocalizedModule.mkLinearMap S M) = g) :
    LocalizedModule.lift S g h = l
-- Mathlib/Analysis/RCLike/Basic.lean
@[rclike_simps, norm_cast]
theorem ofReal_div (r s : ℝ) : ((r / s : ℝ) : K) = r / s
-- Mathlib/Logic/Embedding/Basic.lean
theorem swap_comp {α β : Type*} [DecidableEq α] [DecidableEq β] (f : α ↪ β) (x y : α) :
    Equiv.swap (f x) (f y) ∘ f = f ∘ Equiv.swap x y
-- Mathlib/Tactic/Ring/Basic.lean
theorem pow_zero (a : R) : a ^ 0 = (nat_lit 1).rawCast + 0
-- Mathlib/Order/Circular.lean
theorem btw_refl_right (a b : α) : btw a b b
-- Mathlib/InformationTheory/Hamming.lean
@[simp]
theorem ofHamming_neg [∀ i, Neg (β i)] {x : Hamming β} : ofHamming (-x) = -ofHamming x
-- Mathlib/RingTheory/Generators.lean
@[simp]
lemma σ_smul (x y) : P.σ x • y = x * y
-- Mathlib/Data/Set/UnionLift.lean
/-- `iUnionLift_unary` is useful for proving that `iUnionLift` is a homomorphism
  of algebraic structures when defined on the Union of algebraic subobjects.
  For example, it could be used to prove that the lift of a collection
  of linear_maps on a union of submodules preserves scalar multiplication. -/
theorem iUnionLift_unary (u : T → T) (ui : ∀ i, S i → S i)
    (hui :
      ∀ (i) (x : S i),
        u (Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_iUnion S i) x) =
          Set.inclusion (show S i ⊆ T from hT'.symm ▸ Set.subset_iUnion S i) (ui i x))
    (uβ : β → β) (h : ∀ (i) (x : S i), f i (ui i x) = uβ (f i x)) (x : T) :
    iUnionLift S f hf T (le_of_eq hT') (u x) = uβ (iUnionLift S f hf T (le_of_eq hT') x)
-- Mathlib/Order/OrderIsoNat.lean
theorem not_wellFounded_of_decreasing_seq (f : ((· > ·) : ℕ → ℕ → Prop) ↪r r) : ¬WellFounded r
-- Mathlib/Algebra/Associated/Basic.lean
protected theorem comm [Monoid α] {x y : α} : x ~ᵤ y ↔ y ~ᵤ x
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
theorem Subalgebra.separatesPoints_monotone :
    Monotone fun s : Subalgebra R C(α, A) => s.SeparatesPoints
-- Mathlib/Algebra/Lie/Derivation/Killing.lean
lemma ad_mem_ker_killingForm_ad_range_of_mem_orthogonal
    {D : LieDerivation R L L} (hD : D ∈ 𝕀ᗮ) (x : L) :
    ad R L (D x) ∈ (LinearMap.ker (killingForm R 𝕀)).map (LieHom.range (ad R L)).subtype
-- Mathlib/Order/Monotone/Basic.lean
@[simp]
theorem monotone_toDual_comp_iff : Monotone (toDual ∘ f : α → βᵒᵈ) ↔ Antitone f
-- Mathlib/Order/RelSeries.lean
/--
Given two relations `r, s` on `α` such that `r ≤ s`, any relation series of `r` induces a relation
series of `s`
-/
@[simps!]
def ofLE (x : RelSeries r) {s : Rel α α} (h : r ≤ s) : RelSeries s
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[reassoc (attr := simp)]
lemma opcyclesIsoRightHomology_inv_hom_id (hg : S.g = 0) :
    S.rightHomologyι ≫ (S.opcyclesIsoRightHomology hg).hom = 𝟙 _
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem toReal_mem_Ioc (θ : Angle) : θ.toReal ∈ Set.Ioc (-π) π
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem add_le_add_iff_right {n : Nat} : m + n ≤ k + n ↔ m ≤ k
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isLittleO_congr (hf : f₁ =ᶠ[l] f₂) (hg : g₁ =ᶠ[l] g₂) : f₁ =o[l] g₁ ↔ f₂ =o[l] g₂
-- Mathlib/RingTheory/Nilpotent/Basic.lean
protected lemma isNilpotent_mul_left_iff (h_comm : Commute x y) (hy : y ∈ nonZeroDivisorsLeft R) :
    IsNilpotent (x * y) ↔ IsNilpotent x
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem HasMFDerivWithinAt.congr_of_eventuallyEq (h : HasMFDerivWithinAt I I' f s x f')
    (h₁ : f₁ =ᶠ[𝓝[s] x] f) (hx : f₁ x = f x) : HasMFDerivWithinAt I I' f₁ s x f'
-- Mathlib/Analysis/Normed/Field/Basic.lean
/-- A restatement of `MetricSpace.tendsto_atTop` in terms of the norm. -/
theorem NormedAddCommGroup.tendsto_atTop [Nonempty α] [SemilatticeSup α] {β : Type*}
    [SeminormedAddCommGroup β] {f : α → β} {b : β} :
    Tendsto f atTop (𝓝 b) ↔ ∀ ε, 0 < ε → ∃ N, ∀ n, N ≤ n → ‖f n - b‖ < ε
-- Mathlib/Algebra/Polynomial/Module/AEval.lean
lemma of_aeval_smul (f : R[X]) (m : M) : of R M a (aeval a f • m) = f • of R M a m
-- Mathlib/Topology/Instances/ENNReal.lean
theorem tendsto_ofReal {f : Filter α} {m : α → ℝ} {a : ℝ} (h : Tendsto m f (𝓝 a)) :
    Tendsto (fun a => ENNReal.ofReal (m a)) f (𝓝 (ENNReal.ofReal a))
-- Mathlib/Topology/Algebra/Module/Basic.lean
theorem map_neg (e : M ≃SL[σ₁₂] M₂) (x : M) : e (-x) = -e x
-- Mathlib/Data/DFinsupp/Basic.lean
theorem piecewise_apply (i : ι) : x.piecewise y s i = if i ∈ s then x i else y i
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem min_eq_left {a b : Int} (h : a ≤ b) : min a b = a
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_mono' {s : ι → Set α} {t : ι₂ → Set α} (h : ∀ i, ∃ j, s i ⊆ t j) :
    ⋃ i, s i ⊆ ⋃ i, t i
-- Mathlib/Analysis/Analytic/Basic.lean
/-- For `r` strictly smaller than the radius of `p`, then `‖pₙ‖ rⁿ` is bounded. -/
theorem norm_le_div_pow_of_pos_of_lt_radius (p : FormalMultilinearSeries 𝕜 E F) {r : ℝ≥0}
    (h0 : 0 < r) (h : (r : ℝ≥0∞) < p.radius) : ∃ C > 0, ∀ n, ‖p n‖ ≤ C / (r : ℝ) ^ n
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
/-- The action of the galois group on infinite places. -/
@[simps! smul_coe_apply]
instance : MulAction (K ≃ₐ[k] K) (InfinitePlace K)
-- Mathlib/Order/Booleanisation.lean
@[simp] lemma comp_lt_comp : comp a < comp b ↔ b < a
-- Mathlib/Analysis/Analytic/CPolynomial.lean
/-- If a function admits a finite power series expansion on a disk, then it is continuous there. -/
protected theorem HasFiniteFPowerSeriesOnBall.continuousOn
    (hf : HasFiniteFPowerSeriesOnBall f p x n r) :
    ContinuousOn f (EMetric.ball x r)
-- Mathlib/Analysis/Convex/Function.lean
theorem ConvexOn.lt_left_of_right_lt' (hf : ConvexOn 𝕜 s f) {x y : E} (hx : x ∈ s) (hy : y ∈ s)
    {a b : 𝕜} (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) (hfy : f y < f (a • x + b • y)) :
    f (a • x + b • y) < f x
-- Mathlib/Algebra/Associated/Basic.lean
@[simp]
theorem not_irreducible_one [Monoid α] : ¬Irreducible (1 : α)
-- Mathlib/Geometry/RingedSpace/PresheafedSpace.lean
theorem restrict_top_presheaf (X : PresheafedSpace C) :
    (X.restrict (Opens.openEmbedding ⊤)).presheaf =
      (Opens.inclusionTopIso X.carrier).inv _* X.presheaf
-- Mathlib/Algebra/Homology/Embedding/Boundary.lean
lemma BoundaryGE.not_mem {j : ι} (hj : e.BoundaryGE j) {i' : ι'} (hi' : c'.Rel i' (e.f j))
    (a : ι) : e.f a ≠ i'
-- Mathlib/GroupTheory/GroupAction/ConjAct.lean
/-- The set of fixed points of the conjugation action of `G` on itself is the center of `G`. -/
theorem fixedPoints_eq_center : fixedPoints (ConjAct G) G = center G
-- Mathlib/CategoryTheory/Shift/InducedShiftSequence.lean
@[simp, reassoc]
lemma induced_shiftIso_hom_app_obj (n a a' : M) (ha' : n + a = a') (X : C) :
    letI := (induced e M F' e')
    (F.shiftIso n a a' ha').hom.app (L.obj X) =
      (F.shift a).map ((L.commShiftIso n).inv.app X) ≫ (e' a).hom.app (X⟦n⟧) ≫
        (G.shiftIso n a a' ha').hom.app X ≫ (e' a').inv.app X
-- Mathlib/Algebra/Order/Kleene.lean
theorem add_le (ha : a ≤ c) (hb : b ≤ c) : a + b ≤ c
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma div_mul_div_cancel (a : G₀) (hc : c ≠ 0) : a / c * (c / b) = a / b
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
@[simp]
lemma map_c₆ : (W.map φ).c₆ = φ W.c₆
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem castAdd_natAdd (p m : Nat) {n : Nat} (i : Fin n) :
    castAdd p (natAdd m i) = cast (Nat.add_assoc ..).symm (natAdd m (castAdd p i))
-- Mathlib/FieldTheory/Separable.lean
theorem count_roots_le_one {p : R[X]} (hsep : Separable p) (x : R) : p.roots.count x ≤ 1
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem cof_lsub_le {ι} (f : ι → Ordinal) : cof (lsub.{u, u} f) ≤ #ι
-- Mathlib/Data/Nat/Hyperoperation.lean
@[simp]
theorem hyperoperation_zero (m : ℕ) : hyperoperation 0 m = Nat.succ
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
theorem contMDiffWithinAt_id : ContMDiffWithinAt I I n (id : M → M) s x
-- Mathlib/LinearAlgebra/Dimension/Finrank.lean
/-- The dimension of a finite dimensional space is preserved under linear equivalence. -/
theorem finrank_eq (f : M ≃ₗ[R] M₂) : finrank R M = finrank R M₂
-- Mathlib/Data/Int/Lemmas.lean
theorem natAbs_inj_of_nonneg_of_nonpos {a b : ℤ} (ha : 0 ≤ a) (hb : b ≤ 0) :
    natAbs a = natAbs b ↔ a = -b
-- Mathlib/Order/Filter/CardinalInter.lean
theorem cardinalInterFilter_aleph_one_iff :
    CardinalInterFilter l (aleph 1) ↔ CountableInterFilter l
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Kernels.lean
@[simp]
lemma map_π : (c.map G).π = G.map c.π
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
theorem IsSheafFor.isAmalgamation (t : IsSheafFor P R) {x : FamilyOfElements P R}
    (hx : x.Compatible) : x.IsAmalgamation (t.amalgamate x hx)
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
theorem condexpIndL1Fin_smul (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (c : ℝ) (x : G) :
    condexpIndL1Fin hm hs hμs (c • x) = c • condexpIndL1Fin hm hs hμs x
-- Mathlib/Analysis/InnerProductSpace/Orientation.lean
theorem abs_det_adjustToOrientation (v : ι → E) :
    |(e.adjustToOrientation x).toBasis.det v| = |e.toBasis.det v|
-- Mathlib/Data/Finset/Sym.lean
theorem sym2_image [DecidableEq β] (f : α → β) (s : Finset α) :
    (s.image f).sym2 = s.sym2.image (Sym2.map f)
-- Mathlib/Order/Interval/Multiset.lean
@[simp]
theorem Ico_filter_le (a b c : α) : ((Ico a b).filter fun x => c ≤ x) = Ico (max a c) b
-- Mathlib/Analysis/BoxIntegral/Integrability.lean
/-- If `f : ℝⁿ → E` is continuous on a rectangular box `I`, then it is Box integrable on `I`
w.r.t. a locally finite measure `μ` with the same integral. -/
theorem ContinuousOn.hasBoxIntegral [CompleteSpace E] {f : (ι → ℝ) → E} (μ : Measure (ι → ℝ))
    [IsLocallyFiniteMeasure μ] {I : Box ι} (hc : ContinuousOn f (Box.Icc I))
    (l : IntegrationParams) :
    HasIntegral.{u, v, v} I l f μ.toBoxAdditive.toSMul (∫ x in I, f x ∂μ)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
theorem subNatNat_elim (m n : Nat) (motive : Nat → Nat → Int → Prop)
    (hp : ∀ i n, motive (n + i) n i)
    (hn : ∀ i m, motive m (m + i + 1) -[i+1]) :
    motive m n (subNatNat m n)
-- Mathlib/Data/Rat/Cast/Defs.lean
@[simp] lemma eq_ratCast [DivisionRing α] [FunLike F ℚ α] [RingHomClass F ℚ α] (f : F) (q : ℚ) :
    f q = q
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioi_subset_Ioo_union_Ici : Ioi a ⊆ Ioo a b ∪ Ici b
-- Mathlib/Order/Interval/Basic.lean
@[norm_cast]
theorem coe_iInf₂ [@DecidableRel α (· ≤ ·)] (f : ∀ i, κ i → Interval α) :
    ↑(⨅ (i) (j), f i j) = ⋂ (i) (j), (f i j : Set α)
-- Mathlib/CategoryTheory/Sites/Localization.lean
lemma W_eq_W_range_sheafToPresheaf_obj :
    J.W = LeftBousfield.W (· ∈ Set.range (sheafToPresheaf J A).obj)
-- Mathlib/Tactic/CategoryTheory/MonoidalComp.lean
@[simps]
instance whiskerLeft (X Y Z : C) [MonoidalCoherence Y Z] :
    MonoidalCoherence (X ⊗ Y) (X ⊗ Z)
-- Mathlib/CategoryTheory/Idempotents/Basic.lean
theorem Equivalence.isIdempotentComplete {D : Type*} [Category D] (ε : C ≌ D)
    (h : IsIdempotentComplete C) : IsIdempotentComplete D
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[simp]
theorem differentiableAt_pi : DifferentiableAt 𝕜 Φ x ↔ ∀ i, DifferentiableAt 𝕜 (fun x => Φ x i) x
-- Mathlib/Analysis/Convex/Mul.lean
lemma ConvexOn.smul' (hf : ConvexOn 𝕜 s f) (hg : ConvexOn 𝕜 s g) (hf₀ : ∀ ⦃x⦄, x ∈ s → 0 ≤ f x)
    (hg₀ : ∀ ⦃x⦄, x ∈ s → 0 ≤ g x) (hfg : MonovaryOn f g s) : ConvexOn 𝕜 s (f • g)
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem toList_zero : (Multiset.toList 0 : List α) = []
-- Mathlib/RingTheory/WittVector/WittPolynomial.lean
theorem xInTermsOfW_eq [Invertible (p : R)] {n : ℕ} : xInTermsOfW p R n =
    (X n - ∑ i ∈ range n, C ((p : R) ^ i) *
      xInTermsOfW p R i ^ p ^ (n - i)) * C ((⅟p : R) ^ n)
-- Mathlib/SetTheory/Ordinal/Notation.lean
@[simp] theorem ofNat_succ (n) : ofNat (Nat.succ n) = oadd 0 n.succPNat 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem ContDiffOn.csinh {n} (hf : ContDiffOn ℂ n f s) :
    ContDiffOn ℂ n (fun x => Complex.sinh (f x)) s
-- .lake/packages/batteries/Batteries/Classes/Order.lean
theorem cmp_ne_gt [OrientedCmp cmp] : cmp x y ≠ .gt ↔ cmp y x ≠ .lt
-- Mathlib/Data/ENat/Lattice.lean
lemma coe_sSup : BddAbove s → ↑(sSup s) = ⨆ a ∈ s, (a : ℕ∞)
-- Mathlib/Topology/Sets/Closeds.lean
/-- The term of `TopologicalSpace.IrreducibleCloseds α` corresponding to a singleton. -/
@[simps]
def singleton [T1Space α] (x : α) : IrreducibleCloseds α
-- Mathlib/MeasureTheory/Constructions/Prod/Integral.lean
theorem Integrable.integral_norm_prod_left ⦃f : α × β → E⦄ (hf : Integrable f (μ.prod ν)) :
    Integrable (fun x => ∫ y, ‖f (x, y)‖ ∂ν) μ
-- Mathlib/CategoryTheory/Adjunction/Basic.lean
private theorem he'' (he : ∀ X' X Y f g, e X' Y (F.map f ≫ g) = f ≫ e X Y g)
    {X' X Y} (f g) : F.map f ≫ (e X Y).symm g = (e X' Y).symm (f ≫ g)
-- Mathlib/Order/Concept.lean
@[simp]
theorem sSup_fst (S : Set (Concept α β r)) :
    (sSup S).fst = extentClosure r (⋂ c ∈ S, (c : Concept _ _ _).snd)
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem principalUnitGroup_le_principalUnitGroup {A B : ValuationSubring K} :
    B.principalUnitGroup ≤ A.principalUnitGroup ↔ A ≤ B
-- Mathlib/RingTheory/Trace/Basic.lean
theorem Algebra.traceForm_toMatrix_powerBasis (h : PowerBasis R S) :
    BilinForm.toMatrix h.basis (traceForm R S) = of fun i j => trace R S (h.gen ^ (i.1 + j.1))
-- Mathlib/Algebra/Periodic.lean
@[simp]
theorem Periodic.lift_coe [AddGroup α] (h : Periodic f c) (a : α) :
    h.lift (a : α ⧸ AddSubgroup.zmultiples c) = f a
-- Mathlib/Algebra/MvPolynomial/CommRing.lean
theorem degrees_sub [DecidableEq σ] (p q : MvPolynomial σ R) :
    (p - q).degrees ≤ p.degrees ⊔ q.degrees
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem _root_.MeasurableEmbedding.integrableOn_iff_comap [MeasurableSpace β] {e : α → β}
    (he : MeasurableEmbedding e) {f : β → E} {μ : Measure β} {s : Set β} (hs : s ⊆ range e) :
    IntegrableOn f s μ ↔ IntegrableOn (f ∘ e) (e ⁻¹' s) (μ.comap e)
-- Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean
theorem normNoninc_explicitCokernelπ {X Y : SemiNormedGrp.{u}} (f : X ⟶ Y) :
    (explicitCokernelπ f).NormNoninc
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
/-- The composition `l ∘ f` where `l : F → E` and `f : 𝕜 → F`, has a derivative equal to the
Fréchet derivative of `l` applied to the derivative of `f`. -/
theorem HasFDerivAt.comp_hasDerivAt_of_eq
    (hl : HasFDerivAt l l' y) (hf : HasDerivAt f f' x) (hy : y = f x) :
    HasDerivAt (l ∘ f) (l' f') x