ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive (attr := simp)]
theorem MulHom.coe_mk [Mul M] [Mul N] (f : M → N) (hmul) : (MulHom.mk f hmul : M → N) = f
-- Mathlib/MeasureTheory/Constructions/UnitInterval.lean
@[measurability]
theorem measurable_symm : Measurable symm
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem div_eq_ediv : ∀ {a b : Int}, 0 ≤ a → 0 ≤ b → a.div b = a / b
-- Mathlib/Data/Finset/Sups.lean
@[simp]
theorem empty_infs : ∅ ⊼ t = ∅
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
/-- Make an element of `rootsOfUnity` from a member of the base ring, and a proof that it has
a positive power equal to one. -/
@[simps! coe_val]
def rootsOfUnity.mkOfPowEq (ζ : M) {n : ℕ+} (h : ζ ^ (n : ℕ) = 1) : rootsOfUnity n M
-- Mathlib/Order/Compare.lean
theorem Ordering.Compares.cmp_eq [LinearOrder α] {a b : α} {o : Ordering} (h : o.Compares a b) :
    cmp a b = o
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
theorem inj_of_sep (P : Cᵒᵖ ⥤ D)
    (hsep :
      ∀ (X : C) (S : J.Cover X) (x y : P.obj (op X)),
        (∀ I : S.Arrow, P.map I.f.op x = P.map I.f.op y) → x = y)
    (X : C) : Function.Injective ((J.toPlus P).app (op X))
-- Mathlib/Algebra/GCDMonoid/Nat.lean
theorem Int.associated_iff {a b : ℤ} : Associated a b ↔ a = b ∨ a = -b
-- Mathlib/GroupTheory/Perm/Sign.lean
@[simp]
theorem signAux_one (n : ℕ) : signAux (1 : Perm (Fin n)) = 1
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem hasGroupoid_of_pregroupoid (PG : Pregroupoid H) (h : ∀ {e e' : PartialHomeomorph M H},
    e ∈ atlas H M → e' ∈ atlas H M → PG.property (e.symm ≫ₕ e') (e.symm ≫ₕ e').source) :
    HasGroupoid M PG.groupoid
-- Mathlib/FieldTheory/Adjoin.lean
theorem adjoin.range_algebraMap_subset : Set.range (algebraMap F E) ⊆ adjoin F S
-- Mathlib/Data/List/Forall2.lean
@[simp]
theorem forall₂_reverse_iff {l₁ l₂} : Forall₂ R (reverse l₁) (reverse l₂) ↔ Forall₂ R l₁ l₂
-- Mathlib/CategoryTheory/Limits/Fubini.lean
/-- A structure carrying a diagram of cocones over the functors `F.obj j`.
-/
structure DiagramOfCocones where
  /-- For each object, a cocone. -/
  obj : ∀ j : J, Cocone (F.obj j)
  /-- For each map, a map of cocones. -/
  map : ∀ {j j' : J} (f : j ⟶ j'), (obj j) ⟶ (Cocones.precompose (F.map f)).obj (obj j')
  id : ∀ j : J, (map (𝟙 j)).hom = 𝟙 _ := by aesop_cat
  comp : ∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
    (map (f ≫ g)).hom = (map f).hom ≫ (map g).hom := by aesop_cat
-- Mathlib/Order/Cover.lean
theorem AntisymmRel.trans_covBy (hab : AntisymmRel (· ≤ ·) a b) (hbc : b ⋖ c) : a ⋖ c
-- Mathlib/Data/Finset/Pointwise.lean
/-- Lift a `OneHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift a `ZeroHom` to `Finset` via `image`"]
def imageOneHom [DecidableEq β] [One β] [FunLike F α β] [OneHomClass F α β] (f : F) :
    OneHom (Finset α) (Finset β)
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem nhdsWithin_extChartAt_target_eq (x : M) :
    𝓝[(extChartAt I x).target] (extChartAt I x) x = 𝓝[range I] (extChartAt I x) x
-- Mathlib/LinearAlgebra/Span.lean
theorem span_image [RingHomSurjective σ₁₂] (f : F) :
    span R₂ (f '' s) = map f (span R s)
-- Mathlib/Algebra/Lie/Weights/Basic.lean
/-- For a triangularizable Lie module in finite dimensions, the weight spaces span the entire space.

See also `LieModule.iSup_weightSpace_eq_top'`. -/
lemma iSup_weightSpace_eq_top [IsTriangularizable K L M] :
    ⨆ χ : L → K, weightSpace M χ = ⊤
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem perm_insert_swap (x y : α) (l : List α) :
    List.insert x (List.insert y l) ~ List.insert y (List.insert x l)
-- Mathlib/NumberTheory/Ostrowski.lean
@[simp] lemma mulRingNorm_eq_padic_norm (p : ℕ) [Fact p.Prime] (r : ℚ) :
  mulRingNorm_padic p r = padicNorm p r
-- Mathlib/Algebra/BigOperators/Group/List.lean
@[to_additive]
lemma prod_eq_pow_single [DecidableEq M] (a : M) (h : ∀ a', a' ≠ a → a' ∈ l → a' = 1) :
    l.prod = a ^ l.count a
-- Mathlib/Analysis/PSeries.lean
/-- Harmonic series is not unconditionally summable. -/
theorem not_summable_natCast_inv : ¬Summable (fun n => n⁻¹ : ℕ → ℝ)
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem closure_range_inl_union_inr :
    Subgroup.closure (range (inl : G →* G ∗ H) ∪ range inr) = ⊤
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem mem_cycleType_iff {n : ℕ} {σ : Perm α} :
    n ∈ cycleType σ ↔ ∃ c τ, σ = c * τ ∧ Disjoint c τ ∧ IsCycle c ∧ c.support.card = n
-- Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean
theorem norm_le_norm_mul_left (x : ℤ[i]) {y : ℤ[i]} (hy : y ≠ 0) :
    (norm x).natAbs ≤ (norm (x * y)).natAbs
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem dvd_gcd_mul_iff_dvd_mul [GCDMonoid α] {m n k : α} : k ∣ gcd k m * n ↔ k ∣ m * n
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem lt_trichotomy (a b : Int) : a < b ∨ a = b ∨ b < a
-- Mathlib/Topology/Algebra/Monoid.lean
@[to_additive]
theorem ContinuousMul.of_nhds_one {M : Type u} [Monoid M] [TopologicalSpace M]
    (hmul : Tendsto (uncurry ((· * ·) : M → M → M)) (𝓝 1 ×ˢ 𝓝 1) <| 𝓝 1)
    (hleft : ∀ x₀ : M, 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1))
    (hright : ∀ x₀ : M, 𝓝 x₀ = map (fun x => x * x₀) (𝓝 1)) : ContinuousMul M
-- Mathlib/Algebra/Group/Fin/Tuple.lean
@[simp] lemma head_zero : vecHead (0 : Fin n.succ → α) = 0
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive le_mul_norm_sub]
theorem le_mul_norm_div {f : E → F} (hf : AntilipschitzWith K f) (x y : E) :
    ‖x / y‖ ≤ K * ‖f x / f y‖
-- Mathlib/Topology/VectorBundle/Basic.lean
theorem continuousLinearMapAt_symmL (e : Trivialization F (π F E)) [e.IsLinear R] {b : B}
    (hb : b ∈ e.baseSet) (y : F) : e.continuousLinearMapAt R b (e.symmL R b y) = y
-- Mathlib/Order/CompleteLattice.lean
theorem sSup_image' {s : Set β} {f : β → α} : sSup (f '' s) = ⨆ a : s, f a
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive (attr := simp)]
theorem dist_mul_self_left (a b : E) : dist (a * b) b = ‖a‖
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
theorem exists_mem_ne_zero_of_rank_pos {s : Submodule R M} (h : 0 < Module.rank R s) :
    ∃ b : M, b ∈ s ∧ b ≠ 0
-- Mathlib/Data/Fin/VecNotation.lean
@[simp]
theorem vecAppend_apply_zero {α : Type*} {o : ℕ} (ho : o + 1 = m + 1 + n) (u : Fin (m + 1) → α)
    (v : Fin n → α) : vecAppend ho u v 0 = u 0
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
@[local simp]
private theorem eq_0_of_lt_one (x : Nat) : x < 1 ↔ x = 0
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem map_apply_inl (f : M →* M') (g : N →* N') (x : M) : map f g (inl x) = inl (f x)
-- Mathlib/Data/Finsupp/Defs.lean
/-- `Finsupp.single a b` is injective in `b`. For the statement that it is injective in `a`, see
`Finsupp.single_left_injective` -/
theorem single_injective (a : α) : Function.Injective (single a : M → α →₀ M)
-- Mathlib/Data/Finsupp/Defs.lean
theorem update_eq_sub_add_single [AddGroup G] (f : α →₀ G) (a : α) (b : G) :
    f.update a b = f - single a (f a) + single a b
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.symm (h : (fun x => f₁ x - f₂ x) =o[l] g) : (fun x => f₂ x - f₁ x) =o[l] g
-- Mathlib/Data/Num/Lemmas.lean
theorem ofNat'_succ : ∀ {n}, ofNat' (n + 1) = ofNat' n + 1
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
nonrec theorem UniqueMDiffWithinAt.prod {x : M} {y : M'} {s t} (hs : UniqueMDiffWithinAt I s x)
    (ht : UniqueMDiffWithinAt I' t y) : UniqueMDiffWithinAt (I.prod I') (s ×ˢ t) (x, y)
-- Mathlib/Probability/Kernel/Disintegration/Basic.lean
lemma disintegrate : κ.fst ⊗ₖ κCond = κ
-- Mathlib/FieldTheory/Separable.lean
theorem separable_prod' {ι : Sort _} {f : ι → R[X]} {s : Finset ι} :
    (∀ x ∈ s, ∀ y ∈ s, x ≠ y → IsCoprime (f x) (f y)) →
      (∀ x ∈ s, (f x).Separable) → (∏ x ∈ s, f x).Separable
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem zero_right : v ⟂ᵥ (0 : VectorMeasure α N)
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
nonrec theorem HasStrictDerivAt.smul (hc : HasStrictDerivAt c c' x) (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun y => c y • f y) (c x • f' + c' • f x) x
-- Mathlib/CategoryTheory/Limits/VanKampen.lean
theorem IsVanKampenColimit.mapCocone_iff (G : C ⥤ D) {F : J ⥤ C} {c : Cocone F}
    [G.IsEquivalence] : IsVanKampenColimit (G.mapCocone c) ↔ IsVanKampenColimit c
-- Mathlib/CategoryTheory/Localization/Resolution.lean
@[simp, reassoc]
lemma comp_f {R R' R'' : Φ.RightResolution X₂} (φ : R ⟶ R') (ψ : R' ⟶ R'') :
    (φ ≫ ψ).f = φ.f ≫ ψ.f
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)] theorem fst_comp_inl : (fst : M ∗ N →* M).comp inl = .id _
-- Mathlib/ModelTheory/Satisfiability.lean
theorem inf_semanticallyEquivalent_not_sup_not :
    T.SemanticallyEquivalent (φ ⊓ ψ) (φ.not ⊔ ψ.not).not
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_mul (s t : Finset α) : (↑(s * t) : Set α) = ↑s * ↑t
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
/-- The identity functor on `C`, viewed as a functor from `C` to its monoidal opposite. -/
@[simps obj map] -- need to specify `obj, map` or else we generate `mopFunctor_obj_unmop`
def mopFunctor : C ⥤ Cᴹᵒᵖ
-- Mathlib/Topology/Order/OrderClosed.lean
@[simp]
theorem continuousWithinAt_Ioo_iff_Ioi (h : a < b) :
    ContinuousWithinAt f (Ioo a b) a ↔ ContinuousWithinAt f (Ioi a) a
-- Mathlib/LinearAlgebra/Matrix/GeneralLinearGroup/Defs.lean
@[simp]
theorem coe_one : ↑(1 : GL n R) = (1 : Matrix n n R)
-- Mathlib/SetTheory/Ordinal/CantorNormalForm.lean
theorem one_CNF {o : Ordinal} (ho : o ≠ 0) : CNF 1 o = [⟨0, o⟩]
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
@[simp]
theorem map_zero [Nonempty ι] : f 0 = 0
-- Mathlib/Order/Filter/Germ/Basic.lean
@[simp]
theorem coe_compTendsto (f : α → β) {lc : Filter γ} {g : γ → α} (hg : Tendsto g lc l) :
    (f : Germ l β).compTendsto g hg = f ∘ g
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem val_le_one_iff (v : Valuation K Γ₀) {x : K} (h : x ≠ 0) : v x ≤ 1 ↔ 1 ≤ v x⁻¹
-- Mathlib/Order/Filter/Basic.lean
protected lemma EventuallyEq.iUnion [Finite ι] {s t : ι → Set α}
    (h : ∀ i, s i =ᶠ[l] t i) : (⋃ i, s i) =ᶠ[l] ⋃ i, t i
-- Mathlib/Algebra/Star/Subalgebra.lean
/-- A *-subalgebra is a subalgebra of a *-algebra which is closed under *. -/
structure StarSubalgebra (R : Type u) (A : Type v) [CommSemiring R] [StarRing R] [Semiring A]
  [StarRing A] [Algebra R A] [StarModule R A] extends Subalgebra R A : Type v where
  /-- The `carrier` is closed under the `star` operation. -/
  star_mem' {a} : a ∈ carrier → star a ∈ carrier
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem L1.integral_eq_integral (f : α →₁[μ] E) : L1.integral f = ∫ a, f a ∂μ
-- Mathlib/Data/DFinsupp/Basic.lean
theorem add_apply [∀ i, AddZeroClass (β i)] (g₁ g₂ : Π₀ i, β i) (i : ι) :
    (g₁ + g₂) i = g₁ i + g₂ i
-- Mathlib/Analysis/Normed/Group/Pointwise.lean
@[to_additive]
theorem singleton_div_ball_one : {x} / ball 1 δ = ball x δ
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem not_eq_not : ∀ {a b : Bool}, ¬a = !b ↔ a = b
-- Mathlib/CategoryTheory/Dialectica/Monoidal.lean
/-- The braiding isomorphism `X ⊗ Y ≅ Y ⊗ X` in `Dial C`. -/
@[simps!] def braiding (X Y : Dial C) : tensorObj X Y ≅ tensorObj Y X
-- Mathlib/Algebra/Periodic.lean
protected theorem Periodic.const_smul₀ [AddCommMonoid α] [DivisionSemiring γ] [Module γ α]
    (h : Periodic f c) (a : γ) : Periodic (fun x => f (a • x)) (a⁻¹ • c)
-- Mathlib/FieldTheory/SeparableClosure.lean
/-- The same-universe version of `Field.lift_insepDegree_eq_of_equiv`. -/
theorem insepDegree_eq_of_equiv (K : Type v) [Field K] [Algebra F K] (i : E ≃ₐ[F] K) :
    insepDegree F E = insepDegree F K
-- Mathlib/Order/WithBot.lean
@[simp, norm_cast]
theorem coe_max [LinearOrder α] (x y : α) : (↑(max x y) : WithTop α) = max (x : WithTop α) y
-- Mathlib/Data/Prod/Basic.lean
lemma lex_iff : Prod.Lex r s x y ↔ r x.1 y.1 ∨ x.1 = y.1 ∧ s x.2 y.2
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
theorem DifferentiableAt.fderiv_prod (hf₁ : DifferentiableAt 𝕜 f₁ x)
    (hf₂ : DifferentiableAt 𝕜 f₂ x) :
    fderiv 𝕜 (fun x : E => (f₁ x, f₂ x)) x = (fderiv 𝕜 f₁ x).prod (fderiv 𝕜 f₂ x)
-- Mathlib/Algebra/Lie/Matrix.lean
@[simp]
theorem Matrix.lieConj_symm_apply (P A : Matrix n n R) (h : Invertible P) :
    (P.lieConj h).symm A = P⁻¹ * A * P
-- Mathlib/Order/InitialSeg.lean
theorem top_eq [IsWellOrder γ t] (e : r ≃r s) (f : r ≺i t) (g : s ≺i t) : f.top = g.top
-- Mathlib/Order/UpperLower/Basic.lean
theorem IsLowerSet.bot_mem (hs : IsLowerSet s) : ⊥ ∈ s ↔ s.Nonempty
-- Mathlib/GroupTheory/SpecificGroups/Alternating.lean
/-- Part of proving $A_5$ is simple. Shows that the square of any element of $A_5$ with a 3-cycle in
  its cycle decomposition is a 3-cycle, so the normal closure of the original element must be
  $A_5$. -/
theorem isThreeCycle_sq_of_three_mem_cycleType_five {g : Perm (Fin 5)} (h : 3 ∈ cycleType g) :
    IsThreeCycle (g * g)
-- Mathlib/Logic/Basic.lean
theorem ne_or_eq {α : Sort*} (x y : α) : x ≠ y ∨ x = y
-- Mathlib/Dynamics/Newton.lean
theorem isNilpotent_iterate_newtonMap_sub_of_isNilpotent (h : IsNilpotent <| aeval x P) (n : ℕ) :
    IsNilpotent <| P.newtonMap^[n] x - x
-- Mathlib/FieldTheory/RatFunc/Basic.lean
@[simp]
theorem ofFractionRing_eq :
    (ofFractionRing : FractionRing K[X] → RatFunc K) = IsLocalization.algEquiv K[X]⁰ _ _
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
theorem epi_of_cokernel_zero {X Y : C} {f : X ⟶ Y} [HasColimit (parallelPair f 0)]
    (w : cokernel.π f = 0) : Epi f
-- Mathlib/Topology/MetricSpace/PiNat.lean
/-- A function to a pseudo-metric-space is `1`-Lipschitz if and only if points in the same cylinder
of length `n` are sent to points within distance `(1/2)^n`.
Not expressed using `LipschitzWith` as we don't have a metric space structure -/
theorem lipschitz_with_one_iff_forall_dist_image_le_of_mem_cylinder {α : Type*}
    [PseudoMetricSpace α] {f : (∀ n, E n) → α} :
    (∀ x y : ∀ n, E n, dist (f x) (f y) ≤ dist x y) ↔
      ∀ x y n, y ∈ cylinder x n → dist (f x) (f y) ≤ (1 / 2) ^ n
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.const_mul_right {g : α → 𝕜} {c : 𝕜} (hc : c ≠ 0) (h : f =o[l] g) :
    f =o[l] fun x => c * g x
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem mem_toSubring (s : Subfield K) (x : K) : x ∈ s.toSubring ↔ x ∈ s
-- Mathlib/Algebra/Polynomial/Module/Basic.lean
@[simp]
theorem smul_single_apply (i : ℕ) (f : R[X]) (m : M) (n : ℕ) :
    (f • single R i m) n = ite (i ≤ n) (f.coeff (n - i) • m) 0
-- Mathlib/Analysis/LocallyConvex/Basic.lean
theorem balanced_iff_smul_mem : Balanced 𝕜 s ↔ ∀ ⦃a : 𝕜⦄, ‖a‖ ≤ 1 → ∀ ⦃x : E⦄, x ∈ s → a • x ∈ s
-- Mathlib/MeasureTheory/Constructions/Prod/Integral.lean
/-- A binary function is integrable if the function `x ↦ f (x, y)` is integrable for almost every
  `y` and the function `y ↦ ∫ ‖f (x, y)‖ dx` is integrable. -/
theorem integrable_prod_iff' [SFinite μ] ⦃f : α × β → E⦄
    (h1f : AEStronglyMeasurable f (μ.prod ν)) :
    Integrable f (μ.prod ν) ↔
      (∀ᵐ y ∂ν, Integrable (fun x => f (x, y)) μ) ∧ Integrable (fun y => ∫ x, ‖f (x, y)‖ ∂μ) ν
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean
/-- For 0 < x ≤ 1 we have x - x ^ 3 / 4 < sin x.

This is also true for x > 1, but it's nontrivial for x just above 1. This inequality is not
tight; the tighter inequality is sin x > x - x ^ 3 / 6 for all x > 0, but this inequality has
a simpler proof. -/
theorem sin_gt_sub_cube {x : ℝ} (h : 0 < x) (h' : x ≤ 1) : x - x ^ 3 / 4 < sin x
-- Mathlib/Algebra/Order/Interval/Set/Group.lean
@[to_additive]
theorem pairwise_disjoint_Ico_zpow :
    Pairwise (Disjoint on fun n : ℤ => Ico (b ^ n) (b ^ (n + 1)))
-- Mathlib/CategoryTheory/Functor/Category.lean
@[simp]
theorem id_app (F : C ⥤ D) (X : C) : (𝟙 F : F ⟶ F).app X = 𝟙 (F.obj X)
-- Mathlib/Data/Finset/Basic.lean
theorem erase_union_of_mem (ha : a ∈ t) (s : Finset α) : s.erase a ∪ t = s ∪ t
-- Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean
/-- Write the iterated derivative as the composition of a continuous linear equiv and the iterated
Fréchet derivative -/
theorem iteratedDerivWithin_eq_equiv_comp : iteratedDerivWithin n f s =
    (ContinuousMultilinearMap.piFieldEquiv 𝕜 (Fin n) F).symm ∘ iteratedFDerivWithin 𝕜 n f s
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive add_neg_le_add_neg_iff]
theorem mul_inv_le_mul_inv_iff' : a * b⁻¹ ≤ c * d⁻¹ ↔ a * d ≤ c * b
-- Mathlib/FieldTheory/IntermediateField.lean
@[simp]
theorem coe_smul {R} [Semiring R] [SMul R K] [Module R L] [IsScalarTower R K L] (r : R) (x : S) :
    ↑(r • x : S) = (r • (x : L))
-- Mathlib/Logic/Function/Basic.lean
lemma ne_update_self_iff : f ≠ update f a b ↔ f a ≠ b
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Ioi_mem_nhds (h : a < b) : Ioi a ∈ 𝓝 b
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem top_adj : (⊤ : Subgraph G).Adj a b ↔ G.Adj a b
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
@[simp]
theorem sheafifyMap_id (P : Cᵒᵖ ⥤ D) : J.sheafifyMap (𝟙 P) = 𝟙 (J.sheafify P)
-- Mathlib/Algebra/DirectSum/Module.lean
@[simp]
theorem lof_apply (i : ι) (b : M i) : ((lof R ι M i) b) i = b
-- Mathlib/Order/CompleteLattice.lean
@[gcongr]
theorem iSup_mono (h : ∀ i, f i ≤ g i) : iSup f ≤ iSup g
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- If the second of three points is weakly between the other two, the oriented angle at the
third point is zero. -/
theorem _root_.Wbtw.oangle₂₃₁_eq_zero {p₁ p₂ p₃ : P} (h : Wbtw ℝ p₁ p₂ p₃) : ∡ p₂ p₃ p₁ = 0
-- Mathlib/MeasureTheory/Measure/Content.lean
theorem le_innerContent (K : Compacts G) (U : Opens G) (h2 : (K : Set G) ⊆ U) :
    μ K ≤ μ.innerContent U
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive succ_nsmul]
theorem pow_succ (a : M) (n : ℕ) : a ^ (n + 1) = a ^ n * a
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive lipschitzWith_one_nnnorm]
theorem lipschitzWith_one_nnnorm' : LipschitzWith 1 (NNNorm.nnnorm : E → ℝ≥0)
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
@[simp]
theorem isSymm_neg {B : BilinForm R₁ M₁} : (-B).IsSymm ↔ B.IsSymm
-- Mathlib/GroupTheory/Perm/List.lean
theorem support_formPerm_le' : { x | formPerm l x ≠ x } ≤ l.toFinset
-- Mathlib/MeasureTheory/Measure/FiniteMeasureProd.lean
lemma prod_apply (s : Set (α × β)) (s_mble : MeasurableSet s) :
    μ.prod ν s = ENNReal.toNNReal (∫⁻ x, ν.toMeasure (Prod.mk x ⁻¹' s) ∂μ)
-- .lake/packages/lean4/src/lean/Init/Data/List/Impl.lean
@[csimp] theorem enumFrom_eq_enumFromTR : @enumFrom = @enumFromTR
-- Mathlib/Data/List/Permutation.lean
theorem permutations_append (is ts : List α) :
    permutations (is ++ ts) = (permutations is).map (· ++ ts) ++ permutationsAux ts is.reverse
-- Mathlib/Algebra/Order/Ring/Canonical.lean
theorem tsub_mul (a b c : α) : (a - b) * c = a * c - b * c
-- Mathlib/Analysis/RCLike/Lemmas.lean
@[simp, rclike_simps]
theorem ofRealCLM_norm : ‖(ofRealCLM : ℝ →L[ℝ] K)‖ = 1
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma defaultRatCDF_le_one (q : ℚ) : defaultRatCDF q ≤ 1
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Perm.nodup_iff {l₁ l₂ : List α} : l₁ ~ l₂ → (Nodup l₁ ↔ Nodup l₂)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- A side of a right-angled triangle divided by the cosine of the adjacent angle equals the
hypotenuse. -/
theorem norm_div_cos_oangle_add_left_of_oangle_eq_pi_div_two {x y : V}
    (h : o.oangle x y = ↑(π / 2)) : ‖y‖ / Real.Angle.cos (o.oangle (x + y) y) = ‖x + y‖
-- Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean
theorem valuation_ker_eq :
    valuation.ker = K⟮(∅ : Set <| HeightOneSpectrum R),n⟯.subgroupOf (K⟮S,n⟯)
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
/-- If matrix A is right invertible, then its inverse equals its right inverse. -/
theorem inv_eq_right_inv (h : A * B = 1) : A⁻¹ = B
-- Mathlib/Data/Set/Basic.lean
/-- Duplicate of `Eq.subset'`, which currently has elaboration problems. -/
theorem Eq.subset {α} {s t : Set α} : s = t → s ⊆ t
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma measure_stieltjesOfMeasurableRat_univ (hf : Measurable f) (a : α) :
    (stieltjesOfMeasurableRat f hf a).measure univ = 1
-- Mathlib/Data/ENNReal/Basic.lean
@[simp] theorem toReal_nonneg {a : ℝ≥0∞} : 0 ≤ a.toReal
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1SCLM_congr_left' (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (h : ∀ s, MeasurableSet s → μ s < ∞ → T s = T' s)
    (f : α →₁ₛ[μ] E) : setToL1SCLM α E μ hT f = setToL1SCLM α E μ hT' f
-- Mathlib/RingTheory/Localization/Algebra.lean
/-- The canonical linear map from the kernel of an algebra homomorphism to its localization
is localizing. -/
lemma AlgHom.toKerIsLocalization_isLocalizedModule (f : A →ₐ[R] B) :
    IsLocalizedModule (Algebra.algebraMapSubmonoid A M)
      (AlgHom.toKerIsLocalization M Rₚ Aₚ Bₚ f)
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
lemma countablePartitionSet_eq_iff {n : ℕ} (a : α) {s : Set α} (hs : s ∈ countablePartition α n) :
    countablePartitionSet n a = s ↔ a ∈ s
-- Mathlib/RingTheory/Filtration.lean
theorem pow_smul_le (i j : ℕ) : I ^ i • F.N j ≤ F.N (i + j)
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
/-- Calculate the integral of `(g ∘ f)`, where `g : β → ℝ≥0∞` and `f : α →ₛ β`.  -/
theorem map_lintegral (g : β → ℝ≥0∞) (f : α →ₛ β) :
    (f.map g).lintegral μ = ∑ x ∈ f.range, g x * μ (f ⁻¹' {x})
-- Mathlib/CategoryTheory/Monoidal/Internal/FunctorCategory.lean
/-- When `D` is a monoidal category,
comonoid objects in `C ⥤ D` are the same thing
as functors from `C` into the comonoid objects of `D`.
-/
@[simps]
def comonFunctorCategoryEquivalence : Comon_ (C ⥤ D) ≌ C ⥤ Comon_ D
-- Mathlib/Computability/Reduce.lean
@[simp]
theorem toNat_manyOneReducible {p : Set α} : toNat p ≤₀ p
-- Mathlib/CategoryTheory/Sites/Adjunction.lean
/-- An auxiliary definition to be used in defining `CategoryTheory.Sheaf.adjunction` below. -/
@[simps]
def composeEquiv [HasSheafCompose J F] (adj : G ⊣ F) (X : Sheaf J E) (Y : Sheaf J D) :
    ((composeAndSheafify J G).obj X ⟶ Y) ≃ (X ⟶ (sheafCompose J F).obj Y)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem sup_le_iff {ι : Type u} {f : ι → Ordinal.{max u v}} {a} : sup.{_, v} f ≤ a ↔ ∀ i, f i ≤ a
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem dist_le_iff_of_nonempty [Nonempty α] : dist f g ≤ C ↔ ∀ x, dist (f x) (g x) ≤ C
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem MDifferentiableWithinAt.prod_mk {f : M → M'} {g : M → M''}
    (hf : MDifferentiableWithinAt I I' f s x) (hg : MDifferentiableWithinAt I I'' g s x) :
    MDifferentiableWithinAt I (I'.prod I'') (fun x => (f x, g x)) s x
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem abs_exp (x : ℝ) : |exp x| = exp x
-- Mathlib/Topology/MetricSpace/HausdorffDimension.lean
/-- If `s` is a set in an extended metric space `X` with second countable topology and `f : X → Y`
is Lipschitz in a neighborhood within `s` of every point `x ∈ s`, then the Hausdorff dimension of
the image `f '' s` is at most the Hausdorff dimension of `s`. -/
theorem dimH_image_le_of_locally_lipschitzOn [SecondCountableTopology X] {f : X → Y} {s : Set X}
    (hf : ∀ x ∈ s, ∃ C : ℝ≥0, ∃ t ∈ 𝓝[s] x, LipschitzOnWith C f t) : dimH (f '' s) ≤ dimH s
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem not_false : ¬False
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
/-- Rectangles form a π-system. -/
theorem isPiSystem_prod :
    IsPiSystem (image2 (· ×ˢ ·) { s : Set α | MeasurableSet s } { t : Set β | MeasurableSet t })
-- Mathlib/CategoryTheory/Monad/Equalizer.lean
/-- This is the Beck fork. It is a split equalizer, in particular a equalizer. -/
@[simps! pt]
def beckFork : Fork (T.map X.a) (T.δ.app _)
-- Mathlib/Data/Nat/Fib/Zeckendorf.lean
@[simp] lemma greatestFib_lt : greatestFib m < n ↔ m < fib n
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem Decidable.or_congr_left' [Decidable c] (h : ¬c → (a ↔ b)) : a ∨ c ↔ b ∨ c
-- Mathlib/Data/Finset/Fold.lean
theorem fold_min_lt : s.fold min b f < c ↔ b < c ∨ ∃ x ∈ s, f x < c
-- Mathlib/Algebra/Order/Ring/Basic.lean
theorem one_lt_pow_iff_of_nonneg (ha : 0 ≤ a) (hn : n ≠ 0) : 1 < a ^ n ↔ 1 < a