ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem distortion_le_of_mem (h : J ∈ π) : J.distortion ≤ π.distortion
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem symm_dual_id :
    BoundedLatticeHom.dual.symm (BoundedLatticeHom.id _) = BoundedLatticeHom.id α
-- Mathlib/Order/Zorn.lean
theorem zorn_nonempty_partialOrder₀ (s : Set α)
    (ih : ∀ c ⊆ s, IsChain (· ≤ ·) c → ∀ y ∈ c, ∃ ub ∈ s, ∀ z ∈ c, z ≤ ub) (x : α)
    (hxs : x ∈ s) : ∃ m ∈ s, x ≤ m ∧ ∀ z ∈ s, m ≤ z → z = m
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem pairwiseDisjoint_insert_of_not_mem {i : ι} (hi : i ∉ s) :
    (insert i s).PairwiseDisjoint f ↔ s.PairwiseDisjoint f ∧ ∀ j ∈ s, Disjoint (f i) (f j)
-- Mathlib/RingTheory/Localization/Integral.lean
theorem integerNormalization_eval₂_eq_zero (g : S →+* R') (p : S[X]) {x : R'}
    (hx : eval₂ g x p = 0) : eval₂ (g.comp (algebraMap R S)) x (integerNormalization M p) = 0
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem unique {ζ : M} (hk : IsPrimitiveRoot ζ k) (hl : IsPrimitiveRoot ζ l) : k = l
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem mem_sUnion {x y : Class.{u}} : y ∈ ⋃₀ x ↔ ∃ z, z ∈ x ∧ y ∈ z
-- Mathlib/CategoryTheory/Extensive.lean
lemma FinitaryPreExtensive.hasPullbacks_of_is_coproduct [FinitaryPreExtensive C] {ι : Type*}
    [Finite ι] {F : Discrete ι ⥤ C} {c : Cocone F} (hc : IsColimit c) (i : Discrete ι) {X : C}
    (g : X ⟶ _) : HasPullback g (c.ι.app i)
-- Mathlib/Data/Sym/Sym2.lean
theorem fromRel_toRel (s : Set (Sym2 α)) : fromRel (toRel_symmetric s) = s
-- Mathlib/Data/Fin/Basic.lean
theorem leftInverse_cast (eq : n = m) : LeftInverse (cast eq.symm) (cast eq)
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
lemma ArithmeticFunction.const_one_eq_zeta {R : Type*} [Semiring R] {n : ℕ} (hn : n ≠ 0) :
    (1 : ℕ → R) n = (ζ ·) n
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem le_of_eq_of_le {a b c : α} [LE α] (h₁ : a = b) (h₂ : b ≤ c) : a ≤ c
-- Mathlib/LinearAlgebra/Projectivization/Basic.lean
theorem mk_eq_mk_iff (v w : V) (hv : v ≠ 0) (hw : w ≠ 0) :
    mk K v hv = mk K w hw ↔ ∃ a : Kˣ, a • w = v
-- Mathlib/Analysis/Convex/StrictConvexBetween.lean
/-- Given three collinear points, two (not equal) with distance `r` from `p` and one with
distance less than `r` from `p`, the third point is strictly between the other two points. -/
theorem Collinear.sbtw_of_dist_eq_of_dist_lt {p p₁ p₂ p₃ : P} {r : ℝ}
    (h : Collinear ℝ ({p₁, p₂, p₃} : Set P)) (hp₁ : dist p₁ p = r) (hp₂ : dist p₂ p < r)
    (hp₃ : dist p₃ p = r) (hp₁p₃ : p₁ ≠ p₃) : Sbtw ℝ p₁ p₂ p₃
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Kernels.lean
@[simp]
theorem PreservesKernel.iso_hom : (PreservesKernel.iso G f).hom = kernelComparison f G
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem prev_singleton (x y : α) (h : x ∈ [y]) : prev [y] x h = y
-- Mathlib/Data/Multiset/Bind.lean
theorem bind_map (m : Multiset α) (n : β → Multiset γ) (f : α → β) :
    bind (map f m) n = bind m fun a => n (f a)
-- Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean
theorem IsEquivalent.congr_left {u v w : α → β} {l : Filter α} (huv : u ~[l] v) (huw : u =ᶠ[l] w) :
    w ~[l] v
-- Mathlib/Data/Multiset/Powerset.lean
@[simp]
theorem powersetCard_eq_empty {α : Type*} (n : ℕ) {s : Multiset α} (h : card s < n) :
    powersetCard n s = 0
-- Mathlib/Data/ENat/Basic.lean
@[simp, norm_cast] lemma coe_toNatHom : toNatHom = toNat
-- Mathlib/Analysis/Normed/Group/Int.lean
theorem norm_eq_abs (n : ℤ) : ‖n‖ = |(n : ℝ)|
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem nonempty_of_prod_ne_one (h : ∏ x ∈ s, f x ≠ 1) : s.Nonempty
-- .lake/packages/lean4/src/lean/Init/Data/List/BasicAux.lean
theorem le_antisymm [LT α] [s : Antisymm (¬ · < · : α → α → Prop)] {as bs : List α} (h₁ : as ≤ bs) (h₂ : bs ≤ as) : as = bs
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Bitblast.lean
@[simp] theorem atLeastTwo_false_mid   : atLeastTwo a false c = (a && c)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem degree_le_natDegree : degree p ≤ natDegree p
-- Mathlib/LinearAlgebra/Orientation.lean
/-- The value of `Orientation.map` when the index type has the cardinality of a basis, in terms
of `f.det`. -/
theorem map_orientation_eq_det_inv_smul [Finite ι] (e : Basis ι R M) (x : Orientation R M ι)
    (f : M ≃ₗ[R] M) : Orientation.map ι f x = (LinearEquiv.det f)⁻¹ • x
-- Mathlib/Computability/Language.lean
@[simp]
lemma reverse_pow (l : Language α) (n : ℕ) : (l ^ n).reverse = l.reverse ^ n
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem natDegree_derivative_lt {p : R[X]} (hp : p.natDegree ≠ 0) :
    p.derivative.natDegree < p.natDegree
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive]
theorem isometry_smul {M : Type u} (X : Type w) [PseudoEMetricSpace X] [SMul M X]
    [IsometricSMul M X] (c : M) : Isometry (c • · : X → X)
-- Mathlib/Algebra/Field/Defs.lean
lemma cast_mk' (a b h1 h2) : ((⟨a, b, h1, h2⟩ : ℚ) : K) = a / b
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem eval₂_monomial : (monomial s a).eval₂ f g = f a * s.prod fun n e => g n ^ e
-- Mathlib/Data/List/Basic.lean
theorem length_dropSlice_lt (i j : ℕ) (hj : 0 < j) (xs : List α) (hi : i < xs.length) :
    (List.dropSlice i j xs).length < xs.length
-- Mathlib/Topology/Separation.lean
theorem closedEmbedding_update {ι : Type*} {β : ι → Type*}
    [DecidableEq ι] [(i : ι) → TopologicalSpace (β i)]
    (x : (i : ι) → β i) (i : ι) [(i : ι) → T1Space (β i)] :
    ClosedEmbedding (update x i)
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem coe_id : ⇑(LatticeHom.id α) = id
-- Mathlib/Data/Multiset/Sections.lean
theorem coe_sections :
    ∀ l : List (List α),
      Sections (l.map fun l : List α => (l : Multiset α) : Multiset (Multiset α)) =
        (l.sections.map fun l : List α => (l : Multiset α) : Multiset (Multiset α))
-- Mathlib/Analysis/Normed/Group/AddCircle.lean
theorem norm_eq {x : ℝ} : ‖(x : AddCircle p)‖ = |x - round (p⁻¹ * x) * p|
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem map_eq_bot_iff [LE α] [OrderBot α] [PartialOrder β] [OrderBot β] [OrderIsoClass F α β]
    (f : F) {a : α} : f a = ⊥ ↔ a = ⊥
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[simp] lemma nnnorm_eq_self (x : ℝ≥0) : ‖x‖₊ = x
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem mem_sep {p : ZFSet.{u} → Prop} {x y : ZFSet.{u}} :
    y ∈ ZFSet.sep p x ↔ y ∈ x ∧ p y
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
@[simp]
theorem cliqueFreeOn_univ : G.CliqueFreeOn Set.univ n ↔ G.CliqueFree n
-- Mathlib/Order/Filter/Cofinite.lean
@[simp]
lemma cofinite_inf_principal_neBot_iff {s : Set α} : (cofinite ⊓ 𝓟 s).NeBot ↔ s.Infinite
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
@[simp]
theorem LinearMap.toMatrix₂Aux_apply (f : M₁ →ₛₗ[σ₁] M₂ →ₛₗ[σ₂] N₂) (b₁ : n → M₁) (b₂ : m → M₂)
    (i : n) (j : m) : LinearMap.toMatrix₂Aux R b₁ b₂ f i j = f (b₁ i) (b₂ j)
-- Mathlib/Algebra/Algebra/Hom.lean
@[simp]
theorem toLinearMap_id : toLinearMap (AlgHom.id R A) = LinearMap.id
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
@[simp] theorem countP_append (l₁ l₂) : countP p (l₁ ++ l₂) = countP p l₁ + countP p l₂
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_iUnion_le_sum_mk_lift {α : Type u} {ι : Type v} {f : ι → Set α} :
    lift.{v} #(⋃ i, f i) ≤ sum fun i => #(f i)
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem restrOpen_toPartialEquiv (s : Set X) (hs : IsOpen s) :
    (e.restrOpen s hs).toPartialEquiv = e.toPartialEquiv.restr s
-- Mathlib/Analysis/Convex/Deriv.lean
/-- If a function `f` is continuous on a convex set `D ⊆ ℝ`, is differentiable on its interior,
and `f'` is monotone on the interior, then `f` is convex on `D`. -/
theorem MonotoneOn.convexOn_of_deriv {D : Set ℝ} (hD : Convex ℝ D) {f : ℝ → ℝ}
    (hf : ContinuousOn f D) (hf' : DifferentiableOn ℝ f (interior D))
    (hf'_mono : MonotoneOn (deriv f) (interior D)) : ConvexOn ℝ D f
-- Mathlib/Algebra/Lie/Derivation/AdjointAction.lean
/-- The adjoint action of a Lie algebra `L` on itself, seen as a morphism of Lie algebras from
`L` to its derivations.
Note the minus sign: this is chosen to so that `ad ⁅x, y⁆ = ⁅ad x, ad y⁆`. -/
@[simps!]
def ad : L →ₗ⁅R⁆ LieDerivation R L L
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem vecMul_intCast (x : ℤ) (v : m → α) : v ᵥ* x = MulOpposite.op (x : α) • v
-- Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean
/-- A version of `linearIndependent_le_span` for `Finset`. -/
theorem linearIndependent_le_span_finset {ι : Type*} (v : ι → M) (i : LinearIndependent R v)
    (w : Finset M) (s : span R (w : Set M) = ⊤) : #ι ≤ w.card
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Twice the angle between two multiples of a vector is 0. -/
@[simp]
theorem two_zsmul_oangle_smul_smul_self (x : V) {r₁ r₂ : ℝ} :
    (2 : ℤ) • o.oangle (r₁ • x) (r₂ • x) = 0
-- Mathlib/MeasureTheory/Measure/Regular.lean
theorem mono {p' q' : Set α → Prop} (H : InnerRegularWRT μ p q)
    (h : ∀ s, q' s → q s) (h' : ∀ s, p s → p' s) : InnerRegularWRT μ p' q'
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
theorem cos_eq_neg_one_iff {x : ℂ} : cos x = -1 ↔ ∃ k : ℤ, π + k * (2 * π) = x
-- Mathlib/Logic/Function/Iterate.lean
@[simp]
theorem iterate_zero : f^[0] = id
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem UniqueFactorizationMonoid.iff_exists_prime_factors [CancelCommMonoidWithZero α] :
    UniqueFactorizationMonoid α ↔
      ∀ a : α, a ≠ 0 → ∃ f : Multiset α, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
-- Mathlib/Order/Basic.lean
theorem le_iff_eq_or_lt [PartialOrder α] {a b : α} : a ≤ b ↔ a = b ∨ a < b
-- Mathlib/Topology/Basic.lean
theorem isClosed_biInter {s : Set α} {f : α → Set X} (h : ∀ i ∈ s, IsClosed (f i)) :
    IsClosed (⋂ i ∈ s, f i)
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
/-- One form of **Cramer's rule**. See `Matrix.mulVec_cramer` for a stronger form. -/
@[simp]
theorem det_smul_inv_vecMul_eq_cramer_transpose (A : Matrix n n α) (b : n → α) (h : IsUnit A.det) :
    A.det • b ᵥ* A⁻¹ = cramer Aᵀ b
-- Mathlib/LinearAlgebra/Span.lean
/-- A version of `Submodule.map_span_le` that does not require the `RingHomSurjective`
assumption. -/
theorem image_span_subset (f : F) (s : Set M) (N : Submodule R₂ M₂) :
    f '' span R s ⊆ N ↔ ∀ m ∈ s, f m ∈ N
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
theorem ofReal_eq_ofReal_iff {p q : ℝ} (hp : 0 ≤ p) (hq : 0 ≤ q) :
    ENNReal.ofReal p = ENNReal.ofReal q ↔ p = q
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem IntegrableOn.union (hs : IntegrableOn f s μ) (ht : IntegrableOn f t μ) :
    IntegrableOn f (s ∪ t) μ
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem star_mem_resolventSet_iff {r : R} {a : A} :
    star r ∈ resolventSet R a ↔ r ∈ resolventSet R (star a)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem top_toSubsemiring : (⊤ : Subalgebra R A).toSubsemiring = ⊤
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
theorem nat_sub (h : LiouvilleWith p x) (n : ℕ) : LiouvilleWith p (n - x)
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
theorem aeval_X_left_apply (p : R[X]) : aeval X p = p
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem pow_le_pow_of_le_left {n m : Nat} (h : n ≤ m) : ∀ (i : Nat), n^i ≤ m^i
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem ofSet_symm (s : Set α) : (PartialEquiv.ofSet s).symm = PartialEquiv.ofSet s
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- The points of a face of a simplex are given by `mono_of_fin`. -/
theorem face_points {n : ℕ} (s : Simplex k P n) {fs : Finset (Fin (n + 1))} {m : ℕ}
    (h : fs.card = m + 1) (i : Fin (m + 1)) :
    (s.face h).points i = s.points (fs.orderEmbOfFin h i)
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem map_add_of_distinct_val (h : v x ≠ v y) : v (x + y) = max (v x) (v y)
-- Mathlib/Data/Int/Defs.lean
protected lemma le_add_iff_sub_le : a ≤ b + c ↔ a - c ≤ b
-- Mathlib/Data/Matroid/Basic.lean
@[aesop unsafe 10% (rule_sets := [Matroid])]
theorem Base.subset_ground (hB : M.Base B) : B ⊆ M.E
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive (attr := simp) sub_pos]
theorem one_lt_div' : 1 < a / b ↔ b < a
-- Mathlib/Order/Filter/Cofinite.lean
theorem le_cofinite_iff_compl_singleton_mem : l ≤ cofinite ↔ ∀ x, {x}ᶜ ∈ l
-- Mathlib/Topology/Connected/PathConnected.lean
@[continuity]
theorem truncate_const_continuous_family {a b : X} (γ : Path a b)
    (t : ℝ) : Continuous ↿(γ.truncate t)
-- Mathlib/Geometry/Euclidean/PerpBisector.lean
@[simp] theorem perpBisector_ne_bot : perpBisector p₁ p₂ ≠ ⊥
-- Mathlib/Algebra/Algebra/Unitization.lean
@[simp]
theorem snd_mul [Mul R] [Add A] [Mul A] [SMul R A] (x₁ x₂ : Unitization R A) :
    (x₁ * x₂).snd = x₁.fst • x₂.snd + x₂.fst • x₁.snd + x₁.snd * x₂.snd
-- Mathlib/Algebra/GCDMonoid/Nat.lean
theorem abs_eq_normalize (z : ℤ) : |z| = normalize z
-- Mathlib/Data/List/Basic.lean
theorem length_eq_two {l : List α} : l.length = 2 ↔ ∃ a b, l = [a, b]
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
theorem _root_.lipschitzWith_min : LipschitzWith 1 fun p : ℝ × ℝ => min p.1 p.2
-- Mathlib/Logic/Basic.lean
/-- A two-argument function applied to two `ite`s is a `ite` of that two-argument function
applied to each of the branches. -/
theorem apply_ite₂ {α β γ : Sort*} (f : α → β → γ) (P : Prop) [Decidable P] (a b : α) (c d : β) :
    f (ite P a b) (ite P c d) = ite P (f a c) (f b d)
-- Mathlib/Algebra/GroupWithZero/Conj.lean
@[simp] lemma isConj_iff₀ : IsConj a b ↔ ∃ c : α, c ≠ 0 ∧ c * a * c⁻¹ = b
-- Mathlib/Data/ENNReal/Real.lean
theorem ofReal_sub (p : ℝ) {q : ℝ} (hq : 0 ≤ q) :
    ENNReal.ofReal (p - q) = ENNReal.ofReal p - ENNReal.ofReal q
-- Mathlib/Analysis/Convex/Function.lean
theorem ConvexOn.comp_concaveOn (hg : ConvexOn 𝕜 (f '' s) g) (hf : ConcaveOn 𝕜 s f)
    (hg' : AntitoneOn g (f '' s)) : ConvexOn 𝕜 s (g ∘ f)
-- Mathlib/Topology/ContinuousFunction/ContinuousMapZero.lean
@[simp] lemma coe_sum {ι : Type*} (s : Finset ι)
    (f : ι → C(X, R)₀) : ⇑(s.sum f) = s.sum (fun i => ⇑(f i))
-- Mathlib/Data/Finsupp/Defs.lean
theorem support_single_ne_zero (a : α) (hb : b ≠ 0) : (single a b).support = {a}
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- If `𝔖 : Set (Set α)` is nonempty and directed and `𝓑` is a filter basis of `𝓤 β`, then the
uniformity of `α →ᵤ[𝔖] β` admits the family `{(f, g) | ∀ x ∈ S, (f x, g x) ∈ V}` for `S ∈ 𝔖` and
`V ∈ 𝓑` as a filter basis. -/
protected theorem hasBasis_uniformity_of_basis (h : 𝔖.Nonempty) (h' : DirectedOn (· ⊆ ·) 𝔖)
    {p : ι → Prop} {s : ι → Set (β × β)} (hb : HasBasis (𝓤 β) p s) :
    (𝓤 (α →ᵤ[𝔖] β)).HasBasis (fun Si : Set α × ι => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si =>
      UniformOnFun.gen 𝔖 Si.1 (s Si.2)
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
/-- In any preadditive category, any binary biproduct satsifies
`biprod.fst ≫ biprod.inl + biprod.snd ≫ biprod.inr = 𝟙 (X ⊞ Y)`.
-/
@[simp]
theorem biprod.total : biprod.fst ≫ biprod.inl + biprod.snd ≫ biprod.inr = 𝟙 (X ⊞ Y)
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
theorem convexBodySum_volume_eq_zero_of_le_zero {B} (hB : B ≤ 0) :
    volume (convexBodySum K B) = 0
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem take_prefix (n) (l : List α) : take n l <+: l
-- Mathlib/Control/Fold.lean
@[simp]
theorem foldlm.ofFreeMonoid_comp_of {m} [Monad m] [LawfulMonad m] (f : α → β → m α) :
    foldlM.ofFreeMonoid f ∘ FreeMonoid.of = foldlM.mk ∘ flip f
-- Mathlib/Data/Set/Image.lean
@[simp]
theorem range_const : ∀ [Nonempty ι] {c : α}, (range fun _ : ι => c) = {c}
-- Mathlib/Topology/Order/IntermediateValue.lean
/-- A "continuous induction principle" for a closed interval: if a set `s` meets `[a, b]`
on a closed subset, contains `a`, and the set `s ∩ [a, b)` has no maximal point, then `b ∈ s`. -/
theorem IsClosed.mem_of_ge_of_forall_exists_gt {a b : α} {s : Set α} (hs : IsClosed (s ∩ Icc a b))
    (ha : a ∈ s) (hab : a ≤ b) (hgt : ∀ x ∈ s ∩ Ico a b, (s ∩ Ioc x b).Nonempty) : b ∈ s
-- Mathlib/Data/Finset/Card.lean
theorem card_image_iff [DecidableEq β] : (s.image f).card = s.card ↔ Set.InjOn f s
-- Mathlib/CategoryTheory/NatTrans.lean
/-- `NatTrans F G` represents a natural transformation between functors `F` and `G`.

The field `app` provides the components of the natural transformation.

Naturality is expressed by `α.naturality`.
-/
@[ext]
structure NatTrans (F G : C ⥤ D) : Type max u₁ v₂ where
  /-- The component of a natural transformation. -/
  app : ∀ X : C, F.obj X ⟶ G.obj X
  /-- The naturality square for a given morphism. -/
  naturality : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), F.map f ≫ app Y = app X ≫ G.map f := by aesop_cat
-- Mathlib/CategoryTheory/Adjunction/FullyFaithful.lean
lemma mem_essImage_of_counit_isIso (A : D)
    [IsIso (h.counit.app A)] : A ∈ L.essImage
-- Mathlib/Algebra/Homology/HomotopyCategory/Shift.lean
lemma shiftFunctorZero_eq :
    CategoryTheory.shiftFunctorZero (CochainComplex C ℤ) ℤ = shiftFunctorZero' C 0 rfl
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma div_eq_of_eq_mul (hb : b ≠ 0) : a = c * b → a / b = c
-- Mathlib/Data/Rat/Lemmas.lean
theorem den_div_natCast_eq_one_iff (m n : ℕ) (hn : n ≠ 0) : ((m : ℚ) / n).den = 1 ↔ n ∣ m
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
theorem cos_arcsin_nonneg (x : ℝ) : 0 ≤ cos (arcsin x)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem ContDiff.sin {n} (h : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.sin (f x)
-- Mathlib/Analysis/BoundedVariation.lean
theorem Icc_add_Icc (f : α → E) {s : Set α} {a b c : α} (hab : a ≤ b) (hbc : b ≤ c) (hb : b ∈ s) :
    eVariationOn f (s ∩ Icc a b) + eVariationOn f (s ∩ Icc b c) = eVariationOn f (s ∩ Icc a c)
-- Mathlib/Analysis/InnerProductSpace/Orientation.lean
theorem volumeForm_robust' (b : OrthonormalBasis (Fin n) ℝ E) (v : Fin n → E) :
    |o.volumeForm v| = |b.toBasis.det v|
-- Mathlib/Algebra/Order/Floor.lean
theorem le_floor_add (a b : α) : ⌊a⌋ + ⌊b⌋ ≤ ⌊a + b⌋
-- Mathlib/Algebra/DirectSum/Ring.lean
@[simp]
theorem of_zero_mul (a b : A 0) : of _ 0 (a * b) = of _ 0 a * of _ 0 b
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
/-- The composition of `C^∞` functions is `C^∞`. -/
nonrec theorem Smooth.comp {g : M' → M''} (hg : Smooth I' I'' g) (hf : Smooth I I' f) :
    Smooth I I'' (g ∘ f)
-- Mathlib/Algebra/CharP/Defs.lean
lemma RingHom.charP_iff_charP {K L : Type*} [DivisionRing K] [Semiring L] [Nontrivial L]
    (f : K →+* L) (p : ℕ) : CharP K p ↔ CharP L p
-- Mathlib/Order/KrullDimension.lean
lemma krullDim_nonneg_of_nonempty [Nonempty α] : 0 ≤ krullDim α
-- Mathlib/Topology/Semicontinuous.lean
theorem continuous_iff_lower_upperSemicontinuous {f : α → γ} :
    Continuous f ↔ LowerSemicontinuous f ∧ UpperSemicontinuous f
-- Mathlib/Algebra/Algebra/Operations.lean
@[simp]
theorem one_le_one_div {I : Submodule R A} : 1 ≤ 1 / I ↔ I ≤ 1
-- Mathlib/Topology/ContinuousFunction/CocompactMap.lean
@[simp]
theorem coe_toContinuousMap {f : CocompactMap α β} : (f.toContinuousMap : α → β) = f
-- Mathlib/SetTheory/Ordinal/Exponential.lean
theorem log_of_left_le_one {b : Ordinal} (h : b ≤ 1) : ∀ x, log b x = 0
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
theorem A_mono (L : F) (r : ℝ) {ε δ : ℝ} (h : ε ≤ δ) : A f L r ε ⊆ A f L r δ
-- Mathlib/LinearAlgebra/Dual.lean
theorem map_le_dualAnnihilator_dualAnnihilator (W : Subspace K V) :
    W.map (Module.Dual.eval K V) ≤ W.dualAnnihilator.dualAnnihilator
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
/--
Equality is transitive: if `a = b` and `b = c` then `a = c`.

Because this is in the `Eq` namespace, if you have variables or expressions
`h₁ : a = b` and `h₂ : b = c`, you can use `h₁.trans h₂ : a = c` as shorthand
for `Eq.trans h₁ h₂`.

For more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality)
-/
theorem Eq.trans {α : Sort u} {a b c : α} (h₁ : Eq a b) (h₂ : Eq b c) : Eq a c
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
theorem id_tensor_π_preserves_coequalizer_inv_colimMap_desc {X Y Z X' Y' Z' : C} (f g : X ⟶ Y)
    (f' g' : X' ⟶ Y') (p : Z ⊗ X ⟶ X') (q : Z ⊗ Y ⟶ Y') (wf : (Z ◁ f) ≫ q = p ≫ f')
    (wg : (Z ◁ g) ≫ q = p ≫ g') (h : Y' ⟶ Z') (wh : f' ≫ h = g' ≫ h) :
    (Z ◁ coequalizer.π f g) ≫
        (PreservesCoequalizer.iso (tensorLeft Z) f g).inv ≫
          colimMap (parallelPairHom (Z ◁ f) (Z ◁ g) f' g' p q wf wg) ≫ coequalizer.desc h wh =
      q ≫ h
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
theorem coe_multilinearMap_mk (f : (ι → M) → N) (h₁ h₂ h₃) :
    ((⟨⟨f, h₁, h₂⟩, h₃⟩ : M [⋀^ι]→ₗ[R] N) : MultilinearMap R (fun _ : ι => M) N) =
      ⟨f, @h₁, @h₂⟩
-- Mathlib/NumberTheory/NumberField/Discriminant.lean
theorem exists_ne_zero_mem_ringOfIntegers_of_norm_le_mul_sqrt_discr :
    ∃ (a : 𝓞 K), a ≠ 0 ∧
      |Algebra.norm ℚ (a : K)| ≤ (4 / π) ^ NrComplexPlaces K *
        (finrank ℚ K).factorial / (finrank ℚ K) ^ (finrank ℚ K) * Real.sqrt |discr K|
-- Mathlib/Combinatorics/SetFamily/Intersecting.lean
protected theorem Intersecting.insert (hs : s.Intersecting) (ha : a ≠ ⊥)
    (h : ∀ b ∈ s, ¬Disjoint a b) : (insert a s).Intersecting
-- Mathlib/Analysis/MeanInequalitiesPow.lean
/-- Weighted generalized mean inequality, version for two elements of `ℝ≥0∞` and real
exponents. -/
theorem rpow_arith_mean_le_arith_mean2_rpow (w₁ w₂ z₁ z₂ : ℝ≥0∞) (hw' : w₁ + w₂ = 1) {p : ℝ}
    (hp : 1 ≤ p) : (w₁ * z₁ + w₂ * z₂) ^ p ≤ w₁ * z₁ ^ p + w₂ * z₂ ^ p
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive (attr := simp)]
theorem le_mul_inv_iff_mul_le : c ≤ a * b⁻¹ ↔ c * b ≤ a
-- Mathlib/Order/Interval/Finset/Defs.lean
@[simp]
lemma toFinset_Ici (a : α) [Fintype (Ici a)] : (Ici a).toFinset = Finset.Ici a
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Completeness.lean
/-- Construct a bundled continuous (semi)linear map from a map `f : E → F` and a proof of the fact
that it belongs to the closure of the image of a bounded set `s : Set (E →SL[σ₁₂] F)` under coercion
to function. Coercion to function of the result is definitionally equal to `f`. -/
@[simps! (config := .asFn) apply]
def ofMemClosureImageCoeBounded (f : E' → F) {s : Set (E' →SL[σ₁₂] F)} (hs : IsBounded s)
    (hf : f ∈ closure (((↑) : (E' →SL[σ₁₂] F) → E' → F) '' s)) : E' →SL[σ₁₂] F
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem hasSum_geometric_of_abs_lt_one {r : ℝ} (h : |r| < 1) :
    HasSum (fun n : ℕ ↦ r ^ n) (1 - r)⁻¹
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem denom_mul_dvd (x y : RatFunc K) : denom (x * y) ∣ denom x * denom y
-- Mathlib/Data/Finset/Basic.lean
theorem self_mem_range_succ (n : ℕ) : n ∈ range (n + 1)
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem isPell_pellZd : ∀ n : ℕ, IsPell (pellZd a1 n)
-- Mathlib/Topology/Instances/ENNReal.lean
@[simp]
theorem EMetric.diam_closure (s : Set α) : diam (closure s) = diam s
-- Mathlib/CategoryTheory/Limits/Shapes/KernelPair.lean
/-- If `(a,b)` is a kernel pair for `f₁ ≫ f₂` and `f₂` is mono, then `(a,b)` is a kernel pair for
just `f₁`.
The converse of `comp_of_mono`.
-/
theorem cancel_right_of_mono {f₁ : X ⟶ Y} {f₂ : Y ⟶ Z} [Mono f₂]
    (big_k : IsKernelPair (f₁ ≫ f₂) a b) : IsKernelPair f₁ a b
-- Mathlib/Topology/VectorBundle/Basic.lean
@[simp]
theorem linearEquivAt_symm_apply (e : Trivialization F (π F E)) [e.IsLinear R] (b : B)
    (hb : b ∈ e.baseSet) (v : F) : (e.linearEquivAt R b hb).symm v = e.symm b v
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
theorem chromaticNumber_le_of_forall_imp {V' : Type*} {G' : SimpleGraph V'}
    (h : ∀ n, G'.Colorable n → G.Colorable n) :
    G.chromaticNumber ≤ G'.chromaticNumber
-- Mathlib/Order/Interval/Set/Disjoint.lean
theorem iUnion_Iic_eq_Iic_iSup {R : Type*} [CompleteLinearOrder R] {f : ι → R}
    (has_greatest_elem : (⨆ i, f i) ∈ range f) : ⋃ i : ι, Iic (f i) = Iic (⨆ i, f i)
-- Mathlib/Data/Finset/Functor.lean
@[simp]
theorem pure_def {α} : (pure : α → Finset α) = singleton
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
@[simp]
theorem val_smul (n : α) : ∀ y : HomogeneousLocalization 𝒜 x, (n • y).val = n • y.val
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem deriv_rpow_const {x p : ℝ} (h : x ≠ 0 ∨ 1 ≤ p) :
    deriv (fun x : ℝ => x ^ p) x = p * x ^ (p - 1)
-- Mathlib/Analysis/Normed/Field/Basic.lean
protected theorem List.norm_prod (l : List α) : ‖l.prod‖ = (l.map norm).prod