ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem type_uLift (r : α → α → Prop) [IsWellOrder α r] :
    type (ULift.down.{v,u} ⁻¹'o r) = lift.{v} (type r)
-- Mathlib/Topology/Separation.lean
theorem t2_iff_isClosed_diagonal : T2Space X ↔ IsClosed (diagonal X)
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem extend_image_nhd_mem_nhds_of_boundaryless [I.Boundaryless] {x} (hx : x ∈ f.source)
    {s : Set M} (h : s ∈ 𝓝 x) : (f.extend I) '' s ∈ 𝓝 ((f.extend I) x)
-- Mathlib/Combinatorics/Enumerative/DoubleCounting.lean
theorem card_le_card_of_forall_subsingleton' (ht : ∀ b ∈ t, ∃ a, a ∈ s ∧ r a b)
    (hs : ∀ a ∈ s, ({ b ∈ t | r a b } : Set β).Subsingleton) : t.card ≤ s.card
-- Mathlib/LinearAlgebra/Prod.lean
@[deprecated (since := "2024-06-05")]
theorem tailing_sup_tunnel_succ_le_tunnel (f : M × N →ₗ[R] M) (i : Injective f) (n : ℕ) :
    tailing f i n ⊔ (OrderDual.ofDual (α := Submodule R M) $ tunnel f i (n + 1)) ≤
      (OrderDual.ofDual (α := Submodule R M) <| tunnel f i n)
-- Mathlib/CategoryTheory/EssentialImage.lean
/-- The functor `F` factorises through its essential image, where the first functor is essentially
surjective and the second is fully faithful.
-/
@[simps!]
def toEssImageCompEssentialImageInclusion (F : C ⥤ D) : F.toEssImage ⋙ F.essImageInclusion ≅ F
-- Mathlib/CategoryTheory/Functor/Basic.lean
@[simp]
theorem map_dite (F : C ⥤ D) {X Y : C} {P : Prop} [Decidable P]
    (f : P → (X ⟶ Y)) (g : ¬P → (X ⟶ Y)) :
    F.map (if h : P then f h else g h) = if h : P then F.map (f h) else F.map (g h)
-- Mathlib/Analysis/SpecialFunctions/Sqrt.lean
theorem ContDiffWithinAt.sqrt (hf : ContDiffWithinAt ℝ n f s x) (hx : f x ≠ 0) :
    ContDiffWithinAt ℝ n (fun y => √(f y)) s x
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem comp_continuousOn_iff {f : α → P} {s : Set α} : ContinuousOn (e ∘ f) s ↔ ContinuousOn f s
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem sign_eq_neg_one_of_neg {a : Int} (h : a < 0) : sign a = -1
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
theorem mul_add_lt_is_or {b : Nat} (b_lt : b < 2^i) (a : Nat) : 2^i * a + b = 2^i * a ||| b
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
@[simp, mono]
theorem measure_le_measure_union_left : μ s ≤ μ (s ∪ t)
-- Mathlib/Analysis/Convex/StrictConvexBetween.lean
theorem Wbtw.dist_le_max_dist (p : P) {p₁ p₂ p₃ : P} (h : Wbtw ℝ p₁ p₂ p₃) :
    dist p₂ p ≤ max (dist p₁ p) (dist p₃ p)
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
@[simp]
theorem mul_mk_eq_max {α β : Type u} [Infinite α] [Infinite β] : #α * #β = max #α #β
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_hom_rel [CommMonoid γ] {r : β → γ → Prop} {f : α → β} {g : α → γ} {s : Finset α}
    (h₁ : r 1 1) (h₂ : ∀ a b c, r b c → r (f a * b) (g a * c)) :
    r (∏ x ∈ s, f x) (∏ x ∈ s, g x)
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem LinearMap.curry_uncurryLeft (f : M 0 →ₗ[R] MultilinearMap R (fun i :
    Fin n => M i.succ) M₂) : f.uncurryLeft.curryLeft = f
-- Mathlib/CategoryTheory/Bicategory/Functor/Prelax.lean
@[reassoc, simp]
lemma map₂_inv_hom {f g : a ⟶ b} (η : f ≅ g) :
    F.map₂ η.inv ≫ F.map₂ η.hom = 𝟙 (F.map g)
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- A version of `edist_le_Ico_sum_edist` with each intermediate distance replaced
with an upper estimate. -/
theorem edist_le_Ico_sum_of_edist_le {f : ℕ → α} {m n} (hmn : m ≤ n) {d : ℕ → ℝ≥0∞}
    (hd : ∀ {k}, m ≤ k → k < n → edist (f k) (f (k + 1)) ≤ d k) :
    edist (f m) (f n) ≤ ∑ i ∈ Finset.Ico m n, d i
-- Mathlib/Analysis/RCLike/Basic.lean
theorem real_smul_eq_coe_mul (r : ℝ) (z : K) : r • z = (r : K) * z
-- Mathlib/NumberTheory/Dioph.lean
theorem inter (d : Dioph S) (d' : Dioph S') : Dioph (S ∩ S')
-- Mathlib/CategoryTheory/Monad/Algebra.lean
/-- The adjunction between the free and forgetful constructions for Eilenberg-Moore algebras for
  a monad. cf Lemma 5.2.8 of [Riehl][riehl2017]. -/
@[simps! unit counit]
def adj : T.free ⊣ T.forget
-- Mathlib/Algebra/Group/Semiconj/Defs.lean
/-- If `b` semiconjugates `x` to `y` and `a` semiconjugates `y` to `z`, then `a * b`
semiconjugates `x` to `z`. -/
@[to_additive "If `b` semiconjugates `x` to `y` and `a` semiconjugates `y` to `z`, then `a + b`
semiconjugates `x` to `z`."]
theorem mul_left (ha : SemiconjBy a y z) (hb : SemiconjBy b x y) : SemiconjBy (a * b) x z
-- Mathlib/CategoryTheory/PathCategory.lean
/-- The functor from a category to the canonical quotient of its path category. -/
@[simps]
def toQuotientPaths : C ⥤ Quotient (pathsHomRel C)
-- Mathlib/Algebra/BigOperators/Finsupp.lean
@[to_additive (attr := simp)]
theorem prod_single_index {a : α} {b : M} {h : α → M → N} (h_zero : h a 0 = 1) :
    (single a b).prod h = h a b
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
/-- This definition provides a convenient way to show that a multifork is a limit. -/
@[simps]
def IsLimit.mk (lift : ∀ E : Multifork I, E.pt ⟶ K.pt)
    (fac : ∀ (E : Multifork I) (i : I.L), lift E ≫ K.ι i = E.ι i)
    (uniq : ∀ (E : Multifork I) (m : E.pt ⟶ K.pt), (∀ i : I.L, m ≫ K.ι i = E.ι i) → m = lift E) :
    IsLimit K
-- Mathlib/Data/Multiset/Basic.lean
theorem Rel.add {s t u v} (hst : Rel r s t) (huv : Rel r u v) : Rel r (s + u) (t + v)
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem not_congr (h : a ↔ b) : ¬a ↔ ¬b
-- Mathlib/Analysis/Convex/Extreme.lean
theorem isExtreme_iInter {ι : Sort*} [Nonempty ι] {F : ι → Set E}
    (hAF : ∀ i : ι, IsExtreme 𝕜 A (F i)) : IsExtreme 𝕜 A (⋂ i : ι, F i)
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem fderivWithin_const_apply (c : F) (hxs : UniqueDiffWithinAt 𝕜 s x) :
    fderivWithin 𝕜 (fun _ => c) s x = 0
-- Mathlib/Data/Fintype/Card.lean
theorem Finset.card_compl_lt_iff_nonempty [Fintype α] [DecidableEq α] (s : Finset α) :
    sᶜ.card < Fintype.card α ↔ s.Nonempty
-- Mathlib/Order/Category/Lat.lean
/-- `OrderDual` as a functor. -/
@[simps]
def dual : Lat ⥤ Lat
-- Mathlib/Order/FixedPoints.lean
theorem gfp_le_map {a : α} (ha : gfp f ≤ a) : gfp f ≤ f a
-- Mathlib/Topology/DiscreteSubset.lean
/-- Criterion for a subset `S ⊆ X` to be closed and discrete in terms of the punctured
neighbourhood filter at an arbitrary point of `X`. (Compare `discreteTopology_subtype_iff`.) -/
theorem isClosed_and_discrete_iff {S : Set X} :
    IsClosed S ∧ DiscreteTopology S ↔ ∀ x, Disjoint (𝓝[≠] x) (𝓟 S)
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
@[simp]
theorem range_fromSpec :
    Set.range hU.fromSpec.1.base = (U : Set X)
-- Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean
@[reassoc (attr := simp)]
lemma liftOfIsRightKanExtension_fac_app (G : D ⥤ H) (β : L ⋙ G ⟶ F) (X : C) :
    (F'.liftOfIsRightKanExtension α G β).app (L.obj X) ≫ α.app X = β.app X
-- Mathlib/Data/Set/Prod.lean
theorem prod_image_image_eq {m₁ : α → γ} {m₂ : β → δ} :
    (m₁ '' s) ×ˢ (m₂ '' t) = (fun p : α × β => (m₁ p.1, m₂ p.2)) '' s ×ˢ t
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem rpow_add_nat {x : ℝ} (hx : x ≠ 0) (y : ℝ) (n : ℕ) : x ^ (y + n) = x ^ y * x ^ n
-- Mathlib/CategoryTheory/Limits/Shapes/KernelPair.lean
theorem mono_of_isIso_fst (h : IsKernelPair f a b) [IsIso a] : Mono f
-- Mathlib/Topology/Algebra/Module/FiniteDimension.lean
@[simp]
theorem coe_toContinuousLinearEquiv (e : E ≃ₗ[𝕜] F) : (e.toContinuousLinearEquiv : E →ₗ[𝕜] F) = e
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem mul_le_of_le_one_right [PosMulMono α] (ha : 0 ≤ a) (h : b ≤ 1) : a * b ≤ a
-- Mathlib/RingTheory/Binomial.lean
@[simp]
theorem smeval_ascPochhammer_self_neg : ∀ n : ℕ,
    smeval (ascPochhammer ℕ n) (-n : ℤ) = (-1)^n * n.factorial
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
@[trans]
theorem _root_.Filter.EventuallyEq.trans_isLittleO {f₁ f₂ : α → E} {g : α → F} (hf : f₁ =ᶠ[l] f₂)
    (h : f₂ =o[l] g) : f₁ =o[l] g
-- Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean
/-- The type of bilinear maps which are accepted by `CliffordAlgebra.even.lift`. -/
@[ext]
structure EvenHom : Type max uA uM where
  bilin : M →ₗ[R] M →ₗ[R] A
  contract (m : M) : bilin m m = algebraMap R A (Q m)
  contract_mid (m₁ m₂ m₃ : M) : bilin m₁ m₂ * bilin m₂ m₃ = Q m₂ • bilin m₁ m₃
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
/-- Given a vector `v` of length `n`, make a vector of length `n + 1` whose product is `1`,
by appending the inverse of the product of `v`. -/
@[simps]
def vectorEquiv : Vector G n ≃ vectorsProdEqOne G (n + 1)
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- Assumes right covariance.
The lemma assuming left covariance is `Left.one_le_mul`. -/
@[to_additive Right.add_nonneg "Assumes right covariance.
The lemma assuming left covariance is `Left.add_nonneg`."]
theorem Right.one_le_mul [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b : α} (ha : 1 ≤ a)
    (hb : 1 ≤ b) :
    1 ≤ a * b
-- Mathlib/Data/ENat/Basic.lean
@[simp] lemma zero_ne_top : 0 ≠ (⊤ : ℕ∞)
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
theorem lower_ne_upper (i) : I.lower i ≠ I.upper i
-- Mathlib/Algebra/Order/Field/Unbundled/Basic.lean
lemma zpow_nonneg [PosMulMono α] (ha : 0 ≤ a) : ∀ n : ℤ, 0 ≤ a ^ n
-- Mathlib/Order/Ideal.lean
theorem _root_.IsCoatom.isProper (hI : IsCoatom I) : IsProper I
-- Mathlib/Topology/VectorBundle/Basic.lean
/-- A version of `Trivialization.coordChangeL_apply` that fully unfolds `coordChange`. The
right-hand side is ugly, but has good definitional properties for specifically defined
trivializations. -/
theorem coordChangeL_apply' (e e' : Trivialization F (π F E)) [e.IsLinear R] [e'.IsLinear R] {b : B}
    (hb : b ∈ e.baseSet ∩ e'.baseSet) (y : F) :
    coordChangeL R e e' b y = (e' (e.toPartialHomeomorph.symm (b, y))).2
-- Mathlib/CategoryTheory/Functor/Derived/RightDerived.lean
lemma isRightDerivedFunctor_iff_isIso_rightDerivedDesc (G : D ⥤ H) (β : F ⟶ L ⋙ G) :
    G.IsRightDerivedFunctor β W ↔ IsIso (RF.rightDerivedDesc α W G β)
-- Mathlib/Logic/Equiv/Set.lean
/-- A set is equivalent to its image under an equivalence.
-/
@[simps]
def image {α β : Type*} (e : α ≃ β) (s : Set α) :
    s ≃ e '' s
-- Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean
/-- The product of `X` with an initial object in a category with strict initial objects is itself
initial.
This is the generalisation of the fact that `X × Empty ≃ Empty` for types (or `n * 0 = 0`).
-/
@[simps! hom]
noncomputable def mulInitial (X : C) [HasBinaryProduct X (⊥_ C)] : X ⨯ ⊥_ C ≅ ⊥_ C
-- Mathlib/Topology/Semicontinuous.lean
theorem LowerSemicontinuous.lowerSemicontinuousAt (h : LowerSemicontinuous f) (x : α) :
    LowerSemicontinuousAt f x
-- Mathlib/Algebra/Order/Ring/Rat.lean
@[simp] lemma divInt_nonneg_iff_of_pos_right {a b : ℤ} (hb : 0 < b) : 0 ≤ a /. b ↔ 0 ≤ a
-- Mathlib/Algebra/Order/Group/Indicator.lean
@[to_additive]
lemma le_mulIndicator (hfg : ∀ a ∈ s, f a ≤ g a) (hf : ∀ a ∉ s, f a ≤ 1) :
    f ≤ mulIndicator s g
-- Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean
/-- The axis aligned parallelepiped over `ι → ℝ` is a cuboid. -/
theorem parallelepiped_single [DecidableEq ι] (a : ι → ℝ) :
    (parallelepiped fun i => Pi.single i (a i)) = Set.uIcc 0 a
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem singleton_def (v : α) : singleton v = #[v]
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma monotone_or_antitone_iff_uIcc :
    Monotone f ∨ Antitone f ↔ ∀ a b c, c ∈ [[a, b]] → f c ∈ [[f a, f b]]
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean
lemma toNNReal_add_add_neg_add_neg_eq (f g : C(X, ℝ)) :
    (f + g).toNNReal + (-f).toNNReal + (-g).toNNReal =
      (-(f + g)).toNNReal + f.toNNReal + g.toNNReal
-- Mathlib/Algebra/GroupWithZero/Defs.lean
/-- If `α` has no zero divisors, then for elements `a, b : α`, `a * b` equals zero iff so is
`b * a`. -/
theorem mul_eq_zero_comm : a * b = 0 ↔ b * a = 0
-- Mathlib/Algebra/Module/Equiv/Defs.lean
theorem toFun_eq_coe : e.toFun = e
-- Mathlib/Algebra/Order/Floor.lean
theorem floor_le_ceil (a : α) : ⌊a⌋₊ ≤ ⌈a⌉₊
-- Mathlib/Topology/Algebra/UniformGroup.lean
@[to_additive]
theorem tendsto_div_comap_self (x₀ : α) :
    Tendsto (fun t : β × β => t.2 / t.1) ((comap fun p : β × β => (e p.1, e p.2)) <| 𝓝 (x₀, x₀))
      (𝓝 1)
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
/-- The explicit pullback in the category of types, bundled up as a `LimitCone`
for given `f` and `g`.
-/
@[simps]
def pullbackLimitCone (f : X ⟶ Z) (g : Y ⟶ Z) : Limits.LimitCone (cospan f g)
-- Mathlib/GroupTheory/Complement.lean
@[to_additive]
theorem isComplement_univ_singleton {g : G} : IsComplement (univ : Set G) {g}
-- Mathlib/Logic/Equiv/Set.lean
/-- The set `Set.pi Set.univ s` is equivalent to `Π a, s a`. -/
@[simps]
protected def univPi {α : Type*} {β : α → Type*} (s : ∀ a, Set (β a)) :
    pi univ s ≃ ∀ a, s a
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem div_iUnion₂ (s : Set α) (t : ∀ i, κ i → Set α) :
    (s / ⋃ (i) (j), t i j) = ⋃ (i) (j), s / t i j
-- Mathlib/Data/List/Join.lean
@[simp]
theorem join_filter_ne_nil [DecidablePred fun l : List α => l ≠ []] {L : List (List α)} :
    join (L.filter fun l => l ≠ []) = L.join
-- Mathlib/Logic/Basic.lean
theorem forall_apply_eq_imp_iff' {f : α → β} {p : β → Prop} :
    (∀ a b, f a = b → p b) ↔ ∀ a, p (f a)
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
protected theorem const' (b : β) {K : ℝ≥0} : LipschitzWith K fun _ : α => b
-- Mathlib/Order/Concept.lean
@[simp]
theorem fst_ssubset_fst_iff : c.fst ⊂ d.fst ↔ c < d
-- Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
theorem row_ne_zero [Nontrivial R] (g : SpecialLinearGroup n R) (i : n) : ↑ₘg i ≠ 0
-- Mathlib/CategoryTheory/Shift/Basic.lean
lemma ShiftMkCore.shiftFunctor_eq (h : ShiftMkCore C A) (a : A) :
    letI := hasShiftMk C A h
    shiftFunctor C a = h.F a
-- Mathlib/SetTheory/Surreal/Dyadic.lean
@[simp]
theorem dyadicMap_apply (m : ℤ) (p : Submonoid.powers (2 : ℤ)) :
    dyadicMap (IsLocalization.mk' (Localization (Submonoid.powers 2)) m p) =
      m * powHalf (Submonoid.log p)
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem add_eq_one_iff : I + J = 1 ↔ ∃ i ∈ I, ∃ j ∈ J, i + j = 1
-- Mathlib/Algebra/Module/Submodule/Equiv.lean
@[simp]
theorem ofInjective_apply [RingHomInvPair σ₁₂ σ₂₁] [RingHomInvPair σ₂₁ σ₁₂] {h : Injective f}
    (x : M) : ↑(ofInjective f h x) = f x
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
@[to_additive]
theorem mul_mem_sup {S T : Submonoid M} {x y : M} (hx : x ∈ S) (hy : y ∈ T) : x * y ∈ S ⊔ T
-- Mathlib/GroupTheory/CommutingProbability.lean
@[simp] lemma reciprocalFactors_one : reciprocalFactors 1 = []
-- Mathlib/Algebra/Star/Unitary.lean
@[simp]
theorem star_mem_iff {U : R} : star U ∈ unitary R ↔ U ∈ unitary R
-- Mathlib/Data/Finset/Density.lean
@[simp] lemma dens_disjUnion (s t : Finset α) (h) : dens (s.disjUnion t h) = dens s + dens t
-- Mathlib/Order/Category/FinBddDistLat.lean
/-- The equivalence between `FinBddDistLat` and itself induced by `OrderDual` both ways. -/
@[simps functor inverse]
def dualEquiv : FinBddDistLat ≌ FinBddDistLat
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
/-- A quadratic map on a module.

For a more familiar constructor when `R` is a ring, see `QuadraticMap.ofPolar`. -/
structure QuadraticMap (R : Type u) (M : Type v) (N : Type w) [CommSemiring R] [AddCommMonoid M]
    [Module R M] [AddCommMonoid N] [Module R N] where
  toFun : M → N
  toFun_smul : ∀ (a : R) (x : M), toFun (a • x) = (a * a) • toFun x
  exists_companion' : ∃ B : BilinMap R M N, ∀ x y, toFun (x + y) = toFun x + toFun y + B x y
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
/-- **John Machin's 1706 formula**, which he used to compute π to 100 decimal places. -/
theorem four_mul_arctan_inv_5_sub_arctan_inv_239 : 4 * arctan 5⁻¹ - arctan 239⁻¹ = π / 4
-- Mathlib/Probability/Distributions/Uniform.lean
@[simp]
theorem toMeasure_ofMultiset_apply [MeasurableSpace α] (ht : MeasurableSet t) :
    (ofMultiset s hs).toMeasure t = (∑' x, (s.filter (· ∈ t)).count x : ℝ≥0∞) / (Multiset.card s)
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem one_lt_of_lt_mul_left [ContravariantClass α α (swap (· * ·)) (· < ·)] {a b : α}
    (h : b < a * b) :
    1 < a
-- Mathlib/Data/List/Indexes.lean
theorem foldlIdxM_eq_foldlM_enum [LawfulMonad m] {β} (f : ℕ → β → α → m β) (b : β) (as : List α) :
    foldlIdxM f b as = List.foldlM (fun b p ↦ f p.fst b p.snd) b (enum as)
-- Mathlib/Data/Complex/FiniteDimensional.lean
@[simp]
lemma Complex.rank_rat_complex : Module.rank ℚ ℂ = continuum
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
/-- Bijection between `MulOpposite` of a subring `S` and its opposite. -/
@[simps!]
def mopRingEquivOp (S : Subring R) : Sᵐᵒᵖ ≃+* S.op
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
/-- Two polynomials `p` and `q` such that `p(q(X))=X` and `q(p(X))=X`
  induces an automorphism of the polynomial algebra. -/
@[simps!]
def algEquivOfCompEqX (p q : R[X]) (hpq : p.comp q = X) (hqp : q.comp p = X) : R[X] ≃ₐ[R] R[X]
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem alephIdx.init {a b} : b < alephIdx a → ∃ c, alephIdx c = b
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem lt_of_lt_mul_of_le_one_right [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c : α}
    (h : a < b * c) (hle : b ≤ 1) :
    a < c
-- Mathlib/Algebra/Order/Sub/Basic.lean
theorem AddMonoidHom.le_map_tsub [Preorder β] [AddCommMonoid β] [Sub β] [OrderedSub β] (f : α →+ β)
    (hf : Monotone f) (a b : α) : f a - f b ≤ f (a - b)
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem toCone_pt (B : Bicone F) : B.toCone.pt = B.pt
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
@[simp]
theorem coe_zero : ⇑(0 : VectorMeasure α M) = 0
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem center_eq_top (A : Type*) [CommSemiring A] [Algebra R A] : center R A = ⊤
-- Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean
/-- The functor `Γ₀ : ChainComplex C ℕ ⥤ SimplicialObject C`, on objects. -/
@[simps]
def obj (K : ChainComplex C ℕ) : SimplicialObject C
-- Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean
theorem isBigO_cpow_rpow (hl : IsBoundedUnder (· ≤ ·) l fun x => |(g x).im|) :
    (fun x => f x ^ g x) =O[l] fun x => abs (f x) ^ (g x).re
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem mk_uLift (α) : #(ULift.{v, u} α) = lift.{v} #α
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive]
theorem smul_set_compl : a • sᶜ = (a • s)ᶜ
-- Mathlib/Data/Matroid/Basic.lean
@[simp] theorem basis_empty_iff (M : Matroid α) : M.Basis I ∅ ↔ I = ∅
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
theorem ext_iff {f g : P1 →ᵃ[k] P2} : f = g ↔ ∀ p, f p = g p
-- Mathlib/CategoryTheory/Sites/NonabelianCohomology/H1.lean
@[simp]
lemma mul_ev (γ₁ γ₂ : OneCochain G U) (i j : I) {T : C} (a : T ⟶ U i) (b : T ⟶ U j) :
    (γ₁ * γ₂).ev i j a b = γ₁.ev i j a b * γ₂.ev i j a b
-- Mathlib/CategoryTheory/Monoidal/End.lean
@[reassoc (attr := simp)]
theorem ε_inv_hom_app (X : C) : F.εIso.inv.app X ≫ F.ε.app X = 𝟙 _
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem mem_pow {a : α} {n : ℕ} :
    a ∈ s ^ n ↔ ∃ f : Fin n → s, (List.ofFn fun i => ↑(f i)).prod = a
-- Mathlib/Data/Multiset/Basic.lean
theorem foldr_induction (f : α → α → α) (H : LeftCommutative f) (x : α) (p : α → Prop)
    (s : Multiset α) (p_f : ∀ a b, p a → p b → p (f a b)) (px : p x) (p_s : ∀ a ∈ s, p a) :
    p (foldr f H x s)
-- Mathlib/CategoryTheory/LiftingProperties/Basic.lean
theorem iff_op : HasLiftingProperty i p ↔ HasLiftingProperty p.op i.op
-- Mathlib/ModelTheory/Definability.lean
@[simp, norm_cast]
theorem coe_inf (s t : L.DefinableSet A α) :
    ((s ⊓ t : L.DefinableSet A α) : Set (α → M)) = (s : Set (α → M)) ∩ (t : Set (α → M))
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem IsCoprime.prod_right_iff : IsCoprime x (∏ i ∈ t, s i) ↔ ∀ i ∈ t, IsCoprime x (s i)
-- Mathlib/Analysis/Quaternion.lean
@[continuity]
theorem continuous_imJ : Continuous fun q : ℍ => q.imJ
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Dvd.lean
protected theorem mul_div_assoc (m : Nat) (H : k ∣ n) : m * n / k = m * (n / k)
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem mul_inv_le_one_iff_le : a * b⁻¹ ≤ 1 ↔ a ≤ b
-- Mathlib/Data/Finset/Fold.lean
@[simp]
theorem fold_map {g : γ ↪ α} {s : Finset γ} : (s.map g).fold op b f = s.fold op b (f ∘ g)
-- Mathlib/Data/Finsupp/Defs.lean
/-- `Finsupp.single a b` is injective in `a`. For the statement that it is injective in `b`, see
`Finsupp.single_injective` -/
theorem single_left_injective (h : b ≠ 0) : Function.Injective fun a : α => single a b
-- Mathlib/CategoryTheory/Monad/Algebra.lean
/-- Given a coalgebra morphism whose carrier part is an isomorphism, we get a coalgebra isomorphism.
-/
theorem coalgebra_iso_of_iso {A B : Coalgebra G} (f : A ⟶ B) [IsIso f.f] : IsIso f
-- Mathlib/Combinatorics/SimpleGraph/Metric.lean
protected theorem Connected.exists_walk_length_eq_edist  (hconn : G.Connected) (u v : V) :
    ∃ p : G.Walk u v, p.length = G.edist u v
-- Mathlib/Algebra/Order/Group/Indicator.lean
@[to_additive indicator_apply_nonneg]
lemma one_le_mulIndicator_apply (h : a ∈ s → 1 ≤ f a) : 1 ≤ mulIndicator s f a
-- Mathlib/Data/List/OfFn.lean
/-- Note this matches the convention of `List.ofFn_succ'`, putting the `Fin m` elements first. -/
theorem ofFn_add {m n} (f : Fin (m + n) → α) :
    List.ofFn f =
      (List.ofFn fun i => f (Fin.castAdd n i)) ++ List.ofFn fun j => f (Fin.natAdd m j)
-- Mathlib/Order/Interval/Finset/Defs.lean
@[simp]
theorem finite_interval : (uIcc a b).Finite
-- Mathlib/NumberTheory/EllipticDivisibilitySequence.lean
@[simp]
lemma preNormEDS_zero : preNormEDS b c d 0 = 0
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma not_equiv_of_Z_eq_zero_right {P Q : Fin 3 → R} (hPz : P z ≠ 0) (hQz : Q z = 0) : ¬P ≈ Q
-- Mathlib/CategoryTheory/ChosenFiniteProducts.lean
@[reassoc (attr := simp)]
lemma whiskerRight_snd {X₁ X₂ : C} (f : X₁ ⟶ X₂) (Y : C) :
    (f ▷ Y) ≫ snd _ _ = snd _ _
-- Mathlib/Analysis/LocallyConvex/WeakDual.lean
@[simp]
theorem toSeminormFamily_apply {B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜} {x y} : (B.toSeminormFamily y) x = ‖B x y‖
-- Mathlib/Topology/Sets/Opens.lean
@[simp]
theorem mk_inf_mk {U V : Set α} {hU : IsOpen U} {hV : IsOpen V} :
    (⟨U, hU⟩ ⊓ ⟨V, hV⟩ : Opens α) = ⟨U ⊓ V, IsOpen.inter hU hV⟩
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
theorem zero_addChar_byteIdx (c : Char) : ((0 : Pos) + c).byteIdx = c.utf8Size
-- Mathlib/Order/Filter/Basic.lean
lemma _root_.Set.Finite.eventuallyEq_iUnion {ι : Type*} {s : Set ι} (hs : s.Finite)
    {f g : ι → Set α} (heq : ∀ i ∈ s, f i =ᶠ[l] g i) : (⋃ i ∈ s, f i) =ᶠ[l] (⋃ i ∈ s, g i)
-- Mathlib/LinearAlgebra/BilinearMap.lean
theorem lcomp_apply' (f : M →ₗ[R] Nₗ) (g : Nₗ →ₗ[R] Pₗ) : lcomp R Pₗ f g = g ∘ₗ f
-- Mathlib/Data/Nat/Lattice.lean
theorem iSup_le_succ' (u : ℕ → α) (n : ℕ) : ⨆ k ≤ n + 1, u k = u 0 ⊔ ⨆ k ≤ n, u (k + 1)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Multiplying the first vector passed to `oangle` by a real multiplies the sign of the angle by
the sign of the real. -/
@[simp]
theorem oangle_sign_smul_left (x y : V) (r : ℝ) :
    (o.oangle (r • x) y).sign = SignType.sign r * (o.oangle x y).sign
-- .lake/packages/proofwidgets/ProofWidgets/Demos/Venn.lean
theorem ext {a b : Set α} (h : ∀ (x : α), x ∈ a ↔ x ∈ b) : a = b
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
lemma natDegree_Ψ₂Sq_pos (h : (4 : R) ≠ 0) : 0 < W.Ψ₂Sq.natDegree
-- Mathlib/LinearAlgebra/DFinsupp.lean
theorem independent_iff_linearIndependent_of_ne_zero [NoZeroSMulDivisors R N] {v : ι → N}
    (h_ne_zero : ∀ i, v i ≠ 0) : (Independent fun i => R ∙ v i) ↔ LinearIndependent R v
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem getElem?_eq_none (h : length l ≤ n) : l[n]? = none
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive]
theorem mk_of_inv_mul : ∀ x : G ⊕ H, mk (of (x.map Inv.inv Inv.inv)) * mk (of x) = 1
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem toNat_ge_of_msb_true {x : BitVec n} (p : BitVec.msb x = true) : x.toNat ≥ 2^(n-1)
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
protected theorem ContMDiff.coordChangeL
    (hf : ContMDiff IM IB n f) (he : ∀ x, f x ∈ e.baseSet) (he' : ∀ x, f x ∈ e'.baseSet) :
    ContMDiff IM 𝓘(𝕜, F →L[𝕜] F) n (fun y ↦ (e.coordChangeL 𝕜 e' (f y) : F →L[𝕜] F))