ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean
/-- The main inductive step in the grid-lines lemma for the Gagliardo-Nirenberg-Sobolev inequality.

The grid-lines operation `GridLines.T` on a nonnegative function on a finitary product type is
less than or equal to the grid-lines operation of its partial integral in one co-ordinate
(the latter intuitively considered as a function on a space "one dimension down"). -/
theorem T_insert_le_T_lmarginal_singleton (hp₀ : 0 ≤ p) (s : Finset ι)
    (hp : (s.card : ℝ) * p ≤ 1)
    (i : ι) (hi : i ∉ s) {f : (∀ i, A i) → ℝ≥0∞} (hf : Measurable f) :
    T μ p f (insert i s) ≤ T μ p (∫⋯∫⁻_{i}, f ∂μ) s
-- Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean
/-- From a functor `F : J ⥤ C`, given a terminal object of `J`, construct a cocone for `J`.
In `colimitOfDiagramTerminal` we show it is a colimit cocone. -/
@[simps]
def coconeOfDiagramTerminal {X : J} (tX : IsTerminal X) (F : J ⥤ C) : Cocone F
-- Mathlib/Probability/Martingale/OptionalStopping.lean
/-- Given a submartingale `f` and bounded stopping times `τ` and `π` such that `τ ≤ π`, the
expectation of `stoppedValue f τ` is less than or equal to the expectation of `stoppedValue f π`.
This is the forward direction of the optional stopping theorem. -/
theorem Submartingale.expected_stoppedValue_mono [SigmaFiniteFiltration μ 𝒢]
    (hf : Submartingale f 𝒢 μ) (hτ : IsStoppingTime 𝒢 τ) (hπ : IsStoppingTime 𝒢 π) (hle : τ ≤ π)
    {N : ℕ} (hbdd : ∀ ω, π ω ≤ N) : μ[stoppedValue f τ] ≤ μ[stoppedValue f π]
-- Mathlib/Data/Nat/Bits.lean
theorem bit_eq_zero_iff {n : ℕ} {b : Bool} : bit b n = 0 ↔ n = 0 ∧ b = false
-- Mathlib/Logic/Function/OfArity.lean
@[simp]
theorem ofArity_succ (α β : Type u) (n : ℕ) :
    OfArity α β n.succ = (α → OfArity α β n)
-- Mathlib/CategoryTheory/Sites/LocallySurjective.lean
lemma isAmalgamation_map_localPreimage :
    ((localPreimage φ r').map φ).IsAmalgamation r'
-- Mathlib/Analysis/Complex/Basic.lean
theorem nndist_of_re_eq {z w : ℂ} (h : z.re = w.re) : nndist z w = nndist z.im w.im
-- Mathlib/FieldTheory/PerfectClosure.lean
theorem mk_zero (n : ℕ) : mk K p (n, 0) = 0
-- Mathlib/LinearAlgebra/UnitaryGroup.lean
theorem mem_unitaryGroup_iff' : A ∈ Matrix.unitaryGroup n α ↔ star A * A = 1
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem DifferentiableAt.mul_const (ha : DifferentiableAt 𝕜 a x) (b : 𝔸) :
    DifferentiableAt 𝕜 (fun y => a y * b) x
-- Mathlib/MeasureTheory/OuterMeasure/Basic.lean
@[deprecated measure_diff_null (since := "2024-05-14")]
theorem diff_null (m : OuterMeasure α) (s : Set α) {t : Set α} (ht : m t = 0) : m (s \ t) = m s
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
theorem span_singleton_sup_orthogonal_eq_top {B : V →ₗ[K] V →ₗ[K] K} {x : V} (hx : ¬B.IsOrtho x x) :
    (K ∙ x) ⊔ Submodule.orthogonalBilin (N := K ∙ x) (B := B) = ⊤
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
/-- A trident on `f : J → (X ⟶ Y)` is determined by the morphism `ι : P ⟶ X` satisfying
`∀ j₁ j₂, ι ≫ f j₁ = ι ≫ f j₂`.
-/
@[simps]
def Trident.ofι [Nonempty J] {P : C} (ι : P ⟶ X) (w : ∀ j₁ j₂, ι ≫ f j₁ = ι ≫ f j₂) :
    Trident f
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[simp]
theorem WalkingPair.equivBool_symm_apply_false : WalkingPair.equivBool.symm false = right
-- Mathlib/Data/Set/Lattice.lean
lemma iUnion_congr {s t : ι → Set α} (h : ∀ i, s i = t i) : ⋃ i, s i = ⋃ i, t i
-- Mathlib/Order/CompleteBooleanAlgebra.lean
lemma iInf_iSup_eq' (f : ∀ a, κ a → α) :
    let _ := minAx.toCompleteLattice
    ⨅ i, ⨆ j, f i j = ⨆ g : ∀ i, κ i, ⨅ i, f i (g i)
-- Mathlib/Data/Finset/Image.lean
theorem forall_mem_map {f : α ↪ β} {s : Finset α} {p : ∀ a, a ∈ s.map f → Prop} :
    (∀ y (H : y ∈ s.map f), p y H) ↔ ∀ x (H : x ∈ s), p (f x) (mem_map_of_mem _ H)
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
protected theorem uniformContinuous : UniformContinuous ((↑) : Lp.simpleFunc E p μ → Lp E p μ)
-- Mathlib/CategoryTheory/Filtered/Final.lean
/-- If `StructuredArrow d F` is filtered for any `d : D`, then `F : C ⥤ D` is final. This is
    simply because filtered categories are connected. More profoundly, the converse is also true if
    `C` is filtered, see `final_iff_isFiltered_structuredArrow`. -/
theorem Functor.final_of_isFiltered_structuredArrow [∀ d, IsFiltered (StructuredArrow d F)] :
    Final F
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem sup_succ_le_lsub {ι : Type u} (f : ι → Ordinal.{max u v}) :
    succ (sup.{_, v} f) ≤ lsub.{_, v} f ↔ ∃ i, f i = sup.{_, v} f
-- Mathlib/Order/Filter/Basic.lean
theorem Tendsto.frequently {f : α → β} {l₁ : Filter α} {l₂ : Filter β} {p : β → Prop}
    (hf : Tendsto f l₁ l₂) (h : ∃ᶠ x in l₁, p (f x)) : ∃ᶠ y in l₂, p y
-- Mathlib/Analysis/Analytic/Basic.lean
theorem analyticAt_const {v : F} : AnalyticAt 𝕜 (fun _ => v) x
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Pullbacks.lean
@[reassoc (attr := simp)]
theorem PreservesPushout.inl_iso_inv :
    G.map (pushout.inl _ _) ≫ (PreservesPushout.iso G f g).inv = pushout.inl _ _
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem map_injective_of_injective : Function.Injective (map f)
-- Mathlib/Data/Real/Sqrt.lean
theorem neg_sqrt_lt_of_sq_lt (h : x ^ 2 < y) : -√y < x
-- Mathlib/Data/List/MinMax.lean
theorem mem_argmin_iff :
    m ∈ argmin f l ↔
      m ∈ l ∧ (∀ a ∈ l, f m ≤ f a) ∧ ∀ a ∈ l, f a ≤ f m → l.indexOf m ≤ l.indexOf a
-- Mathlib/MeasureTheory/Function/LpSpace.lean
lemma eLpNorm_indicator_const₀ {c : G} (hs : NullMeasurableSet s μ) (hp : p ≠ 0) (hp_top : p ≠ ∞) :
    eLpNorm (s.indicator fun _ => c) p μ = ‖c‖₊ * μ s ^ (1 / p.toReal)
-- Mathlib/CategoryTheory/Monad/Basic.lean
theorem monadToFunctor_mapIso_monad_iso_mk {M N : Monad C} (f : (M : C ⥤ C) ≅ N) (f_η f_μ) :
    (monadToFunctor _).mapIso (MonadIso.mk f f_η f_μ) = f
-- Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean
lemma ker_evalStarAlgHom_eq_closure_adjoin_id (s : Set 𝕜) (h0 : 0 ∈ s) [CompactSpace s] :
    (RingHom.ker (evalStarAlgHom 𝕜 𝕜 (⟨0, h0⟩ : s)) : Set C(s, 𝕜)) =
      closure (adjoin 𝕜 {(restrict s (.id 𝕜))})
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[local simp] theorem negSucc_add_negSucc (m n : Nat) : -[m+1] + -[n+1] = -[succ (m + n) +1]
-- Mathlib/RingTheory/DedekindDomain/Factorization.lean
/-- For nonzero `I, I'`, `val_v(I*I') = val_v(I) + val_v(I')`. -/
theorem count_mul {I I' : FractionalIdeal R⁰ K} (hI : I ≠ 0) (hI' : I' ≠ 0) :
    count K v (I * I') = count K v I + count K v I'
-- Mathlib/Data/Matrix/Basic.lean
theorem one_apply_ne' {i j} : j ≠ i → (1 : Matrix n n α) i j = 0
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem coe_re : (x : ℍ[R]).re = x
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem takeWhile_map (f : α → β) (p : β → Bool) (l : List α) :
    (l.map f).takeWhile p = (l.takeWhile (p ∘ f)).map f
-- Mathlib/Logic/Lemmas.lean
lemma Prop.exists {f : Prop → Prop} : (∃ p, f p) ↔ f True ∨ f False
-- Mathlib/Algebra/DirectSum/Algebra.lean
theorem algebraMap_apply (r : R) :
    algebraMap R (⨁ i, A i) r = DirectSum.of A 0 (GAlgebra.toFun r)
-- Mathlib/Data/List/GetD.lean
@[simp]
theorem getI_nil : getI ([] : List α) n = default
-- Mathlib/CategoryTheory/Adjunction/Mates.lean
/-- Suppose we have a square of functors (where the top and bottom are adjunctions `L₁ ⊣ R₁`
and `L₂ ⊣ R₂` respectively).

      C ↔ D
    G ↓   ↓ H
      E ↔ F

Then we have a bijection between natural transformations `G ⋙ L₂ ⟶ L₁ ⋙ H` and
`R₁ ⋙ G ⟶ H ⋙ R₂`. This can be seen as a bijection of the 2-cells:

         L₁                  R₁
      C --→ D             C ←-- D
    G ↓  ↗  ↓ H         G ↓  ↘  ↓ H
      E --→ F             E ←-- F
         L₂                  R₂

Note that if one of the transformations is an iso, it does not imply the other is an iso.
-/
@[simps]
def mateEquiv : (G ⋙ L₂ ⟶ L₁ ⋙ H) ≃ (R₁ ⋙ G ⟶ H ⋙ R₂)
-- Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean
theorem incMatrix_transpose_mul_diag [Fintype α] [Decidable (e ∈ G.edgeSet)] :
    ((G.incMatrix R)ᵀ * G.incMatrix R) e e = if e ∈ G.edgeSet then 2 else 0
-- Mathlib/Order/Hom/Basic.lean
theorem apply_eq_iff_eq (e : α ≃o β) {x y : α} : e x = e y ↔ x = y
-- Mathlib/MeasureTheory/Group/Measure.lean
@[to_additive]
theorem map_div_left_eq_self (μ : Measure G) [IsInvInvariant μ] [IsMulLeftInvariant μ] (g : G) :
    map (fun t => g / t) μ = μ
-- Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean
@[simp]
theorem rightUnitor_inv (X : C) : (ρ_ X).inv = Limits.coprod.inl
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Instances.lean
lemma cfc_nnreal_eq_real {a : A} (f : ℝ≥0 → ℝ≥0) (ha : 0 ≤ a := by cfc_tac)  :
    cfc f a = cfc (fun x ↦ f x.toNNReal : ℝ → ℝ) a
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
protected theorem natCast_mem (n : ℕ) : (n : A) ∈ S
-- Mathlib/RingTheory/Binomial.lean
theorem multichoose_one_right [MulOneClass R] [NatPowAssoc R] (r : R) : multichoose r 1 = r
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem ofFinsupp_eq_zero {a} : (⟨a⟩ : R[X]) = 0 ↔ a = 0
-- Mathlib/Algebra/Group/Units.lean
@[to_additive (attr := simp)]
theorem inv_eq_val_inv : a.inv = ((a⁻¹ : αˣ) : α)
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem prod_top (s : NonUnitalSubring R) :
    s.prod (⊤ : NonUnitalSubring S) = s.comap (NonUnitalRingHom.fst R S)
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
/-- A left homology data for a short complex `S` induces a right homology data for `S.op`. -/
@[simps]
def op (h : S.LeftHomologyData) : S.op.RightHomologyData
-- Mathlib/Topology/Order/LocalExtr.lean
nonrec theorem Filter.EventuallyEq.isLocalMinOn_iff {f g : α → β} {a : α} (heq : f =ᶠ[𝓝[s] a] g)
    (hmem : a ∈ s) : IsLocalMinOn f s a ↔ IsLocalMinOn g s a
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
@[simp]
theorem descPochhammer_map (f : R →+* T) (n : ℕ) :
    (descPochhammer R n).map f = descPochhammer T n
-- Mathlib/RingTheory/Valuation/Basic.lean
@[simp]
theorem map_one : v 1 = (0 : Γ₀)
-- Mathlib/Data/Finset/NatAntidiagonal.lean
/-- The set `antidiagonal n` is equivalent to `Fin (n+1)`, via the first projection. --/
@[simps]
def antidiagonalEquivFin (n : ℕ) : antidiagonal n ≃ Fin (n + 1)
-- Mathlib/Logic/Equiv/Defs.lean
protected lemma forall_congr_right : (∀ a, q (e a)) ↔ ∀ b, q b
-- Mathlib/Order/Sublattice.lean
@[simp] lemma mk_sup_mk (a b : α) (ha hb) : (⟨a, ha⟩ ⊔ ⟨b, hb⟩ : L) = ⟨a ⊔ b, L.supClosed ha hb⟩
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[simp]
lemma coe_himp (s t : Subtype (MeasurableSet : Set α → Prop)) : ↑(s ⇨ t) = (s ⇨ t : Set α)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
theorem eq_zero_of_gcd_eq_zero_left {m n : Nat} (H : gcd m n = 0) : m = 0
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.add_isBigOWith (h₁ : f₁ =o[l] g) (h₂ : IsBigOWith c₁ l f₂ g) (hc : c₁ < c₂) :
    IsBigOWith c₂ l (fun x => f₁ x + f₂ x) g
-- Mathlib/Data/DFinsupp/Basic.lean
theorem support_mapRange {f : ∀ i, β₁ i → β₂ i} {hf : ∀ i, f i 0 = 0} {g : Π₀ i, β₁ i} :
    (mapRange f hf g).support ⊆ g.support
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
/-- The symbol `J(a | 0)` has the value `1`. -/
@[simp]
theorem zero_right (a : ℤ) : J(a | 0) = 1
-- Mathlib/LinearAlgebra/Dual.lean
theorem dualAnnihilator_sup_eq (U V : Submodule R M) :
    (U ⊔ V).dualAnnihilator = U.dualAnnihilator ⊓ V.dualAnnihilator
-- Mathlib/Topology/Compactness/Compact.lean
lemma Set.Infinite.exists_accPt_cofinite_inf_principal_of_subset_isCompact
    {K : Set X} (hs : s.Infinite) (hK : IsCompact K) (hsub : s ⊆ K) :
    ∃ x ∈ K, AccPt x (cofinite ⊓ 𝓟 s)
-- Mathlib/Analysis/Convex/Side.lean
theorem WSameSide.trans_sSameSide {s : AffineSubspace R P} {x y z : P} (hxy : s.WSameSide x y)
    (hyz : s.SSameSide y z) : s.WSameSide x z
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
theorem mkPiRing_apply_one_eq_self [Fintype ι] (f : MultilinearMap R (fun _ : ι => R) M₂) :
    MultilinearMap.mkPiRing R ι (f fun _ => 1) = f
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem closedEmbedding_of_spaced_out {α} [TopologicalSpace α] [DiscreteTopology α]
    [T0Space β] {f : α → β} {s : Set (β × β)} (hs : s ∈ 𝓤 β)
    (hf : Pairwise fun x y => (f x, f y) ∉ s) : ClosedEmbedding f
-- Mathlib/MeasureTheory/Function/Jacobian.lean
/-- Let `f` be a function which is sufficiently close (in the Lipschitz sense) to a given linear
map `A`. Then it expands the volume of any set by at least `m` for any `m < det A`. -/
theorem mul_le_addHaar_image_of_lt_det (A : E →L[ℝ] E) {m : ℝ≥0}
    (hm : (m : ℝ≥0∞) < ENNReal.ofReal |A.det|) :
    ∀ᶠ δ in 𝓝[>] (0 : ℝ≥0),
      ∀ (s : Set E) (f : E → E), ApproximatesLinearOn f A s δ → (m : ℝ≥0∞) * μ s ≤ μ (f '' s)
-- Mathlib/Algebra/Category/HopfAlgebraCat/Basic.lean
/-- Build an isomorphism in the category `HopfAlgebraCat R` from a
`BialgEquiv`. -/
@[simps]
def toHopfAlgebraCatIso (e : X ≃ₐc[R] Y) : HopfAlgebraCat.of R X ≅ HopfAlgebraCat.of R Y
-- Mathlib/Algebra/Group/NatPowAssoc.lean
@[simp, norm_cast]
theorem Nat.cast_npow (R : Type*) [NonAssocSemiring R] [Pow R ℕ] [NatPowAssoc R] (n m : ℕ) :
    (↑(n ^ m) : R) = (↑n : R) ^ m
-- Mathlib/Probability/Martingale/Basic.lean
theorem supermartingale [Preorder E] (hf : Martingale f ℱ μ) : Supermartingale f ℱ μ
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem domLCongr_symm (e : M ≃ₗ[R] M₂) : (domLCongr R N ι S e).symm = domLCongr R N ι S e.symm
-- Mathlib/Data/Finset/Basic.lean
theorem union_congr_left (ht : t ⊆ s ∪ u) (hu : u ⊆ s ∪ t) : s ∪ t = s ∪ u
-- Mathlib/Algebra/Order/AbsoluteValue.lean
@[simp]
protected theorem eq_zero {x : R} : abv x = 0 ↔ x = 0
-- Mathlib/Data/Set/Card.lean
theorem ncard_inter_le_ncard_left (s t : Set α) (hs : s.Finite := by toFinite_tac) :
    (s ∩ t).ncard ≤ s.ncard
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive mul_nsmul] lemma pow_mul (a : M) (m : ℕ) : ∀ n, a ^ (m * n) = (a ^ m) ^ n
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurableSet_pi_of_nonempty {s : Set δ} {t : ∀ i, Set (π i)} (hs : s.Countable)
    (h : (pi s t).Nonempty) : MeasurableSet (pi s t) ↔ ∀ i ∈ s, MeasurableSet (t i)
-- Mathlib/Topology/FiberBundle/Trivialization.lean
@[simp]
theorem preimageSingletonHomeomorph_apply {b : B} (hb : b ∈ e.baseSet) (p : proj ⁻¹' {b}) :
    e.preimageSingletonHomeomorph hb p = (e p).2
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem self_symm_id (α : X ≅ Y) : α ≪≫ α.symm = Iso.refl X
-- Mathlib/Data/Matrix/Kronecker.lean
theorem kroneckerMap_diagonal_left [Zero α] [Zero γ] [DecidableEq l] (f : α → β → γ)
    (hf : ∀ b, f 0 b = 0) (a : l → α) (B : Matrix m n β) :
    kroneckerMap f (diagonal a) B =
      Matrix.reindex (Equiv.prodComm _ _) (Equiv.prodComm _ _)
        (blockDiagonal fun i => B.map fun b => f (a i) b)
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem comp_id (f : CompleteLatticeHom α β) : f.comp (CompleteLatticeHom.id α) = f
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_self_nonneg {x : E} : 0 ≤ re ⟪x, x⟫
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive norm_pos_iff']
theorem norm_pos_iff''' [T0Space E] {a : E} : 0 < ‖a‖ ↔ a ≠ 1
-- Mathlib/Algebra/Polynomial/Eval.lean
/-- Evaluate a polynomial `p` given a ring hom `f` from the scalar ring
  to the target and a value `x` for the variable in the target -/
irreducible_def eval₂ (p : R[X]) : S
-- Mathlib/Algebra/ContinuedFractions/Computation/Basic.lean
/-- Shows that `IntFractPair.stream` has the sequence property, that is once we return `none` at
position `n`, we also return `none` at `n + 1`.
-/
theorem stream_isSeq (v : K) : (IntFractPair.stream v).IsSeq
-- Mathlib/Data/Complex/Exponential.lean
nonrec theorem cot_eq_cos_div_sin : cot x = cos x / sin x
-- Mathlib/Topology/Homotopy/Contractible.lean
theorem ContractibleSpace.hequiv_unit (X : Type*) [TopologicalSpace X] [ContractibleSpace X] :
    Nonempty (X ≃ₕ Unit)
-- Mathlib/Topology/Separation.lean
theorem t1Space_iff_exists_open :
    T1Space X ↔ Pairwise fun x y => ∃ U : Set X, IsOpen U ∧ x ∈ U ∧ y ∉ U
-- Mathlib/Data/Part.lean
@[simp]
theorem mem_restrict (p : Prop) (o : Part α) (h : p → o.Dom) (a : α) :
    a ∈ restrict p o h ↔ p ∧ a ∈ o
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem bihimp_eq_right : a ⇔ b = b ↔ a = ⊤
-- Mathlib/Data/Fintype/Card.lean
protected theorem Fintype.finite {α : Type*} (_inst : Fintype α) : Finite α
-- Mathlib/Data/Matrix/Rank.lean
theorem rank_transpose_mul_self (A : Matrix m n R) : (Aᵀ * A).rank = A.rank
-- Mathlib/Data/Bool/Basic.lean
@[simp] lemma toNat_bne_one  (b : Bool) : (b.toNat != 1) = !b
-- Mathlib/Data/Set/NAry.lean
theorem image2_swap (s : Set α) (t : Set β) : image2 f s t = image2 (fun a b => f b a) t s
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
lemma HasHomology.mk' (h : S.HomologyData) : HasHomology S
-- Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean
@[to_additive]
theorem hasProd_iff_tendsto_nat [T2Space M] {f : ℕ → M} (hf : Multipliable f) :
    HasProd f m ↔ Tendsto (fun n : ℕ ↦ ∏ i ∈ range n, f i) atTop (𝓝 m)
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
lemma IsOfFinOrder.mem_zpowers_iff_mem_range_orderOf [DecidableEq G] (hx : IsOfFinOrder x) :
    y ∈ zpowers x ↔ y ∈ (Finset.range (orderOf x)).image (x ^ ·)
-- Mathlib/Order/Interval/Set/Monotone.lean
protected theorem Monotone.Ici (hf : Monotone f) : Antitone fun x => Ici (f x)
-- Mathlib/MeasureTheory/Constructions/Polish/Basic.lean
/-- If `f : X → Z` is a Borel measurable map from a standard Borel space
to a countably separated measurable space,
then for any measurable space `β` and `g : Z → β`, the composition `g ∘ f` is
measurable if and only if the restriction of `g` to the range of `f` is measurable. -/
theorem measurable_comp_iff_restrict {f : X → Z}
    [CountablySeparated (range f)]
    (hf : Measurable f) {g : Z → β} : Measurable (g ∘ f) ↔ Measurable (restrict (range f) g)
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem logb_lt_iff_lt_rpow (hx : 0 < x) : logb b x < y ↔ x < b ^ y
-- Mathlib/Data/Set/Basic.lean
theorem union_inter_distrib_right (s t u : Set α) : (s ∪ t) ∩ u = s ∩ u ∪ t ∩ u
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem lsingle_range_le_ker_lapply (s t : Set α) (h : Disjoint s t) :
    ⨆ a ∈ s, LinearMap.range (lsingle a : M →ₗ[R] α →₀ M) ≤
      ⨅ a ∈ t, ker (lapply a : (α →₀ M) →ₗ[R] M)
-- Mathlib/CategoryTheory/IsConnected.lean
theorem nonempty_hom_of_preconnected_groupoid {G} [Groupoid G] [IsPreconnected G] :
    ∀ x y : G, Nonempty (x ⟶ y)
-- Mathlib/GroupTheory/Coxeter/Basic.lean
/-- The simple reflections of `W` generate `W` as a monoid. -/
theorem submonoid_closure_range_simple : Submonoid.closure (range cs.simple) = ⊤
-- Mathlib/GroupTheory/Coset.lean
@[to_additive mem_rightAddCoset]
theorem mem_rightCoset {s : Set α} {x : α} (a : α) (hxS : x ∈ s) : x * a ∈ op a • s
-- Mathlib/Analysis/Convex/Quasiconvex.lean
theorem MonotoneOn.quasiconcaveOn (hf : MonotoneOn f s) (hs : Convex 𝕜 s) : QuasiconcaveOn 𝕜 s f
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem norm_le_of_tsum_le (hp : 0 < p.toReal) {C : ℝ} (hC : 0 ≤ C) {f : lp E p}
    (hf : ∑' i, ‖f i‖ ^ p.toReal ≤ C ^ p.toReal) : ‖f‖ ≤ C
-- Mathlib/LinearAlgebra/Basis.lean
theorem index_nonempty (b : Basis ι R M) [Nontrivial M] : Nonempty ι
-- Mathlib/CategoryTheory/Bicategory/Extension.lean
/-- The isomorphism between left extensions induced by a right unitor. -/
@[simps! hom_right inv_right]
def whiskerOfCompIdIsoSelf (t : LeftExtension f g) : (t.whisker (𝟙 c)).ofCompId ≅ t
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
@[measurability]
protected theorem Homeomorph.measurable (h : α ≃ₜ γ) : Measurable h
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive (attr := simp) MeasureTheory.sdiff_addFundamentalInterior]
theorem sdiff_fundamentalInterior : s \ fundamentalInterior G s = fundamentalFrontier G s
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem darts_copy {u v u' v'} (p : G.Walk u v) (hu : u = u') (hv : v = v') :
    (p.copy hu hv).darts = p.darts
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
protected theorem Inseparable.inv {x y : G} (h : Inseparable x y) : Inseparable (x⁻¹) (y⁻¹)
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem mapRange.linearMap_toAddMonoidHom (f : M →ₗ[R] N) :
    (mapRange.linearMap f).toAddMonoidHom =
      (mapRange.addMonoidHom f.toAddMonoidHom : (α →₀ M) →+ _)
-- Mathlib/Geometry/Manifold/LocalInvariantProperties.lean
theorem liftPropOn_mono (mono : ∀ ⦃s x t⦄ ⦃f : H → H'⦄, t ⊆ s → P f s x → P f t x)
    (h : LiftPropOn P g t) (hst : s ⊆ t) : LiftPropOn P g s
-- Mathlib/Algebra/DirectSum/Ring.lean
@[simp]
theorem of_intCast (n : ℤ) : of A 0 n = n
-- Mathlib/RingTheory/Localization/Finiteness.lean
/--
If there exists a finite set `{ r }` of `R` such that `Mᵣ` is `Rᵣ`-finite for each `r`,
then `M` is a finite `R`-module.

See `of_localizationSpan` for a version without the finite set assumption.
-/
theorem of_localizationSpan_finite (t : Finset R) (ht : Ideal.span (t : Set R) = ⊤)
    (H : ∀ (g : t), Module.Finite (Localization.Away g.val)
      (LocalizedModule (Submonoid.powers g.val) M)) :
    Module.Finite R M
-- Mathlib/Data/Vector/Basic.lean
theorem toList_injective : Function.Injective (@toList α n)
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- Given a closed set `s`, a point belongs to `s` iff its infimum edistance to this set vanishes -/
theorem mem_iff_infEdist_zero_of_closed (h : IsClosed s) : x ∈ s ↔ infEdist x s = 0
-- Mathlib/Data/Set/Finite.lean
/-- A finset is bounded above. -/
protected theorem bddAbove [SemilatticeSup α] [Nonempty α] (s : Finset α) : BddAbove (↑s : Set α)
-- Mathlib/Order/Birkhoff.lean
@[simp] lemma infIrred_Ici (a : α) : InfIrred (Ici a)
-- Mathlib/GroupTheory/Coxeter/Inversion.lean
@[simp] theorem leftInvSeq_nil : lis [] = []
-- Mathlib/CategoryTheory/SmallObject/Construction.lean
lemma ιFunctorObj_extension {i : I} (t : A i ⟶ X) (b : B i ⟶ S)
    (sq : CommSq t (f i) πX b) :
    ∃ (l : B i ⟶ functorObj f πX), f i ≫ l = t ≫ ιFunctorObj f πX ∧
      l ≫ πFunctorObj f πX = b
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive lt_add_of_pos_right]
theorem lt_mul_of_one_lt_right' [CovariantClass α α (· * ·) (· < ·)] (a : α) {b : α} (h : 1 < b) :
    a < a * b
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp]
theorem extendDomain_mul (e e' : Perm α) :
    e.extendDomain f * e'.extendDomain f = (e * e').extendDomain f
-- Mathlib/Topology/FiberBundle/Constructions.lean
theorem Prod.continuous_to_fun : ContinuousOn (Prod.toFun' e₁ e₂)
    (π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet))
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem refl_le_uniformity : 𝓟 idRel ≤ 𝓤 α
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem succ_sub_succ_eq_sub (n m : Nat) : succ n - succ m = n - m
-- Mathlib/GroupTheory/Divisible.lean
/-- A `Monoid A` is `α`-rootable iff `xⁿ = a` has a solution for all `n ≠ 0 ∈ α` and `a ∈ A`.
Here we adopt a constructive approach where we ask an explicit `root : A → α → A` function such that
* `root a 0 = 1` for all `a ∈ A`
* `(root a n)ⁿ = a` for all `n ≠ 0 ∈ α` and `a ∈ A`.
-/
@[to_additive]
class RootableBy where
  root : A → α → A
  root_zero : ∀ a, root a 0 = 1
  root_cancel : ∀ {n : α} (a : A), n ≠ 0 → root a n ^ n = a
-- Mathlib/Analysis/Complex/Basic.lean
lemma conj_mul' (z : ℂ) : conj z * z = ‖z‖ ^ 2
-- Mathlib/Topology/IndicatorConstPointwise.lean
lemma tendsto_indicator_const_iff_tendsto_pi_pure [T1Space β] (b : β) [NeZero b] :
    Tendsto (fun i ↦ (As i).indicator (fun (_ : α) ↦ b)) L (𝓝 (A.indicator (fun (_ : α) ↦ b)))
      ↔ (Tendsto As L <| Filter.pi (pure <| · ∈ A))
-- Mathlib/Computability/TuringMachine.lean
theorem trTape'_move_left (L R : ListBlank Γ) :
    (Tape.move Dir.left)^[n] (trTape' enc0 L R) = trTape' enc0 L.tail (R.cons L.head)
-- Mathlib/Data/Set/SMulAntidiagonal.lean
@[to_additive VAddAntidiagonal.fst_eq_fst_iff_snd_eq_snd]
theorem fst_eq_fst_iff_snd_eq_snd :
    (x : G × P).1 = (y : G × P).1 ↔ (x : G × P).2 = (y : G × P).2
-- Mathlib/Order/Interval/Finset/Nat.lean
theorem card_fintypeIoo : Fintype.card (Set.Ioo a b) = b - a - 1
-- Mathlib/Data/Set/Functor.lean
theorem image_val_subset : (γ : Set α) ⊆ β
-- Mathlib/Topology/MetricSpace/Gluing.lean
theorem Sum.dist_eq_glueDist {p q : X ⊕ Y} (x : X) (y : Y) :
    Sum.dist p q =
      glueDist (fun _ : Unit => Nonempty.some ⟨x⟩) (fun _ : Unit => Nonempty.some ⟨y⟩) 1 p q