ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Homology/Localization.lean
@[reassoc]
lemma mapHomologicalComplexUpToQuasiIsoFactorsh_hom_app (K : HomologicalComplex C c) :
    (F.mapHomologicalComplexUpToQuasiIsoFactorsh c).hom.app
        ((HomotopyCategory.quotient _ _).obj K) =
      (F.mapHomologicalComplexUpToQuasiIso c).map
          ((HomologicalComplexUpToQuasiIso.quotientCompQhIso C c).hom.app K) ≫
        (F.mapHomologicalComplexUpToQuasiIsoFactors c).hom.app K ≫
          (HomologicalComplexUpToQuasiIso.quotientCompQhIso D c).inv.app _ ≫
            HomologicalComplexUpToQuasiIso.Qh.map
              ((F.mapHomotopyCategoryFactors c).inv.app K)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- A vector equals a rotation of that vector if and only if the vector or the angle is zero. -/
theorem eq_rotation_self_iff (x : V) (θ : Real.Angle) : x = o.rotation θ x ↔ x = 0 ∨ θ = 0
-- Mathlib/Algebra/Divisibility/Basic.lean
theorem dvd_mul_of_dvd_left (h : a ∣ b) (c : α) : a ∣ b * c
-- Mathlib/Order/LiminfLimsup.lean
theorem Monotone.isBoundedUnder_le_comp_iff [Nonempty β] [LinearOrder β] [Preorder γ] [NoMaxOrder γ]
    {g : β → γ} {f : α → β} {l : Filter α} (hg : Monotone g) (hg' : Tendsto g atTop atTop) :
    IsBoundedUnder (· ≤ ·) l (g ∘ f) ↔ IsBoundedUnder (· ≤ ·) l f
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem coe_injective : @Function.Injective (VectorMeasure α M) (Set α → M) (⇑)
-- Mathlib/Topology/MetricSpace/MetricSeparated.lean
@[mono]
theorem mono {s' t'} (hs : s ⊆ s') (ht : t ⊆ t') :
    IsMetricSeparated s' t' → IsMetricSeparated s t
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive (attr := simp)]
theorem toWord_eq_nil_iff {x : FreeGroup α} : x.toWord = [] ↔ x = 1
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
theorem mono_measure (h : AEMeasurable f μ) (h' : ν ≤ μ) : AEMeasurable f ν
-- Mathlib/Algebra/Ring/Rat.lean
@[simp] lemma den_mul_eq_num (q : ℚ) : q.den * q = q.num
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem not_mem_range_self {n : Nat} : n ∉ range n
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem center_eq_top (A : Type*) [NonUnitalCommSemiring A] [StarRing A] [Module R A]
    [IsScalarTower R A A] [SMulCommClass R A A] [StarModule R A] : center R A = ⊤
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem map_map {g : β → γ} {f : α → β} (hg : Measurable g) (hf : Measurable f) :
    (μ.map f).map g = μ.map (g ∘ f)
-- Mathlib/Analysis/Matrix.lean
theorem nnnorm_entry_le_entrywise_sup_nnnorm (A : Matrix m n α) {i : m} {j : n} : ‖A i j‖₊ ≤ ‖A‖₊
-- Mathlib/Probability/Martingale/BorelCantelli.lean
theorem adapted_process (hs : ∀ n, MeasurableSet[ℱ n] (s n)) : Adapted ℱ (process s)
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
@[simp]
theorem exists_mem_algebraMap_eq {x : R} {I : Ideal R} (h : S ≤ nonZeroDivisors R) :
    (∃ x', x' ∈ I ∧ algebraMap R P x' = algebraMap R P x) ↔ x ∈ I
-- Mathlib/Data/Set/Basic.lean
theorem inter_inter_distrib_right (s t u : Set α) : s ∩ t ∩ u = s ∩ u ∩ (t ∩ u)
-- Mathlib/MeasureTheory/Group/Measure.lean
@[to_additive]
theorem map_div_right_eq_self (μ : Measure G) [IsMulRightInvariant μ] (g : G) :
    map (· / g) μ = μ
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
@[elab_as_elim]
theorem induction_on₂ {α' β' : Type*} [MeasurableSpace α'] [TopologicalSpace β'] {μ' : Measure α'}
    (f : α →ₘ[μ] β) (f' : α' →ₘ[μ'] β') {p : (α →ₘ[μ] β) → (α' →ₘ[μ'] β') → Prop}
    (H : ∀ f hf f' hf', p (mk f hf) (mk f' hf')) : p f f'
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean
@[simp]
lemma toNNReal_neg_algebraMap (r : ℝ≥0) : (- algebraMap ℝ C(X, ℝ) r).toNNReal = 0
-- Mathlib/Data/Fin/Basic.lean
@[simp] lemma ofNat'_one {h : 0 < n} [NeZero n] : (Fin.ofNat' 1 h : Fin n) = 1
-- Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean
theorem AEFinStronglyMeasurable.ae_nonneg_of_forall_setIntegral_nonneg {f : α → ℝ}
    (hf : AEFinStronglyMeasurable f μ)
    (hf_int_finite : ∀ s, MeasurableSet s → μ s < ∞ → IntegrableOn f s μ)
    (hf_zero : ∀ s, MeasurableSet s → μ s < ∞ → 0 ≤ ∫ x in s, f x ∂μ) : 0 ≤ᵐ[μ] f
-- Mathlib/ModelTheory/Substructures.lean
theorem lift_card_closure_le :
    Cardinal.lift.{u, w} #(closure L s) ≤
      max ℵ₀ (Cardinal.lift.{u, w} #s + Cardinal.lift.{w, u} #(Σi, L.Functions i))
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)] theorem mrange_inl_sup_mrange_inr :
    MonoidHom.mrange (inl : M →* M ∗ N) ⊔ MonoidHom.mrange (inr : N →* M ∗ N) = ⊤
-- Mathlib/SetTheory/Cardinal/ToNat.lean
theorem toNat_apply_of_aleph0_le {c : Cardinal} (h : ℵ₀ ≤ c) : toNat c = 0
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem join_join (SS : Seq (Seq1 (Seq1 α))) :
    Seq.join (Seq.join SS) = Seq.join (Seq.map join SS)
-- Mathlib/MeasureTheory/Measure/MutuallySingular.lean
lemma eq_zero_of_absolutelyContinuous_of_mutuallySingular {μ ν : Measure α}
    (h_ac : μ ≪ ν) (h_ms : μ ⟂ₘ ν) :
    μ = 0
-- Mathlib/Analysis/CstarAlgebra/GelfandDuality.lean
/-- The Gelfand transform is spectrum-preserving. -/
theorem spectrum.gelfandTransform_eq (a : A) :
    spectrum ℂ (gelfandTransform ℂ A a) = spectrum ℂ a
-- Mathlib/Topology/Category/CompHausLike/Basic.lean
/-- The type of Compact Hausdorff topological spaces satisfying an additional property `P`. -/
structure CompHausLike where
  /-- The underlying topological space of an object of `CompHausLike P`. -/
  toTop : TopCat
  /-- The underlying topological space is compact. -/
  [is_compact : CompactSpace toTop]
  /-- The underlying topological space is T2. -/
  [is_hausdorff : T2Space toTop]
  /-- The underlying topological space satisfies P. -/
  prop : P toTop
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive (attr := ext)]
theorem MulOneClass.ext {M : Type u} : ∀ ⦃m₁ m₂ : MulOneClass M⦄, m₁.mul = m₂.mul → m₁ = m₂
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
@[simp]
protected theorem linearIsometry_apply_single {i : ι} (x : G i) :
    hV.linearIsometry (lp.single 2 i x) = V i x
-- Mathlib/Probability/StrongLaw.lean
theorem truncation_eq_of_nonneg {f : α → ℝ} {A : ℝ} (h : ∀ x, 0 ≤ f x) :
    truncation f A = indicator (Set.Ioc 0 A) id ∘ f
-- Mathlib/Data/ENNReal/Operations.lean
theorem mul_max : a * max b c = max (a * b) (a * c)
-- Mathlib/GroupTheory/GroupAction/Basic.lean
/-- `smul` by a `k : M` over a ring is injective, if `k` is not a zero divisor.
The general theory of such `k` is elaborated by `IsSMulRegular`.
The typeclass that restricts all terms of `M` to have this property is `NoZeroSMulDivisors`. -/
theorem smul_cancel_of_non_zero_divisor {M R : Type*} [Monoid M] [NonUnitalNonAssocRing R]
    [DistribMulAction M R] (k : M) (h : ∀ x : R, k • x = 0 → x = 0) {a b : R} (h' : k • a = k • b) :
    a = b
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
/-- Composition on the left by a (continuous) homomorphism of topological monoids, as a
`MonoidHom`. Similar to `MonoidHom.compLeft`. -/
@[to_additive (attr := simps)
"Composition on the left by a (continuous) homomorphism of topological `AddMonoid`s, as an
`AddMonoidHom`. Similar to `AddMonoidHom.comp_left`."]
protected def _root_.MonoidHom.compLeftContinuous {γ : Type*} [Monoid β] [ContinuousMul β]
    [TopologicalSpace γ] [Monoid γ] [ContinuousMul γ] (g : β →* γ) (hg : Continuous g) :
    C(α, β) →* C(α, γ)
-- Mathlib/MeasureTheory/Measure/WithDensityFinite.lean
lemma measurableSet_sigmaFiniteSet (μ : Measure α) [SFinite μ] :
    MeasurableSet μ.sigmaFiniteSet
-- Mathlib/Logic/Embedding/Basic.lean
theorem coe_injective {α β} : @Injective (α ↪ β) (α → β) (fun f ↦ ↑f)
-- Mathlib/Algebra/BigOperators/Group/Multiset.lean
@[to_additive (attr := simp)]
theorem prod_map_div : (m.map fun i => f i / g i).prod = (m.map f).prod / (m.map g).prod
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive const_add]
theorem MonotoneOn.const_mul' [CovariantClass α α (· * ·) (· ≤ ·)] (hf : MonotoneOn f s) (a : α) :
    MonotoneOn (fun x => a * f x) s
-- Mathlib/Combinatorics/SetFamily/Shatter.lean
/-- Down-compressing decreases the VC-dimension. -/
lemma vcDim_compress_le (a : α) (𝒜 : Finset (Finset α)) : (𝓓 a 𝒜).vcDim ≤ 𝒜.vcDim
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem supported_univ : supported M R (Set.univ : Set α) = ⊤
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Series.lean
/-- The power series expansion of `Complex.sin`. -/
theorem Complex.hasSum_sin (z : ℂ) :
    HasSum (fun n : ℕ => (-1) ^ n * z ^ (2 * n + 1) / ↑(2 * n + 1)!) (Complex.sin z)
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
@[simp, mfld_simps]
theorem singletonChartedSpace_chartAt_eq (h : e.source = Set.univ) {x : α} :
    @chartAt H _ α _ (e.singletonChartedSpace h) x = e
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Instances.lean
@[simp] theorem run_set [Monad m] (s s' : σ) : (set s' : StateT σ m PUnit).run s = pure (⟨⟩, s')
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
/-- A structure containing informations on the way a space `H` embeds in a
model vector space `E` over the field `𝕜`. This is all what is needed to
define a smooth manifold with model space `H`, and model vector space `E`.
-/
@[ext] -- Porting note(#5171): was nolint has_nonempty_instance
structure ModelWithCorners (𝕜 : Type*) [NontriviallyNormedField 𝕜] (E : Type*)
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] (H : Type*) [TopologicalSpace H] extends
    PartialEquiv H E where
  source_eq : source = univ
  unique_diff' : UniqueDiffOn 𝕜 toPartialEquiv.target
  continuous_toFun : Continuous toFun := by continuity
  continuous_invFun : Continuous invFun := by continuity
-- Mathlib/Order/Hom/Basic.lean
/-- An order isomorphism between the domains and codomains of two prosets of
order homomorphisms gives an order isomorphism between the two function prosets. -/
@[simps apply symm_apply]
def arrowCongr {α β γ δ} [Preorder α] [Preorder β] [Preorder γ] [Preorder δ]
    (f : α ≃o γ) (g : β ≃o δ) : (α →o β) ≃o (γ →o δ)
-- Mathlib/LinearAlgebra/RootSystem/Defs.lean
@[simp]
lemma pairing_same : P.pairing i i = 2
-- Mathlib/Algebra/Module/LinearMap/End.lean
theorem iterate_bijective (h : Bijective f') : ∀ n : ℕ, Bijective (f' ^ n)
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive (attr := simp)]
theorem self_comp_symm (e : M ≃* N) : e ∘ e.symm = id
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- For `F : J ⥤ C`, given a cone `c : Cone F`, and a natural isomorphism `α : H ≅ H'` for functors
`H H' : C ⥤ D`, the postcomposition of the cone `H.mapCone` using the isomorphism `α` is
isomorphic to the cone `H'.mapCone`.
-/
@[simps!]
def postcomposeWhiskerLeftMapCone {H H' : C ⥤ D} (α : H ≅ H') (c : Cone F) :
    (Cones.postcompose (whiskerLeft F α.hom : _)).obj (mapCone H c) ≅ mapCone H' c
-- Mathlib/Algebra/Lie/Weights/RootSystem.lean
@[simp]
lemma chainLength_neg :
    chainLength (-α) β = chainLength α β
-- Mathlib/Data/Sigma/Basic.lean
theorem Function.Injective.of_sigma_map {f₁ : α₁ → α₂} {f₂ : ∀ a, β₁ a → β₂ (f₁ a)}
    (h : Injective (Sigma.map f₁ f₂)) (a : α₁) : Injective (f₂ a)
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
/-- The functor `G ↦ k[G]`, from the category of magmas to the category of
non-unital, non-associative algebras over `k` is adjoint to the forgetful functor in the other
direction. -/
@[simps apply_apply symm_apply]
def liftMagma [Module k A] [IsScalarTower k A A] [SMulCommClass k A A] :
    (Multiplicative G →ₙ* A) ≃ (k[G] →ₙₐ[k] A)
-- Mathlib/NumberTheory/ModularForms/EisensteinSeries/UniformConvergence.lean
lemma r1_eq : r1 z = 1 / ((z.re / z.im) ^ 2 + 1)
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem sum_nat_eq_add_sum_succ (f : ℕ → Cardinal.{u}) :
    Cardinal.sum f = f 0 + Cardinal.sum fun i => f (i + 1)
-- Mathlib/Geometry/RingedSpace/PresheafedSpace.lean
/-- The map to the restriction of a presheafed space along the canonical inclusion from the top
subspace.
-/
@[simps]
def toRestrictTop (X : PresheafedSpace C) : X ⟶ X.restrict (Opens.openEmbedding ⊤)
-- Mathlib/Data/Int/Defs.lean
lemma inductionOn'_sub_one (hz : z ≤ b) :
    (z - 1).inductionOn' b H0 Hs Hp = Hp z hz (z.inductionOn' b H0 Hs Hp)
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem Monic.mul_left_ne_zero (hp : Monic p) {q : R[X]} (hq : q ≠ 0) : q * p ≠ 0
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- If the sign of the angle between two vectors is negative, the vectors are not equal. -/
theorem ne_of_oangle_sign_eq_neg_one {x y : V} (h : (o.oangle x y).sign = -1) : x ≠ y
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
theorem ae_eq_mk {f : α → β} (hfm : AEStronglyMeasurable' m f μ) : f =ᵐ[μ] hfm.mk f
-- Mathlib/Topology/MetricSpace/Isometry.lean
theorem mapsTo_closedBall (hf : Isometry f) (x : α) (r : ℝ) :
    MapsTo f (Metric.closedBall x r) (Metric.closedBall (f x) r)
-- Mathlib/RingTheory/WittVector/MulCoeff.lean
theorem nth_mul_coeff' (n : ℕ) :
    ∃ f : TruncatedWittVector p (n + 1) k → TruncatedWittVector p (n + 1) k → k,
    ∀ x y : 𝕎 k, f (truncateFun (n + 1) x) (truncateFun (n + 1) y) =
      (x * y).coeff (n + 1) - y.coeff (n + 1) * x.coeff 0 ^ p ^ (n + 1) -
        x.coeff (n + 1) * y.coeff 0 ^ p ^ (n + 1)
-- Mathlib/Topology/Algebra/InfiniteSum/Group.lean
@[to_additive]
theorem multipliable_const_iff [Infinite β] [T2Space G] (a : G) :
    Multipliable (fun _ : β ↦ a) ↔ a = 1
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive]
lemma mul_le_prod {i j : ι} (hf : ∀ i ∈ s, 1 ≤ f i) (hi : i ∈ s) (hj : j ∈ s) (hne : i ≠ j) :
    f i * f j ≤ ∏ k ∈ s, f k
-- Mathlib/Algebra/Star/Module.lean
theorem StarModule.selfAdjointPart_add_skewAdjointPart (x : A) :
    (selfAdjointPart R x : A) + skewAdjointPart R x = x
-- Mathlib/Data/Finset/Basic.lean
@[aesop unsafe apply (rule_sets := [finsetNonempty])]
theorem Nonempty.inl {s t : Finset α} (h : s.Nonempty) : (s ∪ t).Nonempty
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem MeasurableSet.congr {s t : Set α} (hs : MeasurableSet s) (h : s = t) : MeasurableSet t
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
lemma comap_add (hf : MeasurableEmbedding f) (μ ν : Measure β) :
    (μ + ν).comap f = μ.comap f + ν.comap f
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
/-- The functor forgetting the differential in a complex, obtaining a graded object. -/
@[simps]
def forget : HomologicalComplex V c ⥤ GradedObject ι V
-- Mathlib/Algebra/BigOperators/Group/Multiset.lean
theorem prod_dvd_prod_of_dvd [CommMonoid β] {S : Multiset α} (g1 g2 : α → β)
    (h : ∀ a ∈ S, g1 a ∣ g2 a) : (Multiset.map g1 S).prod ∣ (Multiset.map g2 S).prod
-- Mathlib/Data/Matrix/Basis.lean
@[simp]
theorem mul_right_apply_of_ne (a b : n) (hbj : b ≠ j) (M : Matrix n n α) :
    (M * stdBasisMatrix i j c) a b = 0
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem contDiffWithinAt_ext_coord_change [SmoothManifoldWithCorners I M] (x x' : M) {y : E}
    (hy : y ∈ ((extChartAt I x').symm ≫ extChartAt I x).source) :
    ContDiffWithinAt 𝕜 ⊤ (extChartAt I x ∘ (extChartAt I x').symm) (range I) y
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
theorem append_cons (as : List α) (b : α) (bs : List α) : as ++ b :: bs = as ++ [b] ++ bs
-- Mathlib/Data/Fintype/Pi.lean
lemma filter_piFinset_of_not_mem (t : ∀ a, Finset (δ a)) (a : α) (x : δ a) (hx : x ∉ t a) :
    (piFinset t).filter (· a = x) = ∅
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
lemma hasHomology_of_isIsoLeftRightHomologyComparison [S.HasLeftHomology]
    [S.HasRightHomology] [h : IsIso S.leftRightHomologyComparison] :
    S.HasHomology
-- Mathlib/Algebra/Group/AddChar.lean
@[simp] lemma toAddMonoidHom_apply (ψ : AddChar A M) (a : A) :
    ψ.toAddMonoidHom a = Additive.ofMul (ψ a)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem contDiff_const_smul (c : R) : ContDiff 𝕜 n fun p : F => c • p
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
lemma _root_.fderivWithin_continuousLinearEquiv_comp (L : G ≃L[𝕜] G') (f : E → (F →L[𝕜] G))
    (hs : UniqueDiffWithinAt 𝕜 s x) :
    fderivWithin 𝕜 (fun x ↦ (L : G →L[𝕜] G').comp (f x)) s x =
      (((ContinuousLinearEquiv.refl 𝕜 F).arrowCongr L)) ∘L (fderivWithin 𝕜 f s x)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
protected theorem ContDiffOn.derivWithin (hf : ContDiffOn 𝕜 n f₂ s₂) (hs : UniqueDiffOn 𝕜 s₂)
    (hmn : m + 1 ≤ n) : ContDiffOn 𝕜 m (derivWithin f₂ s₂) s₂
-- Mathlib/Order/Heyting/Hom.lean
@[simp]
theorem map_bihimp (a b : α) : f (a ⇔ b) = f a ⇔ f b
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem rev_rev (i : Fin n) : rev (rev i) = i
-- Mathlib/RingTheory/IsTensorProduct.lean
theorem IsBaseChange.algHom_ext (g₁ g₂ : N →ₗ[S] Q) (e : ∀ x, g₁ (f x) = g₂ (f x)) : g₁ = g₂
-- Mathlib/Data/Real/Basic.lean
private irreducible_def sup : ℝ → ℝ → ℝ
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem ofFractionRing_sub (p q : FractionRing K[X]) :
    ofFractionRing (p - q) = ofFractionRing p - ofFractionRing q
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
private theorem mul_le_of_limit_aux {α β r s} [IsWellOrder α r] [IsWellOrder β s] {c}
    (h : IsLimit (type s)) (H : ∀ b' < type s, type r * b' ≤ c) (l : c < type r * type s) :
    False
-- Mathlib/Data/Finmap.lean
theorem ext_lookup {s₁ s₂ : Finmap β} : (∀ x, s₁.lookup x = s₂.lookup x) → s₁ = s₂
-- Mathlib/ModelTheory/Complexity.lean
theorem induction_on_exists_not {P : ∀ {m}, L.BoundedFormula α m → Prop} (φ : L.BoundedFormula α n)
    (hqf : ∀ {m} {ψ : L.BoundedFormula α m}, IsQF ψ → P ψ)
    (hnot : ∀ {m} {φ : L.BoundedFormula α m}, P φ → P φ.not)
    (hex : ∀ {m} {φ : L.BoundedFormula α (m + 1)}, P φ → P φ.ex)
    (hse : ∀ {m} {φ₁ φ₂ : L.BoundedFormula α m},
      Theory.SemanticallyEquivalent ∅ φ₁ φ₂ → (P φ₁ ↔ P φ₂)) :
    P φ
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem sizeUpTo_succ' (i : Fin c.length) :
    c.sizeUpTo ((i : ℕ) + 1) = c.sizeUpTo i + c.blocksFun i
-- Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean
theorem stream_zero (v : K) : IntFractPair.stream v 0 = some (IntFractPair.of v)
-- Mathlib/Algebra/Group/Commute/Defs.lean
@[to_additive]
protected theorem mul_inv (hab : Commute a b) : (a * b)⁻¹ = a⁻¹ * b⁻¹
-- Mathlib/Data/NNRat/Defs.lean
theorem coe_mono : Monotone ((↑) : ℚ≥0 → ℚ)
-- Mathlib/RingTheory/AdicCompletion/Functoriality.lean
@[simp]
theorem sum_of (j : ι) (x : AdicCompletion I (M j)) :
    sum I M ((DirectSum.of (fun i ↦ AdicCompletion I (M i)) j) x) =
      map I (lof R ι M j) x
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem span_mono {s t : Set α} : s ⊆ t → span s ≤ span t
-- Mathlib/CategoryTheory/Types.lean
@[simp]
theorem types_id_apply (X : Type u) (x : X) : (𝟙 X : X → X) x = x
-- .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean
theorem Heap.WF.of_rankGT (hlt : s.rankGT n) (h : Heap.WF le n' s) : s.WF le (n+1)
-- Mathlib/Order/Cover.lean
theorem wcovBy_iff : x ⩿ y ↔ x.1 ⩿ y.1 ∧ x.2 = y.2 ∨ x.2 ⩿ y.2 ∧ x.1 = y.1
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
@[simp]
theorem ContinuousLinearEquiv.uniqueDiffOn_image_iff (e : E ≃L[𝕜] F) :
    UniqueDiffOn 𝕜 (e '' s) ↔ UniqueDiffOn 𝕜 s
-- Mathlib/Algebra/TrivSqZeroExt.lean
theorem map_comp_map (f : M →ₗ[R'] N) (g : N →ₗ[R'] P) :
    map (g.comp f) = (map g).comp (map f)
-- Mathlib/Data/Matrix/Rank.lean
/-- Left multiplying by an invertible matrix does not change the rank -/
@[simp]
lemma rank_mul_eq_right_of_isUnit_det [Fintype m] [DecidableEq m]
    (A : Matrix m m R) (B : Matrix m n R) (hA : IsUnit A.det) :
    (A * B).rank = B.rank
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem one_le_mul_of_one_le_of_one_le [ZeroLEOneClass α] [PosMulMono α]
    (ha : 1 ≤ a) (hb : 1 ≤ b) : (1 : α) ≤ a * b
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem Finset.toFinset_coe (s : Finset α) [Fintype (s : Set α)] : (s : Set α).toFinset = s
-- Mathlib/Data/Nat/Lattice.lean
theorem sInf_mem {s : Set ℕ} (h : s.Nonempty) : sInf s ∈ s
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
theorem OuterMeasure.coe_mkMetric [MeasurableSpace X] [BorelSpace X] (m : ℝ≥0∞ → ℝ≥0∞) :
    ⇑(OuterMeasure.mkMetric m : OuterMeasure X) = Measure.mkMetric m
-- Mathlib/Topology/ContinuousOn.lean
theorem preimage_nhdsWithin_coinduced' {π : α → β} {s : Set β} {t : Set α} {a : α} (h : a ∈ t)
    (hs : s ∈ @nhds β (.coinduced (fun x : t => π x) inferInstance) (π a)) :
    π ⁻¹' s ∈ 𝓝[t] a
-- Mathlib/Algebra/Associated/Basic.lean
protected theorem Associated.dvd' [Monoid α] {a b : α} (h : a ~ᵤ b) : b ∣ a
-- Mathlib/Data/Set/Basic.lean
theorem ite_eq_of_subset_left (t : Set α) {s₁ s₂ : Set α} (h : s₁ ⊆ s₂) :
    t.ite s₁ s₂ = s₁ ∪ (s₂ \ t)
-- Mathlib/Data/Real/Hyperreal.lean
@[simp, norm_cast]
theorem coe_eq_one {x : ℝ} : (x : ℝ*) = 1 ↔ x = 1
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/InducedMaps.lean
theorem eq_diag_path : (πₘ f).map p ≫ ⟦H.evalAt x₁⟧ = H.diagonalPath' p ∧
    (⟦H.evalAt x₀⟧ ≫ (πₘ g).map p : fromTop (f x₀) ⟶ fromTop (g x₁)) = H.diagonalPath' p
-- Mathlib/Algebra/Order/BigOperators/Ring/Finset.lean
lemma prod_nonneg (h0 : ∀ i ∈ s, 0 ≤ f i) : 0 ≤ ∏ i ∈ s, f i
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
theorem DirectSum.IsInternal.isometryL2OfOrthogonalFamily_symm_apply [DecidableEq ι]
    {V : ι → Submodule 𝕜 E} (hV : DirectSum.IsInternal V)
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) (w : PiLp 2 fun i => V i) :
    (hV.isometryL2OfOrthogonalFamily hV').symm w = ∑ i, (w i : E)
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
/-- The seminorm controls the Schwartz estimate for any fixed `x`. -/
theorem le_seminorm (k n : ℕ) (f : 𝓢(E, F)) (x : E) :
    ‖x‖ ^ k * ‖iteratedFDeriv ℝ n f x‖ ≤ SchwartzMap.seminorm 𝕜 k n f
-- Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean
@[simp, nolint simpNF]
theorem evenToNeg_ι (Q' : QuadraticForm R M) (h : Q' = -Q) (m₁ m₂ : M) :
    evenToNeg Q Q' h ((even.ι Q).bilin m₁ m₂) = -(even.ι Q').bilin m₁ m₂
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem setOf_false : { _a : α | False } = ∅
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_range : ∀ {g : β → α} {f : ι → β}, ⨅ b ∈ range f, g b = ⨅ i, g (f i)
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem closure_iUnion {ι} (s : ι → Set R) : closure (⋃ i, s i) = ⨆ i, closure (s i)
-- Mathlib/Algebra/Order/Pointwise.lean
@[to_additive]
theorem csInf_inv (hs₀ : s.Nonempty) (hs₁ : BddAbove s) : sInf s⁻¹ = (sSup s)⁻¹
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
/-- A continuous monotone function between (conditionally) complete linear ordered spaces sends a
`Filter.liminf` to the `Filter.liminf` of the images (if the filter is bounded from below and
frequently bounded from above). -/
theorem Monotone.map_liminf_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
    (f_cont : ContinuousAt f (F.liminf a))
    (cobdd : F.IsCoboundedUnder (· ≥ ·) a := by isBoundedDefault)
    (bdd_below : F.IsBoundedUnder (· ≥ ·) a := by isBoundedDefault) :
    f (F.liminf a) = F.liminf (f ∘ a)
-- Mathlib/Data/Option/Basic.lean
theorem some_injective (α : Type*) : Function.Injective (@some α)
-- .lake/packages/lean4/src/lean/Init/Core.lean
@[simp] theorem ge_iff_le [LE α] {x y : α} : x ≥ y ↔ y ≤ x
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem iff_or_self (a b : Prop) : (b ↔ a ∨ b) ↔ (a → b)
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem upcrossingsBefore_zero : upcrossingsBefore a b f 0 ω = 0
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem support_toPath_subset {u v : V} (p : G.Walk u v) :
    (p.toPath : G.Walk u v).support ⊆ p.support
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
@[reassoc]
lemma stalkMap_congr_point {X Y : LocallyRingedSpace.{u}} (f : X ⟶ Y) (x x' : X) (hxx' : x = x') :
    f.stalkMap x ≫ X.presheaf.stalkSpecializes (specializes_of_eq hxx'.symm) =
      Y.presheaf.stalkSpecializes (specializes_of_eq <| hxx' ▸ rfl) ≫ f.stalkMap x'
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem integral_mul_upcrossingsBefore_le_integral [IsFiniteMeasure μ] (hf : Submartingale f ℱ μ)
    (hfN : ∀ ω, a ≤ f N ω) (hfzero : 0 ≤ f 0) (hab : a < b) :
    (b - a) * μ[upcrossingsBefore a b f N] ≤ μ[f N]
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive]
theorem smul_set_subset_smul {s : Set α} : a ∈ s → a • t ⊆ s • t
-- Mathlib/RingTheory/WittVector/Compare.lean
theorem toPadicInt_comp_fromPadicInt : (toPadicInt p).comp (fromPadicInt p) = RingHom.id ℤ_[p]
-- Mathlib/Topology/ContinuousFunction/CompactlySupported.lean
theorem add_apply [AddZeroClass β] [ContinuousAdd β] (f g : C_c(α, β)) : (f + g) x = f x + g x