ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
theorem norm_eq_of_add_equiv_zero {f g : PadicSeq p} (h : f + g ≈ 0) : f.norm = g.norm
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem subset_union {R : Type u} [Ring R] {I J K : Ideal R} :
    (I : Set R) ⊆ J ∪ K ↔ I ≤ J ∨ I ≤ K
-- Mathlib/Analysis/Calculus/Implicit.lean
@[simp]
theorem implicitToPartialHomeomorphOfComplemented_self (hf : HasStrictFDerivAt f f' a)
    (hf' : range f' = ⊤) (hker : (ker f').ClosedComplemented) :
    hf.implicitToPartialHomeomorphOfComplemented f f' hf' hker a = (f a, 0)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem extractP_eq_find?_eraseP
    (l : List α) : extractP p l = (find? p l, eraseP p l)
-- Mathlib/Computability/NFA.lean
@[simp]
theorem eval_nil : M.eval [] = M.start
-- Mathlib/Tactic/CC/Lemmas.lean
theorem iff_eq_of_eq_true_left {a b : Prop} (h : a = True) : (a ↔ b) = b
-- Mathlib/Algebra/Lie/Normalizer.lean
@[simp]
theorem comap_normalizer (f : M' →ₗ⁅R,L⁆ M) : N.normalizer.comap f = (N.comap f).normalizer
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem inv_image_trans_target : e'.symm '' (e.trans e').target = e'.source ∩ e.target
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_irreflexive : M ⊨ r.irreflexive ↔ Irreflexive fun x y : M => RelMap r ![x, y]
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
/-- If `f` is a `K`-Lipschitz map, then it increases the Hausdorff `d`-measures of sets at most
by the factor of `K ^ d`. -/
theorem hausdorffMeasure_image_le (h : LipschitzWith K f) {d : ℝ} (hd : 0 ≤ d) (s : Set X) :
    μH[d] (f '' s) ≤ (K : ℝ≥0∞) ^ d * μH[d] s
-- Mathlib/Order/Partition/Equipartition.lean
theorem IsEquipartition.card_part_eq_average_iff (hP : P.IsEquipartition) (ht : t ∈ P.parts) :
    t.card = s.card / P.parts.card ↔ t.card ≠ s.card / P.parts.card + 1
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mul_pos {a b : Ordinal} (h₁ : 0 < a) (h₂ : 0 < b) : 0 < a * b
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem symm_trans_source_eq (e e' : Trivialization F proj) :
    (e.toPartialEquiv.symm.trans e'.toPartialEquiv).source = (e.baseSet ∩ e'.baseSet) ×ˢ univ
-- Mathlib/Logic/Function/OfArity.lean
lemma fromTypes_fin_const (α β : Type u) (n : ℕ) :
    FromTypes (fun (_ : Fin n) => α) β = OfArity α β n
-- Mathlib/Algebra/Homology/ShortComplex/ModuleCat.lean
lemma moduleCat_exact_iff :
    S.Exact ↔ ∀ (x₂ : S.X₂) (_ : S.g x₂ = 0), ∃ (x₁ : S.X₁), S.f x₁ = x₂
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
lemma natDegree_preΨ₄_le : W.preΨ₄.natDegree ≤ 6
-- Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean
lemma exists_smul_basis_eq (x : W.CoordinateRing) :
    ∃ p q : R[X], p • (1 : W.CoordinateRing) + q • mk W Y = x
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem mul_le_mul {a b c d : Int}
    (hac : a ≤ c) (hbd : b ≤ d) (nn_b : 0 ≤ b) (nn_c : 0 ≤ c) : a * b ≤ c * d
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem pi'_pi [∀ i, SigmaFinite (μ i)] (s : ∀ i, Set (α i)) :
    pi' μ (pi univ s) = ∏ i, μ i (s i)
-- Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean
theorem integrable_comp (g : F' → A) : Integrable (g ∘ f) ↔ Integrable g
-- Mathlib/CategoryTheory/Sites/Types.lean
theorem subcanonical_typesGrothendieckTopology : Sheaf.Subcanonical typesGrothendieckTopology.{u}
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
protected theorem fderivWithin (hxs : UniqueDiffWithinAt 𝕜 s x) : fderivWithin 𝕜 iso s x = iso
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
theorem aevalTower_toAlgHom (x : R) : aevalTower g y (IsScalarTower.toAlgHom S R R[X] x) = g x
-- Mathlib/RingTheory/Bialgebra/Equiv.lean
theorem invFun_eq_symm : e.invFun = e.symm
-- Mathlib/CategoryTheory/Sites/Coherent/ExtensiveTopology.lean
lemma extensiveTopology.mem_sieves_iff_contains_colimit_cofan {X : C} (S : Sieve X) :
    S ∈ (extensiveTopology C).sieves X ↔
      (∃ (α : Type) (_ : Finite α) (Y : α → C) (π : (a : α) → (Y a ⟶ X)),
        Nonempty (IsColimit (Cofan.mk X π)) ∧ (∀ a : α, (S.arrows) (π a)))
-- Mathlib/Algebra/FreeMonoid/Basic.lean
@[to_additive (attr := simp)]
theorem toList_prod (xs : List (FreeMonoid α)) : toList xs.prod = (xs.map toList).join
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem mem_ball_comm : x ∈ ball y ε ↔ y ∈ ball x ε
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
/-- In a preadditive category, if the coproduct of `X` and `Y` exists, then the
    binary biproduct of `X` and `Y` exists. -/
theorem HasBinaryBiproduct.of_hasBinaryCoproduct (X Y : C) [HasBinaryCoproduct X Y] :
    HasBinaryBiproduct X Y
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[simp]
theorem differentiableWithinAt_add_const_iff (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => f y + c) s x ↔ DifferentiableWithinAt 𝕜 f s x
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
theorem cliqueFree_of_chromaticNumber_lt {n : ℕ} (hc : G.chromaticNumber < n) :
    G.CliqueFree n
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma map_polynomialX : (W.map f).toAffine.polynomialX = W.polynomialX.map (mapRingHom f)
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive (attr := simp, nolint simpNF) zmultiples_equiv_zmultiples_apply]
theorem zpowersEquivZPowers_apply (h : orderOf x = orderOf y) (n : ℕ) :
    zpowersEquivZPowers h ⟨x ^ n, n, zpow_natCast x n⟩ = ⟨y ^ n, n, zpow_natCast y n⟩
-- Mathlib/Order/PropInstances.lean
@[simp]
theorem Prop.isCompl_iff {P Q : Prop} : IsCompl P Q ↔ ¬(P ↔ Q)
-- Mathlib/Analysis/NormedSpace/MStructure.lean
theorem Lcomplement_iff (P : M) : IsLprojection X P ↔ IsLprojection X (1 - P)
-- Mathlib/Algebra/Polynomial/Div.lean
theorem sum_modByMonic_coeff (hq : q.Monic) {n : ℕ} (hn : q.degree ≤ n) :
    (∑ i : Fin n, monomial i ((p %ₘ q).coeff i)) = p %ₘ q
-- Mathlib/Analysis/NormedSpace/IndicatorFunction.lean
theorem norm_indicator_le_norm_self : ‖indicator s f a‖ ≤ ‖f a‖
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem map_eq_bot_iff_of_injective {I : Ideal R} {f : F} (hf : Function.Injective f) :
    I.map f = ⊥ ↔ I = ⊥
-- Mathlib/Algebra/Order/Rearrangement.lean
/-- **Equality case of the Rearrangement Inequality**: Pointwise scalar multiplication of `f` and
`g`, which antivary together, is unchanged by a permutation if and only if `f ∘ σ` and `g` antivary
together. Stated by permuting the entries of `f`. -/
theorem Antivary.sum_comp_perm_smul_eq_sum_smul_iff (hfg : Antivary f g) :
    ∑ i, f (σ i) • g i = ∑ i, f i • g i ↔ Antivary (f ∘ σ) g
-- Mathlib/Deprecated/Subgroup.lean
@[to_additive]
theorem one_ker_inv' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a⁻¹ * b) = 1) :
    f a = f b
-- Mathlib/Algebra/MvPolynomial/Division.lean
@[simp]
theorem mul_X_divMonomial (x : MvPolynomial σ R) (i : σ) :
    x * X i /ᵐᵒⁿᵒᵐⁱᵃˡ Finsupp.single i 1 = x
-- Mathlib/Data/Nat/PartENat.lean
@[simp]
theorem dom_one : (1 : PartENat).Dom
-- Mathlib/Geometry/RingedSpace/SheafedSpace.lean
/-- The map from the restriction of a presheafed space.
-/
@[simps!]
def ofRestrict {U : TopCat} (X : SheafedSpace C) {f : U ⟶ (X : TopCat)}
    (h : OpenEmbedding f) : X.restrict h ⟶ X
-- Mathlib/Computability/Primrec.lean
theorem _root_.PrimrecPred.and {p q : α → Prop} [DecidablePred p] [DecidablePred q]
    (hp : PrimrecPred p) (hq : PrimrecPred q) : PrimrecPred fun a => p a ∧ q a
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem or_self_right : ∀(a b : Bool), ((a || b) || b) = (a || b)
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
/-- The top subsemigroup is isomorphic to the semigroup. -/
@[to_additive (attr := simps)
  "The top additive subsemigroup is isomorphic to the additive semigroup."]
def topEquiv : (⊤ : Subsemigroup M) ≃* M
-- Mathlib/CategoryTheory/MorphismProperty/Limits.lean
theorem StableUnderBaseChange.baseChange_map [HasPullbacks C] {P : MorphismProperty C}
    (hP : StableUnderBaseChange P) {S S' : C} (f : S' ⟶ S) {X Y : Over S} (g : X ⟶ Y)
    (H : P g.left) : P ((Over.pullback f).map g).left
-- Mathlib/Data/Stream/Init.lean
theorem iterate_eq (f : α → α) (a : α) : iterate f a = a::iterate f (f a)
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
theorem _root_.NonUnitalSubalgebra.starClosure_eq_adjoin (S : NonUnitalSubalgebra R A) :
    S.starClosure = adjoin R (S : Set A)
-- Mathlib/FieldTheory/Adjoin.lean
theorem subsingleton_of_finrank_adjoin_le_one [FiniteDimensional F E]
    (h : ∀ x : E, finrank F F⟮x⟯ ≤ 1) : Subsingleton (IntermediateField F E)
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem norm_setToSimpleFunc_le_integral_norm (T : Set α → E →L[ℝ] F) {C : ℝ}
    (hT_norm : ∀ s, MeasurableSet s → μ s < ∞ → ‖T s‖ ≤ C * (μ s).toReal) {f : α →ₛ E}
    (hf : Integrable f μ) : ‖f.setToSimpleFunc T‖ ≤ C * (f.map norm).integral μ
-- Mathlib/Data/Vector/Defs.lean
/-- `drop` of vectors corresponds under `toList` to `drop` of lists. -/
@[simp]
theorem toList_drop {n m : ℕ} (v : Vector α m) : toList (drop n v) = List.drop n (toList v)
-- Mathlib/Geometry/Euclidean/Sphere/Basic.lean
@[simp]
theorem Sphere.mem_coe' {p : P} {s : Sphere P} : dist p s.center = s.radius ↔ p ∈ s
-- Mathlib/Data/Matroid/Closure.lean
lemma exists_basis_inter_ground_basis_closure (M : Matroid α) (X : Set α) :
    ∃ I, M.Basis I (X ∩ M.E) ∧ M.Basis I (M.closure X)
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
@[mono]
theorem eLpNorm'_mono_measure (f : α → F) (hμν : ν ≤ μ) (hq : 0 ≤ q) :
    eLpNorm' f q ν ≤ eLpNorm' f q μ
-- Mathlib/Analysis/Asymptotics/Theta.lean
lemma IsTheta.add_isLittleO {f₁ f₂ : α → E'} {g : α → F}
    (hΘ : f₁ =Θ[l] g) (ho : f₂ =o[l] g) : (f₁ + f₂) =Θ[l] g
-- Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean
/-- If `forget C` preserves and reflects initials, then `X` is initial if and only if
`(forget C).obj X` is empty. -/
lemma initial_iff_empty_of_preserves_of_reflects [PreservesColimit (Functor.empty.{0} C) (forget C)]
    [ReflectsColimit (Functor.empty.{0} C) (forget C)] (X : C) :
    Nonempty (IsInitial X) ↔ IsEmpty ((forget C).obj X)
-- Mathlib/Data/Multiset/Basic.lean
theorem ext {s t : Multiset α} : s = t ↔ ∀ a, count a s = count a t
-- Mathlib/LinearAlgebra/Finsupp.lean
/-- `Submodule.exists_finset_of_mem_iSup` as an `iff` -/
theorem Submodule.mem_iSup_iff_exists_finset {ι : Sort _} {p : ι → Submodule R M} {m : M} :
    (m ∈ ⨆ i, p i) ↔ ∃ s : Finset ι, m ∈ ⨆ i ∈ s, p i
-- Mathlib/Data/Sigma/Basic.lean
theorem subtype_ext_iff {β : Sort*} {p : α → β → Prop} {x₀ x₁ : Σ'a, Subtype (p a)} :
    x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ (x₀.snd : β) = x₁.snd
-- Mathlib/Data/Fintype/Order.lean
theorem Set.Finite.exists_le [IsDirected α (· ≤ ·)] {s : Set α} (hs : s.Finite) :
    ∃ M, ∀ i ∈ s, i ≤ M
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem mem_subgroupOf {H K : Subgroup G} {h : K} : h ∈ H.subgroupOf K ↔ (h : G) ∈ H
-- Mathlib/Order/SuccPred/Basic.lean
@[simp]
theorem succ_eq_succ_iff : succ a = succ b ↔ a = b
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
@[simp]
theorem mem_sup {μ ν : YoungDiagram} {x : ℕ × ℕ} : x ∈ μ ⊔ ν ↔ x ∈ μ ∨ x ∈ ν
-- Mathlib/GroupTheory/GroupAction/Hom.lean
protected theorem map_smulₛₗ (f : R →ₑ+*[φ] S) (m : M) (x : R) : f (m • x) = φ m • f x
-- Mathlib/Combinatorics/Quiver/Basic.lean
lemma mk_obj {V W : Type*} [Quiver V] [Quiver W] {obj : V → W} {map} {X : V} :
    (Prefunctor.mk obj map).obj X = obj X
-- Mathlib/Analysis/Convex/Normed.lean
/-- The set of nonzero vectors in the same ray as the nonzero vector `x` is connected. -/
theorem isConnected_setOf_sameRay_and_ne_zero {x : E} (hx : x ≠ 0) :
    IsConnected { y | SameRay ℝ x y ∧ y ≠ 0 }
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem coe_refl : ⇑(Diffeomorph.refl I M n) = id
-- Mathlib/Computability/TuringMachine.lean
theorem stmts_supportsStmt {M : Λ → Stmt₂} {S : Finset Λ} {q : Stmt₂} (ss : Supports M S) :
    some q ∈ stmts M S → SupportsStmt S q
-- Mathlib/RingTheory/DedekindDomain/PID.lean
/--
An invertible fractional ideal of a commutative ring with finitely many maximal ideals is principal.

https://math.stackexchange.com/a/95857 -/
theorem FractionalIdeal.isPrincipal.of_finite_maximals_of_inv {A : Type*} [CommRing A]
    [Algebra R A] {S : Submonoid R} [IsLocalization S A] (hS : S ≤ R⁰)
    (hf : {I : Ideal R | I.IsMaximal}.Finite) (I I' : FractionalIdeal S A) (hinv : I * I' = 1) :
    Submodule.IsPrincipal (I : Submodule R A)
-- Mathlib/Data/Matrix/Basic.lean
/-- The `LinearEquiv` between spaces of matrices induced by a `LinearEquiv` between their
coefficients. This is `Matrix.map` as a `LinearEquiv`. -/
@[simps apply]
def mapMatrix (f : α ≃ₗ[R] β) : Matrix m n α ≃ₗ[R] Matrix m n β
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
/-- The left unitor isomorphism for binary coproducts with the initial object. -/
@[simps]
def coprod.leftUnitor (P : C) : (⊥_ C) ⨿ P ≅ P
-- Mathlib/Order/Compare.lean
@[simp]
lemma compares_gt [LT α] (a b : α) : Compares gt a b = (a > b)
-- Mathlib/GroupTheory/Coxeter/Length.lean
theorem isRightDescent_inv_iff {w : W} {i : B} :
    cs.IsRightDescent w⁻¹ i ↔ cs.IsLeftDescent w i
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem cons_erase {s : Multiset α} {a : α} : a ∈ s → a ::ₘ s.erase a = s
-- Mathlib/NumberTheory/ADEInequality.lean
theorem admissible_E8 : Admissible E8
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
@[simp]
lemma evalEval_polynomialX_zero : W.polynomialX.evalEval 0 0 = -W.a₄
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem Disjoint.cycleType {σ τ : Perm α} (h : Disjoint σ τ) :
    (σ * τ).cycleType = σ.cycleType + τ.cycleType
-- Mathlib/Topology/Algebra/ConstMulAction.lean
@[to_additive]
theorem Inseparable.const_smul {x y : α} (h : Inseparable x y) (c : M) :
    Inseparable (c • x) (c • y)
-- Mathlib/Probability/Process/Stopping.lean
theorem memℒp_stoppedValue_of_mem_finset (hτ : IsStoppingTime ℱ τ) (hu : ∀ n, Memℒp (u n) p μ)
    {s : Finset ι} (hbdd : ∀ ω, τ ω ∈ s) : Memℒp (stoppedValue u τ) p μ
-- Mathlib/Analysis/SpecialFunctions/Sqrt.lean
theorem HasFDerivWithinAt.sqrt (hf : HasFDerivWithinAt f f' s x) (hx : f x ≠ 0) :
    HasFDerivWithinAt (fun y => √(f y)) ((1 / (2 * √(f x))) • f') s x
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
@[simp]
theorem isLittleO_neg_right : (f =o[l] fun x => -g' x) ↔ f =o[l] g'
-- Mathlib/CategoryTheory/Filtered/Basic.lean
/-- For every cospan `j ⟶ i ⟵ j'`,
 there exists a cone `j ⟵ k ⟶ j'` such that the square commutes. -/
theorem cospan {i j j' : C} (f : j ⟶ i) (f' : j' ⟶ i) :
    ∃ (k : C) (g : k ⟶ j) (g' : k ⟶ j'), g ≫ f = g' ≫ f'
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem le_edist_of_le_infsep {d x} (hx : x ∈ s) {y} (hy : y ∈ s) (hxy : x ≠ y)
    (hd : d ≤ s.infsep) : d ≤ dist x y
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
/-- Auxiliary lemma for `Lp.induction_stronglyMeasurable`. -/
@[elab_as_elim]
theorem Lp.induction_stronglyMeasurable_aux (hm : m ≤ m0) (hp_ne_top : p ≠ ∞) (P : Lp F p μ → Prop)
    (h_ind : ∀ (c : F) {s : Set α} (hs : MeasurableSet[m] s) (hμs : μ s < ∞),
      P (Lp.simpleFunc.indicatorConst p (hm s hs) hμs.ne c))
    (h_add : ∀ ⦃f g⦄, ∀ hf : Memℒp f p μ, ∀ hg : Memℒp g p μ, AEStronglyMeasurable' m f μ →
      AEStronglyMeasurable' m g μ → Disjoint (Function.support f) (Function.support g) →
        P (hf.toLp f) → P (hg.toLp g) → P (hf.toLp f + hg.toLp g))
    (h_closed : IsClosed {f : lpMeas F ℝ m p μ | P f}) :
    ∀ f : Lp F p μ, AEStronglyMeasurable' m f μ → P f
-- Mathlib/CategoryTheory/Localization/LocalizerMorphism.lean
/-- When `Φ : LocalizerMorphism W₁ W₂`, if the composition `Φ.functor ⋙ L₂` is a
localization functor for `W₁`, then `Φ` is a localized equivalence. -/
lemma IsLocalizedEquivalence.of_isLocalization_of_isLocalization
    [(Φ.functor ⋙ L₂).IsLocalization W₁] :
    IsLocalizedEquivalence Φ
-- Mathlib/RingTheory/Algebraic.lean
/-- An integral element of an algebra is algebraic. -/
theorem IsIntegral.isAlgebraic [Nontrivial R] {x : A} : IsIntegral R x → IsAlgebraic R x
-- Mathlib/Topology/Basic.lean
theorem Filter.EventuallyEq.tendsto {l : Filter α} {f : α → X} (hf : f =ᶠ[l] fun _ ↦ x) :
    Tendsto f l (𝓝 x)
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem TopologicalGroup.t2Space_iff_one_closed : T2Space G ↔ IsClosed ({1} : Set G)
-- Mathlib/CategoryTheory/Products/Unitor.lean
/-- The equivalence of categories expressing right unity of products of categories.  -/
@[simps]
def rightUnitorEquivalence : C × Discrete (PUnit : Type w) ≌ C
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem unitsEquivAut_apply_symm (u : Rˣ) (x : R) : (unitsEquivAut R u).symm x = x * ↑u⁻¹
-- Mathlib/Algebra/Ring/Subring/Pointwise.lean
theorem smul_closure (a : M) (s : Set R) : a • closure s = closure (a • s)
-- Mathlib/Data/Finset/Sups.lean
@[simp]
theorem sups_eq_empty : s ⊻ t = ∅ ↔ s = ∅ ∨ t = ∅
-- Mathlib/Analysis/Normed/Group/SemiNormedGrp.lean
@[ext]
lemma ext {M N : SemiNormedGrp} {f₁ f₂ : M ⟶ N} (h : ∀ (x : M), f₁ x = f₂ x) : f₁ = f₂
-- Mathlib/Topology/LocallyFinite.lean
theorem prod_right (hf : LocallyFinite f) (g : ι → Set Y) : LocallyFinite (fun i ↦ f i ×ˢ g i)
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
protected theorem locallyCompactSpace [LocallyCompactSpace E] (I : ModelWithCorners 𝕜 E H) :
    LocallyCompactSpace H
-- Mathlib/Topology/Basic.lean
theorem ClusterPt.of_le_nhds {f : Filter X} (H : f ≤ 𝓝 x) [NeBot f] : ClusterPt x f
-- Mathlib/Topology/Maps/Basic.lean
theorem Embedding.continuous (hf : Embedding f) : Continuous f
-- Mathlib/LinearAlgebra/QuadraticForm/Prod.lean
@[simp] theorem polar_prod (Q₁ : QuadraticMap R M₁ P) (Q₂ : QuadraticMap R M₂ P) (x y : M₁ × M₂) :
    polar (Q₁.prod Q₂) x y = polar Q₁ x.1 y.1 + polar Q₂ x.2 y.2
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- A point is its own reflection if and only if it is in the subspace. -/
theorem reflection_eq_self_iff (x : E) : reflection K x = x ↔ x ∈ K
-- Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
protected lemma neg_iff {f : ℝ → ℝ} : GrowsPolynomially f ↔ GrowsPolynomially (-f)
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem verts_sInf (s : Set G.Subgraph) : (sInf s).verts = ⋂ G' ∈ s, verts G'
-- Mathlib/Data/Set/Basic.lean
theorem diff_union_diff_cancel (hts : t ⊆ s) (hut : u ⊆ t) : s \ t ∪ t \ u = s \ u
-- Mathlib/Data/Finset/Sups.lean
@[simp] lemma singleton_diffs : {a} \\ t = t.image (a \ ·)
-- Mathlib/GroupTheory/GroupAction/Blocks.lean
/-- The full set is a (trivial) block -/
theorem isFixedBlock_top : IsFixedBlock G (⊤ : Set X)
-- Mathlib/Algebra/Associated/Basic.lean
theorem Irreducible.dvd_irreducible_iff_associated [Monoid α] {p q : α}
    (pp : Irreducible p) (qp : Irreducible q) : p ∣ q ↔ Associated p q
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem set_cons_zero (x : α) (xs : List α) (a : α) :
  (x :: xs).set 0 a = a :: xs
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem map_surjective (hf : Function.Surjective f) :
    Function.Surjective (map f : MvPolynomial σ R → MvPolynomial σ S₁)
-- Mathlib/Data/Real/Cardinality.lean
/-- The cardinality of the interval (a, b]. -/
theorem mk_Ioc_real {a b : ℝ} (h : a < b) : #(Ioc a b) = 𝔠
-- Mathlib/Data/Set/Function.lean
theorem image_inter' (hf : LeftInvOn f' f s) : f '' (s₁ ∩ s) = f' ⁻¹' s₁ ∩ f '' s
-- Mathlib/Analysis/CstarAlgebra/Basic.lean
theorem selfAdjoint.nnnorm_pow_two_pow [NormedRing E] [StarRing E] [CstarRing E] (x : selfAdjoint E)
    (n : ℕ) : ‖x ^ 2 ^ n‖₊ = ‖x‖₊ ^ 2 ^ n
-- Mathlib/Algebra/Polynomial/Derivative.lean
/-- Chain rule for formal derivative of polynomials. -/
theorem derivative_eval₂_C (p q : R[X]) :
    derivative (p.eval₂ C q) = p.derivative.eval₂ C q * derivative q
-- Mathlib/Topology/Order/IntermediateValue.lean
/-- Suppose `α` is equipped with a conditionally complete linear dense order and `f : α → δ` is
continuous and injective. Then `f` is strictly monotone (increasing) if
it is strictly monotone (increasing) on some closed interval `[a, b]`. -/
theorem Continuous.strictMonoOn_of_inj_rigidity {f : α → δ}
    (hf_c : Continuous f) (hf_i : Injective f) {a b : α} (hab : a < b)
    (hf_mono : StrictMonoOn f (Icc a b)) : StrictMono f
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem tendstoUniformlyOn_iff_seq_tendstoUniformlyOn {l : Filter ι} [l.IsCountablyGenerated] :
    TendstoUniformlyOn F f l s ↔
      ∀ u : ℕ → ι, Tendsto u atTop l → TendstoUniformlyOn (fun n => F (u n)) f atTop s
-- Mathlib/GroupTheory/Finiteness.lean
@[to_additive (attr := simp)]
theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasStrictDerivAt.cpow_const (hf : HasStrictDerivAt f f' x)
    (h0 : f x ∈ slitPlane) :
    HasStrictDerivAt (fun x => f x ^ c) (c * f x ^ (c - 1) * f') x
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem Submodule.mem_sSup_iff_exists_finset {S : Set (Submodule R M)} {m : M} :
    m ∈ sSup S ↔ ∃ s : Finset (Submodule R M), ↑s ⊆ S ∧ m ∈ ⨆ i ∈ s, i
-- Mathlib/GroupTheory/GroupAction/Group.lean
@[simp]
theorem Commute.smul_right_iff₀ [Mul β] [SMulCommClass α β β] [IsScalarTower α β β] {a b : β}
    {c : α} (hc : c ≠ 0) : Commute a (c • b) ↔ Commute a b
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] protected theorem mul_div_cancel (a : Int) {b : Int} (H : b ≠ 0) : (a * b).div b = a
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive] lemma prod_le_one (hf : f ≤ 1) : ∏ i, f i ≤ 1
-- Mathlib/CategoryTheory/WithTerminal.lean
/-- The isomorphism between `incl ⋙ lift F _ _` with `F`. -/
@[simps!]
def inclLift {D : Type*} [Category D] {Z : D} (F : C ⥤ D) (M : ∀ x : C, Z ⟶ F.obj x)
    (hM : ∀ (x y : C) (f : x ⟶ y), M x ≫ F.map f = M y) : incl ⋙ lift F M hM ≅ F
-- Mathlib/Topology/Algebra/Valued/ValuedField.lean
theorem Valued.continuous_valuation [Valued K Γ₀] : Continuous (v : K → Γ₀)
-- Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean
/-- `(F ⨿ G).obj a` is in bijection with disjoint union of `F.obj a` and `G.obj a`. -/
@[simps]
noncomputable
def binaryCoproductEquiv (a : C) :
    (F ⨿ G).obj a ≃ (F.obj a) ⊕ (G.obj a)
-- Mathlib/AlgebraicGeometry/StructureSheaf.lean
@[simp, reassoc, elementwise]
theorem localizationToStalk_stalkSpecializes {R : Type*} [CommRing R] {x y : PrimeSpectrum R}
    (h : x ⤳ y) :
    StructureSheaf.localizationToStalk R y ≫ (structureSheaf R).presheaf.stalkSpecializes h =
      CommRingCat.ofHom (PrimeSpectrum.localizationMapOfSpecializes h) ≫
        StructureSheaf.localizationToStalk R x
-- Mathlib/Analysis/Complex/Arg.lean
theorem sameRay_iff_arg_div_eq_zero : SameRay ℝ x y ↔ arg (x / y) = 0
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma irreducible_polynomial [IsDomain R] : Irreducible W.polynomial
-- Mathlib/Data/Finset/Basic.lean
theorem ne_of_mem_erase : b ∈ erase s a → b ≠ a
-- Mathlib/RingTheory/PowerSeries/Order.lean
/-- The `n`th coefficient of a formal power series is `0` if `n` is strictly
smaller than the order of the power series. -/
theorem coeff_of_lt_order (n : ℕ) (h : ↑n < order φ) : coeff R n φ = 0
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem empty_smul (t : Finset β) : (∅ : Finset α) • t = ∅
-- Mathlib/Tactic/FunProp/ContDiff.lean
theorem ContDiff.comp' {g : F → G} (hg : ContDiff K n g) (hf : ContDiff K n f) :
    ContDiff K n (fun x => g (f x))
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem count_edges_eq_one [DecidableEq V] {u v : V} {p : G.Path u v} (e : Sym2 V)
    (hw : e ∈ (p : G.Walk u v).edges) : (p : G.Walk u v).edges.count e = 1
-- Mathlib/Algebra/Module/Basic.lean
lemma support_const_smul_subset [Zero M] [SMulZeroClass R M] (a : R) (f : α → M) :
    support (a • f) ⊆ support f
-- Mathlib/Order/RelClasses.lean
theorem superset_antisymm_iff [IsRefl α (· ⊆ ·)] [IsAntisymm α (· ⊆ ·)] : a = b ↔ b ⊆ a ∧ a ⊆ b
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem measurableSet_lt {m : MeasurableSpace α} [TopologicalSpace β] [LinearOrder β]
    [OrderClosedTopology β] [PseudoMetrizableSpace β] {f g : α → β} (hf : StronglyMeasurable f)
    (hg : StronglyMeasurable g) : MeasurableSet { a | f a < g a }
-- Mathlib/MeasureTheory/Measure/Haar/Basic.lean
@[to_additive is_left_invariant_addCHaar]
theorem is_left_invariant_chaar {K₀ : PositiveCompacts G} (g : G) (K : Compacts G) :
    chaar K₀ (K.map _ <| continuous_mul_left g) = chaar K₀ K