ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Convex/Slope.lean
/-- If `f : 𝕜 → 𝕜` is convex, then for any three points `x < y < z` the slope of the secant line of
`f` on `[x, y]` is less than the slope of the secant line of `f` on `[y, z]`. -/
theorem ConvexOn.slope_mono_adjacent (hf : ConvexOn 𝕜 s f) {x y z : 𝕜} (hx : x ∈ s) (hz : z ∈ s)
    (hxy : x < y) (hyz : y < z) : (f y - f x) / (y - x) ≤ (f z - f y) / (z - y)
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- If `u` is a uniform structure on `β` and `f : γ → β`, then
`𝒱(α, γ, 𝔖, comap f u) = comap (fun g ↦ f ∘ g) 𝒱(α, γ, 𝔖, u₁)`. -/
protected theorem comap_eq {f : γ → β} :
    𝒱(α, γ, 𝔖, ‹UniformSpace β›.comap f) = 𝒱(α, β, 𝔖, _).comap (f ∘ ·)
-- Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean
lemma hasDerivAt_mul_log {x : ℝ} (hx : x ≠ 0) : HasDerivAt (fun x ↦ x * log x) (log x + 1) x
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem _root_.MeasurableEmbedding.eLpNormEssSup_map_measure {g : β → F}
    (hf : MeasurableEmbedding f) : eLpNormEssSup g (Measure.map f μ) = eLpNormEssSup (g ∘ f) μ
-- Mathlib/CategoryTheory/Sites/DenseSubsite.lean
/--
If the pullback map is obtained via whiskering,
then the result `sheaf_hom (whisker_left G.op α)` is equal to `α`.
-/
theorem sheafHom_eq (α : ℱ ⟶ ℱ'.val) : sheafHom (whiskerLeft G.op α) = α
-- Mathlib/Algebra/Ring/Hom/Defs.lean
theorem mul_def (f g : α →ₙ+* α) : f * g = f.comp g
-- Mathlib/Algebra/BigOperators/Ring/List.lean
lemma list_sum_right (a : R) (l : List R) (h : ∀ b ∈ l, Commute a b) : Commute a l.sum
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Bounded.to_sep {t₁ t₂ o₁ o₂} {x : α}
    (h₁ : Bounded t₁ o₁ (x : WithTop α)) (h₂ : Bounded t₂ (x : WithBot α) o₂) :
    t₁.All fun y => t₂.All fun z : α => y < z
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
@[simp]
theorem ofCoconeEquiv_symm_apply_desc {D : Type u₄} [Category.{v₄} D] {G : K ⥤ D}
    (h : Cocone G ≌ Cocone F) {c : Cocone G} (P : IsColimit c) (s) :
    ((ofCoconeEquiv h).symm P).desc s =
      (h.functor.map (P.descCoconeMorphism (h.inverse.obj s))).hom ≫ (h.counit.app s).hom
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
/-- Measures `ν` on `α` and `μ` on the `Quotient` of `α` mod `G` satisfy
  `QuotientMeasureEqMeasurePreimage` if: for any fundamental domain `t`, and any measurable subset
  `U` of the quotient, `μ U = ν ((π ⁻¹' U) ∩ t)`. -/
class QuotientMeasureEqMeasurePreimage (ν : Measure α := by volume_tac)
    (μ : Measure (Quotient α_mod_G)) : Prop where
  projection_respects_measure' (t : Set α) : IsFundamentalDomain G t ν → μ = (ν.restrict t).map π
-- Mathlib/Combinatorics/Configuration.lean
theorem two_lt_pointCount [Finite P] [Finite L] (l : L) : 2 < pointCount P l
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
lemma hasRightHomology_iff_op (S : ShortComplex C) :
    S.HasRightHomology ↔ S.op.HasLeftHomology
-- Mathlib/NumberTheory/Padics/Hensel.lean
private theorem a_is_soln (ha : F.eval a = 0) :
    F.eval a = 0 ∧
      ‖a - a‖ < ‖F.derivative.eval a‖ ∧
        ‖F.derivative.eval a‖ = ‖F.derivative.eval a‖ ∧
          ∀ z', F.eval z' = 0 → ‖z' - a‖ < ‖F.derivative.eval a‖ → z' = a
-- Mathlib/Data/Set/Function.lean
theorem _root_.Disjoint.image {s t u : Set α} {f : α → β} (h : Disjoint s t) (hf : u.InjOn f)
    (hs : s ⊆ u) (ht : t ⊆ u) : Disjoint (f '' s) (f '' t)
-- Mathlib/Combinatorics/SimpleGraph/Maps.lean
@[simp, norm_cast] lemma coe_ofLE (h : G₁ ≤ G₂) : ⇑(ofLE h) = id
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem prodCongr_symm (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂) :
    (prodCongr e₁ e₂).symm = prodCongr e₁.symm e₂.symm
-- Mathlib/Topology/Support.lean
@[to_additive]
theorem intro' {K : Set α} (hK : IsCompact K) (h'K : IsClosed K)
    (hfK : ∀ x, x ∉ K → f x = 1) : HasCompactMulSupport f
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[simp]
theorem pointwise_smul_le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : AddSubgroup A} :
    a • S ≤ a • T ↔ S ≤ T
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem refl_toAlgHom : ↑(refl : A₁ ≃ₐ[R] A₁) = AlgHom.id R A₁
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
protected theorem eLpNorm'_eq {p : ℝ} (f : α →ₛ F) (μ : Measure α) :
    eLpNorm' f p μ = (∑ y ∈ f.range, (‖y‖₊ : ℝ≥0∞) ^ p * μ (f ⁻¹' {y})) ^ (1 / p)
-- Mathlib/CategoryTheory/Bicategory/Extension.lean
/-- Whiskering a 1-morphism is a functor. -/
@[simps]
def whiskering {x : B} (h : c ⟶ x) : LeftExtension f g ⥤ LeftExtension f (g ≫ h)
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_eq_zero_iff {α : Type u} : #α = 0 ↔ IsEmpty α
-- Mathlib/NumberTheory/Dioph.lean
/-- Extensionality for `Poly α` -/
@[ext]
theorem ext {f g : Poly α} : (∀ x, f x = g x) → f = g
-- Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean
@[simp, nolint simpNF] -- see std4#365 for the simpNF issue
theorem mk_reindex_cast {n m : ℕ} (h : n = m) (x : ⨂[R]^n M) :
    GradedMonoid.mk (A := fun i => (⨂[R]^i) M) m
    (PiTensorProduct.reindex R (fun _ ↦ M) (Equiv.cast <| congr_arg Fin h) x) =
    GradedMonoid.mk n x
-- Mathlib/LinearAlgebra/Prod.lean
theorem range_coprod (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) : range (f.coprod g) = range f ⊔ range g
-- Mathlib/Order/SupClosed.lean
lemma SupClosed.finsetSup'_mem (hs : SupClosed s) (ht : t.Nonempty) :
    (∀ i ∈ t, f i ∈ s) → t.sup' ht f ∈ s
-- Mathlib/Probability/Independence/Conditional.lean
theorem CondIndep.condIndepSet_of_measurableSet {μ : Measure Ω} [IsFiniteMeasure μ]
    (h_indep : CondIndep m' m₁ m₂ hm' μ) {s t : Set Ω} (hs : MeasurableSet[m₁] s)
    (ht : MeasurableSet[m₂] t) :
    CondIndepSet m' hm' s t μ
-- Mathlib/Geometry/Euclidean/Basic.lean
/-- The result of reflecting. -/
theorem reflection_apply (s : AffineSubspace ℝ P) [Nonempty s] [HasOrthogonalProjection s.direction]
    (p : P) : reflection s p = ↑(orthogonalProjection s p) -ᵥ p +ᵥ (orthogonalProjection s p : P)
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem one_apply_eq (i) : (1 : Matrix n n α) i i = 1
-- Mathlib/Algebra/Homology/ShortComplex/ModuleCat.lean
@[simp]
lemma moduleCat_zero_apply (x : S.X₁) : S.g (S.f x) = 0
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem isEquiv_iff_val_eq_one [LinearOrderedCommGroupWithZero Γ₀]
    [LinearOrderedCommGroupWithZero Γ'₀] (v : Valuation K Γ₀) (v' : Valuation K Γ'₀) :
    v.IsEquiv v' ↔ ∀ {x : K}, v x = 1 ↔ v' x = 1
-- Mathlib/Data/PFun.lean
theorem image_def (s : Set α) : f.image s = { y | ∃ x ∈ s, y ∈ f x }
-- Mathlib/RingTheory/Ideal/Operations.lean
protected theorem mul_assoc : I * J * K = I * (J * K)
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
lemma absolutelyContinuous_zero_iff : μ ≪ 0 ↔ μ = 0
-- Mathlib/Topology/Basic.lean
theorem isOpen_biUnion {s : Set α} {f : α → Set X} (h : ∀ i ∈ s, IsOpen (f i)) :
    IsOpen (⋃ i ∈ s, f i)
-- Mathlib/Data/Set/Card.lean
@[simp, norm_cast] theorem encard_coe_eq_coe_finsetCard (s : Finset α) :
    encard (s : Set α) = s.card
-- Mathlib/Analysis/Convex/Deriv.lean
/-- If `f : 𝕜 → 𝕜` is convex on `s`, then for any point `x ∈ s` the slope of the secant line of `f`
through `x` is monotone on `s \ {x}`. -/
lemma ConvexOn.slope_mono (hfc : ConvexOn 𝕜 s f) (hx : x ∈ s) : MonotoneOn (slope f x) (s \ {x})
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem toLp_const_smul {f : α → E} (c : 𝕜) (hf : Memℒp f p μ) :
    (hf.const_smul c).toLp (c • f) = c • hf.toLp f
-- Mathlib/Analysis/Convex/Radon.lean
/-- Corner case for `helly_theorem'`. -/
private lemma helly_theorem_corner {F : ι → Set E} {s : Finset ι}
    (h_card_small : s.card ≤ finrank 𝕜 E + 1)
    (h_inter : ∀ I ⊆ s, I.card ≤ finrank 𝕜 E + 1 → (⋂ i ∈ I, F i).Nonempty) :
    (⋂ i ∈ s, F i).Nonempty
-- Mathlib/SetTheory/Ordinal/FixedPointApproximants.lean
theorem lfpApprox_add_one (h : x ≤ f x) (a : Ordinal) :
    lfpApprox f x (a+1) = f (lfpApprox f x a)
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem disjoint_univ_pi : Disjoint (pi univ t₁) (pi univ t₂) ↔ ∃ i, Disjoint (t₁ i) (t₂ i)
-- Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
lemma growsPolynomially_log : GrowsPolynomially Real.log
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem map_eq_iff {x y : P₁'} : f₁ x = f₁ y ↔ x = y
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem preimage_eq_empty_iff (f : α →ₛ β) (b : β) : f ⁻¹' {b} = ∅ ↔ b ∉ f.range
-- Mathlib/Topology/Algebra/Constructions/DomMulAct.lean
@[to_additive (attr := simp)] theorem coe_mkHomeomorph : ⇑(mkHomeomorph : M ≃ₜ Mᵈᵐᵃ) = mk
-- Mathlib/Probability/Independence/Basic.lean
theorem indep_of_indep_of_le_left (h_indep : Indep m₁ m₂ μ) (h31 : m₃ ≤ m₁) :
    Indep m₃ m₂ μ
-- Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean
/-- The equivalence `A ≅ B` whose functor is `F ⋙ eB.inverse` and
whose inverse is `G : B ≅ A`. -/
@[simps! inverse]
def equivalence : A ≌ B
-- Mathlib/Order/Heyting/Hom.lean
/-- The type of Heyting homomorphisms from `α` to `β`. Bounded lattice homomorphisms that preserve
Heyting implication. -/
structure HeytingHom (α β : Type*) [HeytingAlgebra α] [HeytingAlgebra β] extends
  LatticeHom α β where
  /-- The proposition that a Heyting homomorphism preserves the bottom element. -/
  protected map_bot' : toFun ⊥ = ⊥
  /-- The proposition that a Heyting homomorphism preserves the Heyting implication. -/
  protected map_himp' : ∀ a b, toFun (a ⇨ b) = toFun a ⇨ toFun b
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem prob_le_one [IsProbabilityMeasure μ] : μ s ≤ 1
-- Mathlib/Algebra/Group/Action/Defs.lean
/-- Typeclass for faithful actions. -/
@[to_additive]
class FaithfulSMul (M : Type*) (α : Type*) [SMul M α] : Prop where
  /-- Two elements `m₁` and `m₂` are equal whenever they act in the same way on all points. -/
  eq_of_smul_eq_smul : ∀ {m₁ m₂ : M}, (∀ a : α, m₁ • a = m₂ • a) → m₁ = m₂
-- Mathlib/Data/List/Basic.lean
theorem replicate_add (m n) (a : α) : replicate (m + n) a = replicate m a ++ replicate n a
-- Mathlib/GroupTheory/Perm/Sign.lean
theorem signAux_mul {n : ℕ} (f g : Perm (Fin n)) : signAux (f * g) = signAux f * signAux g
-- Mathlib/GroupTheory/OrderOfElement.lean
/-- If the order of `x` is finite, then `x` is a unit with inverse `x ^ (orderOf x - 1)`. -/
@[simps]
noncomputable
def IsOfFinOrder.unit {M} [Monoid M] {x : M} (hx : IsOfFinOrder x) : Mˣ
-- Mathlib/Order/Interval/Set/OrdConnected.lean
theorem image_Icc (e : α ↪o β) (he : OrdConnected (range e)) (x y : α) :
    e '' Icc x y = Icc (e x) (e y)
-- Mathlib/GroupTheory/QuotientGroup.lean
@[to_additive (attr := simp)]
theorem quotientMapSubgroupOfOfLe_mk {A' A B' B : Subgroup G} [_hAN : (A'.subgroupOf A).Normal]
    [_hBN : (B'.subgroupOf B).Normal] (h' : A' ≤ B') (h : A ≤ B) (x : A) :
    quotientMapSubgroupOfOfLe h' h x = ↑(Subgroup.inclusion h x : B)
-- Mathlib/Analysis/Convex/Side.lean
theorem _root_.Wbtw.wSameSide₂₃ {s : AffineSubspace R P} {x y z : P} (h : Wbtw R x y z)
    (hx : x ∈ s) : s.WSameSide y z
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
@[to_additive (attr := simp)]
theorem mem_inf {p p' : Submonoid M} {x : M} : x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p'
-- Mathlib/Order/SymmDiff.lean
theorem bihimp_comm : a ⇔ b = b ⇔ a
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem mdifferentiableAt_snd {x : M × M'} : MDifferentiableAt (I.prod I') I' Prod.snd x
-- Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean
/-- `χ₈` takes values in `{0, 1, -1}` -/
theorem isQuadratic_χ₈ : χ₈.IsQuadratic
-- Mathlib/RingTheory/Bialgebra/Equiv.lean
/-- The identity map is a bialgebra equivalence. -/
@[refl, simps!]
def refl : A ≃ₐc[R] A
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[mono]
theorem toSubsemiring_strictMono : StrictMono (toSubsemiring : Subring R → Subsemiring R)
-- Mathlib/GroupTheory/Congruence/Basic.lean
@[to_additive (attr := simp)]
theorem rel_eq_coe (c : Con M) : c.r = c
-- Mathlib/Data/Bool/Basic.lean
theorem le_iff_imp : ∀ {x y : Bool}, x ≤ y ↔ x → y
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem coe_toIsometryEquiv : ⇑e.toIsometryEquiv = e
-- Mathlib/AlgebraicTopology/SplitSimplicialObject.lean
/-- The distinguished element in `Splitting.IndexSet Δ` which corresponds to the
identity of `Δ`. -/
@[simps]
def id : IndexSet Δ
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem bsup_not_succ_of_ne_bsup {o : Ordinal.{u}} {f : ∀ a < o, Ordinal.{max u v}}
    (hf : ∀ {i : Ordinal} (h : i < o), f i h ≠ bsup.{_, v} o f) (a) :
    a < bsup.{_, v} o f → succ a < bsup.{_, v} o f
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
@[gcongr]
theorem mul_le_mul_of_nonneg_left [PosMulMono α] (h : b ≤ c) (a0 : 0 ≤ a) : a * b ≤ a * c
-- Mathlib/NumberTheory/WellApproximable.lean
/-- **Dirichlet's approximation theorem**

See also `Real.exists_rat_abs_sub_le_and_den_le`. -/
lemma exists_norm_nsmul_le (ξ : 𝕊) {n : ℕ} (hn : 0 < n) :
    ∃ j ∈ Icc 1 n, ‖j • ξ‖ ≤ T / ↑(n + 1)
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
theorem le_iff_le (x : K) (r : ℝ) : (∀ w : InfinitePlace K, w x ≤ r) ↔ ∀ φ : K →+* ℂ, ‖φ x‖ ≤ r
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
@[simp]
lemma _root_.LinearIsometryEquiv.star_eq_symm (e : H ≃ₗᵢ[𝕜] H) :
    star (e : H →L[𝕜] H) = e.symm
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
theorem eventually_le_limsup (hf : IsBoundedUnder (· ≤ ·) f u := by isBoundedDefault) :
    ∀ᶠ b in f, u b ≤ f.limsup u
-- Mathlib/Topology/Separation.lean
protected theorem R1Space.inf {X : Type*} {t₁ t₂ : TopologicalSpace X}
    (h₁ : @R1Space X t₁) (h₂ : @R1Space X t₂) : @R1Space X (t₁ ⊓ t₂)
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean
@[simp]
lemma isEmpty_iff (X : Type*) :
    IsEmpty (FundamentalGroupoid X) ↔ IsEmpty X
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem Matrix.mulVecLin_submatrix [Fintype n] [Fintype l] (f₁ : m → k) (e₂ : n ≃ l)
    (M : Matrix k l R) :
    (M.submatrix f₁ e₂).mulVecLin = funLeft R R f₁ ∘ₗ M.mulVecLin ∘ₗ funLeft _ _ e₂.symm
-- Mathlib/Data/Countable/Defs.lean
protected theorem Function.Injective.countable [Countable β] {f : α → β} (hf : Injective f) :
    Countable α
-- Mathlib/CategoryTheory/Localization/Triangulated.lean
lemma complete_distinguished_essImageDistTriang_morphism
    (H : ∀ (T₁' T₂' : Triangle C) (_ : T₁' ∈ distTriang C) (_ : T₂' ∈ distTriang C)
      (a : L.obj (T₁'.obj₁) ⟶ L.obj (T₂'.obj₁)) (b : L.obj (T₁'.obj₂) ⟶ L.obj (T₂'.obj₂))
      (_ : L.map T₁'.mor₁ ≫ b = a ≫ L.map T₂'.mor₁),
      ∃ (φ : L.mapTriangle.obj T₁' ⟶ L.mapTriangle.obj T₂'), φ.hom₁ = a ∧ φ.hom₂ = b)
    (T₁ T₂ : Triangle D)
    (hT₁ : T₁ ∈ Functor.essImageDistTriang L) (hT₂ : T₂ ∈ L.essImageDistTriang)
    (a : T₁.obj₁ ⟶ T₂.obj₁) (b : T₁.obj₂ ⟶ T₂.obj₂) (fac : T₁.mor₁ ≫ b = a ≫ T₂.mor₁) :
    ∃ c, T₁.mor₂ ≫ c = b ≫ T₂.mor₂ ∧ T₁.mor₃ ≫ a⟦1⟧' = c ≫ T₂.mor₃
-- Mathlib/Data/ENNReal/Inv.lean
theorem inv_lt_iff_inv_lt : a⁻¹ < b ↔ b⁻¹ < a
-- Mathlib/FieldTheory/PerfectClosure.lean
@[simp]
theorem quot_mk_eq_mk (x : ℕ × K) : (Quot.mk (R K p) x : PerfectClosure K p) = mk K p x
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem exists_finset_le_card (α : Type*) (n : ℕ) (h : n ≤ #α) :
    ∃ s : Finset α, n ≤ s.card
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
@[simp]
theorem Matrix.toLinAlgEquiv_symm :
    (Matrix.toLinAlgEquiv v₁).symm = LinearMap.toMatrixAlgEquiv v₁
-- Mathlib/Data/Set/Card.lean
theorem ncard_diff_singleton_lt_of_mem {a : α} (h : a ∈ s) (hs : s.Finite := by toFinite_tac) :
    (s \ {a}).ncard < s.ncard
-- Mathlib/Data/List/Sublists.lean
theorem pairwise_sublists {R} {l : List α} (H : Pairwise R l) :
    Pairwise (fun l₁ l₂ => Lex R (reverse l₁) (reverse l₂)) (sublists l)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- An oriented angle is unchanged by replacing the first point by one strictly further away on
the same ray. -/
theorem _root_.Sbtw.oangle_eq_left {p₁ p₁' p₂ p₃ : P} (h : Sbtw ℝ p₂ p₁ p₁') :
    ∡ p₁ p₂ p₃ = ∡ p₁' p₂ p₃
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp]
theorem dTo_eq_zero {j : ι} (h : ¬c.Rel (c.prev j) j) : C.dTo j = 0
-- Mathlib/Order/Filter/Basic.lean
theorem image_mem_map (hs : s ∈ f) : m '' s ∈ map m f
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[simp]
theorem differentiableWithinAt_const_add_iff (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => c + f y) s x ↔ DifferentiableWithinAt 𝕜 f s x
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean
@[reassoc (attr := simp)]
lemma pullback_inv_fst_snd_of_right_isIso :
    inv (pullback.fst f g) ≫ pullback.snd f g = f ≫ inv g
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
lemma of_id_fst : IsPushout (𝟙 _) f f (𝟙 _)
-- Mathlib/Analysis/NormedSpace/HahnBanach/Extension.lean
/-- Corollary of the **Hahn-Banach theorem**: if `f : p → F` is a continuous linear map
from a submodule of a normed space `E` over `𝕜`, `𝕜 = ℝ` or `𝕜 = ℂ`,
with a finite dimensional range,
then `f` admits an extension to a continuous linear map `E → F`.

Note that contrary to the case `F = 𝕜`, see `exists_extension_norm_eq`,
we provide no estimates on the norm of the extension.
-/
lemma ContinuousLinearMap.exist_extension_of_finiteDimensional_range {p : Submodule 𝕜 E}
    (f : p →L[𝕜] F) [FiniteDimensional 𝕜 (LinearMap.range f)] :
    ∃ g : E →L[𝕜] F, f = g.comp p.subtypeL
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem eq_zero_of_div_eq_zero {d n : Int} (h : d ∣ n) (H : n.div d = 0) : n = 0
-- Mathlib/Topology/Order/Monotone.lean
/-- If a monotone function sending `top` to `top` is continuous at the indexed infimum over
a `Sort`, then it sends this indexed infimum to the indexed infimum of the composition. -/
theorem Monotone.map_iInf_of_continuousAt {ι : Sort*} {f : α → β} {g : ι → α}
    (Cf : ContinuousAt f (iInf g)) (Mf : Monotone f) (ftop : f ⊤ = ⊤) : f (iInf g) = iInf (f ∘ g)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem id_toContinuousLinearMap : id.toContinuousLinearMap = ContinuousLinearMap.id R E
-- Mathlib/Data/List/InsertNth.lean
theorem getElem_insertNth_of_lt (l : List α) (x : α) (n k : ℕ) (hn : k < n) (hk : k < l.length)
    (hk' : k < (insertNth n x l).length := hk.trans_le (length_le_length_insertNth _ _ _)) :
    (insertNth n x l)[k] = l[k]
-- Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean
theorem setIntegral_comp_smul (f : E → F) {R : ℝ} (s : Set E) (hR : R ≠ 0) :
    ∫ x in s, f (R • x) ∂μ = |(R ^ finrank ℝ E)⁻¹| • ∫ x in R • s, f x ∂μ
-- Mathlib/Topology/Algebra/Nonarchimedean/AdicTopology.lean
theorem adic_basis (I : Ideal R) : SubmodulesRingBasis fun n : ℕ => (I ^ n • ⊤ : Ideal R)
-- Mathlib/Algebra/Tropical/BigOperators.lean
theorem Multiset.trop_inf [LinearOrder R] [OrderTop R] (s : Multiset R) :
    trop s.inf = Multiset.sum (s.map trop)
-- .lake/packages/lean4/src/lean/Init/Control/ExceptCps.lean
@[simp] theorem run_throw [Monad m] : run (throw e : ExceptCpsT ε m β) = pure (Except.error e)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem X_add_C_ne_zero (r : R) : X + C r ≠ 0
-- Mathlib/Data/Complex/Abs.lean
theorem lim_eq_lim_im_add_lim_re (f : CauSeq ℂ Complex.abs) :
    lim f = ↑(lim (cauSeqRe f)) + ↑(lim (cauSeqIm f)) * I
-- Mathlib/Logic/Basic.lean
theorem not_iff_not : (¬a ↔ ¬b) ↔ (a ↔ b)
-- Mathlib/CategoryTheory/Limits/Constructions/FiniteProductsOfBinaryProducts.lean
/--
If `C` has an initial object and binary coproducts, then it has a coproduct for objects indexed by
`Fin n`.
This is a helper lemma for `hasCofiniteProductsOfHasBinaryAndTerminal`, which is more general
than this.
-/
private theorem hasCoproduct_fin : ∀ (n : ℕ) (f : Fin n → C), HasCoproduct f
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem HasFiniteIntegral.max_zero {f : α → ℝ} (hf : HasFiniteIntegral f μ) :
    HasFiniteIntegral (fun a => max (f a) 0) μ
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
lemma vanishingIdeal_isIrreducible :
    vanishingIdeal (R := R) '' {s | IsIrreducible s} = {P | P.IsPrime}
-- Mathlib/Analysis/Convex/Complex.lean
theorem convex_halfspace_re_le (r : ℝ) : Convex ℝ { c : ℂ | c.re ≤ r }
-- Mathlib/AlgebraicTopology/DoldKan/Equivalence.lean
theorem equivalence_inverse : (equivalence : SimplicialObject A ≌ _).inverse = Γ
-- Mathlib/Topology/UniformSpace/Pi.lean
theorem Pi.uniformity :
    𝓤 (∀ i, α i) = ⨅ i : ι, (Filter.comap fun a => (a.1 i, a.2 i)) (𝓤 (α i))
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
@[simp]
theorem zero_rpow_mul_self (y : ℝ) : (0 : ℝ≥0∞) ^ y * (0 : ℝ≥0∞) ^ y = (0 : ℝ≥0∞) ^ y
-- Mathlib/MeasureTheory/Function/LpSeminorm/Trim.lean
theorem limsup_trim (hm : m ≤ m0) {f : α → ℝ≥0∞} (hf : Measurable[m] f) :
    limsup f (ae (μ.trim hm)) = limsup f (ae μ)
-- Mathlib/Data/Rel.lean
theorem preimage_union (s t : Set β) : r.preimage (s ∪ t) = r.preimage s ∪ r.preimage t
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem isBounded_image (f : α →ᵇ β) (s : Set α) : IsBounded (f '' s)
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
@[simp]
theorem zero_snd : (0 : WithLp p (α × β)).snd = 0
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
@[simp]
theorem toOuterMeasure_ofFinset_apply :
    (ofFinset f s h h').toOuterMeasure t = ∑' x, t.indicator f x
-- Mathlib/Algebra/MvPolynomial/Equiv.lean
lemma optionEquivLeft_X_none : optionEquivLeft R S₁ (X none) = Polynomial.X
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem empty_union (s : Finset α) : ∅ ∪ s = s
-- Mathlib/CategoryTheory/Monad/Algebra.lean
@[simp]
theorem id_eq_id (A : Coalgebra G) : Coalgebra.Hom.id A = 𝟙 A
-- Mathlib/CategoryTheory/Yoneda.lean
lemma fullyFaithful_preimage {X Y : Cᵒᵖ} (f : coyoneda.obj X ⟶ coyoneda.obj Y) :
    fullyFaithful.preimage f = (f.app X.unop (𝟙 X.unop)).op
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
lemma IsCircuit.not_nil {p : G.Walk v v} (hp : IsCircuit p) : ¬ p.Nil
-- Mathlib/Algebra/RingQuot.lean
theorem liftAlgHom_unique (f : A →ₐ[S] B) {s : A → A → Prop} (w : ∀ ⦃x y⦄, s x y → f x = f y)
    (g : RingQuot s →ₐ[S] B) (h : g.comp (mkAlgHom S s) = f) : g = liftAlgHom S ⟨f, w⟩
-- Mathlib/GroupTheory/Index.lean
@[to_additive (attr := simp)]
theorem index_bot : (⊥ : Subgroup G).index = Nat.card G
-- Mathlib/Topology/Instances/NNReal.lean
@[norm_cast]
theorem summable_coe {f : α → ℝ≥0} : (Summable fun a => (f a : ℝ)) ↔ Summable f
-- Mathlib/Analysis/Convex/Extreme.lean
theorem IsExtreme.inter (hAB : IsExtreme 𝕜 A B) (hAC : IsExtreme 𝕜 A C) :
    IsExtreme 𝕜 A (B ∩ C)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] protected theorem neg_div : ∀ a b : Int, (-a).div b = -(a.div b)
-- Mathlib/Algebra/Homology/Localization.lean
lemma ComplexShape.quotient_isLocalization :
    (HomotopyCategory.quotient C c).IsLocalization
      (HomologicalComplex.homotopyEquivalences _ _)
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem fst_intCast [AddGroupWithOne R] [AddGroup M] (z : ℤ) : (z : tsze R M).fst = z
-- Mathlib/Algebra/Algebra/Hom.lean
@[deprecated map_zero (since := "2024-06-26")]
protected theorem map_zero : φ 0 = 0
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
/-- Turn a subgraph of a `SimpleGraph` into a member of its subgraph type. -/
@[simps]
def _root_.SimpleGraph.toSubgraph (H : SimpleGraph V) (h : H ≤ G) : G.Subgraph
-- Mathlib/Data/Finset/Sort.lean
@[simp]
theorem sort_eq (s : Finset α) : ↑(sort r s) = s.1
-- Mathlib/Analysis/Convex/Side.lean
theorem sSameSide_smul_vsub_vadd_left {s : AffineSubspace R P} {x p₁ p₂ : P} (hx : x ∉ s)
    (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s) {t : R} (ht : 0 < t) : s.SSameSide (t • (x -ᵥ p₁) +ᵥ p₂) x
-- Mathlib/Algebra/Order/Group/Int.lean
protected theorem sign_eq_ediv_abs (a : ℤ) : sign a = a / |a|
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[reassoc (attr := simp)] lemma ι_g' : h.ι ≫ h.g' = 0
-- Mathlib/RingTheory/Etale/Basic.lean
/-- The localization of a formally étale map is formally étale. -/
theorem localization_map [FormallyEtale R S] : FormallyEtale Rₘ Sₘ
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
@[simp]
theorem prod_apply (f : ContinuousMultilinearMap R M₁ M₂) (g : ContinuousMultilinearMap R M₁ M₃)
    (m : ∀ i, M₁ i) : (f.prod g) m = (f m, g m)
-- Mathlib/NumberTheory/ModularForms/EisensteinSeries/Defs.lean
/-- For level `N = 1`, the gamma sets are all equal. -/
lemma gammaSet_one_eq (a a' : Fin 2 → ZMod 1) : gammaSet 1 a = gammaSet 1 a'
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
@[simp]
theorem deriv_log' : deriv log = Inv.inv
-- Mathlib/Order/RelIso/Basic.lean
protected theorem surjective (e : r ≃r s) : Surjective e