ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean
@[reassoc]
lemma mapHomologyIso'_hom_naturality [S₁.HasHomology] [S₂.HasHomology]
    [(S₁.map F).HasHomology] [(S₂.map F).HasHomology]
    [F.PreservesRightHomologyOf S₁] [F.PreservesRightHomologyOf S₂] :
    @homologyMap _ _ _ (S₁.map F) (S₂.map F) (F.mapShortComplex.map φ) _ _ ≫
      (S₂.mapHomologyIso' F).hom = (S₁.mapHomologyIso' F).hom ≫ F.map (homologyMap φ)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem div_nonneg_iff_of_pos {a b : Int} (h : 0 < b) : a / b ≥ 0 ↔ a ≥ 0
-- Mathlib/Topology/Sets/Compacts.lean
theorem map_comp (f : β → γ) (g : α → β) (hf : Continuous f) (hg : Continuous g) (hf' : IsOpenMap f)
    (hg' : IsOpenMap g) (K : PositiveCompacts α) :
    K.map (f ∘ g) (hf.comp hg) (hf'.comp hg') = (K.map g hg hg').map f hf hf'
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem inr_mul_inr [Semiring R] [AddCommMonoid M] [Module R M] [Module Rᵐᵒᵖ M] (m₁ m₂ : M) :
    (inr m₁ * inr m₂ : tsze R M) = 0
-- Mathlib/LinearAlgebra/Span.lean
@[simp]
theorem span_nat_eq (s : AddSubmonoid M) : (span ℕ (s : Set M)).toAddSubmonoid = s
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem toFinset_inj {s t : Set α} [Fintype s] [Fintype t] : s.toFinset = t.toFinset ↔ s = t
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ico_bot : Ico ⊥ a = Iio a
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
protected theorem hasMFDerivWithinAt : HasMFDerivWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') f s x f
-- Mathlib/Order/LiminfLimsup.lean
theorem liminf_le_liminf {α : Type*} [ConditionallyCompleteLattice β] {f : Filter α} {u v : α → β}
    (h : ∀ᶠ a in f, u a ≤ v a)
    (hu : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault)
    (hv : f.IsCoboundedUnder (· ≥ ·) v := by isBoundedDefault) :
    liminf u f ≤ liminf v f
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem lift'_smul (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x))
    (r : R) (m) : r • LocalizedModule.lift' S g h m = LocalizedModule.lift' S g h (r • m)
-- Mathlib/LinearAlgebra/Eigenspace/Triangularizable.lean
/-- In finite dimensions, over an algebraically closed field, the generalized eigenspaces of any
linear endomorphism span the whole space. -/
theorem iSup_genEigenspace_eq_top [IsAlgClosed K] [FiniteDimensional K V] (f : End K V) :
    ⨆ (μ : K) (k : ℕ), f.genEigenspace μ k = ⊤
-- Mathlib/Algebra/Order/Sub/Defs.lean
@[simp]
theorem tsub_le_iff_right [LE α] [Add α] [Sub α] [OrderedSub α] {a b c : α} :
    a - b ≤ c ↔ a ≤ c + b
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem isWide_iff_objs_eq_univ : S.IsWide ↔ S.objs = Set.univ
-- Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean
/-- In a finite-dimensional space, linear maps are inverse to each other on one side if and only if
they are inverse to each other on the other side. -/
theorem mul_eq_one_comm [FiniteDimensional K V] {f g : V →ₗ[K] V} : f * g = 1 ↔ g * f = 1
-- Mathlib/RingTheory/Noetherian.lean
/-- A ring is Noetherian if and only if all its ideals are finitely-generated. -/
theorem isNoetherianRing_iff_ideal_fg (R : Type*) [Semiring R] :
    IsNoetherianRing R ↔ ∀ I : Ideal R, I.FG
-- Mathlib/Algebra/Homology/Single.lean
/-- Morphisms to a single object cochain complex with `X` concentrated in degree 0
to an `ℕ`-indexed cochain complex `C` are the same as morphisms `f : C.X 0 ⟶ X`.
-/
@[simps apply]
noncomputable def toSingle₀Equiv (C : CochainComplex V ℕ) (X : V) :
    (C ⟶ (single₀ V).obj X) ≃ (C.X 0 ⟶ X)
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem imI_star : (star a).imI = -a.imI
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem le_liftLinear_apply {f : OuterMeasure α →ₗ[ℝ≥0∞] OuterMeasure β} (hf) (s : Set β) :
    f μ.toOuterMeasure s ≤ liftLinear f hf μ s
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
theorem div_add_mod (m n : Nat) : n * (m / n) + m % n = m
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem extract_empty (start stop : Nat) : (#[] : Array α).extract start stop = #[]
-- Mathlib/MeasureTheory/Integral/TorusIntegral.lean
theorem torusIntegral_add (hf : TorusIntegrable f c R) (hg : TorusIntegrable g c R) :
    (∯ x in T(c, R), f x + g x) = (∯ x in T(c, R), f x) + ∯ x in T(c, R), g x
-- Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean
theorem span_gramSchmidt_Iic (f : ι → E) (c : ι) :
    span 𝕜 (gramSchmidt 𝕜 f '' Set.Iic c) = span 𝕜 (f '' Set.Iic c)
-- Mathlib/RingTheory/WittVector/Defs.lean
@[simp]
theorem wittSub_zero : wittSub p 0 = X (0, 0) - X (1, 0)
-- Mathlib/Data/TwoPointing.lean
theorem swap_fst : p.swap.fst = p.snd
-- Mathlib/Analysis/LocallyConvex/AbsConvex.lean
theorem coe_balanced (s : AbsConvexOpenSets 𝕜 E) : Balanced 𝕜 (s : Set E)
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
@[simp]
theorem self_comp_symm (e : α ≃ᵐ β) : e ∘ e.symm = id
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
theorem ofAdd_symm_eq : (@ofAdd α).symm = toAdd
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma isZero₁_iff_isIso₂ :
    IsZero T.obj₁ ↔ IsIso T.mor₂
-- Mathlib/NumberTheory/Padics/PadicNorm.lean
/-- The `p`-adic norm is nonarchimedean: the norm of `p + q` is at most the max of the norm of `p`
and the norm of `q`. -/
protected theorem nonarchimedean {q r : ℚ} :
    padicNorm p (q + r) ≤ max (padicNorm p q) (padicNorm p r)
-- Mathlib/Topology/Maps/Basic.lean
theorem continuous_iff (hg : Inducing g) :
    Continuous f ↔ Continuous (g ∘ f)
-- Mathlib/Logic/Hydra.lean
theorem cutExpand_le_invImage_lex [DecidableEq α] [IsIrrefl α r] :
    CutExpand r ≤ InvImage (Finsupp.Lex (rᶜ ⊓ (· ≠ ·)) (· < ·)) toFinsupp
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- Two different points are affinely independent. -/
theorem affineIndependent_of_ne {p₁ p₂ : P} (h : p₁ ≠ p₂) : AffineIndependent k ![p₁, p₂]
-- Mathlib/RingTheory/Trace/Basic.lean
theorem traceMatrix_of_basis [Fintype κ] [DecidableEq κ] (b : Basis κ A B) :
    traceMatrix A b = BilinForm.toMatrix b (traceForm A B)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma addPolynomial_slope {x₁ x₂ y₁ y₂ : F} (h₁ : W.Equation x₁ y₁) (h₂ : W.Equation x₂ y₂)
    (hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂) : W.addPolynomial x₁ y₁ (W.slope x₁ x₂ y₁ y₂) =
      -((X - C x₁) * (X - C x₂) * (X - C (W.addX x₁ x₂ <| W.slope x₁ x₂ y₁ y₂)))
-- Mathlib/Data/Set/Lattice.lean
theorem inter_iUnion (s : Set β) (t : ι → Set β) : (s ∩ ⋃ i, t i) = ⋃ i, s ∩ t i
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Order.lean
lemma IsSelfAdjoint.le_algebraMap_norm_self {a : A} (ha : IsSelfAdjoint a := by cfc_tac) :
    a ≤ algebraMap ℝ A ‖a‖
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Prod.lean
theorem _root_.ContinuousOn.prod_map_equivL {f : X → M₁ ≃L[𝕜] M₂} {g : X → M₃ ≃L[𝕜] M₄} {s : Set X}
    (hf : ContinuousOn (fun x => (f x : M₁ →L[𝕜] M₂)) s)
    (hg : ContinuousOn (fun x => (g x : M₃ →L[𝕜] M₄)) s) :
    ContinuousOn (fun x => ((f x).prod (g x) : M₁ × M₃ →L[𝕜] M₂ × M₄)) s
-- Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean
theorem singularPart_add (s t : SignedMeasure α) (μ : Measure α) [s.HaveLebesgueDecomposition μ]
    [t.HaveLebesgueDecomposition μ] :
    (s + t).singularPart μ = s.singularPart μ + t.singularPart μ
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
theorem ofReal_le_ofReal_iff {p q : ℝ} (h : 0 ≤ q) :
    ENNReal.ofReal p ≤ ENNReal.ofReal q ↔ p ≤ q
-- Mathlib/SetTheory/Cardinal/Basic.lean
protected theorem IsLimit.ne_zero {c} (h : IsLimit c) : c ≠ 0
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
protected theorem smul_def (f : A₁ ≃ₐ[R] A₁) (a : A₁) : f • a = f a
-- Mathlib/Data/ENNReal/Inv.lean
@[simp]
theorem orderIsoIicOneBirational_symm_apply (x : Iic (1 : ℝ≥0∞)) :
    orderIsoIicOneBirational.symm x = (x.1⁻¹ - 1)⁻¹
-- Mathlib/Data/Finsupp/Basic.lean
theorem mem_splitSupport_iff_nonzero (i : ι) : i ∈ splitSupport l ↔ split l i ≠ 0
-- Mathlib/Data/Nat/Factorization/Defs.lean
theorem factorization_eq_zero_of_remainder {p r : ℕ} (i : ℕ) (hr : ¬p ∣ r) :
    (p * i + r).factorization p = 0
-- Mathlib/Algebra/Module/Submodule/Basic.lean
@[simp]
theorem mem_toAddSubmonoid (p : Submodule R M) (x : M) : x ∈ p.toAddSubmonoid ↔ x ∈ p
-- Mathlib/Topology/Order/Basic.lean
theorem pi_Iic_mem_nhds' (ha : ∀ i, x' i < a' i) : Iic a' ∈ 𝓝 x'
-- Mathlib/Analysis/Convex/Between.lean
theorem Wbtw.right_mem_image_Ici_of_left_ne {x y z : P} (h : Wbtw R x y z) (hne : x ≠ y) :
    z ∈ lineMap x y '' Set.Ici (1 : R)
-- .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean
/-- `SatisfiesM` distributes over `<$>`, general version. -/
protected theorem map [Functor m] [LawfulFunctor m] {x : m α}
    (hx : SatisfiesM p x) (hf : ∀ {a}, p a → q (f a)) : SatisfiesM q (f <$> x)
-- Mathlib/Topology/ContinuousOn.lean
theorem continuousOn_iff_isClosed {f : α → β} {s : Set α} :
    ContinuousOn f s ↔ ∀ t : Set β, IsClosed t → ∃ u, IsClosed u ∧ f ⁻¹' t ∩ s = u ∩ s
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem continuousOn_setToFun_of_dominated (hT : DominatedFinMeasAdditive μ T C) {fs : X → α → E}
    {bound : α → ℝ} {s : Set X} (hfs_meas : ∀ x ∈ s, AEStronglyMeasurable (fs x) μ)
    (h_bound : ∀ x ∈ s, ∀ᵐ a ∂μ, ‖fs x a‖ ≤ bound a) (bound_integrable : Integrable bound μ)
    (h_cont : ∀ᵐ a ∂μ, ContinuousOn (fun x => fs x a) s) :
    ContinuousOn (fun x => setToFun μ T hT (fs x)) s
-- Mathlib/Analysis/NormedSpace/HomeomorphBall.lean
theorem univBall_target (c : P) {r : ℝ} (hr : 0 < r) : (univBall c r).target = ball c r
-- Mathlib/Order/Defs.lean
/-- A version of `le_refl` where the argument is implicit -/
theorem le_rfl {a : α} : a ≤ a
-- Mathlib/Data/Matroid/Restrict.lean
theorem restrict_finite {R : Set α} (hR : R.Finite) : (M ↾ R).Finite
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem singleton_nonempty (u : ZFSet) : ZFSet.Nonempty {u}
-- Mathlib/Topology/Homeomorph.lean
@[simp]
theorem isClosed_preimage (h : X ≃ₜ Y) {s : Set Y} : IsClosed (h ⁻¹' s) ↔ IsClosed s
-- Mathlib/Algebra/Polynomial/Coeff.lean
@[simp]
theorem coeff_mul_X_pow (p : R[X]) (n d : ℕ) :
    coeff (p * Polynomial.X ^ n) (d + n) = coeff p d
-- Mathlib/Topology/Separation.lean
protected theorem Embedding.t0Space [TopologicalSpace Y] [T0Space Y] {f : X → Y}
    (hf : Embedding f) : T0Space X
-- Mathlib/Topology/ContinuousFunction/Basic.lean
@[simp]
theorem liftCover_coe {i : ι} (x : S i) : liftCover S φ hφ hS x = φ i x
-- Mathlib/Order/CompleteLattice.lean
theorem sInf_image2 {f : β → γ → α} {s : Set β} {t : Set γ} :
    sInf (image2 f s t) = ⨅ (a ∈ s) (b ∈ t), f a b
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem nndist_triangle_left (x y z : α) : nndist x y ≤ nndist z x + nndist z y
-- Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean
nonrec theorem SmoothAt.smul {f : M → 𝕜} {g : M → V} (hf : SmoothAt I 𝓘(𝕜) f x)
    (hg : SmoothAt I 𝓘(𝕜, V) g x) : SmoothAt I 𝓘(𝕜, V) (fun p => f p • g p) x
-- Mathlib/Combinatorics/SimpleGraph/Density.lean
theorem mem_interedges_iff {x : α × α} : x ∈ G.interedges s t ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ G.Adj x.1 x.2
-- Mathlib/Order/Filter/Basic.lean
theorem compl_mem_kernMap {s : Set β} : sᶜ ∈ kernMap m f ↔ ∃ t, tᶜ ∈ f ∧ m '' t = s
-- Mathlib/Order/Chain.lean
theorem isChain_empty : IsChain r ∅
-- Mathlib/RingTheory/Smooth/Basic.lean
/-- Let `P →ₐ[R] A` be a surjection with kernel `J`, and `P` a formally smooth `R`-algebra,
then `A` is formally smooth over `R` iff the surjection `P ⧸ J ^ 2 →ₐ[R] A` has a section.

Geometric intuition: we require that a first-order thickening of `Spec A` inside `Spec P` admits
a retraction. -/
theorem iff_split_surjection [FormallySmooth R P] :
    FormallySmooth R A ↔ ∃ g, f.kerSquareLift.comp g = AlgHom.id R A
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem TendstoLocallyUniformlyOn.unique [p.NeBot] [T2Space β] {g : α → β}
    (hf : TendstoLocallyUniformlyOn F f p s) (hg : TendstoLocallyUniformlyOn F g p s) :
    s.EqOn f g
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem setSeq_mem (n : ℕ) : setSeq hf U_mem n ∈ f
-- Mathlib/FieldTheory/Minpoly/Field.lean
theorem eq_X_sub_C' (a : A) : minpoly A a = X - C a
-- Mathlib/Topology/Order/DenselyOrdered.lean
theorem right_nhdsWithin_Ico_neBot {a b : α} (H : a < b) : NeBot (𝓝[Ico a b] b)
-- Mathlib/Analysis/Convex/Between.lean
@[simp]
theorem sbtw_lineMap_iff [NoZeroSMulDivisors R V] {x y : P} {r : R} :
    Sbtw R x (lineMap x y r) y ↔ x ≠ y ∧ r ∈ Set.Ioo (0 : R) 1
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem dart_snd_mem_support_of_mem_darts {u v : V} (p : G.Walk u v) {d : G.Dart}
    (h : d ∈ p.darts) : d.snd ∈ p.support
-- Mathlib/Analysis/Asymptotics/Theta.lean
@[simp]
theorem isTheta_norm_left : (fun x ↦ ‖f' x‖) =Θ[l] g ↔ f' =Θ[l] g
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Basic.lean
theorem shiftLeft_eq (a b : Nat) : a <<< b = a * 2 ^ b
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
@[simp]
theorem ennrealToMeasure_toENNRealVectorMeasure (μ : Measure α) :
    ennrealToMeasure (toENNRealVectorMeasure μ) = μ
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem range_comp_subset_range [MeasurableSpace β] (f : β →ₛ γ) {g : α → β} (hgm : Measurable g) :
    (f.comp g hgm).range ⊆ f.range
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The second projection within a domain at a point in a product is `C^∞`. -/
theorem contDiffWithinAt_snd {s : Set (E × F)} {p : E × F} :
    ContDiffWithinAt 𝕜 n (Prod.snd : E × F → F) s p
-- Mathlib/Data/Matrix/Basic.lean
theorem algebraMap_matrix_apply {r : R} {i j : n} :
    algebraMap R (Matrix n n α) r i j = if i = j then algebraMap R α r else 0
-- .lake/packages/lean4/src/lean/Init/Data/Int/Pow.lean
protected theorem pow_zero (b : Int) : b^0 = 1
-- Mathlib/Order/Monotone/Basic.lean
protected theorem StrictAntiOn.compares (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s)
    (hb : b ∈ s) {o : Ordering} : o.Compares (f a) (f b) ↔ o.Compares b a
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
/-- If `μ i` is a countable family of outer measures, then for every set `s` there exists
a measurable set `t ⊇ s` such that `μ i t = (μ i).trim s` for all `i`. -/
theorem exists_measurable_superset_forall_eq_trim {ι} [Countable ι] (μ : ι → OuterMeasure α)
    (s : Set α) : ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ∀ i, μ i t = (μ i).trim s
-- Mathlib/Analysis/SpecialFunctions/Stirling.lean
@[simp]
theorem stirlingSeq_one : stirlingSeq 1 = exp 1 / √2
-- Mathlib/Order/Interval/Set/Basic.lean
theorem not_mem_Icc_of_lt (ha : c < a) : c ∉ Icc a b
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
@[simp]
theorem support_map : (map f p).support = f '' p.support
-- Mathlib/Algebra/Category/CoalgebraCat/ComonEquivalence.lean
theorem counit_tensorObj_tensorObj_left :
    Coalgebra.counit (R := R)
      (A := ((CoalgebraCat.of R M ⊗ CoalgebraCat.of R N) ⊗ CoalgebraCat.of R P : CoalgebraCat R))
      = Coalgebra.counit (A := (M ⊗[R] N) ⊗[R] P)
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
theorem mem_pointwise_smul_iff_inv_smul_mem {a : α} {S : Submonoid M} {x : M} :
    x ∈ a • S ↔ a⁻¹ • x ∈ S
-- Mathlib/Algebra/BigOperators/GroupWithZero/Finset.lean
lemma prod_eq_zero_iff : ∏ x ∈ s, f x = 0 ↔ ∃ a ∈ s, f a = 0
-- Mathlib/Data/Real/Archimedean.lean
@[simp]
theorem ciInf_const_zero {α : Sort*} : ⨅ _ : α, (0 : ℝ) = 0
-- Mathlib/LinearAlgebra/Prod.lean
@[simp] theorem fst_comp_inr : fst R M M₂ ∘ₗ inr R M M₂ = 0
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
theorem differentiableOn_pi : DifferentiableOn 𝕜 Φ s ↔ ∀ i, DifferentiableOn 𝕜 (fun x => Φ x i) s
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
theorem decay_smul_aux (k n : ℕ) (f : 𝓢(E, F)) (c : 𝕜) (x : E) :
    ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (c • (f : E → F)) x‖ =
      ‖c‖ * ‖x‖ ^ k * ‖iteratedFDeriv ℝ n f x‖
-- Mathlib/LinearAlgebra/Matrix/Symmetric.lean
/-- A version of `Matrix.ext` that unfolds the `Matrix.transpose`. -/
-- @[ext] -- Porting note: removed attribute
theorem IsSymm.ext {A : Matrix n n α} : (∀ i j, A j i = A i j) → A.IsSymm
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem rangeRestrict_surjective (f : R →+* S) : Function.Surjective f.rangeRestrict
-- Mathlib/Topology/Sets/Opens.lean
theorem openEmbedding_of_le {U V : Opens α} (i : U ≤ V) :
    OpenEmbedding (Set.inclusion <| SetLike.coe_subset_coe.2 i)
-- Mathlib/LinearAlgebra/Matrix/PosDef.lean
@[simp]
lemma sqrt_mul_self : hA.sqrt * hA.sqrt = A
-- Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean
theorem pullback_fst_map_snd_isPullback :
    IsPullback (fst _ _ ≫ i₁ ≫ fst _ _)
      (map i₁ i₂ (i₁ ≫ snd _ _) (i₂ ≫ snd _ _) _ _ _
        (Category.id_comp _).symm (Category.id_comp _).symm)
      (diagonal f)
      (map (i₁ ≫ snd _ _) (i₂ ≫ snd _ _) f f (i₁ ≫ fst _ _) (i₂ ≫ fst _ _) i (by simp [condition])
        (by simp [condition]))
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem type_lt_iff {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
    [IsWellOrder β s] : type r < type s ↔ Nonempty (r ≺i s)
-- Mathlib/Probability/Process/HittingTime.lean
theorem hitting_of_le {m : ι} (hmn : m ≤ n) : hitting u s n m ω = m
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
/-- A nonsquare is a natural number that is not equal to the square of an
  integer. This is implemented as a typeclass because it's a necessary condition
  for much of the Pell equation theory. -/
class Nonsquare (x : ℕ) : Prop where
  ns' : ∀ n : ℕ, x ≠ n * n
-- Mathlib/Topology/PartialHomeomorph.lean
theorem eventually_left_inverse' {x} (hx : x ∈ e.target) :
    ∀ᶠ y in 𝓝 (e.symm x), e.symm (e y) = y
-- Mathlib/Data/Matrix/Rank.lean
theorem ker_mulVecLin_conjTranspose_mul_self (A : Matrix m n R) :
    LinearMap.ker (Aᴴ * A).mulVecLin = LinearMap.ker (mulVecLin A)
-- Mathlib/Data/Set/Function.lean
protected theorem _root_.StrictAntiOn.strictAnti (h : StrictAntiOn f s) :
    StrictAnti (f ∘ Subtype.val : s → β)
-- Mathlib/Algebra/Ring/Equiv.lean
theorem toRingHom_injective : Function.Injective (toRingHom : R ≃+* S → R →+* S)
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem divInt_sub_divInt (n₁ n₂ : Int) {d₁ d₂} (z₁ : d₁ ≠ 0) (z₂ : d₂ ≠ 0) :
    n₁ /. d₁ - n₂ /. d₂ = (n₁ * d₂ - n₂ * d₁) /. (d₁ * d₂)
-- Mathlib/Order/CompleteLattice.lean
theorem iSup_plift_up (f : PLift ι → α) : ⨆ i, f (PLift.up i) = ⨆ i, f i
-- Mathlib/Topology/Order/IntermediateValue.lean
/-- **Intermediate Value Theorem** for continuous functions on closed intervals, unordered case. -/
theorem intermediate_value_uIcc {a b : α} {f : α → δ} (hf : ContinuousOn f (uIcc a b)) :
    uIcc (f a) (f b) ⊆ f '' uIcc a b
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem rotate_darts {u v : V} (c : G.Walk v v) (h : u ∈ c.support) :
    (c.rotate h).darts ~r c.darts
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem abs_integral_eq_abs_integral_uIoc (f : ℝ → ℝ) :
    |∫ x in a..b, f x ∂μ| = |∫ x in Ι a b, f x ∂μ|
-- Mathlib/LinearAlgebra/Projectivization/Basic.lean
@[simp]
theorem map_id : map (LinearMap.id : V →ₗ[K] V) (LinearEquiv.refl K V).injective = id
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive (attr := simp) abs_nonneg] lemma one_le_mabs (a : α) : 1 ≤ |a|ₘ
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem disjoint_compl_compl_right_iff : Disjoint a bᶜᶜ ↔ Disjoint a b
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem add_right_cancel_iff {n : Nat} : m + n = k + n ↔ m = k
-- Mathlib/Topology/Compactness/Compact.lean
nonrec theorem Ultrafilter.le_nhds_lim [CompactSpace X] (F : Ultrafilter X) : ↑F ≤ 𝓝 F.lim
-- Mathlib/Algebra/Order/Archimedean.lean
/-- Given `x` and `y` between `0` and `1`, `x` is between two successive powers of `y`.
This is the same as `exists_nat_pow_near`, but for elements between `0` and `1` -/
theorem exists_nat_pow_near_of_lt_one (xpos : 0 < x) (hx : x ≤ 1) (ypos : 0 < y) (hy : y < 1) :
    ∃ n : ℕ, y ^ (n + 1) < x ∧ x ≤ y ^ n
-- Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean
@[reassoc] theorem associator_inv_snd (X Y Z : C) :
    (α_ X Y Z).inv ≫ prod.snd = prod.snd ≫ prod.snd
-- Mathlib/Analysis/Convex/SimplicialComplex/Basic.lean
theorem faces_bot : (⊥ : SimplicialComplex 𝕜 E).faces = ∅
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
lemma map_preΨ (n : ℤ) : (W.map f).preΨ n = (W.preΨ n).map f
-- Mathlib/Data/List/Forall2.lean
theorem rel_bind : (Forall₂ R ⇒ (R ⇒ Forall₂ P) ⇒ Forall₂ P) List.bind List.bind
-- Mathlib/Data/Multiset/Basic.lean
@[simp, norm_cast] lemma filter_coe (l : List α) : filter p l = l.filter p
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem neg_comp [RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [TopologicalAddGroup M₃] (g : M₂ →SL[σ₂₃] M₃)
    (f : M →SL[σ₁₂] M₂) : (-g).comp f = -g.comp f
-- Mathlib/Algebra/MvPolynomial/Division.lean
@[simp]
theorem divMonomial_monomial_mul (a : σ →₀ ℕ) (x : MvPolynomial σ R) :
    monomial a 1 * x /ᵐᵒⁿᵒᵐⁱᵃˡ a = x
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem contDiff_prod' {t : Finset ι} {f : ι → E → 𝔸'} (h : ∀ i ∈ t, ContDiff 𝕜 n (f i)) :
    ContDiff 𝕜 n (∏ i ∈ t, f i)
-- Mathlib/RingTheory/Polynomial/Quotient.lean
@[simp]
theorem quotientSpanXSubCAlgEquiv_symm_apply (x : R) (y : R) :
    (quotientSpanXSubCAlgEquiv x).symm y = algebraMap R _ y
-- Mathlib/Order/InitialSeg.lean
@[simp, nolint simpNF]
theorem ofElement_apply {α : Type*} (r : α → α → Prop) (a : α) (b) : ofElement r a b = b.1
-- Mathlib/Order/Disjoint.lean
theorem disjoint_assoc : Disjoint (a ⊓ b) c ↔ Disjoint a (b ⊓ c)
-- Mathlib/Order/GaloisConnection.lean
theorem u_iSup_of_lu_eq_self [CompleteLattice α] [CompleteLattice β] (gi : GaloisCoinsertion l u)
    {ι : Sort x} (f : ι → β) (hf : ∀ i, l (u (f i)) = f i) : u (⨆ i, f i) = ⨆ i, u (f i)
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If an intermediate field of `E / F` is separable over `F`, and `E` is purely inseparable
over it, then it is equal to the separable closure of `F` in `E`. -/
theorem eq_separableClosure (L : IntermediateField F E)
    [Algebra.IsSeparable F L] [IsPurelyInseparable L E] : L = separableClosure F E
-- Mathlib/NumberTheory/Padics/RingHoms.lean
theorem modPart_nonneg : 0 ≤ modPart p r
-- Mathlib/Algebra/DirectSum/Module.lean
/-- If a direct sum of submodules is internal then the submodules are independent. -/
theorem IsInternal.submodule_independent (h : IsInternal A) : CompleteLattice.Independent A
-- Mathlib/RingTheory/Filtration.lean
/-- The trivial `I`-filtration of `N`. -/
@[simps]
def _root_.Ideal.trivialFiltration (I : Ideal R) (N : Submodule R M) : I.Filtration M
-- Mathlib/Order/Monotone/Basic.lean
theorem antitoneOn_iff_forall_lt :
    AntitoneOn f s ↔ ∀ ⦃a⦄ (_ : a ∈ s) ⦃b⦄ (_ : b ∈ s), a < b → f b ≤ f a
-- Mathlib/Data/PNat/Factors.lean
theorem coePNat_nat (v : PrimeMultiset) : ((v : Multiset ℕ+) : Multiset ℕ) = (v : Multiset ℕ)
-- Mathlib/Topology/FiberBundle/Constructions.lean
theorem Pullback.continuous_totalSpaceMk [∀ x, TopologicalSpace (E x)] [FiberBundle F E]
    {f : B' → B} {x : B'} : Continuous (@TotalSpace.mk _ F (f *ᵖ E) x)
-- Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean
/-- If `δ` is small enough, a `(1-δ)`-separated set in the ball of radius `2` also has cardinality
at most `multiplicity E`. -/
theorem exists_goodδ :
    ∃ δ : ℝ, 0 < δ ∧ δ < 1 ∧ ∀ s : Finset E, (∀ c ∈ s, ‖c‖ ≤ 2) →
      (∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 - δ ≤ ‖c - d‖) → s.card ≤ multiplicity E
-- Mathlib/CategoryTheory/Sites/LocallyInjective.lean
lemma isLocallyInjective_comp_iff [IsLocallyInjective J ψ] :
    IsLocallyInjective J (φ ≫ ψ) ↔ IsLocallyInjective J φ
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem length_eraseIdx : ∀ {l i}, i < length l → length (@eraseIdx α l i) = length l - 1
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp]
theorem not_ite_eq_true_eq_false (p : Prop) [h : Decidable p] (b c : Bool) :
  ¬(ite p (b = true) (c = false)) ↔ (ite p (b = false) (c = true))
-- Mathlib/RingTheory/Unramified/Finite.lean
lemma lmul_elem [EssFiniteType R S] [FormallyUnramified R S] :
    TensorProduct.lmul' R (elem R S) = 1
-- Mathlib/CategoryTheory/Subterminal.lean
theorem IsSubterminal.def : IsSubterminal A ↔ ∀ ⦃Z : C⦄ (f g : Z ⟶ A), f = g
-- Mathlib/Geometry/Euclidean/Sphere/Power.lean
/-- **Intersecting Chords Theorem**. -/
theorem mul_dist_eq_mul_dist_of_cospherical_of_angle_eq_pi {a b c d p : P}
    (h : Cospherical ({a, b, c, d} : Set P)) (hapb : ∠ a p b = π) (hcpd : ∠ c p d = π) :
    dist a p * dist b p = dist c p * dist d p