ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
/-- If `f` is a collection of linear maps, then the construction `MultilinearMap.compLinearMap`
sending a multilinear map `g` to `g (f₁ ⬝ , ..., fₙ ⬝ )` is linear in `g` and multilinear in
`f₁, ..., fₙ`. -/
@[simps] def compLinearMapMultilinear :
  @MultilinearMap R ι (fun i ↦ M₁ i →ₗ[R] M₁' i)
    ((MultilinearMap R M₁' M₂) →ₗ[R] MultilinearMap R M₁ M₂) _ _ _
      (fun i ↦ LinearMap.module) _
-- Mathlib/Algebra/CharP/Defs.lean
lemma intCast_eq_zero_iff (a : ℤ) : (a : R) = 0 ↔ (p : ℤ) ∣ a
-- Mathlib/Data/Vector3.lean
theorem exists_vector_zero (f : Vector3 α 0 → Prop) : Exists f ↔ f []
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
theorem disjoint_def' {p p' : Submodule R M} :
    Disjoint p p' ↔ ∀ x ∈ p, ∀ y ∈ p', x = y → x = (0 : M)
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
theorem ContDiffWithinAt.log {n} (hf : ContDiffWithinAt ℝ n f s x) (hx : f x ≠ 0) :
    ContDiffWithinAt ℝ n (fun x => log (f x)) s x
-- Mathlib/Algebra/Algebra/Equiv.lean
theorem coe_algHom_injective : Function.Injective ((↑) : (A₁ ≃ₐ[R] A₂) → A₁ →ₐ[R] A₂)
-- Mathlib/Order/CompleteBooleanAlgebra.lean
theorem iSup₂_inf_eq {f : ∀ i, κ i → α} (a : α) :
    (⨆ (i) (j), f i j) ⊓ a = ⨆ (i) (j), f i j ⊓ a
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
/-- If `s` is not in `-ℕ`, and either `a ≠ 0` or `s ≠ 1`, then
`hurwitzZetaEven a (1 - s)` is an explicit multiple of `cosZeta s`. -/
lemma hurwitzZetaEven_one_sub (a : UnitAddCircle) {s : ℂ}
    (hs : ∀ (n : ℕ), s ≠ -n) (hs' : a ≠ 0 ∨ s ≠ 1) :
    hurwitzZetaEven a (1 - s) = 2 * (2 * π) ^ (-s) * Gamma s * cos (π * s / 2) * cosZeta a s
-- Mathlib/Data/List/Infix.lean
@[simp, deprecated get_tails (since := "2024-04-16")]
theorem nth_le_tails (l : List α) (n : ℕ) (hn : n < length (tails l)) :
    nthLe (tails l) n hn = l.drop n
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
theorem map_comp_reindex_symm (f : Π i, s i →ₗ[R] t i) (e : ι ≃ ι₂) :
    map f ∘ₗ (reindex R s e).symm = (reindex R t e).symm ∘ₗ map (fun i => f (e.symm i))
-- Mathlib/FieldTheory/SeparableDegree.lean
/-- The minimal polynomial of an element `x` of `E / F` of exponential characteristic `q` has
separable degree one if and only if the minimal polynomial is of the form
`(X - x) ^ (q ^ n)` for some `n : ℕ`. -/
theorem natSepDegree_eq_one_iff_eq_X_sub_C_pow : (minpoly F x).natSepDegree = 1 ↔
    ∃ n : ℕ, (minpoly F x).map (algebraMap F E) = (X - C x) ^ q ^ n
-- Mathlib/RingTheory/WittVector/Truncated.lean
/-- The universal property of `𝕎 R` as projective limit of truncated Witt vector rings. -/
@[simps]
def liftEquiv : { f : ∀ k, S →+* TruncatedWittVector p k R // ∀ (k₁ k₂) (hk : k₁ ≤ k₂),
    (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁ } ≃ (S →+* 𝕎 R)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem map_injective {f : A →ₐ[R] B} (hf : Function.Injective f) : Function.Injective (map f)
-- Mathlib/Control/LawfulFix.lean
theorem fix_eq (hc : Continuous f) : Part.fix f = f (Part.fix f)
-- Mathlib/Order/Interval/Set/Disjoint.lean
theorem IsGLB.iUnion_Ioi_eq (h : IsGLB (range f) a) : ⋃ x, Ioi (f x) = Ioi a
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
nonrec theorem HasFDerivAt.add (hf : HasFDerivAt f f' x) (hg : HasFDerivAt g g' x) :
    HasFDerivAt (fun x => f x + g x) (f' + g') x
-- Mathlib/Analysis/Seminorm.lean
/-- Seminorm-balls containing the origin are absorbent. -/
protected theorem absorbent_ball (hpr : p x < r) : Absorbent 𝕜 (ball p x r)
-- Mathlib/LinearAlgebra/TensorProduct/Opposite.lean
theorem opAlgEquiv_apply (x : Aᵐᵒᵖ ⊗[R] Bᵐᵒᵖ) :
    opAlgEquiv R S A B x =
      op (_root_.TensorProduct.map
        (opLinearEquiv R).symm.toLinearMap (opLinearEquiv R).symm.toLinearMap x)
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
/-- A bounded convergence theorem for a finite measure:
If a sequence of bounded continuous non-negative functions are uniformly bounded by a constant and
tend pointwise to a limit, then their integrals (`MeasureTheory.FiniteMeasure.testAgainstNN`)
against the finite measure tend to the integral of the limit.

Related results:
 * `MeasureTheory.FiniteMeasure.tendsto_testAgainstNN_filter_of_le_const`:
   more general assumptions
 * `MeasureTheory.FiniteMeasure.tendsto_lintegral_nn_of_le_const`:
   using `MeasureTheory.lintegral` for integration.
-/
theorem tendsto_testAgainstNN_of_le_const {μ : FiniteMeasure Ω} {fs : ℕ → Ω →ᵇ ℝ≥0} {c : ℝ≥0}
    (fs_le_const : ∀ n ω, fs n ω ≤ c) {f : Ω →ᵇ ℝ≥0}
    (fs_lim : ∀ ω, Tendsto (fun n => fs n ω) atTop (𝓝 (f ω))) :
    Tendsto (fun n => μ.testAgainstNN (fs n)) atTop (𝓝 (μ.testAgainstNN f))
-- Mathlib/Data/Set/Subset.lean
lemma subset_preimage_val_image_val_iff : D ⊆ A ↓∩ ↑E ↔ D ⊆ E
-- Mathlib/Algebra/Polynomial/Laurent.lean
@[simp]
theorem single_eq_C_mul_T (r : R) (n : ℤ) :
    (Finsupp.single n r : R[T;T⁻¹]) = (C r * T n : R[T;T⁻¹])
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem eq_aleph_of_eq_card_ord {o : Ordinal} (ho : o.card.ord = o) (ho' : ω ≤ o) :
    ∃ a, (aleph a).ord = o
-- Mathlib/Order/Filter/AtTopBot.lean
@[simp]
theorem eventually_atBot [SemilatticeInf α] [Nonempty α] {p : α → Prop} :
    (∀ᶠ x in atBot, p x) ↔ ∃ a, ∀ b ≤ a, p b
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem div_add_mod' (m k : Int) : m.div k * k + mod m k = m
-- Mathlib/InformationTheory/Hamming.lean
/-- Corresponds to `eq_of_dist_eq_zero`. -/
theorem eq_of_hammingDist_eq_zero {x y : ∀ i, β i} : hammingDist x y = 0 → x = y
-- Mathlib/FieldTheory/KummerExtension.lean
lemma rootOfSplitsXPowSubC_pow :
    (rootOfSplitsXPowSubC hn a L) ^ n = algebraMap K L a
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
/-- Obvious triangles `0 ⟶ X ⟶ X ⟶ 0⟦1⟧` are distinguished -/
lemma contractible_distinguished₁ (X : C) :
    Triangle.mk (0 : 0 ⟶ X) (𝟙 X) 0 ∈ distTriang C
-- Mathlib/Data/Fin/Tuple/Basic.lean
@[simp]
theorem repeat_add {α : Type*} (a : Fin n → α) (m₁ m₂ : ℕ) : Fin.repeat (m₁ + m₂) a =
    append (Fin.repeat m₁ a) (Fin.repeat m₂ a) ∘ cast (Nat.add_mul ..)
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
@[simp]
theorem nadd_nat (n : ℕ) : a ♯ n = a + n
-- Mathlib/ModelTheory/DirectLimit.lean
theorem of_f {i j : ι} {hij : i ≤ j} {x : G i} : of L ι G f j (f i j hij x) = of L ι G f i x
-- Mathlib/Topology/Order/LocalExtr.lean
theorem IsLocalMaxOn.on_subset {t : Set α} (hf : IsLocalMaxOn f t a) (h : s ⊆ t) :
    IsLocalMaxOn f s a
-- Mathlib/Data/Set/Countable.lean
/-- A set `s : Set α` is countable if and only if there exists a function `α → ℕ` injective
on `s`. -/
theorem countable_iff_exists_injOn {s : Set α} : s.Countable ↔ ∃ f : α → ℕ, InjOn f s
-- Mathlib/Data/Real/Hyperreal.lean
theorem coe_ne_coe {x y : ℝ} : (x : ℝ*) ≠ y ↔ x ≠ y
-- Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean
@[simp]
theorem of_symm_of (x : A ⊗[R] B) : (of R 𝒜 ℬ).symm (of R 𝒜 ℬ x) = x
-- Mathlib/MeasureTheory/Measure/Content.lean
theorem outerMeasure_caratheodory (A : Set G) :
    MeasurableSet[μ.outerMeasure.caratheodory] A ↔
      ∀ U : Opens G, μ.outerMeasure (U ∩ A) + μ.outerMeasure (U \ A) ≤ μ.outerMeasure U
-- Mathlib/Data/Rat/Defs.lean
theorem coe_int_inj (m n : ℤ) : (m : ℚ) = n ↔ m = n
-- Mathlib/Topology/EMetricSpace/Basic.lean
@[simp] theorem mem_closedBall : y ∈ closedBall x ε ↔ edist y x ≤ ε
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
/-- The extension of a family agrees with the original family. -/
theorem extend_agrees {x : FamilyOfElements P R} (t : x.Compatible) {f : Y ⟶ X} (hf : R f) :
    x.sieveExtend f (le_generate R Y hf) = x f hf
-- Mathlib/Order/CompleteLattice.lean
theorem OrderIso.map_iInf [CompleteLattice β] (f : α ≃o β) (x : ι → α) :
    f (⨅ i, x i) = ⨅ i, f (x i)
-- Mathlib/Data/Complex/Exponential.lean
theorem add_one_le_exp (x : ℝ) : x + 1 ≤ Real.exp x
-- Mathlib/Data/Complex/Exponential.lean
theorem exp_pos (x : ℝ) : 0 < exp x
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem replaceF_nil : [].replaceF p = []
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem CPolynomialOn.mono {s t : Set E} (hf : CPolynomialOn 𝕜 f t) (hst : s ⊆ t) :
    CPolynomialOn 𝕜 f s
-- Mathlib/Topology/Order.lean
theorem setOf_isOpen_iSup {t : ι → TopologicalSpace α} :
    { s | IsOpen[⨆ i, t i] s } = ⋂ i, { s | IsOpen[t i] s }
-- Mathlib/Topology/Order/LocalExtr.lean
theorem IsLocalMax.comp_continuous [TopologicalSpace δ] {g : δ → α} {b : δ}
    (hf : IsLocalMax f (g b)) (hg : ContinuousAt g b) : IsLocalMax (f ∘ g) b
-- Mathlib/Topology/Compactness/Compact.lean
lemma noncompact_univ (X : Type*) [TopologicalSpace X] [NoncompactSpace X] :
    ¬IsCompact (univ : Set X)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem mem_carrier {s : Subalgebra R A} {x : A} : x ∈ s.carrier ↔ x ∈ s
-- Mathlib/Topology/MetricSpace/Antilipschitz.lean
protected theorem uniformEmbedding {α : Type*} {β : Type*} [EMetricSpace α] [PseudoEMetricSpace β]
    {K : ℝ≥0} {f : α → β} (hf : AntilipschitzWith K f) (hfc : UniformContinuous f) :
    UniformEmbedding f
-- Mathlib/Probability/Kernel/RadonNikodym.lean
lemma measurable_singularPart_fun (κ η : Kernel α γ) :
    Measurable (fun p : α × γ ↦ Real.toNNReal (rnDerivAux κ (κ + η) p.1 p.2)
      - Real.toNNReal (1 - rnDerivAux κ (κ + η) p.1 p.2) * rnDeriv κ η p.1 p.2)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem not_mem_of_not_mem_closure {s : Set R} {P : R} (hP : P ∉ closure s) : P ∉ s
-- Mathlib/Analysis/InnerProductSpace/Rayleigh.lean
theorem image_rayleigh_eq_image_rayleigh_sphere {r : ℝ} (hr : 0 < r) :
    rayleighQuotient T '' {0}ᶜ = rayleighQuotient T '' sphere 0 r
-- Mathlib/Data/Set/Sups.lean
theorem sups_right_comm : s ⊻ t ⊻ u = s ⊻ u ⊻ t
-- Mathlib/CategoryTheory/Limits/Preserves/Limits.lean
@[reassoc (attr := simp)]
theorem ι_preservesColimitsIso_hom (j : J) :
    G.map (colimit.ι F j) ≫ (preservesColimitIso G F).hom = colimit.ι (F ⋙ G) j
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[ext] theorem ext_of {X Y : Type u} [CommSemiring X] [CommSemiring Y] (f g : X →+* Y)
    (h : ∀ x, f x = g x) :
    @Eq (CommSemiRingCat.of X ⟶ CommSemiRingCat.of Y) f g
-- Mathlib/CategoryTheory/Endofunctor/Algebra.lean
/-- A morphism between algebras of endofunctor `F` -/
@[ext]
structure Hom (A₀ A₁ : Algebra F) where
  /-- underlying morphism between the carriers -/
  f : A₀.1 ⟶ A₁.1
  /-- compatibility condition -/
  h : F.map f ≫ A₁.str = A₀.str ≫ f := by aesop_cat
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
theorem differentiableAt_log (hx : x ≠ 0) : DifferentiableAt ℝ log x
-- Mathlib/Analysis/Convex/Side.lean
theorem SSameSide.nonempty {s : AffineSubspace R P} {x y : P} (h : s.SSameSide x y) :
    (s : Set P).Nonempty
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_sub {x : ℝ≥0∞} (y z : ℝ) (hx : x ≠ 0) (h'x : x ≠ ⊤) : x ^ (y - z) = x ^ y / x ^ z
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_congr_ae {f g : α → G} (h : f =ᵐ[μ] g) : ∫ a, f a ∂μ = ∫ a, g a ∂μ
-- Mathlib/Data/List/Pairwise.lean
theorem pairwise_pmap {p : β → Prop} {f : ∀ b, p b → α} {l : List β} (h : ∀ x ∈ l, p x) :
    Pairwise R (l.pmap f h) ↔
      Pairwise (fun b₁ b₂ => ∀ (h₁ : p b₁) (h₂ : p b₂), R (f b₁ h₁) (f b₂ h₂)) l
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem diagonal_smul [Zero α] [SMulZeroClass R α] (r : R) (d : n → α) :
    diagonal (r • d) = r • diagonal d
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLog.lean
theorem log_injective : Function.Injective log
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem injective : Injective I
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem aecover_Iio_of_Iic : AECover (μ.restrict (Iio B)) l fun i ↦ Iic (b i)
-- Mathlib/Data/Set/Opposite.lean
@[simp]
theorem unop_op (s : Set αᵒᵖ) : s.unop.op = s
-- Mathlib/Algebra/Module/LinearMap/End.lean
theorem End.natCast_def (n : ℕ) [AddCommMonoid N₁] [Module R N₁] :
    (↑n : Module.End R N₁) = Module.toModuleEnd R N₁ n
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem not_le_of_lt : ∀{a b : Nat}, a < b → ¬(b ≤ a)
-- Mathlib/Logic/Equiv/Defs.lean
theorem rightInverse_symm (f : Equiv α β) : Function.RightInverse f.symm f
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem intervalIntegrable_iff_integrableOn_Ioc_of_le (hab : a ≤ b) :
    IntervalIntegrable f μ a b ↔ IntegrableOn f (Ioc a b) μ
-- Mathlib/Algebra/Polynomial/Basic.lean
private irreducible_def neg {R : Type u} [Ring R] : R[X] → R[X]
-- Mathlib/Order/OrderIsoNat.lean
theorem WellFounded.monotone_chain_condition' [Preorder α] :
    WellFounded ((· > ·) : α → α → Prop) ↔ ∀ a : ℕ →o α, ∃ n, ∀ m, n ≤ m → ¬a n < a m
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
theorem LinearIsometry.map_orthogonalProjection {E E' : Type*} [NormedAddCommGroup E]
    [NormedAddCommGroup E'] [InnerProductSpace 𝕜 E] [InnerProductSpace 𝕜 E'] (f : E →ₗᵢ[𝕜] E')
    (p : Submodule 𝕜 E) [HasOrthogonalProjection p] [HasOrthogonalProjection (p.map f.toLinearMap)]
    (x : E) : f (orthogonalProjection p x) = orthogonalProjection (p.map f.toLinearMap) (f x)
-- Mathlib/Order/Filter/Basic.lean
theorem principal_subtype {α : Type*} (s : Set α) (t : Set s) :
    𝓟 t = comap (↑) (𝓟 (((↑) : s → α) '' t))
-- Mathlib/Topology/Order/OrderClosed.lean
@[simp]
theorem disjoint_nhds_atBot_iff : Disjoint (𝓝 a) atBot ↔ ¬IsBot a
-- Mathlib/Logic/Function/Conjugate.lean
@[symm]
theorem symm (h : Commute f g) : Commute g f
-- Mathlib/Probability/Martingale/Basic.lean
theorem neg (hf : Martingale f ℱ μ) : Martingale (-f) ℱ μ
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem fdiv_nonneg {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : 0 ≤ a.fdiv b
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
theorem lt_iff (s t : String) : s < t ↔ s.data < t.data
-- Mathlib/Algebra/Category/BialgebraCat/Basic.lean
@[simp] theorem toBialgEquiv_toBialgHom (i : X ≅ Y) :
    (i.toBialgEquiv : X →ₐc[R] Y) = i.hom.1
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
@[simp]
theorem generateFrom_insert_empty (S : Set (Set α)) :
    generateFrom (insert ∅ S) = generateFrom S
-- Mathlib/CategoryTheory/Functor/OfSequence.lean
/-- The functor `ℕ ⥤ C` constructed from a sequence of
morphisms `f : X n ⟶ X (n + 1)` for all `n : ℕ`. -/
@[simps obj]
def ofSequence : ℕ ⥤ C
-- Mathlib/Order/Monotone/Basic.lean
theorem strictMonoOn_id [Preorder α] {s : Set α} : StrictMonoOn id s
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem splits_of_exists_multiset {f : K[X]} {s : Multiset L}
    (hs : f.map i = C (i f.leadingCoeff) * (s.map fun a : L => X - C a).prod) : Splits i f
-- Mathlib/Topology/Instances/Sign.lean
theorem continuousAt_sign_of_neg {a : α} (h : a < 0) : ContinuousAt SignType.sign a
-- Mathlib/GroupTheory/HNNExtension.lean
/-- A reduced word is a `head`, which is an element of `G`, followed by the product list of pairs.
There should also be no sequences of the form `t^u * g * t^-u`, where `g` is in
`toSubgroup A B u` This is a less strict condition than required for `NormalWord`. -/
structure ReducedWord : Type _ :=
  /-- Every `ReducedWord` is the product of an element of the group and a word made up
  of letters each of which is in the transversal. `head` is that element of the base group. -/
  head : G
  /-- The list of pairs `(ℤˣ × G)`, where each pair `(u, g)` represents the element `t^u * g` of
  `HNNExtension G A B φ` -/
  toList : List (ℤˣ × G)
  /-- There are no sequences of the form `t^u * g * t^-u` where `g ∈ toSubgroup A B u` -/
  chain : toList.Chain' (fun a b => a.2 ∈ toSubgroup A B a.1 → a.1 = b.1)
-- Mathlib/Algebra/Lie/Weights/Killing.lean
lemma lie_eq_smul_of_mem_rootSpace {α : H → K} {x : L} (hx : x ∈ rootSpace H α) (h : H) :
    ⁅h, x⁆ = α h • x
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem PosDef.smul {R} [LinearOrderedCommRing R] [Module R M] [Module R N] [PosSMulStrictMono R N]
    {Q : QuadraticMap R M N} (h : PosDef Q) {a : R} (a_pos : 0 < a) : PosDef (a • Q)
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Chunk.lean
private theorem sum_density_div_card_le_density_add_eps [Nonempty α]
    (hPα : P.parts.card * 16 ^ P.parts.card ≤ card α) (hPε : ↑100 ≤ ↑4 ^ P.parts.card * ε ^ 5)
    (hε₁ : ε ≤ 1) {hU : U ∈ P.parts} {hV : V ∈ P.parts} {A B : Finset (Finset α)}
    (hA : A ⊆ (chunk hP G ε hU).parts) (hB : B ⊆ (chunk hP G ε hV).parts) :
    (∑ ab ∈ A.product B, G.edgeDensity ab.1 ab.2 : ℝ) / (A.card * B.card) ≤
    G.edgeDensity (A.biUnion id) (B.biUnion id) + ε ^ 5 / 49
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem bihimp_top : a ⇔ ⊤ = a
-- Mathlib/Data/List/Sublists.lean
theorem sublistsLenAux_eq (l : List α) (n) (f : List α → β) (r) :
    sublistsLenAux n l f r = (sublistsLen n l).map f ++ r
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
@[ext]
theorem ext {x y : AdicCompletion I M} (h : ∀ n, x.val n = y.val n) : x = y
-- Mathlib/Order/SuccPred/Relation.lean
/-- `(n, m)` is in the reflexive-transitive closure of `~` if `i ~ pred i` and `pred i ~ i`
  for all `i` between `n` and `m`. -/
theorem reflTransGen_of_pred (r : α → α → Prop) {n m : α} (h1 : ∀ i ∈ Ioc m n, r i (pred i))
    (h2 : ∀ i ∈ Ioc n m, r (pred i) i) : ReflTransGen r n m
-- Mathlib/Data/Set/Basic.lean
theorem subset_diff_union (s t : Set α) : s ⊆ s \ t ∪ t
-- Mathlib/LinearAlgebra/Span.lean
@[simp]
theorem map_subtype_span_singleton {p : Submodule R M} (x : p) :
    map p.subtype (R ∙ x) = R ∙ (x : M)
-- Mathlib/Deprecated/Ring.lean
/-- The composition of two semiring homomorphisms is a semiring homomorphism. -/
theorem comp (hf : IsSemiringHom f) {γ} [Semiring γ] {g : β → γ} (hg : IsSemiringHom g) :
    IsSemiringHom (g ∘ f)
-- Mathlib/Order/Closure.lean
lemma closure_isGLB (x : α) : IsGLB { y | x ≤ y ∧ c.IsClosed y } (c x)
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem blockDiagonal'_inj [DecidableEq o] {M N : ∀ i, Matrix (m' i) (n' i) α} :
    blockDiagonal' M = blockDiagonal' N ↔ M = N
-- Mathlib/NumberTheory/LucasLehmer.lean
@[simp]
theorem mul_fst (x y : X q) : (x * y).1 = x.1 * y.1 + 3 * x.2 * y.2
-- Mathlib/Data/Set/Basic.lean
theorem not_mem_compl_iff {x : α} : x ∉ sᶜ ↔ x ∈ s
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_const_mul_Ici_of_neg (a : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Ici a = Iic (a / c)
-- Mathlib/Algebra/Homology/Homotopy.lean
@[simp 1100]
theorem prevD_chainComplex (f : ∀ i j, P.X i ⟶ Q.X j) (j : ℕ) :
    prevD j f = f j (j + 1) ≫ Q.d _ _
-- Mathlib/RingTheory/FiniteType.lean
theorem of_comp_finiteType {f : A →ₐ[R] B} {g : B →ₐ[R] C} (h : (g.comp f).FiniteType) :
    g.FiniteType
-- Mathlib/Data/List/Forall2.lean
theorem _root_.Relator.BiUnique.forall₂ (hr : BiUnique R) : BiUnique (Forall₂ R)
-- Mathlib/GroupTheory/Coxeter/Basic.lean
@[simp] theorem wordProd_reverse (ω : List B) : π (reverse ω) = (π ω)⁻¹
-- Mathlib/Analysis/SpecialFunctions/CompareExp.lean
theorem tendsto_abs (hl : IsExpCmpFilter l) : Tendsto abs l atTop
-- Mathlib/GroupTheory/Transfer.lean
/-- **Burnside's normal p-complement theorem**: If `N(P) ≤ C(P)`, then `P` has a normal
complement. -/
theorem ker_transferSylow_isComplement' : IsComplement' (transferSylow P hP).ker P
-- Mathlib/Order/Interval/Set/ProjIcc.lean
@[simp]
theorem projIci_self (a : α) : projIci a a = ⟨a, le_rfl⟩
-- .lake/packages/lean4/src/lean/Init/Data/Array/Mem.lean
theorem sizeOf_lt_of_mem [SizeOf α] {as : Array α} (h : a ∈ as) : sizeOf a < sizeOf as
-- Mathlib/Topology/Separation.lean
theorem t0Space_iff_inseparable (X : Type u) [TopologicalSpace X] :
    T0Space X ↔ ∀ x y : X, Inseparable x y → x = y
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem Trivialization.contMDiffWithinAt_snd_comp_iff₂ {f : M → TotalSpace F E}
    (hp : ContMDiffWithinAt IM IB n (π F E ∘ f) s x)
    (he : f x ∈ e.source) (he' : f x ∈ e'.source) :
    ContMDiffWithinAt IM 𝓘(𝕜, F) n (fun y ↦ (e (f y)).2) s x ↔
      ContMDiffWithinAt IM 𝓘(𝕜, F) n (fun y ↦ (e' (f y)).2) s x
-- Mathlib/Order/Minimal.lean
theorem inter_minimals_subset : s ∩ minimals r t ⊆ minimals r (s ∩ t)
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid'.balance'_aux {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H₁ : 2 * @size α r ≤ 9 * size l + 5 ∨ size r ≤ 3)
    (H₂ : 2 * @size α l ≤ 9 * size r + 5 ∨ size l ≤ 3) : Valid' o₁ (@balance' α l x r) o₂
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- If `u₁` and `u₂` are two uniform structures on `γ`, then
`𝒱(α, γ, 𝔖, u₁ ⊓ u₂) = 𝒱(α, γ, 𝔖, u₁) ⊓ 𝒱(α, γ, 𝔖, u₂)`. -/
protected theorem inf_eq {u₁ u₂ : UniformSpace γ} :
    𝒱(α, γ, 𝔖, u₁ ⊓ u₂) = 𝒱(α, γ, 𝔖, u₁) ⊓ 𝒱(α, γ, 𝔖, u₂)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem Sublist.length_le : l₁ <+ l₂ → length l₁ ≤ length l₂
-- Mathlib/Algebra/Group/Even.lean
@[simp]
lemma even_ofMul_iff {a : α} : Even (Additive.ofMul a) ↔ IsSquare a
-- Mathlib/Tactic/CategoryTheory/BicategoricalComp.lean
/-- A typeclass carrying a choice of bicategorical structural isomorphism between two objects.
Used by the `⊗≫` bicategorical composition operator, and the `coherence` tactic.
-/
class BicategoricalCoherence (f g : a ⟶ b) where
  /-- The chosen structural isomorphism between to 1-morphisms. -/
  hom : f ⟶ g
  [isIso : IsIso hom]
-- Mathlib/Data/Vector/MapLemmas.lean
@[simp]
theorem mapAccumr₂_mapAccumr_right (f₁ : α → γ → σ₁ → σ₁ × ζ) (f₂ : β → σ₂ → σ₂ × γ) :
    (mapAccumr₂ f₁ xs (mapAccumr f₂ ys s₂).snd s₁)
    = let m := (mapAccumr₂ (fun x y s =>
          let r₂ := f₂ y s.snd
          let r₁ := f₁ x r₂.snd s.fst
          ((r₁.fst, r₂.fst), r₁.snd)
        ) xs ys (s₁, s₂))
      (m.fst.fst, m.snd)
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
lemma ofNat_le_ofReal {n : ℕ} [n.AtLeastTwo] {p : ℝ} :
    no_index (OfNat.ofNat n) ≤ ENNReal.ofReal p ↔ OfNat.ofNat n ≤ p
-- Mathlib/Topology/Order/LocalExtr.lean
nonrec theorem IsLocalMinOn.inf (hf : IsLocalMinOn f s a) (hg : IsLocalMinOn g s a) :
    IsLocalMinOn (fun x => f x ⊓ g x) s a
-- Mathlib/Data/List/Basic.lean
theorem length_modifyNth (f : α → α) : ∀ n l, length (modifyNth f n l) = length l
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem eLpNorm_indicator_const {c : G} (hs : MeasurableSet s) (hp : p ≠ 0) (hp_top : p ≠ ∞) :
    eLpNorm (s.indicator fun _ => c) p μ = ‖c‖₊ * μ s ^ (1 / p.toReal)
-- Mathlib/RingTheory/Flat/Algebra.lean
/-- An `R`-algebra `S` is flat if it is flat as `R`-module. -/
class Algebra.Flat (R : Type u) (S : Type v) [CommRing R] [CommRing S] [Algebra R S] : Prop where
  out : Module.Flat R S
-- Mathlib/Topology/Order/LowerUpperTopology.lean
lemma ofUpper_inj {a b : WithUpper α} : ofUpper a = ofUpper b ↔ a = b
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
theorem IsAdjointPair.sub (h : IsAdjointPair B B' f g) (h' : IsAdjointPair B B' f' g') :
    IsAdjointPair B B' (f - f') (g - g')
-- Mathlib/Order/Filter/Extr.lean
theorem Filter.EventuallyEq.isMaxFilter_iff {α β : Type*} [Preorder β] {f g : α → β} {a : α}
    {l : Filter α} (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMaxFilter f l a ↔ IsMaxFilter g l a
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem nhds_eq_comap_uniformity {x : α} : 𝓝 x = (𝓤 α).comap (Prod.mk x)
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem denom_add_dvd (x y : RatFunc K) : denom (x + y) ∣ denom x * denom y
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem MDifferentiable.const_smul (s : 𝕜) (hf : MDifferentiable I 𝓘(𝕜, E') f) :
    MDifferentiable I 𝓘(𝕜, E') (s • f)
-- .lake/packages/batteries/Batteries/Logic.lean
theorem eqRec_eq_cast {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
    (x : motive a (rfl : a = a)) {a' : α} (e : a = a') :
    @Eq.rec α a motive x a' e = cast (e ▸ rfl) x
-- Mathlib/Dynamics/FixedPoints/Basic.lean
/-- If `x` is a fixed point of `f`, then it is a fixed point of `f^[n]`. -/
protected theorem iterate (hf : IsFixedPt f x) (n : ℕ) : IsFixedPt f^[n] x
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
@[simp]
theorem Biprod.ofComponents_snd :
    Biprod.ofComponents f₁₁ f₁₂ f₂₁ f₂₂ ≫ biprod.snd = biprod.fst ≫ f₁₂ + biprod.snd ≫ f₂₂
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
lemma map_ψ₂ : (W.map f).ψ₂ = W.ψ₂.map (mapRingHom f)
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem insert_diff_singleton {a : α} {s : Set α} : insert a (s \ {a}) = insert a s
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem coe_sub_iff_lt {a b : Fin n} : (↑(a - b) : Nat) = n + a - b ↔ a < b