ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The infimum distance to `s` and `t` are the same, up to the Hausdorff distance
between `s` and `t` -/
theorem infDist_le_infDist_add_hausdorffDist (fin : hausdorffEdist s t ≠ ⊤) :
    infDist x t ≤ infDist x s + hausdorffDist s t
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem length_reverse {u v : V} (p : G.Walk u v) : p.reverse.length = p.length
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addY_self {P : Fin 3 → R} (hP : W'.Equation P) : W'.addY P P = 0
-- Mathlib/LinearAlgebra/Dual.lean
lemma finrank_ker_add_one_of_ne_zero :
    finrank K (LinearMap.ker f) + 1 = finrank K V₁
-- Mathlib/Topology/Basic.lean
theorem frontier_closure_subset : frontier (closure s) ⊆ frontier s
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem blockDiagonal'_pow [∀ i, DecidableEq (m' i)] [Fintype o] [∀ i, Fintype (m' i)] [Semiring α]
    (M : ∀ i, Matrix (m' i) (m' i) α) (n : ℕ) : blockDiagonal' (M ^ n) = blockDiagonal' M ^ n
-- Mathlib/Analysis/Normed/Field/Basic.lean
theorem Units.norm_pos [Nontrivial α] (x : αˣ) : 0 < ‖(x : α)‖
-- Mathlib/Order/Minimal.lean
theorem maximals_Icc (hab : a ≤ b) : maximals (· ≤ ·) (Icc a b) = {b}
-- Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean
theorem associator_hom (X Y Z : C) :
    (α_ X Y Z).hom =
      coprod.desc (coprod.desc coprod.inl (coprod.inl ≫ coprod.inr)) (coprod.inr ≫ coprod.inr)
-- Mathlib/Data/Nat/Digits.lean
theorem ofDigits_one (L : List ℕ) : ofDigits 1 L = L.sum
-- Mathlib/RingTheory/Polynomial/GaussLemma.lean
/-- Integrally closed domains are precisely the domains for in which Gauss's lemma holds
    for monic polynomials -/
theorem isIntegrallyClosed_iff' :
    IsIntegrallyClosed R ↔
      ∀ p : R[X], p.Monic → (Irreducible p ↔ Irreducible (p.map <| algebraMap R K))
-- Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean
private lemma adic_surj : Function.Surjective (map I f)
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
theorem Disjoint.cycleFactorsFinset_mul_eq_union {f g : Perm α} (h : Disjoint f g) :
    cycleFactorsFinset (f * g) = cycleFactorsFinset f ∪ cycleFactorsFinset g
-- Mathlib/GroupTheory/GroupAction/ConjAct.lean
@[simp]
theorem mem_orbit_conjAct {g h : G} : g ∈ orbit (ConjAct G) h ↔ IsConj g h
-- Mathlib/Geometry/RingedSpace/PresheafedSpace.lean
@[simp]
theorem mapPresheaf_map_c (F : C ⥤ D) {X Y : PresheafedSpace C} (f : X ⟶ Y) :
    (F.mapPresheaf.map f).c = whiskerRight f.c F
-- Mathlib/InformationTheory/Hamming.lean
theorem hammingDist_comp_le_hammingDist (f : ∀ i, γ i → β i) {x y : ∀ i, γ i} :
    (hammingDist (fun i => f i (x i)) fun i => f i (y i)) ≤ hammingDist x y
-- Mathlib/MeasureTheory/Group/Measure.lean
@[to_additive (attr := deprecated IsCompact.measure_closure (since := "2024-01-28"))]
lemma _root_.IsCompact.measure_closure_eq_of_group {k : Set G} (hk : IsCompact k) (μ : Measure G) :
    μ (closure k) = μ k
-- Mathlib/Topology/Maps/Basic.lean
theorem range_mem_nhds (hf : IsOpenMap f) (x : X) : range f ∈ 𝓝 (f x)
-- Mathlib/AlgebraicTopology/SimplicialSet/Monoidal.lean
@[simp]
lemma leftUnitor_inv_app_apply (K : SSet.{u}) {Δ : SimplexCategoryᵒᵖ} (x : K.obj Δ) :
    (λ_ K).inv.app Δ x = ⟨PUnit.unit, x⟩
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean
lemma hasSum_jacobiTheta₂_term (z : ℂ) {τ : ℂ} (hτ : 0 < im τ) :
    HasSum (fun n ↦ jacobiTheta₂_term n z τ) (jacobiTheta₂ z τ)
-- Mathlib/Order/Filter/Basic.lean
protected theorem Eventually.and {p q : α → Prop} {f : Filter α} :
    f.Eventually p → f.Eventually q → ∀ᶠ x in f, p x ∧ q x
-- Mathlib/Topology/Algebra/Module/CharacterSpace.lean
theorem eq_set_map_one_map_mul [Nontrivial 𝕜] :
    characterSpace 𝕜 A = {φ : WeakDual 𝕜 A | φ 1 = 1 ∧ ∀ x y : A, φ (x * y) = φ x * φ y}
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem lsum_single (f : α → M →ₗ[R] N) (i : α) (m : M) :
    Finsupp.lsum S f (Finsupp.single i m) = f i m
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem linearEquivFunOnFinite_single [DecidableEq α] (x : α) (m : M) :
    (linearEquivFunOnFinite R M α) (single x m) = Pi.single x m
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
/-- The formula x(P₁ + P₂) = x(P₁ - P₂) - ψ(P₁)ψ(P₂) / (x(P₂) - x(P₁))²,
where ψ(x,y) = 2y + a₁x + a₃. -/
lemma addX_eq_addX_negY_sub :
    W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂) = W.addX x₁ x₂ (W.slope x₁ x₂ y₁ (W.negY x₂ y₂))
      - (y₁ - W.negY x₁ y₁) * (y₂ - W.negY x₂ y₂) / (x₂ - x₁) ^ 2
-- Mathlib/GroupTheory/GroupAction/Blocks.lean
/-- The full set is a (trivial) block -/
theorem isBlock_top : IsBlock G (⊤ : Set X)
-- Mathlib/Order/CompleteLattice.lean
theorem sInf_union {s t : Set α} : sInf (s ∪ t) = sInf s ⊓ sInf t
-- Mathlib/Data/Finset/Piecewise.lean
@[simp]
lemma piecewise_idem_right (f g₁ g₂ : ∀ a, π a) :
    s.piecewise f (s.piecewise g₁ g₂) = s.piecewise f g₂
-- Mathlib/Analysis/Normed/Ring/SeminormFromConst.lean
/-- The terms in the sequence `seminormFromConst_seq c f x` are nonnegative. -/
theorem seminormFromConst_seq_nonneg (x : R) : 0 ≤ seminormFromConst_seq c f x
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
theorem id_comp (f : A →⋆ₐ[R] B) : (StarAlgHom.id _ _).comp f = f
-- Mathlib/Data/Finset/Basic.lean
theorem union_eq_sdiff_union_sdiff_union_inter (s t : Finset α) : s ∪ t = s \ t ∪ t \ s ∪ s ∩ t
-- Mathlib/Data/Stream/Init.lean
@[simp] theorem dropLast_take {n : ℕ} {xs : Stream' α} :
    (Stream'.take n xs).dropLast = Stream'.take (n-1) xs
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem comp_apply (f : LatticeHom β γ) (g : LatticeHom α β) (a : α) : (f.comp g) a = f (g a)
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem measurableSet_sup {m₁ m₂ : MeasurableSpace α} {s : Set α} :
    MeasurableSet[m₁ ⊔ m₂] s ↔ GenerateMeasurable (MeasurableSet[m₁] ∪ MeasurableSet[m₂]) s
-- Mathlib/Algebra/Star/Module.lean
@[simp]
theorem algebraMap_star_comm (r : R) : algebraMap R A (star r) = star (algebraMap R A r)
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem mem_discrete_iff {c d : C} (f : c ⟶ d) :
    f ∈ discrete.arrows c d ↔ ∃ h : c = d, f = eqToHom h
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem ne_false_of_self : p → p ≠ False
-- Mathlib/Topology/Constructions.lean
theorem Continuous.fin_insertNth {n} {π : Fin (n + 1) → Type*} [∀ i, TopologicalSpace (π i)]
    (i : Fin (n + 1)) {f : X → π i} (hf : Continuous f) {g : X → ∀ j : Fin n, π (i.succAbove j)}
    (hg : Continuous g) : Continuous fun a => i.insertNth (f a) (g a)
-- Mathlib/Analysis/Seminorm.lean
protected theorem continuous' [TopologicalSpace E] [TopologicalAddGroup E] [ContinuousConstSMul 𝕜 E]
    {p : Seminorm 𝕜 E} {r : ℝ} (hp : p.closedBall 0 r ∈ (𝓝 0 : Filter E)) :
    Continuous p
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
theorem continuousWithinAt_arg_of_re_neg_of_im_zero {z : ℂ} (hre : z.re < 0) (him : z.im = 0) :
    ContinuousWithinAt arg { z : ℂ | 0 ≤ z.im } z
-- Mathlib/AlgebraicTopology/DoldKan/Degeneracies.lean
theorem σ_comp_P_eq_zero (X : SimplicialObject C) {n q : ℕ} (i : Fin (n + 1)) (hi : n + 1 ≤ i + q) :
    X.σ i ≫ (P q).f (n + 1) = 0
-- Mathlib/CategoryTheory/Abelian/Basic.lean
theorem epi_of_cokernel_π_eq_zero (h : cokernel.π f = 0) : Epi f
-- Mathlib/CategoryTheory/CofilteredSystem.lean
theorem isMittagLeffler_of_exists_finite_range
    (h : ∀ j : J, ∃ (i : _) (f : i ⟶ j), (range <| F.map f).Finite) : F.IsMittagLeffler
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem symm_image_target_inter_eq (s : Set β) :
    e.symm '' (e.target ∩ s) = e.source ∩ e ⁻¹' (e.target ∩ s)
-- Mathlib/Data/List/MinMax.lean
theorem minimum_of_length_pos_le_of_mem (h : a ∈ l) (w : 0 < l.length) :
    l.minimum_of_length_pos w ≤ a
-- Mathlib/RingTheory/Polynomial/Basic.lean
@[simp]
theorem toSubring_zero : toSubring (0 : R[X]) T (by simp [coeffs]) = 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
/-- In the range `[0, π / 2]`, we have a linear lower bound on `sin`. This inequality forms one half
of Jordan's inequality, the other half is `Real.sin_lt` -/
theorem mul_le_sin {x : ℝ} (hx : 0 ≤ x) (hx' : x ≤ π / 2) : 2 / π * x ≤ sin x
-- Mathlib/Algebra/Polynomial/Degree/Lemmas.lean
theorem coeff_add_eq_left_of_lt (qn : q.natDegree < n) : (p + q).coeff n = p.coeff n
-- Mathlib/Data/List/Cycle.lean
theorem prev_mem (s : Cycle α) (hs : Nodup s) (x : α) (hx : x ∈ s) : s.prev hs x hx ∈ s
-- Mathlib/Data/Multiset/Powerset.lean
@[simp]
theorem mem_powersetCard {n : ℕ} {s t : Multiset α} : s ∈ powersetCard n t ↔ s ≤ t ∧ card s = n
-- Mathlib/Algebra/Group/AddChar.lean
/-- An additive character is nontrivial iff it is not the trivial character. -/
@[deprecated ne_one_iff (since := "2024-06-06")]
lemma isNontrivial_iff_ne_trivial (ψ : AddChar A M) : IsNontrivial ψ ↔ ψ ≠ 1
-- Mathlib/RingTheory/MvPolynomial/Localization.lean
lemma isLocalization_C_mk' (a : R) (m : M) :
    C (IsLocalization.mk' S a m) = IsLocalization.mk' (MvPolynomial σ S) (C (σ := σ) a)
      ⟨C m, Submonoid.mem_map_of_mem C m.property⟩
-- Mathlib/Data/Set/Basic.lean
theorem inter_left' (u : Set α) (h : Disjoint s t) : Disjoint (u ∩ s) t
-- Mathlib/CategoryTheory/Monoidal/Center.lean
/-- Auxiliary definition for the `MonoidalCategory` instance on `Center C`. -/
@[simps]
def tensorHom {X₁ Y₁ X₂ Y₂ : Center C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
    tensorObj X₁ X₂ ⟶ tensorObj Y₁ Y₂
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem lt_bsup_of_ne_bsup {o : Ordinal.{u}} {f : ∀ a < o, Ordinal.{max u v}} :
    (∀ i h, f i h ≠ bsup.{_, v} o f) ↔ ∀ i h, f i h < bsup.{_, v} o f
-- Mathlib/RingTheory/TensorProduct/Basic.lean
theorem productMap_left_apply (a : A) : productMap f g (a ⊗ₜ 1) = f a
-- Mathlib/Algebra/Homology/TotalComplexShift.lean
@[reassoc]
lemma ι_totalShift₂Iso_inv_f (a b n : ℤ) (h : a + b = n) (b' n' : ℤ)
    (hb' : a + b' = n') (hn' : n' = n + y) :
    K.ιTotal (up ℤ) a b' n' hb' ≫
      (CochainComplex.shiftFunctorObjXIso (K.total (up ℤ)) y n n' hn').inv ≫
        (K.totalShift₂Iso y).inv.f n =
      (a * y).negOnePow • (K.shiftFunctor₂XXIso a b y b' (by omega)).inv ≫
        ((shiftFunctor₂ C y).obj K).ιTotal (up ℤ) a b n h
-- Mathlib/Analysis/InnerProductSpace/Positive.lean
theorem IsPositive.add {T S : E →L[𝕜] E} (hT : T.IsPositive) (hS : S.IsPositive) :
    (T + S).IsPositive
-- Mathlib/Order/Bounds/Basic.lean
/-- A monotone map sends a greatest element of a set to a greatest element of its image. -/
theorem map_isGreatest (Hf : MonotoneOn f t) (Ha : IsGreatest t a) : IsGreatest (f '' t) (f a)
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem mulVec_injective_iff_isUnit {A : Matrix m m K} :
    Function.Injective A.mulVec ↔ IsUnit A
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Mul.lean
@[simp]
theorem mul_apply' (x y : 𝕜') : mul 𝕜 𝕜' x y = x * y
-- Mathlib/Topology/AlexandrovDiscrete.lean
lemma isClopen_sUnion (hS : ∀ s ∈ S, IsClopen s) : IsClopen (⋃₀ S)
-- Mathlib/LinearAlgebra/Matrix/Symmetric.lean
@[simp]
theorem IsSymm.map {A : Matrix n n α} (h : A.IsSymm) (f : α → β) : (A.map f).IsSymm
-- Mathlib/Algebra/Order/Interval/Set/Group.lean
theorem add_mem_Icc_iff_left : a + b ∈ Set.Icc c d ↔ a ∈ Set.Icc (c - b) (d - b)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Restrict.lean
lemma cfcₙHom_eq_restrict (f : C(S, R)) (halg : UniformEmbedding (algebraMap R S)) {a : A}
    (hpa : p a) (hqa : q a) (h : QuasispectrumRestricts a f) [CompactSpace (σₙ S a)] :
    cfcₙHom hpa = h.nonUnitalStarAlgHom (cfcₙHom hqa)
-- Mathlib/RingTheory/IntegralClosure/IsIntegral/Basic.lean
theorem Submodule.span_range_natDegree_eq_adjoin {R A} [CommRing R] [Semiring A] [Algebra R A]
    {x : A} {f : R[X]} (hf : f.Monic) (hfx : aeval x f = 0) :
    span R (Finset.image (x ^ ·) (Finset.range (natDegree f))) =
      Subalgebra.toSubmodule (Algebra.adjoin R {x})
-- Mathlib/Algebra/Tropical/BigOperators.lean
theorem Multiset.trop_sum [AddCommMonoid R] (s : Multiset R) :
    trop s.sum = Multiset.prod (s.map trop)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
/-- The formula
ψ(P₁ + P₂) = (ψ(P₂)(x(P₁) - x(P₃)) - ψ(P₁)(x(P₂) - x(P₃))) / (x(P₂) - x(P₁)),
where ψ(x,y) = 2y + a₁x + a₃. -/
lemma addY_sub_negY_addY :
    letI x₃ := W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂)
    letI y₃ := W.addY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂)
    y₃ - W.negY x₃ y₃ =
      ((y₂ - W.negY x₂ y₂) * (x₁ - x₃) - (y₁ - W.negY x₁ y₁) * (x₂ - x₃)) / (x₂ - x₁)
-- Mathlib/LinearAlgebra/Contraction.lean
@[simp]
theorem homTensorHomEquiv_toLinearMap :
    (homTensorHomEquiv R M N P Q).toLinearMap = homTensorHomMap R M N P Q
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem le_zero [LE R] [OrderTop R] (x : Tropical R) : x ≤ 0
-- Mathlib/Data/Finset/Basic.lean
@[elab_as_elim]
theorem cons_induction_on {α : Type*} {p : Finset α → Prop} (s : Finset α) (h₁ : p ∅)
    (h₂ : ∀ ⦃a : α⦄ {s : Finset α} (h : a ∉ s), p s → p (cons a s h)) : p s
-- Mathlib/SetTheory/Surreal/Dyadic.lean
theorem dyadic_aux {m₁ m₂ : ℤ} {y₁ y₂ : ℕ} (h₂ : m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂) :
    m₁ * powHalf y₂ = m₂ * powHalf y₁
-- Mathlib/Data/Complex/Order.lean
@[simp, norm_cast]
theorem real_le_real {x y : ℝ} : (x : ℂ) ≤ (y : ℂ) ↔ x ≤ y
-- Mathlib/Algebra/Periodic.lean
/-- If a function `f` is `Periodic` with positive period `c`, then for all `x` there exists some
  `y ∈ Ico a (a + c)` such that `f x = f y`. -/
theorem Periodic.exists_mem_Ico [LinearOrderedAddCommGroup α] [Archimedean α] (h : Periodic f c)
    (hc : 0 < c) (x a) : ∃ y ∈ Ico a (a + c), f x = f y
-- Mathlib/Algebra/Order/Interval/Multiset.lean
lemma map_add_right_Icc (a b c : α) : ((Icc a b).map fun x => x + c) = Icc (a + c) (b + c)
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp] theorem Decidable.not_not [Decidable p] : ¬¬p ↔ p
-- Mathlib/Analysis/Normed/Module/Span.lean
theorem toSpanSingleton_homothety (x : E) (c : 𝕜) :
    ‖LinearMap.toSpanSingleton 𝕜 E x c‖ = ‖x‖ * ‖c‖
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Or.comm : a ∨ b ↔ b ∨ a
-- Mathlib/Order/Hom/Lattice.lean
theorem copy_eq (f : InfHom α β) (f' : α → β) (h : f' = f) : f.copy f' h = f
-- Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean
theorem widePullback_ext {B : C} {ι : Type w} {X : ι → C} (f : ∀ j : ι, X j ⟶ B)
    [HasWidePullback B X f] [PreservesLimit (wideCospan B X f) (forget C)]
    (x y : ↑(widePullback B X f)) (h₀ : base f x = base f y) (h : ∀ j, π f j x = π f j y) :
    x = y
-- Mathlib/Algebra/GroupWithZero/Divisibility.lean
theorem ne_zero_of_dvd_ne_zero {p q : α} (h₁ : q ≠ 0) (h₂ : p ∣ q) : p ≠ 0
-- Mathlib/LinearAlgebra/Quotient.lean
theorem comap_liftQ (f : M →ₛₗ[τ₁₂] M₂) (h) : q.comap (p.liftQ f h) = (q.comap f).map (mkQ p)
-- Mathlib/Topology/Maps/Basic.lean
theorem tendsto_nhds_iff {f : ι → Y} {l : Filter ι} {y : Y} (hg : Inducing g) :
    Tendsto f l (𝓝 y) ↔ Tendsto (g ∘ f) l (𝓝 (g y))
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem GoodProducts.linearIndependent (hC : IsClosed C) :
    LinearIndependent ℤ (GoodProducts.eval C)
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
/-- Monomials are weighted homogeneous. -/
theorem isWeightedHomogeneous_monomial (w : σ → M) (d : σ →₀ ℕ) (r : R) {m : M}
    (hm : weight w d = m) : IsWeightedHomogeneous w (monomial d r) m
-- Mathlib/Data/Real/Hyperreal.lean
@[simp] theorem infinitesimal_real_iff {r : ℝ} : Infinitesimal r ↔ r = 0
-- Mathlib/Data/Nat/Cast/Commute.lean
@[simp] lemma natCast_mul_natCast_mul (h : Commute a b) (m n : ℕ) : Commute (m * a) (n * b)
-- Mathlib/Order/Interval/Set/Disjoint.lean
theorem Ioc_disjoint_Ioi_same : Disjoint (Ioc a b) (Ioi b)
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- Fundamental theorem of calculus: if `f : ℝ → E` is integrable on `a..b` and `f x` is continuous
from the left or from the right at `a`, then `u ↦ ∫ x in u..b, f x` has left (resp., right)
derivative `-f a` at `a`. -/
theorem integral_hasDerivWithinAt_left (hf : IntervalIntegrable f volume a b) {s t : Set ℝ}
    [FTCFilter a (𝓝[s] a) (𝓝[t] a)] (hmeas : StronglyMeasurableAtFilter f (𝓝[t] a))
    (ha : ContinuousWithinAt f t a) : HasDerivWithinAt (fun u => ∫ x in u..b, f x) (-f a) s a
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem HasFiniteIntegral.mono_measure {f : α → β} (h : HasFiniteIntegral f ν) (hμ : μ ≤ ν) :
    HasFiniteIntegral f μ
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions/Fractions.lean
lemma exists_leftFraction₂ {X Y : C} (f f' : L.obj X ⟶ L.obj Y) :
    ∃ (φ : W.LeftFraction₂ X Y), f = φ.fst.map L (inverts L W) ∧
      f' = φ.snd.map L (inverts L W)
-- Mathlib/Probability/Independence/Conditional.lean
theorem iCondIndepSet.condIndep_generateFrom_of_disjoint {s : ι → Set Ω}
    (hsm : ∀ n, MeasurableSet (s n)) (hs : iCondIndepSet m' hm' s μ) (S T : Set ι)
    (hST : Disjoint S T) :
    CondIndep m' (generateFrom { t | ∃ n ∈ S, s n = t })
      (generateFrom { t | ∃ k ∈ T, s k = t }) hm' μ
-- Mathlib/Data/Nat/PartENat.lean
/-- Alias of `Nat.cast_lt` specialized to `PartENat` --/
theorem coe_lt_coe {x y : ℕ} : (x : PartENat) < y ↔ x < y
-- Mathlib/RingTheory/Multiplicity.lean
theorem multiplicity_eq_zero_of_coprime {p a b : ℕ} (hp : p ≠ 1)
    (hle : multiplicity p a ≤ multiplicity p b) (hab : Nat.Coprime a b) : multiplicity p a = 0
-- Mathlib/Analysis/Normed/MulAction.lean
theorem nnnorm_smul (r : α) (x : β) : ‖r • x‖₊ = ‖r‖₊ * ‖x‖₊
-- Mathlib/Data/Set/Prod.lean
theorem prod_univ {s : Set α} : s ×ˢ (univ : Set β) = Prod.fst ⁻¹' s
-- Mathlib/Data/Finset/Basic.lean
@[simp] lemma right_eq_union : s = t ∪ s ↔ t ⊆ s
-- Mathlib/Algebra/Ring/Subring/Basic.lean
/-- The range of a surjective ring homomorphism is the whole of the codomain. -/
@[simp]
theorem range_top_of_surjective (f : R →+* S) (hf : Function.Surjective f) :
    f.range = (⊤ : Subring S)
-- Mathlib/Analysis/NormedSpace/HomeomorphBall.lean
theorem ball_subset_univBall_target (c : P) (r : ℝ) : ball c r ⊆ (univBall c r).target
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem normalize_mul_left {a : Nat} (d0 : d ≠ 0) (a0 : a ≠ 0) :
    normalize (↑a * n) (a * d) (Nat.mul_ne_zero a0 d0) = normalize n d d0
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem not_forall_of_exists_not {p : α → Prop} : (∃ x, ¬p x) → ¬∀ x, p x
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem inf_compl_self (a : α) : a ⊓ aᶜ = ⊥
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
theorem fst_univ : ρ.fst univ = ρ univ
-- Mathlib/Probability/Moments.lean
theorem IndepFun.mgf_add' {X Y : Ω → ℝ} (h_indep : IndepFun X Y μ) (hX : AEStronglyMeasurable X μ)
    (hY : AEStronglyMeasurable Y μ) : mgf (X + Y) μ t = mgf X μ t * mgf Y μ t
-- Mathlib/CategoryTheory/Limits/Pi.lean
/-- If we have a functor `F : J ⥤ Π i, C i` into a category of indexed families,
and colimits exist for each of the `F ⋙ Pi.eval C i`,
there is a colimit for `F`.
-/
theorem hasColimit_of_hasColimit_comp_eval : HasColimit F
-- Mathlib/Algebra/Category/Grp/EpiMono.lean
theorem fromCoset_ne_of_nin_range {b : B} (hb : b ∉ f.range) :
    fromCoset ⟨b • ↑f.range, b, rfl⟩ ≠ fromCoset ⟨f.range, 1, one_leftCoset _⟩
-- Mathlib/Data/ENNReal/Operations.lean
protected theorem sub_eq_of_eq_add (hb : b ≠ ∞) : a = c + b → a - b = c
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
lemma mk_v (v : ∀ (p q : ℤ) (_ : p + n = q), F.X p ⟶ G.X q) (p q : ℤ) (hpq : p + n = q) :
    (Cochain.mk v).v p q hpq = v p q hpq
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem toFun_embedding_empty (f : M ↪ N) : (Embedding.empty f : M → N) = f
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
@[simp]
theorem midpoint_add_sub (x y : V) : midpoint R (x + y) (x - y) = x
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem map_inf_comap_of_surjective (I J : Ideal S) : (I.comap f ⊓ J.comap f).map f = I ⊓ J
-- Mathlib/Algebra/GCDMonoid/Finset.lean
theorem gcd_eq_of_dvd_sub {s : Finset β} {f g : β → α} {a : α}
    (h : ∀ x : β, x ∈ s → a ∣ f x - g x) :
    GCDMonoid.gcd a (s.gcd f) = GCDMonoid.gcd a (s.gcd g)
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem empty.nonempty_equiv_iff :
    Nonempty (M ≃[Language.empty] N) ↔ Cardinal.lift.{w'} #M = Cardinal.lift.{w} #N
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem of_decide_eq_true [inst : Decidable p] : Eq (decide p) true → p
-- Mathlib/RingTheory/DedekindDomain/Different.lean
lemma Submodule.one_le_traceDual_one :
    (1 : Submodule B L) ≤ 1ᵛ
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[measurability, fun_prop]
theorem Measurable.ennreal_toNNReal {f : α → ℝ≥0∞} (hf : Measurable f) :
    Measurable fun x => (f x).toNNReal
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
/-- The Gram operator T†T is a positive operator. -/
theorem re_inner_adjoint_mul_self_nonneg (T : E →ₗ[𝕜] E) (x : E) :
    0 ≤ re ⟪x, (LinearMap.adjoint T * T) x⟫
-- Mathlib/Analysis/Calculus/Taylor.lean
theorem taylor_within_apply (f : ℝ → E) (n : ℕ) (s : Set ℝ) (x₀ x : ℝ) :
    taylorWithinEval f n s x₀ x =
      ∑ k ∈ Finset.range (n + 1), ((k ! : ℝ)⁻¹ * (x - x₀) ^ k) • iteratedDerivWithin k f s x₀
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem subtype_substructureEquivMap (f : M ↪[L] N) (s : L.Substructure M) :
    (subtype _).comp (f.substructureEquivMap s).toEmbedding = f.comp (subtype _)
-- Mathlib/RingTheory/AdjoinRoot.lean
theorem minpoly_powerBasis_gen_of_monic (hf : f.Monic) (hf' : f ≠ 0 := hf.ne_zero) :
    minpoly K (powerBasis hf').gen = f
-- Mathlib/Topology/Category/LightProfinite/AsLimit.lean
lemma proj_comp_transitionMap' (n : ℕ) : S.transitionMap n ∘ S.proj (n + 1) = S.proj n
-- Mathlib/Algebra/Star/BigOperators.lean
@[simp]
theorem star_sum [AddCommMonoid R] [StarAddMonoid R] {α : Type*} (s : Finset α) (f : α → R) :
    star (∑ x ∈ s, f x) = ∑ x ∈ s, star (f x)
-- Mathlib/CategoryTheory/Category/ULift.lean
@[simp]
theorem objDown_objUp {C} (A : C) : (ULiftHom.objUp A).objDown = A
-- Mathlib/Data/DFinsupp/Basic.lean
@[ext]
theorem ext {f g : Π₀ i, β i} (h : ∀ i, f i = g i) : f = g
-- Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean
theorem Summable.unop {f : β → αᵐᵒᵖ} (hf : Summable f) : Summable (unop ∘ f)
-- Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean
theorem deriv_sqrt_mul_log' :
    (deriv fun x => √x * log x) = fun x => (2 + log x) / (2 * √x)
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
@[simp]
theorem range_toAlternatingMap :
    Set.range (toAlternatingMap : M [⋀^ι]→L[R] N → (M [⋀^ι]→ₗ[R] N)) =
      {f : M [⋀^ι]→ₗ[R] N | Continuous f}
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem tsub_eq_zero_iff_le : a - b = 0 ↔ a ≤ b
-- Mathlib/Data/Finset/Powerset.lean
theorem powerset_insert [DecidableEq α] (s : Finset α) (a : α) :
    powerset (insert a s) = s.powerset ∪ s.powerset.image (insert a)
-- Mathlib/RingTheory/MaximalSpectrum.lean
theorem toPrimeSpectrum_injective : (@toPrimeSpectrum R _).Injective
-- Mathlib/CategoryTheory/Category/Preorder.lean
@[simp]
theorem homOfLE_refl {x : X} (h : x ≤ x) : h.hom = 𝟙 x
-- Mathlib/Algebra/Lie/Nilpotent.lean
@[simp]
theorem nilpotencyLength_eq_one_iff [Nontrivial M] :
    nilpotencyLength R L M = 1 ↔ IsTrivial L M
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem addNat_one {i : Fin n} : addNat i 1 = i.succ
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
theorem ext_iff' : μ₁ = μ₂ ↔ ∀ s, μ₁ s = μ₂ s
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem card_univ : card univ.{u,v} = Cardinal.univ.{u,v}
-- Mathlib/NumberTheory/NumberField/Basic.lean
theorem isIntegral_coe (x : 𝓞 K) : IsIntegral ℤ (algebraMap _ K x)
-- Mathlib/Algebra/Group/Defs.lean
/-- A `LeftCancelSemigroup` is a semigroup such that `a * b = a * c` implies `b = c`. -/
@[ext]
class LeftCancelSemigroup (G : Type u) extends Semigroup G where
  protected mul_left_cancel : ∀ a b c : G, a * b = a * c → b = c
-- Mathlib/NumberTheory/FLT/Three.lean
private lemma x_spec : S.a + S.b = λ ^ (3 * S.multiplicity - 2) * S.x
-- Mathlib/Algebra/Order/Monoid/Unbundled/Defs.lean
theorem Covariant.flip (h : Covariant M N μ r) : Covariant M N μ (flip r)
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
@[simp]
lemma rightUnshift_smul {n' a : ℤ} (γ : Cochain K (L⟦a⟧) n') (n : ℤ) (hn : n' + a = n) (x : R) :
    (x • γ).rightUnshift n hn = x • γ.rightUnshift n hn