ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Function/Intersectivity.lean
/-- **Bergelson Intersectivity Lemma**: In a finite measure space, a sequence of events that have
measure at least `r` has an infinite subset whose finite intersections all have positive volume. -/
lemma bergelson [Infinite ι] {s : ι → Set α} (hs : ∀ i, MeasurableSet (s i)) (hr₀ : r ≠ 0)
    (hr : ∀ i, r ≤ μ (s i)) :
    ∃ t : Set ι, t.Infinite ∧ ∀ ⦃u⦄, u ⊆ t → u.Finite → 0 < μ (⋂ i ∈ u, s i)
-- Mathlib/Probability/Independence/Conditional.lean
@[simp]
theorem CondIndepSets.union_iff {s₁ s₂ s' : Set (Set Ω)}  :
    CondIndepSets m' hm' (s₁ ∪ s₂) s' μ
      ↔ CondIndepSets m' hm' s₁ s' μ ∧ CondIndepSets m' hm' s₂ s' μ
-- Mathlib/RingTheory/IsAdjoinRoot.lean
theorem minpoly_eq [IsDomain R] [IsDomain S] [NoZeroSMulDivisors R S] [IsIntegrallyClosed R]
    (h : IsAdjoinRootMonic S f) (hirr : Irreducible f) : minpoly R h.root = f
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem mem_coe {a : α} {l : List α} : a ∈ (l : Multiset α) ↔ a ∈ l
-- Mathlib/Topology/Separation.lean
theorem t0Space_iff_or_not_mem_closure (X : Type u) [TopologicalSpace X] :
    T0Space X ↔ Pairwise fun a b : X => a ∉ closure ({b} : Set X) ∨ b ∉ closure ({a} : Set X)
-- Mathlib/Data/List/MinMax.lean
theorem argmax_mem : ∀ {l : List α} {m : α}, m ∈ argmax f l → m ∈ l
-- Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean
theorem diagonalSucc_hom_single (f : Gⁿ⁺¹) (a : k) :
    (diagonalSucc k G n).hom.hom (single f a) =
      single (f 0) 1 ⊗ₜ single (fun i => (f (Fin.castSucc i))⁻¹ * f i.succ) a
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
/-- If `x` is not in the closure of `s`, then `f` has any derivative at `x` within `s`,
as this statement is empty. -/
theorem hasFDerivWithinAt_of_nmem_closure (h : x ∉ closure s) : HasFDerivWithinAt f f' s x
-- Mathlib/Order/Fin/Basic.lean
lemma strictMono_castLE (h : n ≤ m) : StrictMono (castLE h : Fin n → Fin m)
-- Mathlib/ModelTheory/Satisfiability.lean
theorem IsSatisfiable.mono (h : T'.IsSatisfiable) (hs : T ⊆ T') : T.IsSatisfiable
-- Mathlib/Order/LiminfLimsup.lean
@[simp, nolint simpNF]
theorem liminf_nat_add (f : ℕ → α) (k : ℕ) :
    liminf (fun i => f (i + k)) atTop = liminf f atTop
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
theorem inl_of_isLimit {X Y : C} {t : BinaryBicone X Y} (ht : IsLimit t.toCone) :
    t.inl = ht.lift (BinaryFan.mk (𝟙 X) 0)
-- Mathlib/Algebra/Order/Archimedean.lean
theorem le_of_forall_rat_lt_imp_le (h : ∀ q : ℚ, (q : α) < x → (q : α) ≤ y) : x ≤ y
-- Mathlib/FieldTheory/IsPerfectClosure.lean
@[simp]
theorem liftAux_id_apply (x : K) : liftAux (RingHom.id K) j p x = j x
-- Mathlib/CategoryTheory/Equivalence.lean
/-- To see that a functor is an equivalence, it suffices to provide an inverse functor `G` such that
    `F ⋙ G` and `G ⋙ F` are naturally isomorphic to identity functors. -/
protected lemma mk' {F : C ⥤ D} (G : D ⥤ C) (η : 𝟭 C ≅ F ⋙ G) (ε : G ⋙ F ≅ 𝟭 D) :
    IsEquivalence F
-- Mathlib/Algebra/Homology/DifferentialObject.lean
@[reassoc (attr := simp)]
theorem eqToHom_f' {X Y : DifferentialObject ℤ (GradedObjectWithShift b V)} (f : X ⟶ Y) {x y : β}
    (h : x = y) : X.objEqToHom h ≫ f.f y = f.f x ≫ Y.objEqToHom h
-- Mathlib/Data/Set/Image.lean
theorem image_pair (f : α → β) (a b : α) : f '' {a, b} = {f a, f b}
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
theorem rank_pos_iff_exists_ne_zero : 0 < Module.rank R M ↔ ∃ x : M, x ≠ 0
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem sum_apply_eq_zero' {μ : ι → Measure α} {s : Set α} (hs : MeasurableSet s) :
    sum μ s = 0 ↔ ∀ i, μ i s = 0
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem map_zipWith {δ : Type _} (f : α → β) (g : γ → δ → α) (l : List γ) (l' : List δ) :
    map f (zipWith g l l') = zipWith (fun x y => f (g x y)) l l'
-- Mathlib/Analysis/Convex/Basic.lean
theorem convex_iff_ordConnected [LinearOrderedField 𝕜] {s : Set 𝕜} :
    Convex 𝕜 s ↔ s.OrdConnected
-- Mathlib/Combinatorics/Enumerative/Partition.lean
/-- A `Multiset ℕ` induces a partition on its sum. -/
@[simps!]
def ofMultiset (l : Multiset ℕ) : Partition l.sum
-- Mathlib/Analysis/Convex/Between.lean
theorem Wbtw.map {x y z : P} (h : Wbtw R x y z) (f : P →ᵃ[R] P') : Wbtw R (f x) (f y) (f z)
-- Mathlib/Algebra/Field/Subfield.lean
/-- A subfield is closed under multiplication. -/
protected theorem mul_mem {x y : K} : x ∈ s → y ∈ s → x * y ∈ s
-- Mathlib/SetTheory/Cardinal/Finite.lean
@[simp]
theorem card_eq_fintype_card [Fintype α] : Nat.card α = Fintype.card α
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
/-- The Lebesgue integral is measurable. This shows that the integrand of (the right-hand-side of)
  Tonelli's theorem is measurable.
  This version has the argument `f` in curried form. -/
theorem Measurable.lintegral_prod_right [SFinite ν] {f : α → β → ℝ≥0∞}
    (hf : Measurable (uncurry f)) : Measurable fun x => ∫⁻ y, f x y ∂ν
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
theorem prod_edist_eq_of_L2 (x y : WithLp 2 (α × β)) :
    edist x y = (edist x.fst y.fst ^ 2 + edist x.snd y.snd ^ 2) ^ (1 / 2 : ℝ)
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem eq_of_monic_of_dvd_of_natDegree_le {R} [CommRing R] {p q : R[X]} (hp : p.Monic)
    (hq : q.Monic) (hdiv : p ∣ q) (hdeg : q.natDegree ≤ p.natDegree) : q = p
-- Mathlib/Analysis/Calculus/Deriv/Inverse.lean
theorem HasStrictDerivAt.hasStrictFDerivAt_equiv {f : 𝕜 → 𝕜} {f' x : 𝕜}
    (hf : HasStrictDerivAt f f' x) (hf' : f' ≠ 0) :
    HasStrictFDerivAt f (ContinuousLinearEquiv.unitsEquivAut 𝕜 (Units.mk0 f' hf') : 𝕜 →L[𝕜] 𝕜) x
-- Mathlib/Analysis/SpecialFunctions/Bernstein.lean
theorem δ_pos {f : C(I, ℝ)} {ε : ℝ} {h : 0 < ε} : 0 < δ f ε h
-- Mathlib/Data/Multiset/Basic.lean
theorem count_replicate (a b : α) (n : ℕ) : count a (replicate n b) = if a = b then n else 0
-- Mathlib/Data/Matroid/Map.lean
@[simp] lemma comap_base_iff {B : Set α} :
    (N.comap f).Base B ↔ N.Basis (f '' B) (f '' (f ⁻¹' N.E)) ∧ B.InjOn f ∧ B ⊆ f ⁻¹' N.E
-- Mathlib/Combinatorics/SimpleGraph/Density.lean
theorem interedges_mono (hs : s₂ ⊆ s₁) (ht : t₂ ⊆ t₁) : interedges r s₂ t₂ ⊆ interedges r s₁ t₁
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
@[simp]
theorem mk_conjugate_eq (φ : K →+* ℂ) : mk (ComplexEmbedding.conjugate φ) = mk φ
-- .lake/packages/batteries/Batteries/Data/Nat/Lemmas.lean
@[simp] theorem casesDiagOn_zero_zero {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 (n+1)) (succ_zero : ∀ m, motive (m+1) 0)
    (succ_succ : ∀ m n, motive (m+1) (n+1)) :
    Nat.casesDiagOn 0 0 (motive:=motive) zero_zero zero_succ succ_zero succ_succ = zero_zero
-- Mathlib/Dynamics/PeriodicPts.lean
theorem comp {g : α → α} (hco : Commute f g) (hf : IsPeriodicPt f n x) (hg : IsPeriodicPt g n x) :
    IsPeriodicPt (f ∘ g) n x
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
@[reassoc]
theorem δ_comp_σ_self' {n} {j : Fin (n + 2)} {i : Fin (n + 1)} (H : j = Fin.castSucc i) :
    X.σ i ≫ X.δ j = 𝟙 _
-- Mathlib/Data/Num/Lemmas.lean
theorem bit0_of_bit0 : ∀ n : ZNum, n + n = n.bit0
-- Mathlib/Data/Fintype/Quotient.lean
theorem Quotient.finChoiceAux_eq {ι : Type*} [DecidableEq ι] {α : ι → Type*}
    [S : ∀ i, Setoid (α i)] :
    ∀ (l : List ι) (f : ∀ i ∈ l, α i), (Quotient.finChoiceAux l fun i h => ⟦f i h⟧) = ⟦f⟧
-- Mathlib/Data/Nat/Log.lean
theorem pow_pred_clog_lt_self {b : ℕ} (hb : 1 < b) {x : ℕ} (hx : 1 < x) :
    b ^ (clog b x).pred < x
-- Mathlib/MeasureTheory/Measure/Lebesgue/VolumeOfBalls.lean
theorem MeasureTheory.measure_le_eq_lt [Nontrivial E] (r : ℝ) :
    μ {x : E | g x ≤ r} = μ {x : E | g x < r}
-- Mathlib/MeasureTheory/Integral/Bochner.lean
/-- Hölder's inequality for the integral of a product of norms. The integral of the product of two
norms of functions is bounded by the product of their `ℒp` and `ℒq` seminorms when `p` and `q` are
conjugate exponents. -/
theorem integral_mul_norm_le_Lp_mul_Lq {E} [NormedAddCommGroup E] {f g : α → E} {p q : ℝ}
    (hpq : p.IsConjExponent q) (hf : Memℒp f (ENNReal.ofReal p) μ)
    (hg : Memℒp g (ENNReal.ofReal q) μ) :
    ∫ a, ‖f a‖ * ‖g a‖ ∂μ ≤ (∫ a, ‖f a‖ ^ p ∂μ) ^ (1 / p) * (∫ a, ‖g a‖ ^ q ∂μ) ^ (1 / q)
-- Mathlib/Topology/ContinuousOn.lean
theorem continuous_piecewise {s : Set α} {f g : α → β} [∀ a, Decidable (a ∈ s)]
    (hs : ∀ a ∈ frontier s, f a = g a) (hf : ContinuousOn f (closure s))
    (hg : ContinuousOn g (closure sᶜ)) : Continuous (piecewise s f g)
-- Mathlib/Algebra/Star/Subalgebra.lean
@[simp]
theorem mem_inf {S T : StarSubalgebra R A} {x : A} : x ∈ S ⊓ T ↔ x ∈ S ∧ x ∈ T
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem eq_top_iff' (A : Subring R) : A = ⊤ ↔ ∀ x : R, x ∈ A
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem iteratedFDerivWithin_const_of_ne {n : ℕ} (hn : n ≠ 0) (c : F)
    (hs : UniqueDiffOn 𝕜 s) (hx : x ∈ s) :
    iteratedFDerivWithin 𝕜 n (fun _ : E ↦ c) s x = 0
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
@[simp]
theorem beth_lt {o₁ o₂ : Ordinal} : beth o₁ < beth o₂ ↔ o₁ < o₂
-- Mathlib/Algebra/ContinuedFractions/Computation/Approximations.lean
/-- Shows that the fractional parts of the stream are nonnegative. -/
theorem nth_stream_fr_nonneg {ifp_n : IntFractPair K}
    (nth_stream_eq : IntFractPair.stream v n = some ifp_n) : 0 ≤ ifp_n.fr
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem LineDifferentiableAt.hasLineDerivAt (h : LineDifferentiableAt 𝕜 f x v) :
    HasLineDerivAt 𝕜 f (lineDeriv 𝕜 f x v) x v
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive (attr := simp)]
theorem smul_empty : s • (∅ : Set β) = ∅
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace/ResidueField.lean
lemma evaluation_ne_zero_iff_mem_basicOpen (x : U) (f : X.presheaf.obj (op U)) :
    X.evaluation x f ≠ 0 ↔ x.val ∈ X.toRingedSpace.basicOpen f
-- Mathlib/Analysis/RCLike/Basic.lean
theorem isCauSeq_re (f : CauSeq K norm) : IsCauSeq abs fun n => re (f n)
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive neg_le_iff_add_nonneg]
theorem inv_le_iff_one_le_mul : a⁻¹ ≤ b ↔ 1 ≤ b * a
-- Mathlib/Analysis/RCLike/Basic.lean
theorem I_mul_I_of_nonzero : (I : K) ≠ 0 → (I : K) * I = -1
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
theorem toFun_eq_coe {f : M →ₛₗ[σ] M₃} : f.toFun = (f : M → M₃)
-- Mathlib/Algebra/Field/Subfield.lean
theorem mem_sSup_of_directedOn {S : Set (Subfield K)} (Sne : S.Nonempty) (hS : DirectedOn (· ≤ ·) S)
    {x : K} : x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s
-- Mathlib/Algebra/Ring/Parity.lean
lemma odd_add' : Odd (m + n) ↔ (Odd n ↔ Even m)
-- Mathlib/CategoryTheory/Triangulated/Opposite.lean
lemma mem_distTriang_op_iff (T : Triangle Cᵒᵖ) :
    (T ∈ distTriang Cᵒᵖ) ↔ ((triangleOpEquivalence C).inverse.obj T).unop ∈ distTriang C
-- Mathlib/Algebra/Algebra/RestrictScalars.lean
@[simp]
theorem RestrictScalars.ringEquiv_map_smul (r : R) (x : RestrictScalars R S A) :
    RestrictScalars.ringEquiv R S A (r • x) =
      algebraMap R S r • RestrictScalars.ringEquiv R S A x
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem tendsto_iff_of_dist {f₁ f₂ : ι → α} {p : Filter ι} {a : α}
    (h : Tendsto (fun x => dist (f₁ x) (f₂ x)) p (𝓝 0)) : Tendsto f₁ p (𝓝 a) ↔ Tendsto f₂ p (𝓝 a)
-- Mathlib/Topology/IsLocalHomeomorph.lean
theorem OpenEmbedding.isLocalHomeomorph (hf : OpenEmbedding f) : IsLocalHomeomorph f
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
@[simp]
theorem nonsing_inv_mul_cancel_right (B : Matrix m n α) (h : IsUnit A.det) : B * A⁻¹ * A = B
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
lemma adjoin_eq (s : NonUnitalSubalgebra R A) : adjoin R (s : Set A) = s
-- Mathlib/RingTheory/WittVector/MulCoeff.lean
theorem mul_polyOfInterest_aux5 (n : ℕ) :
    (p : 𝕄) ^ (n + 1) * polyOfInterest p n = remainder p n - wittPolyProdRemainder p (n + 1)
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem mul_add_right_left {x y : R} (h : IsCoprime x y) (z : R) : IsCoprime (z * y + x) y
-- Mathlib/Order/Disjoint.lean
theorem Codisjoint.of_codisjoint_sup_of_le' (h : Codisjoint (a ⊔ b) c) (hle : c ≤ b) :
    Codisjoint a b
-- Mathlib/CategoryTheory/MorphismProperty/Composition.lean
/-- Typeclass expressing that a morphism property contain identities. -/
class ContainsIdentities (W : MorphismProperty C) : Prop :=
  /-- for all `X : C`, the identity of `X` satisfies the morphism property -/
  id_mem : ∀ (X : C), W (𝟙 X)
-- Mathlib/Data/Fintype/Card.lean
@[simp]
theorem Fintype.card_prop : Fintype.card Prop = 2
-- Mathlib/Algebra/Lie/Weights/Cartan.lean
theorem toLieSubmodule_le_rootSpace_zero : H.toLieSubmodule ≤ rootSpace H 0
-- Mathlib/SetTheory/Surreal/Multiplication.lean
lemma P24_neg_left : P24 x₁ x₂ y ↔ P24 (-x₂) (-x₁) y
-- Mathlib/Order/Filter/Basic.lean
theorem map_comap_le : map m (comap m g) ≤ g
-- Mathlib/Order/CompleteLattice.lean
@[simp] lemma iSup_ulift {ι : Type*} [SupSet α] (f : ULift ι → α) :
    ⨆ i : ULift ι, f i = ⨆ i, f (.up i)
-- Mathlib/Algebra/Polynomial/Laurent.lean
@[simp] lemma invert_C (t : R) : invert (C t) = C t
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem disjoint_prod : Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂
-- Mathlib/Topology/UniformSpace/Cauchy.lean
nonrec theorem Cauchy.map [UniformSpace β] {f : Filter α} {m : α → β} (hf : Cauchy f)
    (hm : UniformContinuous m) : Cauchy (map m f)
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
@[simp]
theorem eLpNorm_neg {f : α → F} : eLpNorm (-f) p μ = eLpNorm f p μ
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
theorem testBit_one_zero : testBit 1 0 = true
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem mkRat_ne_zero (d0 : d ≠ 0) : mkRat n d ≠ 0 ↔ n ≠ 0
-- Mathlib/Data/Set/Finite.lean
@[simp]
protected theorem Finite.insert (a : α) {s : Set α} (hs : s.Finite) : (insert a s).Finite
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem setLIntegral_const (s : Set α) (c : ℝ≥0∞) : ∫⁻ _ in s, c ∂μ = c * μ s
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Icc_bot : Icc ⊥ a = Iic a
-- Mathlib/Combinatorics/Enumerative/Composition.lean
@[simp]
theorem ones_sizeUpTo (n : ℕ) (i : ℕ) : (ones n).sizeUpTo i = min i n
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
@[simp]
theorem csInf_Icc (h : a ≤ b) : sInf (Icc a b) = a
-- Mathlib/Algebra/Ring/Hom/Defs.lean
theorem codomain_trivial (f : α →+* β) [h : Subsingleton α] : Subsingleton β
-- Mathlib/Data/Multiset/Basic.lean
@[simp] theorem card_replicate (n) (a : α) : card (replicate n a) = n
-- Mathlib/Data/Setoid/Partition.lean
theorem eqv_class_mem' {c : Set (Set α)} (H : ∀ a, ∃! b ∈ c, a ∈ b) {x} :
    { y : α | (mkClasses c H).Rel x y } ∈ c
-- Mathlib/Order/Filter/Basic.lean
theorem comap_sup : comap m (g₁ ⊔ g₂) = comap m g₁ ⊔ comap m g₂
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem ContDiffWithinAt.contDiffOn {m : ℕ} (hm : (m : ℕ∞) ≤ n) (h : ContDiffWithinAt 𝕜 n f s x) :
    ∃ u ∈ 𝓝[insert x s] x, u ⊆ insert x s ∧ ContDiffOn 𝕜 m f u
-- Mathlib/Topology/StoneCech.lean
theorem denseRange_preStoneCechUnit : DenseRange (preStoneCechUnit : α → PreStoneCech α)
-- Mathlib/Algebra/Lie/Basic.lean
protected theorem bijective (e : L₁ ≃ₗ⁅R⁆ L₂) : Function.Bijective ((e : L₁ →ₗ⁅R⁆ L₂) : L₁ → L₂)
-- Mathlib/Topology/Gluing.lean
theorem π_surjective : Function.Surjective 𝖣.π
-- Mathlib/Order/Concept.lean
@[simp]
theorem intentClosure_extentClosure_intentClosure (s : Set α) :
    intentClosure r (extentClosure r <| intentClosure r s) = intentClosure r s
-- Mathlib/LinearAlgebra/Trace.lean
lemma trace_mul_cycle (f g h : M →ₗ[R] M) :
    trace R M (f * g * h) = trace R M (h * f * g)
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
/-- The bijection `normalized_factors_equiv_span_normalized_factors.symm` between the set of prime
    factors of the ideal `⟨r⟩` and the set of prime factors of `r` preserves multiplicities. -/
theorem multiplicity_normalizedFactorsEquivSpanNormalizedFactors_symm_eq_multiplicity {r : R}
    (hr : r ≠ 0) (I : { I : Ideal R | I ∈ normalizedFactors (Ideal.span ({r} : Set R)) }) :
    multiplicity ((normalizedFactorsEquivSpanNormalizedFactors hr).symm I : R) r =
      multiplicity (I : Ideal R) (Ideal.span {r})
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
@[simp]
theorem trailingDegree_eq_top : trailingDegree p = ⊤ ↔ p = 0
-- Mathlib/Logic/Equiv/Basic.lean
theorem swap_comp_apply {a b x : α} (π : Perm α) :
    π.trans (swap a b) x = if π x = a then b else if π x = b then a else π x
-- Mathlib/Topology/MetricSpace/Basic.lean
/-- Two metric space structures with the same distance coincide. -/
@[ext]
theorem MetricSpace.ext {α : Type*} {m m' : MetricSpace α} (h : m.toDist = m'.toDist) :
    m = m'
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_iAlls [Finite γ] {f : α → β ⊕ γ}
    {φ : L.Formula α} {v : β → M} {v' : Fin 0 → M} :
    BoundedFormula.Realize (φ.iAlls f) v v' ↔
      ∀ (i : γ → M), φ.Realize (fun a => Sum.elim v i (f a))
-- Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean
@[simp]
theorem algebraMap_eq_one_iff (x : R) : algebraMap R (TensorAlgebra R M) x = 1 ↔ x = 1
-- Mathlib/Data/Fin/Tuple/Basic.lean
@[simp]
theorem cons_succ : cons x p i.succ = p i
-- Mathlib/Topology/Order/Lattice.lean
lemma ContinuousWithinAt.sup' (hf : ContinuousWithinAt f s x) (hg : ContinuousWithinAt g s x) :
    ContinuousWithinAt (f ⊔ g) s x
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem zipWith_map_left (l₁ : List α) (l₂ : List β) (f : α → α') (g : α' → β → γ) :
    zipWith g (l₁.map f) l₂ = zipWith (fun a b => g (f a) b) l₁ l₂
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma growsPolynomially_one_sub_smoothingFn : GrowsPolynomially fun x => 1 - ε x
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem false_ne_true : false ≠ true
-- Mathlib/CategoryTheory/ComposableArrows.lean
lemma hom_ext_succ {F G : ComposableArrows C (n + 1)} {f g : F ⟶ G}
    (h₀ : app' f 0 = app' g 0) (h₁ : δ₀Functor.map f = δ₀Functor.map g) : f = g
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean
@[reassoc (attr := simp)]
lemma pullback_inv_snd_fst_of_left_isIso :
    inv (pullback.snd f g) ≫ pullback.fst f g = g ≫ inv f
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem attach_empty : attach (∅ : Finset α) = ∅
-- Mathlib/Algebra/Order/Group/Int.lean
lemma natAbs_le_self_sq (a : ℤ) : (Int.natAbs a : ℤ) ≤ a ^ 2
-- Mathlib/Data/Finset/Density.lean
lemma dens_ne_one : dens s ≠ 1 ↔ s ≠ univ
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[simp]
theorem mul_apply (f g : α →*₀o β) (a : α) : (f * g) a = f a * g a
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem finiteAtFilter_of_finite {_m0 : MeasurableSpace α} (μ : Measure α) [IsFiniteMeasure μ]
    (f : Filter α) : μ.FiniteAtFilter f
-- Mathlib/Topology/Semicontinuous.lean
theorem IsClosed.lowerSemicontinuousAt_indicator (hs : IsClosed s) (hy : y ≤ 0) :
    LowerSemicontinuousAt (indicator s fun _x => y) x
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
@[simp]
theorem integrableOn_empty : IntegrableOn f ∅ μ
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem lieSpan_le {N} : lieSpan R L s ≤ N ↔ s ⊆ N
-- Mathlib/Data/Finset/Basic.lean
@[simp, norm_cast]
theorem coe_empty : ((∅ : Finset α) : Set α) = ∅
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem symm_self_id_assoc (α : X ≅ Y) (β : Y ≅ Z) : α.symm ≪≫ α ≪≫ β = β
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem pred_mk_succ (i : Nat) (h : i < n + 1) :
    Fin.pred ⟨i + 1, Nat.add_lt_add_right h 1⟩ (ne_of_val_ne (Nat.ne_of_gt (mk_succ_pos i h))) =
      ⟨i, h⟩
-- Mathlib/Data/Int/Bitwise.lean
theorem bitwise_and : bitwise and = land
-- Mathlib/Order/Monotone/Basic.lean
theorem monotone_nat_of_le_succ {f : ℕ → α} (hf : ∀ n, f n ≤ f (n + 1)) : Monotone f
-- Mathlib/Data/Nat/Lattice.lean
theorem biUnion_lt_succ (u : ℕ → Set α) (n : ℕ) : ⋃ k < n + 1, u k = (⋃ k < n, u k) ∪ u n
-- Mathlib/Topology/Category/LightProfinite/AsLimit.lean
lemma surjective_transitionMapLE {n m : ℕ} (h : n ≤ m) :
    Function.Surjective (S.transitionMapLE h)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem degree_C_mul_X_pow (n : ℕ) (ha : a ≠ 0) : degree (C a * X ^ n) = n
-- Mathlib/Combinatorics/Additive/AP/Three/Defs.lean
theorem rothNumberNat_spec (n : ℕ) :
    ∃ t ⊆ range n, t.card = rothNumberNat n ∧ ThreeAPFree (t : Set ℕ)
-- Mathlib/Topology/Instances/ENNReal.lean
protected theorem tsum_sigma' {β : α → Type*} (f : (Σa, β a) → ℝ≥0∞) :
    ∑' p : Σa, β a, f p = ∑' (a) (b), f ⟨a, b⟩
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem coe_zetaUnit : ((zetaUnit : (ArithmeticFunction R)ˣ) : ArithmeticFunction R) = ζ
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem toNat_ofInt {n : Nat} (i : Int) :
  (BitVec.ofInt n i).toNat = (i % (2^n : Nat)).toNat
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- Morphisms between direct sums are matrices. -/
@[simps]
def biproduct.matrixEquiv : (⨁ f ⟶ ⨁ g) ≃ ∀ j k, f j ⟶ g k
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.const_mul [DivisionSemiring α] [Neg β] (h : Antiperiodic f c) {a : α}
    (ha : a ≠ 0) : Antiperiodic (fun x => f (a * x)) (a⁻¹ * c)
-- Mathlib/Order/Interval/Set/Disjoint.lean
@[simp]
theorem Ioo_disjoint_Ioo [DenselyOrdered α] :
    Disjoint (Set.Ioo a₁ a₂) (Set.Ioo b₁ b₂) ↔ min a₂ b₂ ≤ max a₁ b₁
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem getElem_append : ∀ {l₁ l₂ : List α} (n : Nat) (h : n < l₁.length),
    (l₁ ++ l₂)[n]'(length_append .. ▸ Nat.lt_add_right _ h) = l₁[n]
-- Mathlib/Order/Interval/Set/Image.lean
@[simp]
lemma image_subtype_val_Ioc_Iio {a b : α} (c : Ioc a b) : Subtype.val '' Iio c = Ioo a c
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
@[ext]
theorem eq_of_forall_toMeasure_apply_eq (μ ν : ProbabilityMeasure Ω)
    (h : ∀ s : Set Ω, MeasurableSet s → (μ : Measure Ω) s = (ν : Measure Ω) s) : μ = ν
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[deprecated getElem_dropLast (since := "2024-06-12")]
theorem get_dropLast (xs : List α) (i : Fin xs.dropLast.length) :
    xs.dropLast.get i = xs.get ⟨i, Nat.lt_of_lt_of_le i.isLt (length_dropLast .. ▸ Nat.pred_le _)⟩
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean
/-- The composition in the opposite direction is equal to the identity if and only if `F` preserves
    the biproduct, see `preservesBinaryBiproduct_of_monoBiprodComparison`. -/
@[reassoc (attr := simp)]
theorem biprodComparison'_comp_biprodComparison :
    biprodComparison' F X Y ≫ biprodComparison F X Y = 𝟙 (F.obj X ⊞ F.obj Y)
-- Mathlib/Analysis/Convex/Function.lean
/-- A strictly convex function admits at most one global minimum. -/
lemma StrictConvexOn.eq_of_isMinOn (hf : StrictConvexOn 𝕜 s f) (hfx : IsMinOn f s x)
    (hfy : IsMinOn f s y) (hx : x ∈ s) (hy : y ∈ s) : x = y
-- Mathlib/Analysis/Normed/Module/FiniteDimension.lean
/-- In an infinite dimensional space, given a finite number of points, one may find a point
with norm at most `R` which is at distance at least `1` of all these points. -/
theorem exists_norm_le_le_norm_sub_of_finset {c : 𝕜} (hc : 1 < ‖c‖) {R : ℝ} (hR : ‖c‖ < R)
    (h : ¬FiniteDimensional 𝕜 E) (s : Finset E) : ∃ x : E, ‖x‖ ≤ R ∧ ∀ y ∈ s, 1 ≤ ‖y - x‖
-- Mathlib/Data/ENNReal/Real.lean
/-- If `x ≠ 0` and `x ≠ ∞`, then left multiplication by `x` maps infimum to infimum.
See also `ENNReal.mul_iInf` that assumes `[Nonempty ι]` but does not require `x ≠ 0`. -/
theorem mul_iInf_of_ne {ι} {f : ι → ℝ≥0∞} {x : ℝ≥0∞} (h0 : x ≠ 0) (h : x ≠ ∞) :
    x * iInf f = ⨅ i, x * f i
-- Mathlib/Data/List/Join.lean
/-- Taking only the first `i+1` elements in a list, and then dropping the first `i` ones, one is
left with a list of length `1` made of the `i`-th element of the original list. -/
theorem drop_take_succ_eq_cons_getElem (L : List α) (i : Nat) (h : i < L.length) :
    (L.take (i + 1)).drop i = [L[i]]
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := simp)]
theorem iInter_inv (s : ι → Set α) : (⋂ i, s i)⁻¹ = ⋂ i, (s i)⁻¹
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem map_modByMonicHom (h : IsAdjoinRootMonic S f) (x : S) : h.map (h.modByMonicHom x) = x
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem denseRange_iff {f : β → α} : DenseRange f ↔ ∀ x, ∀ r > 0, ∃ y, dist x (f y) < r
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
theorem exists_affineBasis_of_finiteDimensional [Fintype ι] [FiniteDimensional k V]
    (h : Fintype.card ι = FiniteDimensional.finrank k V + 1) : Nonempty (AffineBasis ι k P)