ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Module/LinearMap/End.lean
theorem one_eq_id : (1 : Module.End R M) = id
-- Mathlib/Data/Seq/WSeq.lean
theorem mem_cons_of_mem {s : WSeq α} (b) {a} (h : a ∈ s) : a ∈ cons b s
-- Mathlib/Analysis/Convex/Basic.lean
/-- Affine subspaces are convex. -/
theorem AffineSubspace.convex (Q : AffineSubspace 𝕜 E) : Convex 𝕜 (Q : Set E)
-- Mathlib/CategoryTheory/ClosedUnderIsomorphisms.lean
lemma mem_isoClosure_iff (X : C) :
    isoClosure P X ↔ ∃ (Y : C) (_ : P Y), Nonempty (X ≅ Y)
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
@[simp]
theorem adjugate_diagonal (v : n → α) :
    adjugate (diagonal v) = diagonal fun i => ∏ j ∈ Finset.univ.erase i, v j
-- Mathlib/Analysis/Analytic/Constructions.lean
/-- Analytic functions on products are analytic in the first coordinate -/
theorem AnalyticAt.curry_left {f : E × F → G} {p : E × F} (fa : AnalyticAt 𝕜 f p) :
    AnalyticAt 𝕜 (fun x ↦ f (x, p.2)) p.1
-- Mathlib/Analysis/Convex/Cone/Closure.lean
@[simp, norm_cast]
theorem coe_closure (K : PointedCone 𝕜 E) : (K.closure : Set E) = closure K
-- Mathlib/Probability/Independence/ZeroOne.lean
theorem condIndep_limsup_atBot_self [StandardBorelSpace Ω] [Nonempty Ω]
    (hm : m ≤ m0) [IsFiniteMeasure μ]
    (h_le : ∀ n, s n ≤ m0) (h_indep : iCondIndep m hm s μ) :
    CondIndep m (limsup s atBot) (limsup s atBot) hm μ
-- Mathlib/Algebra/Lie/Weights/Basic.lean
lemma mem_posFittingComp (m : M) :
    m ∈ posFittingComp R L M ↔ m ∈ ⨆ (x : L), posFittingCompOf R M x
-- Mathlib/Algebra/Regular/Basic.lean
theorem Commute.isRegular_iff {a : R} (ca : ∀ b, Commute a b) : IsRegular a ↔ IsLeftRegular a
-- Mathlib/Algebra/Bounds.lean
@[to_additive (attr := simp)]
theorem isGLB_inv : IsGLB s⁻¹ a ↔ IsLUB s a⁻¹
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
@[ext]
theorem ext {f g : M [⋀^ι]→L[R] N} (H : ∀ x, f x = g x) : f = g
-- Mathlib/FieldTheory/SeparableClosure.lean
/-- If `K / E / F` is a field extension tower, such that `K / E` has no non-trivial separable
subextensions (when `K / E` is algebraic, this means that it is purely inseparable),
then the image of `separableClosure F E` in `K` is equal to `separableClosure F K`. -/
theorem separableClosure.map_eq_of_separableClosure_eq_bot [Algebra E K] [IsScalarTower F E K]
    (h : separableClosure E K = ⊥) :
    (separableClosure F E).map (IsScalarTower.toAlgHom F E K) = separableClosure F K
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigO.of_bound' (h : ∀ᶠ x in l, ‖f x‖ ≤ ‖g x‖) : f =O[l] g
-- Mathlib/Data/Int/ModEq.lean
protected theorem mul_right' (h : a ≡ b [ZMOD n]) : a * c ≡ b * c [ZMOD n * c]
-- Mathlib/Algebra/Field/Subfield.lean
/-- A subfield is closed under inverses. -/
protected theorem inv_mem {x : K} : x ∈ s → x⁻¹ ∈ s
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem mem_vanishingIdeal (t : Set (ProjectiveSpectrum 𝒜)) (f : A) :
    f ∈ vanishingIdeal t ↔ ∀ x : ProjectiveSpectrum 𝒜, x ∈ t → f ∈ x.asHomogeneousIdeal
-- Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean
/-- The algebra morphism `B →ₐ[R] A ⊗[R] B` sending `b` to `1 ⊗ₜ b`. -/
@[simps!]
def includeRight : B →ₐ[R] (𝒜 ᵍ⊗[R] ℬ)
-- Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean
/-- Expresses the integral over `Ioi 0` of `t ^ (a - 1) * exp (-(r * t))`, for positive real `r`,
in terms of the Gamma function. -/
lemma integral_rpow_mul_exp_neg_mul_Ioi {a r : ℝ} (ha : 0 < a) (hr : 0 < r) :
    ∫ t : ℝ in Ioi 0, t ^ (a - 1) * exp (-(r * t)) = (1 / r) ^ a * Gamma a
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive (attr := simp)]
lemma inv_smul_set_distrib (a : α) (s : Set α) : (a • s)⁻¹ = op a⁻¹ • s⁻¹
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem mul_ne_zero {a b : Int} (a0 : a ≠ 0) (b0 : b ≠ 0) : a * b ≠ 0
-- Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean
theorem isCaratheodory_compl : IsCaratheodory m s₁ → IsCaratheodory m s₁ᶜ
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
@[simp]
theorem toIdeal_add (I J : HomogeneousIdeal 𝒜) : (I + J).toIdeal = I.toIdeal + J.toIdeal
-- Mathlib/Algebra/Order/Floor/Div.lean
@[simp] lemma smul_floorDiv [PosSMulMono α β] [PosSMulReflectLE α β] (ha : 0 < a) (b : β) :
    a • b ⌊/⌋ a = b
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
@[simp]
lemma dualBasis_dualBasis (B : BilinForm K V) (hB : B.Nondegenerate) (hB' : B.IsSymm) {ι}
    [Finite ι] [DecidableEq ι] [FiniteDimensional K V] (b : Basis ι K V) :
    B.dualBasis hB (B.dualBasis hB b) = b
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem mem_uIcc_of_ge (hb : b ≤ x) (ha : x ≤ a) : x ∈ [[a, b]]
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
theorem eq_zero_or_eq_zero_of_kahler_eq_zero {x y : E} (hx : o.kahler x y = 0) : x = 0 ∨ y = 0
-- Mathlib/Algebra/Module/Defs.lean
theorem Nat.smul_one_eq_cast {R : Type*} [NonAssocSemiring R] (m : ℕ) : m • (1 : R) = ↑m
-- Mathlib/Order/Compare.lean
theorem Compares.inj [Preorder α] {o₁} :
    ∀ {o₂} {a b : α}, Compares o₁ a b → Compares o₂ a b → o₁ = o₂
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem lift_unique' (F : k[G] →ₐ[k] A) :
    F = lift k G A ((F : k[G] →* A).comp (of k G))
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
@[simp]
theorem iter_deriv_exp : ∀ n : ℕ, deriv^[n] exp = exp
-- Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean
/-- Any morphism to an initial object is epi. -/
theorem IsInitial.epi_to {X Y : C} (t : IsInitial X) (f : Y ⟶ X) : Epi f
-- Mathlib/Algebra/PUnitInstances/Algebra.lean
@[to_additive (attr := simp, nolint simpNF)]
theorem one_eq : (1 : PUnit) = unit
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
@[simp, norm_cast]
theorem coe_intCast (z : ℤ) : ((z : ℤ_[p]) : ℚ_[p]) = z
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
theorem dFrom_eq {i j : ι} (r : c.Rel i j) : C.dFrom i = C.d i j ≫ (C.xNextIso r).inv
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
theorem fromSpec_preimage_basicOpen' :
    hU.fromSpec ⁻¹ᵁ X.basicOpen f = (Spec Γ(X, U)).basicOpen ((Scheme.ΓSpecIso Γ(X, U)).inv f)
-- Mathlib/Topology/Order/LocalExtr.lean
nonrec theorem IsLocalExtrOn.neg (hf : IsLocalExtrOn f s a) : IsLocalExtrOn (fun x => -f x) s a
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem iteratedFDerivWithin_congr_set (h : s =ᶠ[𝓝 x] t) (n : ℕ) :
    iteratedFDerivWithin 𝕜 n f s x = iteratedFDerivWithin 𝕜 n f t x
-- Mathlib/Analysis/Convex/Mul.lean
lemma ConvexOn.mul (hf : ConvexOn 𝕜 s f) (hg : ConvexOn 𝕜 s g) (hf₀ : ∀ ⦃x⦄, x ∈ s → 0 ≤ f x)
    (hg₀ : ∀ ⦃x⦄, x ∈ s → 0 ≤ g x) (hfg : MonovaryOn f g s) :
    ConvexOn 𝕜 s (f * g)
-- Mathlib/NumberTheory/MulChar/Basic.lean
/-- This is the corresponding extension of `MonoidHomClass`. -/
class MulCharClass (F : Type*) (R R' : outParam Type*) [CommMonoid R]
  [CommMonoidWithZero R'] [FunLike F R R'] extends MonoidHomClass F R R' : Prop where
  map_nonunit : ∀ (χ : F) {a : R} (_ : ¬IsUnit a), χ a = 0
-- Mathlib/Analysis/Calculus/BumpFunction/Basic.lean
theorem tsupport_eq : tsupport f = closedBall c f.rOut
-- Mathlib/Data/Finset/Sups.lean
theorem disjSups_singleton : ({a} ○ {b} : Finset α) = if Disjoint a b then {a ⊔ b} else ∅
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem natDegree_of_a_eq_zero' : (toPoly ⟨0, b, c, d⟩).natDegree ≤ 2
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem subtypeEquiv_symm {p : α → Prop} {q : β → Prop} (e : α ≃ β) (h : ∀ a : α, p a ↔ q (e a)) :
    (e.subtypeEquiv h).symm =
      e.symm.subtypeEquiv fun a => by
        convert (h <| e.symm a).symm
        exact (e.apply_symm_apply a).symm
-- Mathlib/Data/Multiset/Fintype.lean
@[simp] lemma toEnumFinset_filter_eq (m : Multiset α) (a : α) :
    m.toEnumFinset.filter (·.1 = a) = {a} ×ˢ Finset.range (m.count a)
-- Mathlib/GroupTheory/CosetCover.lean
@[to_additive]
theorem index_le_of_leftCoset_cover_const : H.index ≤ s.card
-- Mathlib/Algebra/Module/Submodule/Pointwise.lean
@[simp]
theorem pointwise_smul_toAddSubmonoid (a : α) (S : Submodule R M) :
    (a • S).toAddSubmonoid = a • S.toAddSubmonoid
-- Mathlib/Init/Logic.lean
theorem if_simp_congr_prop {b c x y u v : Prop} [Decidable b] (h_c : b ↔ c) (h_t : x ↔ u)
    -- FIXME: after https://github.com/leanprover/lean4/issues/1867 is fixed,
    -- this should be changed back to:
    -- (h_e : y ↔ v) : ite b x y ↔ (ite c (h := decidable_of_decidable_of_iff h_c) u v) :=
    (h_e : y ↔ v) : ite b x y ↔ (@ite _ c (decidable_of_decidable_of_iff h_c) u v)
-- Mathlib/Order/Monotone/Monovary.lean
theorem antivary_const_right (f : ι → α) (b : β) : Antivary f (const ι b)
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem lt_map_of_nat_lt_translationNumber {n : ℕ} (h : ↑n < τ f) (x : ℝ) : x + n < f x
-- Mathlib/Data/Stream/Init.lean
@[simp]
theorem drop_const (n : ℕ) (a : α) : drop n (const a) = const a
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
@[simp] theorem zero_and (x : Nat) : 0 &&& x = 0
-- Mathlib/MeasureTheory/Measure/Stieltjes.lean
/-- If a compact interval `[a, b]` is covered by a union of open interval `(c i, d i)`, then
`f b - f a ≤ ∑ f (d i) - f (c i)`. This is an auxiliary technical statement to prove the same
statement for half-open intervals, the point of the current statement being that one can use
compactness to reduce it to a finite sum, and argue by induction on the size of the covering set. -/
theorem length_subadditive_Icc_Ioo {a b : ℝ} {c d : ℕ → ℝ} (ss : Icc a b ⊆ ⋃ i, Ioo (c i) (d i)) :
    ofReal (f b - f a) ≤ ∑' i, ofReal (f (d i) - f (c i))
-- Mathlib/RingTheory/Localization/AtPrime.lean
/-- The unique maximal ideal of the localization at `I.primeCompl` lies over the ideal `I`. -/
theorem AtPrime.comap_maximalIdeal :
    Ideal.comap (algebraMap R (Localization.AtPrime I))
        (LocalRing.maximalIdeal (Localization I.primeCompl)) =
      I
-- Mathlib/Algebra/Group/Subgroup/ZPowers.lean
@[to_additive]
theorem centralizer_closure (S : Set G) :
    centralizer (closure S : Set G) = ⨅ g ∈ S, centralizer (zpowers g : Set G)
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem map_sup {G : SimpleGraph V} {G' : SimpleGraph W} (f : G →g G') {H H' : G.Subgraph} :
    (H ⊔ H').map f = H.map f ⊔ H'.map f
-- Mathlib/Order/Filter/Basic.lean
protected theorem push_pull (f : α → β) (F : Filter α) (G : Filter β) :
    map f (F ⊓ comap f G) = map f F ⊓ G
-- Mathlib/Topology/MetricSpace/Contracting.lean
/-- Banach fixed-point theorem for maps contracting on a complete subset. -/
theorem exists_fixedPoint' {s : Set α} (hsc : IsComplete s) (hsf : MapsTo f s s)
    (hf : ContractingWith K <| hsf.restrict f s s) {x : α} (hxs : x ∈ s) (hx : edist x (f x) ≠ ∞) :
    ∃ y ∈ s, IsFixedPt f y ∧ Tendsto (fun n ↦ f^[n] x) atTop (𝓝 y) ∧
      ∀ n : ℕ, edist (f^[n] x) y ≤ edist x (f x) * (K : ℝ≥0∞) ^ n / (1 - K)
-- Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean
theorem integral_gaussian (b : ℝ) : ∫ x : ℝ, exp (-b * x ^ 2) = √(π / b)
-- Mathlib/Analysis/SpecialFunctions/Polynomials.lean
theorem isEquivalent_atTop_lead :
    (fun x => eval x P) ~[atTop] fun x => P.leadingCoeff * x ^ P.natDegree
-- Mathlib/Control/Fold.lean
theorem foldrm_toList (f : α → β → m β) (x : β) (xs : t α) :
    foldrm f x xs = List.foldrM f x (toList xs)
-- Mathlib/GroupTheory/GroupAction/Group.lean
@[simp]
theorem smul_eq_zero {u : α} (hu : IsUnit u) {x : β} : u • x = 0 ↔ x = 0
-- Mathlib/LinearAlgebra/Pi.lean
@[simp]
theorem piFinTwo_apply (M : Fin 2 → Type v)
    [(i : Fin 2) → AddCommMonoid (M i)] [(i : Fin 2) → Module R (M i)] :
    (piFinTwo R M : ((i : Fin 2) → M i) → M 0 × M 1) = fun f => (f 0, f 1)
-- Mathlib/Topology/Order/ScottTopology.lean
lemma DirSupClosed.inter (hs : DirSupClosed s) (ht : DirSupClosed t) : DirSupClosed (s ∩ t)
-- Mathlib/Data/Finset/Density.lean
lemma dens_sdiff_add_dens (s t : Finset α) : dens (s \ t) + dens t = (s ∪ t).dens
-- Mathlib/RingTheory/Nilpotent/Basic.lean
theorem isNilpotent_add (h_comm : Commute x y) (hx : IsNilpotent x) (hy : IsNilpotent y) :
    IsNilpotent (x + y)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem ExprCnstr.denote_toNormPoly (ctx : Context) (c : ExprCnstr) : c.toNormPoly.denote ctx = c.denote ctx
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
lemma notNilRec_cons {motive : {u w : V} → (p : G.Walk u w) → ¬ p.Nil → Sort*}
    (cons : {u v w : V} → (h : G.Adj u v) → (q : G.Walk v w) →
    motive (q.cons h) Walk.not_nil_cons) (h' : G.Adj u v) (q' : G.Walk v w) :
    @Walk.notNilRec _ _ _ _ _ cons _ _ = cons h' q'
-- Mathlib/RingTheory/Trace/Basic.lean
theorem trace_eq_sum_embeddings [FiniteDimensional K L] [Algebra.IsSeparable K L] {x : L} :
    algebraMap K E (Algebra.trace K L x) = ∑ σ : L →ₐ[K] E, σ x
-- Mathlib/Combinatorics/SimpleGraph/Turan.lean
/-- In a Turán-maximal graph, non-adjacency is an equivalence relation. -/
theorem equivalence_not_adj : Equivalence (¬G.Adj · ·)
-- Mathlib/Logic/Function/Basic.lean
theorem exists_update_iff (f : ∀ a, β a) {a : α} {b : β a} (p : ∀ a, β a → Prop) :
    (∃ x, p x (update f a b x)) ↔ p a b ∨ ∃ x ≠ a, p x (f x)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem _root_.aestronglyMeasurable_indicator_iff [Zero β] {s : Set α} (hs : MeasurableSet s) :
    AEStronglyMeasurable (indicator s f) μ ↔ AEStronglyMeasurable f (μ.restrict s)
-- Mathlib/Data/Finset/Fold.lean
@[simp]
theorem fold_image [DecidableEq α] {g : γ → α} {s : Finset γ}
    (H : ∀ x ∈ s, ∀ y ∈ s, g x = g y → x = y) : (s.image g).fold op b f = s.fold op b (f ∘ g)
-- Mathlib/RingTheory/Polynomial/Chebyshev.lean
theorem U_sub_two (n : ℤ) : U R (n - 2) = 2 * X * U R (n - 1) - U R n
-- Mathlib/NumberTheory/NumberField/Basic.lean
/-- The canonical map from `𝓞 K` to `K` is injective.

This is a convenient abbreviation for `map_ne_zero_iff` applied to
`NoZeroSMulDivisors.algebraMap_injective`.
-/
lemma coe_ne_zero_iff {x : 𝓞 K} : algebraMap _ K x ≠ 0 ↔ x ≠ 0
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
@[reassoc (attr := simp)]
theorem Fork.hom_comp_ι {s t : Fork f g} (f : s ⟶ t) : f.hom ≫ t.ι = s.ι
-- Mathlib/Order/Iterate.lean
theorem seq_pos_lt_seq_of_le_of_lt (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h₀ : x 0 ≤ y 0)
    (hx : ∀ k < n, x (k + 1) ≤ f (x k)) (hy : ∀ k < n, f (y k) < y (k + 1)) : x n < y n
-- Mathlib/Combinatorics/Colex.lean
@[simp] theorem toFinset_bitIndices_twoPowSum (s : Finset ℕ) :
    (∑ i in s, 2 ^ i).bitIndices.toFinset = s
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[fun_prop]
protected theorem DifferentiableWithinAt.snd (h : DifferentiableWithinAt 𝕜 f₂ s x) :
    DifferentiableWithinAt 𝕜 (fun x => (f₂ x).2) s x
-- Mathlib/MeasureTheory/Integral/TorusIntegral.lean
/-- Recurrent formula for `torusIntegral`, see also `torusIntegral_succAbove`. -/
theorem torusIntegral_succ {f : ℂⁿ⁺¹ → E} {c : ℂⁿ⁺¹} {R : ℝⁿ⁺¹} (hf : TorusIntegrable f c R) :
    (∯ x in T(c, R), f x) =
      ∮ x in C(c 0, R 0), ∯ y in T(c ∘ Fin.succ, R ∘ Fin.succ), f (Fin.cons x y)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma ofJ_0_of_two_eq_zero (h2 : (2 : F) = 0) :
    ofJ 0 = @ofJ0 _ _ (invertibleOfNonzero <| two_or_three_ne_zero.neg_resolve_left h2)
-- Mathlib/Data/List/InsertNth.lean
@[simp]
theorem insertNth_zero (s : List α) (x : α) : insertNth 0 x s = x :: s
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
theorem coe_orthogonalProjection_vadd_smul_vsub_orthogonalProjection {n : ℕ} {r₁ : ℝ}
    (s : Simplex ℝ P n) {p p₁o : P} (hp₁o : p₁o ∈ affineSpan ℝ (Set.range s.points)) :
    ↑(s.orthogonalProjectionSpan (r₁ • (p -ᵥ ↑(s.orthogonalProjectionSpan p)) +ᵥ p₁o)) = p₁o
-- Mathlib/Data/Finset/Basic.lean
/-- `Finset α` is the type of finite sets of elements of `α`. It is implemented
  as a multiset (a list up to permutation) which has no duplicate elements. -/
structure Finset (α : Type*) where
  /-- The underlying multiset -/
  val : Multiset α
  /-- `val` contains no duplicates -/
  nodup : Nodup val
-- Mathlib/Data/Num/Lemmas.lean
theorem add_one : ∀ n : Num, n + 1 = succ n
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
@[simp, mfld_simps]
theorem modelWithCorners_prod_coe_symm (I : ModelWithCorners 𝕜 E H)
    (I' : ModelWithCorners 𝕜 E' H') :
    ((I.prod I').symm : _ × _ → _ × _) = Prod.map I.symm I'.symm
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_mul_le (p q : R[X]) : degree (p * q) ≤ degree p + degree q
-- Mathlib/Order/Sublattice.lean
lemma mem_map_of_mem (f : LatticeHom α β) {a : α} : a ∈ L → f a ∈ L.map f
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem zero_apply {x : ℕ} : (0 : ArithmeticFunction R) x = 0
-- Mathlib/RingTheory/Nilpotent/Lemmas.lean
@[simp]
theorem isNilpotent_mulRight_iff (a : A) : IsNilpotent (mulRight R a) ↔ IsNilpotent a
-- Mathlib/CategoryTheory/Sites/Discrete.lean
lemma isDiscrete_iff_forget [(sheafCompose J U).ReflectsIsomorphisms] : F.IsDiscrete J ht ↔
    ((sheafCompose J U).obj F).IsDiscrete J ht
-- Mathlib/SetTheory/Game/Basic.lean
@[simp]
theorem inv_zero : (0 : PGame)⁻¹ = 0
-- Mathlib/Algebra/Group/Int.lean
@[parity_simps] lemma even_add : Even (m + n) ↔ (Even m ↔ Even n)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem hasPrev : ∀ {it}, ValidFor l r it → (it.hasPrev ↔ l ≠ [])
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
theorem coe_piCongrLeft (f : δ ≃ δ') :
    ⇑(MeasurableEquiv.piCongrLeft π f) = f.piCongrLeft π
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem HasStrictDerivAt.clm_apply (hc : HasStrictDerivAt c c' x) (hu : HasStrictDerivAt u u' x) :
    HasStrictDerivAt (fun y => (c y) (u y)) (c' (u x) + c x u') x
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
lemma Pi.map_comp_map {f g h : α → C} [HasProduct f] [HasProduct g] [HasProduct h]
    (q : ∀ (a : α), f a ⟶ g a) (q' : ∀ (a : α), g a ⟶ h a) :
    Pi.map q ≫ Pi.map q' = Pi.map (fun a => q a ≫ q' a)
-- Mathlib/Order/SupClosed.lean
lemma isSublattice_iInter (hf : ∀ i, IsSublattice (f i)) : IsSublattice (⋂ i, f i)
-- Mathlib/Algebra/Category/Grp/Limits.lean
@[simp]
theorem kernelIsoKer_inv_comp_ι {G H : AddCommGrp.{u}} (f : G ⟶ H) :
    (kernelIsoKer f).inv ≫ kernel.ι f = AddSubgroup.subtype f.ker
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[simp]
theorem map_comp {f : α → β} {g : β → γ} : (m.map f).map g = m.map (g ∘ f)
-- Mathlib/MeasureTheory/Decomposition/Jordan.lean
@[simp]
theorem smul_posPart (r : ℝ≥0) : (r • j).posPart = r • j.posPart
-- Mathlib/Data/List/Rotate.lean
theorem isRotated_iff_mod : l ~r l' ↔ ∃ n ≤ l.length, l.rotate n = l'
-- Mathlib/Algebra/DirectSum/Basic.lean
@[simp]
theorem equivCongrLeft_apply (h : ι ≃ κ) (f : ⨁ i, β i) (k : κ) :
    equivCongrLeft h f k = f (h.symm k)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addXYZ_neg {P : Fin 3 → R} (hP : W'.Equation P) :
    W'.addXYZ P (W'.neg P) = -W'.dblZ P • ![1, 1, 0]
-- Mathlib/Probability/CondCount.lean
theorem pred_true_of_condCount_eq_one (h : condCount s t = 1) : s ⊆ t
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
theorem adjugate_apply (A : Matrix n n α) (i j : n) :
    adjugate A i j = (A.updateRow j (Pi.single i 1)).det
-- Mathlib/Topology/Basic.lean
theorem continuousAt_def : ContinuousAt f x ↔ ∀ A ∈ 𝓝 (f x), f ⁻¹' A ∈ 𝓝 x
-- Mathlib/Data/Set/Image.lean
@[simp]
theorem image_preimage_eq {f : α → β} (s : Set β) (h : Surjective f) : f '' (f ⁻¹' s) = s
-- Mathlib/Analysis/Convex/Extreme.lean
@[simp]
theorem extremePoints_prod (s : Set E) (t : Set F) :
    (s ×ˢ t).extremePoints 𝕜 = s.extremePoints 𝕜 ×ˢ t.extremePoints 𝕜
-- Mathlib/Topology/Instances/CantorSet.lean
/-- The preCantor sets are closed. -/
lemma isClosed_preCantorSet (n : ℕ) : IsClosed (preCantorSet n)
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
theorem eq_right_getRight_of_isRight : ∀ {x : α ⊕ β} (h : x.isRight), x = inr (x.getRight h)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Fold.lean
theorem foldr'_ι_mul (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N)
    (hf : ∀ m x fx, f m (ι Q m * x, f m (x, fx)) = Q m • fx) (n m) (x) :
    foldr' Q f hf n (ι Q m * x) = f m (x, foldr' Q f hf n x)
-- Mathlib/Data/Set/Function.lean
theorem EqOn.cancel_left (h : s.EqOn (g ∘ f₁) (g ∘ f₂)) (hg : t.InjOn g) (hf₁ : s.MapsTo f₁ t)
    (hf₂ : s.MapsTo f₂ t) : s.EqOn f₁ f₂
-- Mathlib/Order/Filter/ENNReal.lean
theorem limsup_eq_zero_iff [CountableInterFilter f] {u : α → ℝ≥0∞} :
    f.limsup u = 0 ↔ u =ᶠ[f] 0
-- Mathlib/Data/Real/Hyperreal.lean
theorem st_neg (x : ℝ*) : st (-x) = -st x
-- Mathlib/Algebra/Bounds.lean
@[to_additive]
theorem subset_upperBounds_mul (s t : Set M) :
    upperBounds s * upperBounds t ⊆ upperBounds (s * t)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
protected theorem isometry : Isometry e
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
theorem det_zero (_ : Nonempty n) : det (0 : Matrix n n R) = 0
-- Mathlib/LinearAlgebra/AffineSpace/MidpointZero.lean
theorem lineMap_one_half {R : Type*} {V P : Type*} [DivisionRing R] [CharZero R] [AddCommGroup V]
    [Module R V] [AddTorsor V P] (a b : P) : lineMap a b (1 / 2 : R) = midpoint R a b
-- Mathlib/Analysis/Calculus/ContDiff/Bounds.lean
/-- If the derivatives within a set of `g` at `f x` are bounded by `C`, and the `i`-th derivative
within a set of `f` at `x` is bounded by `D^i` for all `1 ≤ i ≤ n`, then the `n`-th derivative
of `g ∘ f` is bounded by `n! * C * D^n`. -/
theorem norm_iteratedFDerivWithin_comp_le {g : F → G} {f : E → F} {n : ℕ} {s : Set E} {t : Set F}
    {x : E} {N : ℕ∞} (hg : ContDiffOn 𝕜 N g t) (hf : ContDiffOn 𝕜 N f s) (hn : (n : ℕ∞) ≤ N)
    (ht : UniqueDiffOn 𝕜 t) (hs : UniqueDiffOn 𝕜 s) (hst : MapsTo f s t) (hx : x ∈ s) {C : ℝ}
    {D : ℝ} (hC : ∀ i, i ≤ n → ‖iteratedFDerivWithin 𝕜 i g t (f x)‖ ≤ C)
    (hD : ∀ i, 1 ≤ i → i ≤ n → ‖iteratedFDerivWithin 𝕜 i f s x‖ ≤ D ^ i) :
    ‖iteratedFDerivWithin 𝕜 n (g ∘ f) s x‖ ≤ n ! * C * D ^ n
-- Mathlib/Topology/Algebra/Module/Star.lean
/-- The self-adjoint part of an element of a star module, as a continuous linear map. -/
@[simps!]
def selfAdjointPartL [ContinuousAdd A] [ContinuousStar A] [ContinuousConstSMul R A] :
    A →L[R] selfAdjoint A
-- Mathlib/Data/Nat/PartENat.lean
theorem find_eq_top_iff : find P = ⊤ ↔ ∀ n, ¬P n
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
theorem subNatNat_add_left : subNatNat (m + n) m = n
-- Mathlib/CategoryTheory/DifferentialObject.lean
/-- A morphism of differential objects is a morphism commuting with the differentials. -/
@[ext] -- Porting note(#5171): removed `nolint has_nonempty_instance`
structure Hom (X Y : DifferentialObject S C) where
  /-- The morphism between underlying objects of the two differentiable objects. -/
  f : X.obj ⟶ Y.obj
  comm : X.d ≫ f⟦1⟧' = f ≫ Y.d := by aesop_cat
-- Mathlib/Algebra/Homology/ExactSequence.lean
lemma isComplex_iff_of_iso {S₁ S₂ : ComposableArrows C n} (e : S₁ ≅ S₂) :
    S₁.IsComplex ↔ S₂.IsComplex
-- Mathlib/RingTheory/Algebraic.lean
protected theorem Algebra.isAlgebraic_iff_isIntegral :
    Algebra.IsAlgebraic K A ↔ Algebra.IsIntegral K A
-- Mathlib/Probability/ProbabilityMassFunction/Monad.lean
@[simp]
theorem support_bind : (p.bind f).support = ⋃ a ∈ p.support, (f a).support
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
lemma of_iso (h : IsPushout f g inl inr)
    {Z' X' Y' P' : C} {f' : Z' ⟶ X'} {g' : Z' ⟶ Y'} {inl' : X' ⟶ P'} {inr' : Y' ⟶ P'}
    (e₁ : Z ≅ Z') (e₂ : X ≅ X') (e₃ : Y ≅ Y') (e₄ : P ≅ P')
    (commf : f ≫ e₂.hom = e₁.hom ≫ f')
    (commg : g ≫ e₃.hom = e₁.hom ≫ g')
    (comminl : inl ≫ e₄.hom = e₂.hom ≫ inl')
    (comminr : inr ≫ e₄.hom = e₃.hom ≫ inr') :
    IsPushout f' g' inl' inr'
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[reassoc (attr := simp)]
lemma RightHomologyData.homologyIso_hom_comp_ι (h : S.RightHomologyData) :
    h.homologyIso.hom ≫ h.ι = S.homologyι ≫ h.opcyclesIso.hom
-- Mathlib/Data/Nat/PrimeFin.lean
@[simp] lemma primeFactors_zero : primeFactors 0 = ∅
-- Mathlib/Data/Fintype/Basic.lean
@[simp] lemma subtype_eq_univ {p : α → Prop} [DecidablePred p] [Fintype {a // p a}] :
    s.subtype p = univ ↔ ∀ ⦃a⦄, p a → a ∈ s
-- Mathlib/Topology/Order/ExtrClosure.lean
protected theorem IsMinOn.closure (h : IsMinOn f s a) (hc : ContinuousOn f (closure s)) :
    IsMinOn f (closure s) a
-- Mathlib/Topology/Constructions.lean
/-- The image of a dense set under `Quotient.mk'` is a dense set. -/
theorem Dense.quotient [Setoid X] [TopologicalSpace X] {s : Set X} (H : Dense s) :
    Dense (Quotient.mk' '' s)
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem infsep_nonneg : 0 ≤ s.infsep