ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
@[reassoc]
theorem equalizer.lift_ι {W : C} (k : W ⟶ X) (h : k ≫ f = k ≫ g) :
    equalizer.lift k h ≫ equalizer.ι f g = k
-- Mathlib/Data/QPF/Univariate/Basic.lean
theorem recF_eq' {α : Type _} (g : F α → α) (a : q.P.A) (f : q.P.B a → q.P.W) :
    recF g ⟨a, f⟩ = g (abs (q.P.map (recF g) ⟨a, f⟩))
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
/-- Every Schwartz function is differentiable. -/
protected theorem differentiable (f : 𝓢(E, F)) : Differentiable ℝ f
-- Mathlib/CategoryTheory/Monoidal/Category.lean
/-- The tensor product of two isomorphisms is an isomorphism. -/
@[simps]
def tensorIso {C : Type u} {X Y X' Y' : C} [Category.{v} C] [MonoidalCategory.{v} C] (f : X ≅ Y)
    (g : X' ≅ Y') : X ⊗ X' ≅ Y ⊗ Y'
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sqrtTwoAddSeries_one : sqrtTwoAddSeries 0 1 = √2
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The scalar multiplication of a constant and a `C^n` function at a point is `C^n` at this
point. -/
theorem ContDiffAt.const_smul {f : E → F} {x : E} (c : R) (hf : ContDiffAt 𝕜 n f x) :
    ContDiffAt 𝕜 n (fun y => c • f y) x
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
@[simp]
theorem Matrix.mulVecLin_mul [Fintype m] (M : Matrix l m R) (N : Matrix m n R) :
    Matrix.mulVecLin (M * N) = (Matrix.mulVecLin M).comp (Matrix.mulVecLin N)
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[ext]
theorem ext ⦃f g : α →ₙ+* β⦄ : (∀ x, f x = g x) → f = g
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem coeFn_sub (Q Q' : QuadraticMap R M N) : ⇑(Q - Q') = Q - Q'
-- Mathlib/Algebra/Category/Grp/Limits.lean
/-- A functor `F : J ⥤ Grp.{u}` has a limit iff `(F ⋙ forget Grp).sections` is
`u`-small.  -/
@[to_additive "A functor `F : J ⥤ AddGrp.{u}` has a limit iff
`(F ⋙ forget AddGrp).sections` is `u`-small."]
lemma hasLimit_iff_small_sections :
    HasLimit F ↔ Small.{u} (F ⋙ forget Grp).sections
-- Mathlib/Data/Part.lean
@[simp]
theorem pure_eq_some (a : α) : pure a = some a
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem mul_single_zero_apply [AddZeroClass G] (f : k[G]) (r : k) (x : G) :
    (f * single (0 : G) r) x = f x * r
-- Mathlib/Algebra/Lie/Classical.lean
theorem pd_inv [Fintype l] [Invertible (2 : R)] : PD l R * ⅟ (2 : R) • (PD l R)ᵀ = 1
-- Mathlib/Topology/GDelta.lean
/-- A set `s` is closed and nowhere dense iff its complement `sᶜ` is open and dense. -/
lemma isClosed_isNowhereDense_iff_compl {s : Set X} :
    IsClosed s ∧ IsNowhereDense s ↔ IsOpen sᶜ ∧ Dense sᶜ
-- Mathlib/Algebra/Homology/Localization.lean
lemma quotient_map_mem_quasiIso_iff {K L : HomologicalComplex C c} (f : K ⟶ L) :
    quasiIso C c ((quotient C c).map f) ↔ HomologicalComplex.quasiIso C c f
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
@[simp]
lemma ofHom_lift :
    Cochain.ofHom (lift φ α β eq) = liftCochain φ α β (zero_add 1)
-- Mathlib/Analysis/Normed/Group/Constructions.lean
lemma norm_unop [SeminormedAddGroup E] (a : Eᵐᵒᵖ) : ‖MulOpposite.unop a‖ = ‖a‖
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem map_map {M : Matrix m n α} {β γ : Type*} {f : α → β} {g : β → γ} :
    (M.map f).map g = M.map (g ∘ f)
-- Mathlib/Topology/Sheaves/Stalks.lean
@[reassoc]
lemma map_germ_eq_Γgerm (F : X.Presheaf C) {U : Opens X} {i : U ⟶ ⊤} (x : U) :
    F.map i.op ≫ germ F x = Γgerm F (i x)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- The sine of an angle in a right-angled triangle as a ratio of sides. -/
theorem sin_oangle_right_of_oangle_eq_pi_div_two {p₁ p₂ p₃ : P} (h : ∡ p₁ p₂ p₃ = ↑(π / 2)) :
    Real.Angle.sin (∡ p₂ p₃ p₁) = dist p₁ p₂ / dist p₁ p₃
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
@[reassoc (attr := simp)]
theorem image.factorThruImage_preComp [HasImage g] [HasImage (f ≫ g)] :
    factorThruImage (f ≫ g) ≫ image.preComp f g = f ≫ factorThruImage g
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem Homeomorph.mulRight_symm (a : G) :
    (Homeomorph.mulRight a).symm = Homeomorph.mulRight a⁻¹
-- Mathlib/Analysis/Complex/CauchyIntegral.lean
/-- **Cauchy-Goursat theorem** for a rectangle: the integral of a complex differentiable function
over the boundary of a rectangle equals zero. More precisely, if `f` is complex differentiable on a
closed rectangle, then its integral over the boundary of the rectangle equals zero. -/
theorem integral_boundary_rect_eq_zero_of_differentiableOn (f : ℂ → E) (z w : ℂ)
    (H : DifferentiableOn ℂ f ([[z.re, w.re]] ×ℂ [[z.im, w.im]])) :
    (∫ x : ℝ in z.re..w.re, f (x + z.im * I)) - (∫ x : ℝ in z.re..w.re, f (x + w.im * I)) +
      I • (∫ y : ℝ in z.im..w.im, f (re w + y * I)) -
      I • (∫ y : ℝ in z.im..w.im, f (re z + y * I)) = 0
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
/-- If `S / R` and `S' / R'` are algebras, `i : R →+* R'` is a surjective ring homomorphism,
`j : S →+* S'` is an injective ring homomorphism, such that `R → R' → S'` and `R → S → S'` commute,
then the rank of `S / R` is smaller than or equal to the rank of `S' / R'`. -/
theorem lift_rank_le_of_surjective_injective
    (i : R →+* R') (j : S →+* S') (hi : Surjective i) (hj : Injective j)
    (hc : (algebraMap R' S').comp i = j.comp (algebraMap R S)) :
    lift.{v'} (Module.rank R S) ≤ lift.{v} (Module.rank R' S')
-- Mathlib/Algebra/Category/Grp/Basic.lean
@[to_additive]
lemma comp_def {X Y Z : Grp} {f : X ⟶ Y} {g : Y ⟶ Z} : f ≫ g = g.comp f
-- Mathlib/Analysis/Complex/Circle.lean
@[simp]
lemma norm_circle_smul {E : Type*} [SeminormedAddCommGroup E] [NormedSpace ℂ E]
    (u : circle) (v : E) :
    ‖u • v‖ = ‖v‖
-- Mathlib/Topology/FiberBundle/Trivialization.lean
@[ext]
lemma ext' (e e' : Trivialization F proj) (h₁ : e.toPartialHomeomorph = e'.toPartialHomeomorph)
    (h₂ : e.baseSet = e'.baseSet) : e = e'
-- Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean
theorem sdiff_compl_neighborFinset_inter_eq {v w : V} (h : G.Adj v w) :
    ((G.neighborFinset v)ᶜ ∩ (G.neighborFinset w)ᶜ) \ ({w} ∪ {v}) =
      (G.neighborFinset v)ᶜ ∩ (G.neighborFinset w)ᶜ
-- Mathlib/NumberTheory/Padics/PadicVal.lean
theorem padicValNat_factorial_mul_add {n : ℕ} (m : ℕ) [hp : Fact p.Prime] (h : n < p) :
    padicValNat p (p * m + n) ! = padicValNat p (p * m) !
-- .lake/packages/lean4/src/lean/Init/Grind/Norm.lean
@[grind_norm] theorem not_eq_prop (p q : Prop) : (¬(p = q)) = (p = ¬q)
-- Mathlib/Order/SuccPred/Relation.lean
/-- For `n ≠ m`, `(n, m)` is in the transitive closure of a relation `~` if `i ~ pred i` and
  `pred i ~ i` for all `i` between `n` and `m`. -/
theorem transGen_of_pred_of_ne (r : α → α → Prop) {n m : α} (h1 : ∀ i ∈ Ioc m n, r i (pred i))
    (h2 : ∀ i ∈ Ioc n m, r (pred i) i) (hnm : n ≠ m) : TransGen r n m
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem mul_coeff_order_add_order {Γ} [LinearOrderedCancelAddCommMonoid Γ]
    [NonUnitalNonAssocSemiring R] (x y : HahnSeries Γ R) :
    (x * y).coeff (x.order + y.order) = x.leadingCoeff * y.leadingCoeff
-- Mathlib/Algebra/Polynomial/Laurent.lean
@[simp] lemma invert_comp_C : invert ∘ (@C R _) = C
-- Mathlib/Algebra/MvPolynomial/Monad.lean
theorem eval₂Hom_bind₁ (f : R →+* S) (g : τ → S) (h : σ → MvPolynomial τ R) (φ : MvPolynomial σ R) :
    eval₂Hom f g (bind₁ h φ) = eval₂Hom f (fun i => eval₂Hom f g (h i)) φ
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
theorem le_pre : μ ≤ pre m r ↔ ∀ s : Set X, diam s ≤ r → μ s ≤ m s
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem bind_id (l : List (List α)) : List.bind l id = l.join
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem domRestrict_apply (f : M ↪[L] N) (p : L.Substructure M) (x : p) : f.domRestrict p x = f x
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- `functoriality F _ ⋙ precompose (whiskerLeft F _)` simplifies to `functoriality F _`. -/
@[simps!]
def functorialityCompPrecompose {H H' : C ⥤ D} (α : H ≅ H') :
    Cocones.functoriality F H ⋙ Cocones.precompose (whiskerLeft F α.inv) ≅
      Cocones.functoriality F H'
-- Mathlib/Order/Defs.lean
theorem ne_iff_lt_or_gt {a b : α} : a ≠ b ↔ a < b ∨ a > b
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
protected theorem HasDerivAt.continuousOn {f f' : 𝕜 → F} (hderiv : ∀ x ∈ s, HasDerivAt f (f' x) x) :
    ContinuousOn f s
-- Mathlib/Data/Set/Sups.lean
theorem sups_subset : s₁ ⊆ s₂ → t₁ ⊆ t₂ → s₁ ⊻ t₁ ⊆ s₂ ⊻ t₂
-- Mathlib/Data/Finset/NAry.lean
theorem card_image₂_singleton_right (hf : Injective fun a => f a b) :
    (image₂ f s {b}).card = s.card
-- Mathlib/Data/Nat/Defs.lean
lemma decreasingInduction_succ_left  {motive : (m : ℕ) → m ≤ n → Sort*} (of_succ self)
    (smn : m + 1 ≤ n) (mn : m ≤ n) :
    decreasingInduction (motive := motive) of_succ self mn =
      of_succ m smn (decreasingInduction of_succ self smn)
-- Mathlib/Analysis/CstarAlgebra/GelfandDuality.lean
/-- If `a : A` is not a unit, then some character takes the value zero at `a`. This is equivalent
to `gelfandTransform ℂ A a` takes the value zero at some character. -/
theorem WeakDual.CharacterSpace.exists_apply_eq_zero {a : A} (ha : ¬IsUnit a) :
    ∃ f : characterSpace ℂ A, f a = 0
-- Mathlib/Order/UpperLower/Basic.lean
theorem IsLowerSet.ordConnected (h : IsLowerSet s) : s.OrdConnected
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
theorem find?_cons : (a::as).find? p = match p a with | true => some a | false => as.find? p
-- Mathlib/Algebra/Homology/TotalComplex.lean
@[reassoc (attr := simp)]
lemma D₂_D₁ (i₁₂ i₁₂' i₁₂'' : I₁₂) :
    K.D₂ c₁₂ i₁₂ i₁₂' ≫ K.D₁ c₁₂ i₁₂' i₁₂'' = - K.D₁ c₁₂ i₁₂ i₁₂' ≫ K.D₂ c₁₂ i₁₂' i₁₂''
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- `mapCocone` commutes with `precomposeEquivalence`
-/
@[simps!]
def mapCoconePrecomposeEquivalenceFunctor {α : F ≅ G} {c} :
    mapCocone H ((Cocones.precomposeEquivalence α).functor.obj c) ≅
      (Cocones.precomposeEquivalence (isoWhiskerRight α H : _)).functor.obj (mapCocone H c)
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem hasFDerivWithinAt_euclidean :
    HasFDerivWithinAt f f' t y ↔
      ∀ i, HasFDerivWithinAt (fun x => f x i) (EuclideanSpace.proj i ∘L f') t y
-- Mathlib/Data/Set/Image.lean
theorem coe_image_univ (s : Set α) : ((↑) : s → α) '' Set.univ = s
-- Mathlib/SetTheory/Game/Basic.lean
theorem inv_eq_of_lf_zero {x : PGame} (h : x ⧏ 0) : x⁻¹ = -inv' (-x)
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
lemma Pi.map'_id_id {f : α → C} [HasProduct f] : Pi.map' id (fun a => 𝟙 (f a)) = 𝟙 (∏ᶜ f)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem u_ciInf_set (gc : GaloisConnection l u) {s : Set γ} {f : γ → β} (hf : BddBelow (f '' s))
    (hne : s.Nonempty) : u (⨅ i : s, f i) = ⨅ i : s, u (f i)
-- .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Rfl.lean
/-- Helper theorem for `Lean.MVarId.liftReflToEq`. -/
private theorem rel_of_eq_and_refl {α : Sort _} {R : α → α → Prop}
    {x y : α} (hxy : x = y) (h : R x x) : R x y
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem map_preimage_singleton (f : α →ₛ β) (g : β → γ) (c : γ) :
    f.map g ⁻¹' {c} = f ⁻¹' ↑(f.range.filter fun b => g b = c)
-- Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean
theorem orthogonal_span_singleton_eq_toLin_ker {B : BilinForm K V} (x : V) :
    B.orthogonal (K ∙ x) = LinearMap.ker (LinearMap.BilinForm.toLinHomAux₁ B x)
-- Mathlib/Data/Set/Lattice.lean
theorem Sigma.univ (X : α → Type*) : (Set.univ : Set (Σa, X a)) = ⋃ a, range (Sigma.mk a)
-- Mathlib/Data/Nat/Log.lean
@[mono]
theorem log_anti_left {b c n : ℕ} (hc : 1 < c) (hb : c ≤ b) : log b n ≤ log c n
-- Mathlib/Order/Bounds/Basic.lean
theorem image2_lowerBounds_lowerBounds_subset :
    image2 f (lowerBounds s) (lowerBounds t) ⊆ lowerBounds (image2 f s t)
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem ofInt_eq_intCast (n : ℤ) : (ofInt n : ℤ√d) = n
-- Mathlib/Data/Finsupp/Defs.lean
theorem single_left_inj (h : b ≠ 0) : single a b = single a' b ↔ a = a'
-- Mathlib/Topology/Compactness/Compact.lean
/-- For every directed family of closed sets whose intersection avoids a compact set,
there exists a single element of the family which itself avoids this compact set. -/
theorem IsCompact.elim_directed_family_closed {ι : Type v} [hι : Nonempty ι] (hs : IsCompact s)
    (t : ι → Set X) (htc : ∀ i, IsClosed (t i)) (hst : (s ∩ ⋂ i, t i) = ∅)
    (hdt : Directed (· ⊇ ·) t) : ∃ i : ι, s ∩ t i = ∅
-- Mathlib/Data/Matrix/Hadamard.lean
theorem hadamard_comm [CommSemigroup α] : A ⊙ B = B ⊙ A
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem map_univ_val_equiv (e : α ≃ β) :
    map e univ.val = univ.val
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
@[simp]
theorem Matrix.toBilin_toMatrix (B : BilinForm R₂ M₂) :
    Matrix.toBilin b (BilinForm.toMatrix b B) = B
-- Mathlib/Algebra/Order/Monoid/Unbundled/Defs.lean
/-- The partial application of a constant to a covariant operator is monotone. -/
theorem Covariant.monotone_of_const [CovariantClass M N μ (· ≤ ·)] (m : M) : Monotone (μ m)
-- Mathlib/Data/Set/Function.lean
lemma RightInvOn.prodMap (h₁ : RightInvOn g₁ f₁ t₁) (h₂ : RightInvOn g₂ f₂ t₂) :
    RightInvOn (fun x ↦ (g₁ x.1, g₂ x.2)) (fun x ↦ (f₁ x.1, f₂ x.2)) (t₁ ×ˢ t₂)
-- Mathlib/CategoryTheory/Bicategory/Extension.lean
/-- Construct a left extension of `g : a ⟶ c` from a left extension of `g ≫ 𝟙 c`. -/
@[simps!]
def ofCompId (t : LeftExtension f (g ≫ 𝟙 c)) : LeftExtension f g
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[simp]
lemma zeroLocus_empty_eq_univ {U : X.Opens} :
    X.zeroLocus (∅ : Set Γ(X, U)) = Set.univ
-- Mathlib/Combinatorics/SimpleGraph/Maps.lean
theorem map_mem_edgeSet_iff {e : Sym2 V} : e.map f ∈ G'.edgeSet ↔ e ∈ G.edgeSet
-- Mathlib/RingTheory/Regular/IsSMulRegular.lean
lemma isSMulRegular_of_smul_eq_zero_imp_eq_zero
    (h : ∀ x : M, r • x = 0 → x = 0) : IsSMulRegular M r
-- Mathlib/CategoryTheory/Limits/Final.lean
theorem final_iff_comp_final_full_faithful [Final G] [Full G] [Faithful G] :
    Final F ↔ Final (F ⋙ G)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
theorem conjugatesOfSet_mono {s t : Set G} (h : s ⊆ t) : conjugatesOfSet s ⊆ conjugatesOfSet t
-- Mathlib/Algebra/Algebra/Equiv.lean
/-- If an algebra morphism has an inverse, it is an algebra isomorphism. -/
@[simps]
def ofAlgHom (f : A₁ →ₐ[R] A₂) (g : A₂ →ₐ[R] A₁) (h₁ : f.comp g = AlgHom.id R A₂)
    (h₂ : g.comp f = AlgHom.id R A₁) : A₁ ≃ₐ[R] A₂
-- Mathlib/Logic/IsEmpty.lean
theorem wellFounded_of_isEmpty {α} [IsEmpty α] (r : α → α → Prop) : WellFounded r
-- Mathlib/Geometry/Manifold/Algebra/Monoid.lean
@[to_additive]
theorem smoothWithinAt_finset_prod (h : ∀ i ∈ t, SmoothWithinAt I' I (f i) s x) :
    SmoothWithinAt I' I (fun x => ∏ i ∈ t, f i x) s x
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- A `Simplex k P n` is a collection of `n + 1` affinely
independent points. -/
structure Simplex (n : ℕ) where
  points : Fin (n + 1) → P
  independent : AffineIndependent k points
-- Mathlib/Algebra/Polynomial/Div.lean
theorem map_divByMonic [Ring S] (f : R →+* S) (hq : Monic q) :
    (p /ₘ q).map f = p.map f /ₘ q.map f
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem QuotientAddGroup.equivIocMod_coe (a b : α) :
    QuotientAddGroup.equivIocMod hp a ↑b = ⟨toIocMod hp a b, toIocMod_mem_Ioc hp a _⟩
-- Mathlib/Analysis/CstarAlgebra/Basic.lean
@[simp]
theorem norm_unitary_smul (U : unitary E) (A : E) : ‖U • A‖ = ‖A‖
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
theorem mkPiRing_zero : ContinuousMultilinearMap.mkPiRing R ι (0 : M) = 0
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma unop_whiskerLeft (X : Cᵒᵖ) {Y Z : Cᵒᵖ} (f : Y ⟶ Z) :
    (X ◁ f).unop =  unop X ◁ f.unop
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
theorem limit.lift_extend {F : J ⥤ C} [HasLimit F] (c : Cone F) {X : C} (f : X ⟶ c.pt) :
    limit.lift F (c.extend f) = f ≫ limit.lift F c
-- Mathlib/CategoryTheory/Limits/Preserves/Limits.lean
@[simp]
theorem preserves_desc_mapCocone (c₁ c₂ : Cocone F) (t : IsColimit c₁) :
    (PreservesColimit.preserves t).desc (G.mapCocone _) = G.map (t.desc c₂)
-- Mathlib/Deprecated/Submonoid.lean
/-- The union of an indexed, directed, nonempty set of submonoids of a monoid `M` is a submonoid
    of `M`. -/
@[to_additive
      "The union of an indexed, directed, nonempty set of `AddSubmonoid`s of an `AddMonoid` `M`
      is an `AddSubmonoid` of `M`. "]
theorem isSubmonoid_iUnion_of_directed {ι : Type*} [hι : Nonempty ι] {s : ι → Set M}
    (hs : ∀ i, IsSubmonoid (s i)) (Directed : ∀ i j, ∃ k, s i ⊆ s k ∧ s j ⊆ s k) :
    IsSubmonoid (⋃ i, s i)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigO_fst_prod : f' =O[l] fun x => (f' x, g' x)
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem swap_swap (a : Array α) {i j : Fin a.size} :
    (a.swap i j).swap ⟨i.1, (a.size_swap ..).symm ▸i.2⟩ ⟨j.1, (a.size_swap ..).symm ▸j.2⟩ = a
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
/-- For functions to `ℝ`, it suffices to prove `f x ≤ f y + K * dist x y`; this version
assumes `0≤K`. -/
protected theorem of_le_add_mul {f : α → ℝ} (K : ℝ≥0)
    (h : ∀ x ∈ s, ∀ y ∈ s, f x ≤ f y + K * dist x y) : LipschitzOnWith K f s
-- Mathlib/Algebra/Group/Hom/Basic.lean
@[to_additive (attr := simp)]
lemma div_comp (f g : N →* G) (h : M →* N) : (f / g).comp h = f.comp h / g.comp h
-- Mathlib/Combinatorics/Quiver/Cast.lean
theorem Path.cast_cons {u v w u' w' : U} (p : Path u v) (e : v ⟶ w) (hu : u = u') (hw : w = w') :
    (p.cons e).cast hu hw = (p.cast hu rfl).cons (e.cast rfl hw)
-- Mathlib/Computability/DFA.lean
@[simp]
theorem accepts_reindex (g : σ ≃ σ') : (reindex g M).accepts = M.accepts
-- Mathlib/Data/Set/Countable.lean
theorem countable_iff_exists_subset_range [Nonempty α] {s : Set α} :
    s.Countable ↔ ∃ f : ℕ → α, s ⊆ range f
-- Mathlib/Data/Finset/Sum.lean
@[simp]
theorem empty_disjSum : (∅ : Finset α).disjSum t = t.map Embedding.inr
-- Mathlib/Topology/NhdsSet.lean
@[simp]
theorem nhdsSet_eq_principal_iff : 𝓝ˢ s = 𝓟 s ↔ IsOpen s
-- Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean
theorem comp (hg : IsConformalMap g) (hf : IsConformalMap f) : IsConformalMap (g.comp f)
-- Mathlib/Algebra/Group/Support.lean
@[to_additive (attr := simp)]
theorem mulSupport_eq_empty_iff {f : α → M} : mulSupport f = ∅ ↔ f = 1
-- Mathlib/Data/Nat/Defs.lean
lemma one_lt_pow (hn : n ≠ 0) (ha : 1 < a) : 1 < a ^ n
-- Mathlib/GroupTheory/Perm/List.lean
theorem formPerm_apply_head (x y : α) (xs : List α) (h : Nodup (x :: y :: xs)) :
    formPerm (x :: y :: xs) x = y
-- Mathlib/Data/Set/Function.lean
lemma _root_.Set.rightInvOn_id (s : Set α) : RightInvOn id id s
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.to_image_id {ι : Type*} {p : ι → Prop} {s : ι → Set α} (h : l.HasBasis p s) :
    l.HasBasis (· ∈ s '' {i | p i}) id
-- Mathlib/Order/Circular.lean
/-- A circular partial order is the analogue of a partial order where you can loop around. `≤` and
`<` are replaced by ternary relations `btw` and `sbtw`. `btw` is reflexive, cyclic and
antisymmetric. `sbtw` is transitive. -/
class CircularPartialOrder (α : Type*) extends CircularPreorder α where
  /-- If `b` is between `a` and `c` and also between `c` and `a`, then at least one pair of points
  among `a`, `b`, `c` are identical. -/
  btw_antisymm {a b c : α} : btw a b c → btw c b a → a = b ∨ b = c ∨ c = a
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Basic.lean
@[simp] theorem natCast_eq_ofNat (w x : Nat) : @Nat.cast (BitVec w) _ x = .ofNat w x
-- Mathlib/RingTheory/PowerSeries/Basic.lean
theorem rescale_zero_apply : rescale 0 X = C R (constantCoeff R X)
-- Mathlib/Data/Seq/Computation.lean
theorem think_empty : empty α = think (empty α)
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
/-- An element of a DVR is irreducible iff it is a uniformizer, that is, generates the
  maximal ideal of `R`. -/
theorem irreducible_iff_uniformizer (ϖ : R) : Irreducible ϖ ↔ maximalIdeal R = Ideal.span {ϖ}
-- Mathlib/Topology/Instances/ENNReal.lean
theorem tendsto_finset_prod_of_ne_top {ι : Type*} {f : ι → α → ℝ≥0∞} {x : Filter α} {a : ι → ℝ≥0∞}
    (s : Finset ι) (h : ∀ i ∈ s, Tendsto (f i) x (𝓝 (a i))) (h' : ∀ i ∈ s, a i ≠ ∞) :
    Tendsto (fun b => ∏ c ∈ s, f c b) x (𝓝 (∏ c ∈ s, a c))
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem isClosedMap_div_left (a : G) : IsClosedMap (a / ·)
-- Mathlib/Data/List/Forall2.lean
theorem left_unique_forall₂' (hr : LeftUnique R) : ∀ {a b c}, Forall₂ R a c → Forall₂ R b c → a = b
-- Mathlib/Topology/Order.lean
@[simp] theorem isClosed_discrete (s : Set α) : IsClosed s
-- Mathlib/MeasureTheory/Constructions/Cylinders.lean
theorem empty_mem_measurableCylinders (α : ι → Type*) [∀ i, MeasurableSpace (α i)] :
    ∅ ∈ measurableCylinders α
-- Mathlib/SetTheory/Cardinal/ENat.lean
lemma ofENat_strictMono : StrictMono ofENat
-- Mathlib/Topology/Defs/Sequences.lean
/-- A topological space is called a *Fréchet-Urysohn space*, if the sequential closure of any set
is equal to its closure. Since one of the inclusions is trivial, we require only the non-trivial one
in the definition. -/
class FrechetUrysohnSpace : Prop where
  closure_subset_seqClosure : ∀ s : Set X, closure s ⊆ seqClosure s
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma SMulPosReflectLT.toSMulPosReflectLE [SMulPosReflectLT α β] : SMulPosReflectLE α β
-- Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean
lemma Algebra.map_intTraceAux [IsIntegrallyClosed A] (x : B) :
    algebraMap A K (Algebra.intTraceAux A K L B x) = Algebra.trace K L (algebraMap B L x)
-- Mathlib/ModelTheory/Semantics.lean
theorem realize_iff_of_model_completeTheory [N ⊨ L.completeTheory M] (φ : L.Sentence) :
    N ⊨ φ ↔ M ⊨ φ
-- Mathlib/Algebra/Polynomial/Smeval.lean
@[simp]
theorem smeval_X :
    (X : R[X]).smeval x = x ^ 1
-- Mathlib/Order/MinMax.lean
@[simp]
theorem min_lt_iff : min a b < c ↔ a < c ∨ b < c
-- Mathlib/Order/RelIso/Basic.lean
protected theorem isPreorder : ∀ (_ : r ↪r s) [IsPreorder β s], IsPreorder α r
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem Finset.coe_einfsep [DecidableEq α] {s : Finset α} :
    (s : Set α).einfsep = s.offDiag.inf (uncurry edist)
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem type_lift_preimage {α : Type u} {β : Type v} (r : α → α → Prop) [IsWellOrder α r]
    (f : β ≃ α) : lift.{u} (type (f ⁻¹'o r)) = lift.{v} (type r)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
@[simp]
theorem Orthonormal.equiv_toLinearEquiv {v : Basis ι 𝕜 E} (hv : Orthonormal 𝕜 v)
    {v' : Basis ι' 𝕜 E'} (hv' : Orthonormal 𝕜 v') (e : ι ≃ ι') :
    (hv.equiv hv' e).toLinearEquiv = v.equiv v' e
-- Mathlib/Algebra/Star/StarRingHom.lean
@[simp]
theorem toRingEquiv_eq_coe (e : A ≃⋆+* B) : e.toRingEquiv = e
-- Mathlib/Data/Nat/Cast/Basic.lean
@[simp] lemma _root_.nsmul_eq_mul (n : ℕ) (a : α) : n • a = n * a
-- Mathlib/Data/Multiset/Basic.lean
theorem le_union_right (s t : Multiset α) : t ≤ s ∪ t
-- Mathlib/GroupTheory/Perm/Support.lean
@[simp]
theorem support_swap {x y : α} (h : x ≠ y) : support (swap x y) = {x, y}
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem isInt_rpow_pos {a b : ℝ} {nb ne : ℕ}
    (pb : IsNat b nb) (pe' : IsInt (a ^ nb) (Int.negOfNat ne)) :
    IsInt (a ^ b) (Int.negOfNat ne)
-- Mathlib/Topology/Order/DenselyOrdered.lean
@[simp, nolint simpNF]
theorem tendsto_comp_coe_Iio_atTop :
    Tendsto (fun x : Iio a => f x) atTop l ↔ Tendsto f (𝓝[<] a) l
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem aleph0_add_aleph0 : ℵ₀ + ℵ₀ = ℵ₀
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem mem_prod {s : Subsemiring R} {t : Subsemiring S} {p : R × S} :
    p ∈ s.prod t ↔ p.1 ∈ s ∧ p.2 ∈ t
-- Mathlib/Data/Nat/Bits.lean
lemma div2_val (n) : div2 n = n / 2
-- Mathlib/CategoryTheory/Simple.lean
theorem epi_from_simple_zero_of_not_iso {X Y : C} [Simple X] {f : X ⟶ Y} [Epi f]
    (w : IsIso f → False) : f = 0
-- Mathlib/Probability/Kernel/Composition.lean
theorem compProdFun_empty (κ : Kernel α β) (η : Kernel (α × β) γ) (a : α) :
    compProdFun κ η a ∅ = 0
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Integrable.hasFiniteIntegral {f : α → β} (hf : Integrable f μ) : HasFiniteIntegral f μ
-- Mathlib/Analysis/LocallyConvex/AbsConvex.lean
theorem coe_convex (s : AbsConvexOpenSets 𝕜 E) : Convex ℝ (s : Set E)
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem untrop_one [Zero R] : untrop (1 : Tropical R) = 0
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
@[simp]
theorem restrict_iSup {ι} (s : Set α) (m : ι → OuterMeasure α) :
    restrict s (⨆ i, m i) = ⨆ i, restrict s (m i)