ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/FiberBundle/Trivialization.lean
@[simp, mfld_simps]
theorem symm_coe_proj {x : B} {y : F} (e : Trivialization F (π F E)) (h : x ∈ e.baseSet) :
    (e.toPartialHomeomorph.symm (x, y)).1 = x
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem le_logb_iff_rpow_le (hy : 0 < y) : x ≤ logb b y ↔ b ^ x ≤ y
-- Mathlib/Topology/MetricSpace/GromovHausdorff.lean
/-- Auxiliary structure used to glue metric spaces below, recording an isometric embedding
of a type `A` in another metric space. -/
structure AuxGluingStruct (A : Type) [MetricSpace A] : Type 1 where
  Space : Type
  metric : MetricSpace Space
  embed : A → Space
  isom : Isometry embed
-- Mathlib/Algebra/MonoidAlgebra/ToDirectSum.lean
@[simp]
theorem toDirectSum_mul [DecidableEq ι] [AddMonoid ι] [Semiring M] (f g : AddMonoidAlgebra M ι) :
    (f * g).toDirectSum = f.toDirectSum * g.toDirectSum
-- Mathlib/Logic/Equiv/Basic.lean
/-- Note: the "obvious" statement `(piCongrLeft' P e).symm g a = g (e a)` doesn't typecheck: the
LHS would have type `P a` while the RHS would have type `P (e.symm (e a))`. This lemma is a way
around it in the case where `a` is of the form `e.symm b`, so we can use `g b` instead of
`g (e (e.symm b))`. -/
lemma piCongrLeft'_symm_apply_apply (P : α → Sort*) (e : α ≃ β) (g : ∀ b, P (e.symm b)) (b : β) :
    (piCongrLeft' P e).symm g (e.symm b) = g b
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
protected theorem tendsto_approx {_ : MeasurableSpace α} (hf : StronglyMeasurable f) :
    ∀ x, Tendsto (fun n => hf.approx n x) atTop (𝓝 (f x))
-- Mathlib/CategoryTheory/Galois/Basic.lean
@[simp]
lemma fiberPullbackEquiv_symm_fst_apply {X A B : C} {f : A ⟶ X} {g : B ⟶ X}
    (a : F.obj A) (b : F.obj B) (h : F.map f a = F.map g b) :
    F.map (pullback.fst f g) ((fiberPullbackEquiv F f g).symm ⟨(a, b), h⟩) = a
-- Mathlib/MeasureTheory/Measure/Stieltjes.lean
theorem iInf_rat_gt_eq (f : StieltjesFunction) (x : ℝ) :
    ⨅ r : { r' : ℚ // x < r' }, f r = f x
-- Mathlib/NumberTheory/EulerProduct/Basic.lean
/-- The *Euler Product* for a multiplicative arithmetic function `f` with values in a
complete normed commutative ring `R`: if `‖f ·‖` is summable, then
`∏' p : Nat.Primes, ∑' e, f (p ^ e) = ∑' n, f n`. -/
nonrec theorem IsMultiplicative.eulerProduct_tprod {f : ArithmeticFunction R}
    (hf : f.IsMultiplicative) (hsum : Summable (‖f ·‖)) :
    ∏' p : Primes, ∑' e, f (p ^ e) = ∑' n, f n
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_comp_inv (f : R → R) (a : Aˣ)
    (hf : ContinuousOn f ((· ⁻¹) '' (spectrum R (a : A))) := by cfc_cont_tac)
    (ha : p a := by cfc_tac) :
    cfc (fun x ↦ f x⁻¹) (a : A) = cfc f (↑a⁻¹ : A)
-- Mathlib/Analysis/Convex/Join.lean
theorem convexJoin_singleton_segment (a b c : E) :
    convexJoin 𝕜 {a} (segment 𝕜 b c) = convexHull 𝕜 {a, b, c}
-- Mathlib/Combinatorics/SimpleGraph/Metric.lean
theorem edist_eq_sInf : G.edist u v = sInf (Set.range fun w : G.Walk u v ↦ (w.length : ℕ∞))
-- Mathlib/Probability/Kernel/Disintegration/Density.lean
@[simp]
lemma densityProcess_empty (κ : Kernel α (γ × β)) (ν : Kernel α γ) (n : ℕ) (a : α) (x : γ) :
    densityProcess κ ν n a x ∅ = 0
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
@[simp]
theorem circleIntegrable_sub_inv_iff {c w : ℂ} {R : ℝ} :
    CircleIntegrable (fun z => (z - w)⁻¹) c R ↔ R = 0 ∨ w ∉ sphere c |R|
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
/-- A non-unital subring is closed under addition. -/
protected theorem add_mem {x y : R} : x ∈ s → y ∈ s → x + y ∈ s
-- Mathlib/Data/Set/Lattice.lean
theorem surjOn_sUnion {s : Set α} {T : Set (Set β)} {f : α → β} (H : ∀ t ∈ T, SurjOn f s t) :
    SurjOn f s (⋃₀T)
-- Mathlib/Data/Finset/Image.lean
@[simp]
theorem image_singleton (f : α → β) (a : α) : image f {a} = {f a}
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem not_not_eq : ∀ {a b : Bool}, ¬(!a) = b ↔ a = b
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem comp_apply (f : BoundedLatticeHom β γ) (g : BoundedLatticeHom α β) (a : α) :
    (f.comp g) a = f (g a)
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem ltEmbedding_apply (x : α) : f.ltEmbedding x = f x
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem pow_add (a m n : Nat) : a ^ (m + n) = a ^ m * a ^ n
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem mk_le_mk {S S' : Subsemiring R} (h₁ h₂) :
    (⟨S, h₁⟩ : Subring R) ≤ (⟨S', h₂⟩ : Subring R) ↔ S ≤ S'
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem sub_toIcoDiv_zsmul_mem_Ico (a b : α) : b - toIcoDiv hp a b • p ∈ Set.Ico a (a + p)
-- Mathlib/Algebra/Module/Submodule/RestrictScalars.lean
@[simp]
theorem restrictScalars_eq_top_iff {p : Submodule R M} : restrictScalars S p = ⊤ ↔ p = ⊤
-- Mathlib/NumberTheory/MulChar/Basic.lean
/-- The inverse of a multiplicative character `χ`, applied to `a`, is the inverse of `χ a`.
Variant when the target is a field -/
theorem inv_apply_eq_inv' {R' : Type*} [Field R'] (χ : MulChar R R') (a : R) : χ⁻¹ a = (χ a)⁻¹
-- Mathlib/Order/Filter/Basic.lean
theorem principal_mono {s t : Set α} : 𝓟 s ≤ 𝓟 t ↔ s ⊆ t
-- Mathlib/Data/List/Sigma.lean
@[simp]
theorem mem_keys_kunion {a} {l₁ l₂ : List (Sigma β)} :
    a ∈ (kunion l₁ l₂).keys ↔ a ∈ l₁.keys ∨ a ∈ l₂.keys
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem stoppedValue_upperCrossingTime (h : upperCrossingTime a b f N (n + 1) ω ≠ N) :
    b ≤ stoppedValue f (upperCrossingTime a b f N (n + 1)) ω
-- Mathlib/Data/Countable/Defs.lean
protected theorem Function.Surjective.uncountable [Uncountable β] {f : α → β} (hf : Surjective f) :
    Uncountable α
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- Two simplices are equal if they have the same points. -/
@[ext]
theorem ext {n : ℕ} {s1 s2 : Simplex k P n} (h : ∀ i, s1.points i = s2.points i) : s1 = s2
-- Mathlib/Algebra/Homology/TotalComplex.lean
lemma d₁_eq {i₁ i₁' : I₁} (h : c₁.Rel i₁ i₁') (i₂ : I₂) (i₁₂ : I₁₂)
    (h' : ComplexShape.π c₁ c₂ c₁₂ ⟨i₁', i₂⟩ = i₁₂) :
    K.d₁ c₁₂ i₁ i₂ i₁₂ = ComplexShape.ε₁ c₁ c₂ c₁₂ ⟨i₁, i₂⟩ • ((K.d i₁ i₁').f i₂ ≫
      K.toGradedObject.ιMapObj (ComplexShape.π c₁ c₂ c₁₂) ⟨i₁', i₂⟩ i₁₂ h')
-- Mathlib/NumberTheory/ClassNumber/Finite.lean
/-- A nonzero ideal has an element of minimal norm. -/
theorem exists_min (I : (Ideal S)⁰) :
    ∃ b ∈ (I : Ideal S),
      b ≠ 0 ∧ ∀ c ∈ (I : Ideal S), abv (Algebra.norm R c) < abv (Algebra.norm R b) → c =
      (0 : S)
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
theorem norm_eq_ciSup (f : PiLp ∞ β) : ‖f‖ = ⨆ i, ‖f i‖
-- Mathlib/GroupTheory/Commutator.lean
theorem one_mem_commutatorSet : (1 : G) ∈ commutatorSet G
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
/-- In a space with second countable topology and a sigma-finite measure,
  an `AEMeasurable` function is `AEFinStronglyMeasurable`. -/
@[aesop 90% apply (rule_sets := [Measurable])]
theorem aefinStronglyMeasurable_of_aemeasurable {_m0 : MeasurableSpace α} (μ : Measure α)
    [SigmaFinite μ] (hf : AEMeasurable f μ) : AEFinStronglyMeasurable f μ
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem pi_trans (ei : ∀ i, PartialEquiv (αi i) (βi i)) (ei' : ∀ i, PartialEquiv (βi i) (γi i)) :
    (PartialEquiv.pi ei).trans (PartialEquiv.pi ei') = .pi fun i ↦ (ei i).trans (ei' i)
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
@[simp]
theorem mem_primitiveRoots {ζ : R} (h0 : 0 < k) : ζ ∈ primitiveRoots k R ↔ IsPrimitiveRoot ζ k
-- Mathlib/Data/Nat/Bits.lean
theorem bit_cases_on_injective {C : ℕ → Sort u} :
    Function.Injective fun H : ∀ b n, C (bit b n) => fun n => bitCasesOn n H
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
protected theorem Nat.le_antisymm {n m : Nat} (h₁ : LE.le n m) (h₂ : LE.le m n) : Eq n m
-- Mathlib/Analysis/Calculus/BumpFunction/Basic.lean
protected theorem neg (f : ContDiffBump (0 : E)) (x : E) : f (-x) = f x
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The Hausdorff distance is invariant under isometries. -/
theorem hausdorffDist_image (h : Isometry Φ) :
    hausdorffDist (Φ '' s) (Φ '' t) = hausdorffDist s t
-- Mathlib/Data/Bool/Basic.lean
theorem coe_xor_iff (a b : Bool) : xor a b ↔ Xor' (a = true) (b = true)
-- Mathlib/Topology/Connected/PathConnected.lean
theorem pathConnectedSpace_iff_univ : PathConnectedSpace X ↔ IsPathConnected (univ : Set X)
-- Mathlib/Order/LiminfLimsup.lean
theorem IsBoundedUnder.mono {f g : Filter β} {u : β → α} (h : f ≤ g) :
    g.IsBoundedUnder r u → f.IsBoundedUnder r u
-- .lake/packages/batteries/Batteries/Data/UInt.lean
@[simp] theorem UInt8.toUInt64_toNat (x : UInt8) : x.toUInt64.toNat = x.toNat
-- Mathlib/Logic/Function/Basic.lean
protected theorem uncurry {α β γ : Type*} {f : α → β → γ} (hf : Injective2 f) :
    Function.Injective (uncurry f)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Expand the square -/
theorem norm_add_sq (x y : E) : ‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * re ⟪x, y⟫ + ‖y‖ ^ 2
-- Mathlib/Data/Set/Sigma.lean
theorem Nonempty.sigma_snd : (s.sigma t).Nonempty → ∃ i ∈ s, (t i).Nonempty
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
/-- A measure `μ` is called σ-finite if there is a countable collection of sets
 `{ A i | i ∈ ℕ }` such that `μ (A i) < ∞` and `⋃ i, A i = s`. -/
class SigmaFinite {m0 : MeasurableSpace α} (μ : Measure α) : Prop where
  out' : Nonempty (μ.FiniteSpanningSetsIn univ)
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean
theorem hundred_le_m [Nonempty α] (hPα : P.parts.card * 16 ^ P.parts.card ≤ card α)
    (hPε : 100 ≤ (4 : ℝ) ^ P.parts.card * ε ^ 5) (hε : ε ≤ 1) : 100 ≤ m
-- Mathlib/Computability/Primrec.lean
theorem swap {f : α → β → σ} (h : Primrec₂ f) : Primrec₂ (swap f)
-- Mathlib/FieldTheory/IntermediateField.lean
protected theorem coe_add (x y : S) : (↑(x + y) : L) = ↑x + ↑y
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem Monic.mul_left_eq_zero_iff (h : Monic p) {q : R[X]} : q * p = 0 ↔ q = 0
-- Mathlib/Data/Sum/Order.lean
theorem inl_strictMono : StrictMono (inl : α → α ⊕ β)
-- Mathlib/Data/Finset/Pointwise.lean
theorem zero_mul_subset (s : Finset α) : 0 * s ⊆ 0
-- Mathlib/Order/Interval/Finset/Fin.lean
@[simp]
theorem card_Iic : (Iic b).card = b + 1
-- Mathlib/Geometry/Manifold/MFDeriv/FDeriv.lean
theorem writtenInExtChartAt_model_space : writtenInExtChartAt 𝓘(𝕜, E) 𝓘(𝕜, E') x f = f
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
theorem minkowskiBound_pos : 0 < minkowskiBound K I
-- Mathlib/AlgebraicTopology/DoldKan/Projections.lean
theorem P_add_Q (q : ℕ) : P q + Q q = 𝟙 K[X]
-- Mathlib/Data/Set/Subset.lean
@[simp]
lemma image_val_sInter (hT : T.Nonempty) : (↑(⋂₀ T) : Set α) = ⋂₀ { (↑B : Set α) | B ∈ T }
-- Mathlib/Order/UpperLower/Basic.lean
@[simp, norm_cast]
theorem coe_bot : ((⊥ : LowerSet α) : Set α) = ∅
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
/-- If `f` is continuous alternating, then `f (Σ_{j₁ ∈ A₁} g₁ j₁, ..., Σ_{jₙ ∈ Aₙ} gₙ jₙ)` is the
sum of `f (g₁ (r 1), ..., gₙ (r n))` where `r` ranges over all functions with `r 1 ∈ A₁`, ...,
`r n ∈ Aₙ`. This follows from multilinearity by expanding successively with respect to each
coordinate. -/
theorem map_sum_finset :
    (f fun i => ∑ j ∈ A i, g' i j) = ∑ r ∈ piFinset A, f fun i => g' i (r i)
-- Mathlib/Data/List/Rotate.lean
theorem rotate_perm (l : List α) (n : ℕ) : l.rotate n ~ l
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
/-- Variant of `Real.rpow_add'` that avoids having to prove `y + z = w` twice. -/
lemma rpow_of_add_eq (hx : 0 ≤ x) (hw : w ≠ 0) (h : y + z = w) : x ^ w = x ^ y * x ^ z
-- Mathlib/Order/Bounds/Basic.lean
@[simp] lemma bddAbove_singleton : BddAbove ({a} : Set α)
-- Mathlib/Data/List/Basic.lean
theorem replicate_right_inj {a b : α} {n : ℕ} (hn : n ≠ 0) :
    replicate n a = replicate n b ↔ a = b
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem neighborSet_subset_of_subgraph {x y : Subgraph G} (h : x ≤ y) (v : V) :
    x.neighborSet v ⊆ y.neighborSet v
-- Mathlib/Algebra/Ring/Hom/Defs.lean
theorem one_def : (1 : α →ₙ+* α) = NonUnitalRingHom.id α
-- Mathlib/Algebra/GroupWithZero/Basic.lean
@[simp] lemma pow_eq_zero_iff' [Nontrivial M₀] : a ^ n = 0 ↔ a = 0 ∧ n ≠ 0
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
@[simp]
theorem MeasurableSet.compl_iff : MeasurableSet sᶜ ↔ MeasurableSet s
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
@[deprecated le_rpow_inv_iff (since := "2024-07-10")]
theorem le_rpow_one_div_iff {x y : ℝ≥0∞} {z : ℝ} (hz : 0 < z) : x ≤ y ^ (1 / z) ↔ x ^ z ≤ y
-- Mathlib/Data/Finite/Card.lean
theorem Nat.card_eq (α : Type*) :
    Nat.card α = if h : Finite α then @Fintype.card α (Fintype.ofFinite α) else 0
-- Mathlib/Algebra/Homology/Single.lean
@[simp]
lemma single_obj_d (j : ι) (A : V) (k l : ι) :
    ((single V c j).obj A).d k l = 0
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
theorem lt_iff {i₁ i₂ : Pos} : i₁ < i₂ ↔ i₁.byteIdx < i₂.byteIdx
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem csInf_le_of_le (hs : BddBelow s) (hb : b ∈ s) (h : b ≤ a) : sInf s ≤ a
-- Mathlib/Order/CompleteLattice.lean
theorem Monotone.iSup_comp_eq [Preorder β] {f : β → α} (hf : Monotone f) {s : ι → β}
    (hs : ∀ x, ∃ i, x ≤ s i) : ⨆ x, f (s x) = ⨆ y, f y
-- Mathlib/Analysis/Calculus/Deriv/Linear.lean
protected theorem LinearMap.hasDerivAt : HasDerivAt e (e 1) x
-- Mathlib/Algebra/BigOperators/Group/List.lean
/-- In a join, taking the first elements up to an index which is the sum of the lengths of the
first `i` sublists, is the same as taking the join of the first `i` sublists. -/
lemma take_sum_join (L : List (List α)) (i : ℕ) :
    L.join.take ((L.map length).take i).sum = (L.take i).join
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
@[simp] theorem data_push (s : String) (c : Char) : (s.push c).data = s.data ++ [c]
-- Mathlib/Data/Set/Subset.lean
@[simp]
lemma image_val_iUnion : ↑(⋃ i, t i) = ⋃ i, (t i : Set α)
-- Mathlib/Combinatorics/HalesJewett.lean
/-- The type of combinatorial lines. A line `l : Line α ι` in the hypercube `ι → α` defines a
function `α → ι → α` from `α` to the hypercube, such that for each coordinate `i : ι`, the function
`fun x ↦ l x i` is either `id` or constant. We require lines to be nontrivial in the sense that
`fun x ↦ l x i` is `id` for at least one `i`.

Formally, a line is represented by a word `l.idxFun : ι → Option α` which says whether
`fun x ↦ l x i` is `id` (corresponding to `l.idxFun i = none`) or constantly `y` (corresponding to
`l.idxFun i = some y`).

When `α` has size `1` there can be many elements of `Line α ι` defining the same function. -/
@[ext]
structure Line (α ι : Type*) where
  /-- The word representing a combinatorial line. `l.idxfun i = none` means that
  `l x i = x` for all `x` and `l.idxfun i = some y` means that `l x i = y`. -/
  idxFun : ι → Option α
  /-- We require combinatorial lines to be nontrivial in the sense that `fun x ↦ l x i` is `id` for
  at least one coordinate `i`. -/
  proper : ∃ i, idxFun i = none
-- Mathlib/Probability/StrongLaw.lean
/-- Preliminary lemma for the strong law of large numbers for vector-valued random variables,
assuming measurability in addition to integrability. This is weakened to ae measurability in
the full version `ProbabilityTheory.strong_law_ae`. -/
lemma strong_law_ae_of_measurable
    (X : ℕ → Ω → E) (hint : Integrable (X 0)) (h' : StronglyMeasurable (X 0))
    (hindep : Pairwise (fun i j ↦ IndepFun (X i) (X j))) (hident : ∀ i, IdentDistrib (X i) (X 0)) :
    ∀ᵐ ω, Tendsto (fun n : ℕ ↦ (n : ℝ) ⁻¹ • (∑ i ∈ range n, X i ω)) atTop (𝓝 𝔼[X 0])
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Icc_subset_Icc_union_Icc : Icc a c ⊆ Icc a b ∪ Icc b c
-- Mathlib/Algebra/Order/Sub/Canonical.lean
/-- See `tsub_tsub_le` for an inequality. -/
theorem tsub_tsub_cancel_of_le (h : a ≤ b) : b - (b - a) = a
-- Mathlib/Analysis/Calculus/Deriv/Inv.lean
theorem hasFDerivAt_inv (x_ne_zero : x ≠ 0) :
    HasFDerivAt (fun x => x⁻¹) (smulRight (1 : 𝕜 →L[𝕜] 𝕜) (-(x ^ 2)⁻¹) : 𝕜 →L[𝕜] 𝕜) x
-- Mathlib/Data/TypeVec.lean
theorem eq_of_drop_last_eq {α β : TypeVec (n + 1)} {f g : α ⟹ β} (h₀ : dropFun f = dropFun g)
    (h₁ : lastFun f = lastFun g) : f = g
-- Mathlib/Topology/Instances/ENNReal.lean
/-- The sum over the complement of a finset tends to `0` when the finset grows to cover the whole
space. This does not need a summability assumption, as otherwise all sums are zero. -/
theorem tendsto_tsum_compl_atTop_zero {α : Type*} {f : α → ℝ≥0∞} (hf : ∑' x, f x ≠ ∞) :
    Tendsto (fun s : Finset α => ∑' b : { x // x ∉ s }, f b) atTop (𝓝 0)
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- If `Fₙ` converges locally uniformly on a neighborhood of `x` to a function `f` which is
continuous at `x`, and `gₙ` tends to `x`, then `Fₙ (gₙ)` tends to `f x`. -/
theorem tendsto_comp_of_locally_uniform_limit (h : ContinuousAt f x) (hg : Tendsto g p (𝓝 x))
    (hunif : ∀ u ∈ 𝓤 β, ∃ t ∈ 𝓝 x, ∀ᶠ n in p, ∀ y ∈ t, (f y, F n y) ∈ u) :
    Tendsto (fun n => F n (g n)) p (𝓝 (f x))
-- Mathlib/Dynamics/PeriodicPts.lean
/-- A fixed point of `f` is a periodic point of `f` of any prescribed period. -/
theorem IsFixedPt.isPeriodicPt (hf : IsFixedPt f x) (n : ℕ) : IsPeriodicPt f n x
-- Mathlib/Topology/Order/LeftRightLim.lean
@[mono]
protected theorem rightLim : Antitone (rightLim f)
-- Mathlib/Tactic/Abel.lean
theorem zero_smulg {α} [AddCommGroup α] (c) : smulg c (0 : α) = 0
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
@[simp]
lemma image_top_eq_opensRange : f ''ᵁ ⊤ = f.opensRange
-- Mathlib/Data/Real/Irrational.lean
theorem rat_add (h : Irrational x) : Irrational (q + x)
-- Mathlib/Data/Int/GCD.lean
@[simp]
theorem lcm_one_right (i : ℤ) : lcm i 1 = natAbs i
-- Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean
theorem seminormFromBounded_aux (f_nonneg : 0 ≤ f)
    (f_mul : ∀ x y : R, f (x * y) ≤ c * f x * f y) (x : R) : 0 ≤ c * f x
-- Mathlib/Data/Set/Lattice.lean
theorem nonempty_of_nonempty_iUnion_eq_univ
    {s : ι → Set α} [Nonempty α] (h_Union : ⋃ i, s i = univ) : Nonempty ι
-- Mathlib/Order/Hom/Set.lean
theorem image_eq_preimage (e : α ≃o β) (s : Set α) : e '' s = e.symm ⁻¹' s
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem bddAbove_range_norm_comp : BddAbove <| Set.range <| norm ∘ f
-- Mathlib/Data/PNat/Xgcd.lean
theorem v_eq_succ_vp : u.v = succ₂ u.vp
-- Mathlib/Data/Multiset/Nodup.lean
theorem inj_on_of_nodup_map {f : α → β} {s : Multiset α} :
    Nodup (map f s) → ∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
theorem sup_singleton'' [DecidableEq α] (s : Finset β) (f : β → α) :
    (s.sup fun b => {f b}) = s.image f
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem comap_equiv_eq_map_symm (f : R ≃+* S) (K : NonUnitalSubring S) :
    K.comap (f : R →ₙ+* S) = K.map f.symm
-- Mathlib/Algebra/Category/ModuleCat/Sheaf/Generators.lean
/-- A sheaf of modules is of finite type if locally, it is generated by finitely
many sections. -/
class IsFiniteType : Prop where
  exists_localGeneratorsData :
    ∃ (σ : M.LocalGeneratorsData), ∀ (i : σ.I), Finite (σ.generators i).I
-- Mathlib/Logic/Denumerable.lean
@[simp]
theorem ofEquiv_ofNat (α) {β} [Denumerable α] (e : β ≃ α) (n) :
    @ofNat β (ofEquiv _ e) n = e.symm (ofNat α n)
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[simp]
theorem map_comp (C : G.ConnectedComponent) (φ : G →g G') (ψ : G' →g G'') :
    (C.map φ).map ψ = C.map (ψ.comp φ)
-- Mathlib/LinearAlgebra/Ray.lean
@[simp]
theorem zero_right (x : M) : SameRay R x 0
-- Mathlib/CategoryTheory/Subobject/FactorThru.lean
theorem factorThru_right {X Y Z : C} {P : Subobject Z} (f : X ⟶ Y) (g : Y ⟶ Z) (h : P.Factors g) :
    f ≫ P.factorThru g h = P.factorThru (f ≫ g) (factors_of_factors_right f h)
-- Mathlib/Data/List/Sublists.lean
theorem sublists'_map (f : α → β) : ∀ (l : List α),
    sublists' (map f l) = map (map f) (sublists' l)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem filter_eq_nil {l} : filter p l = [] ↔ ∀ a, a ∈ l → ¬p a
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- Angles are translation invariant -/
@[simp]
theorem angle_const_vsub (p p₁ p₂ p₃ : P) : ∠ (p -ᵥ p₁) (p -ᵥ p₂) (p -ᵥ p₃) = ∠ p₁ p₂ p₃
-- Mathlib/Algebra/Order/Ring/Nat.lean
lemma isCompl_even_odd : IsCompl { n : ℕ | Even n } { n | Odd n }
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem AECover.integrable_of_integral_norm_bounded [l.NeBot] [l.IsCountablyGenerated]
    {φ : ι → Set α} (hφ : AECover μ l φ) {f : α → E} (I : ℝ) (hfi : ∀ i, IntegrableOn f (φ i) μ)
    (hbounded : ∀ᶠ i in l, (∫ x in φ i, ‖f x‖ ∂μ) ≤ I) : Integrable f μ
-- Mathlib/Analysis/Complex/Basic.lean
theorem norm_exp_ofReal_mul_I (t : ℝ) : ‖exp (t * I)‖ = 1
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
/-- In the model space, `chartAt` is always the identity. -/
theorem chartAt_self_eq {H : Type*} [TopologicalSpace H] {x : H} :
    chartAt H x = PartialHomeomorph.refl H
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem DifferentiableOn.const_mul (ha : DifferentiableOn 𝕜 a s) (b : 𝔸) :
    DifferentiableOn 𝕜 (fun y => b * a y) s
-- Mathlib/Data/Stream/Init.lean
theorem tail_map (s : Stream' α) : tail (map f s) = map f (tail s)
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NNNorm.lean
/-- continuous linear maps are Lipschitz continuous. -/
theorem lipschitz : LipschitzWith ‖f‖₊ f
-- Mathlib/Data/ZMod/Basic.lean
lemma ringEquivCongr_trans {a b c : ℕ} (hab : a = b) (hbc : b = c) :
    (ringEquivCongr hab).trans (ringEquivCongr hbc) = ringEquivCongr (hab.trans hbc)
-- Mathlib/Order/Atoms.lean
theorem isAtomic_iff_isCoatomic : IsAtomic α ↔ IsCoatomic α
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem mapMatrix_trans (f : α ≃+* β) (g : β ≃+* γ) :
    f.mapMatrix.trans g.mapMatrix = ((f.trans g).mapMatrix : Matrix m m α ≃+* _)
-- Mathlib/Data/Real/Sqrt.lean
lemma le_sqrt_iff_sq_le : x ≤ sqrt y ↔ x ^ 2 ≤ y
-- Mathlib/Topology/UnitInterval.lean
theorem two_mul_sub_one_mem_iff {t : ℝ} : 2 * t - 1 ∈ I ↔ t ∈ Set.Icc (1 / 2 : ℝ) 1
-- Mathlib/RingTheory/Valuation/ValuationRing.lean
theorem iff_local_bezout_domain : ValuationRing R ↔ LocalRing R ∧ IsBezout R
-- Mathlib/RingTheory/HahnSeries/Basic.lean
@[simp]
theorem single_coeff_same (a : Γ) (r : R) : (single a r).coeff a = r
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem leadingCoeff_of_c_eq_zero' : (toPoly ⟨0, 0, 0, d⟩).leadingCoeff = d
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem ContMDiffAt.mdifferentiableAt (hf : ContMDiffAt I I' n f x) (hn : 1 ≤ n) :
    MDifferentiableAt I I' f x
-- Mathlib/Topology/Instances/Int.lean
theorem ball_eq_Ioo (x : ℤ) (r : ℝ) : ball x r = Ioo ⌊↑x - r⌋ ⌈↑x + r⌉
-- Mathlib/Analysis/Complex/ReImTopology.lean
@[simp]
theorem closure_setOf_lt_re (a : ℝ) : closure { z : ℂ | a < z.re } = { z | a ≤ z.re }
-- .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean
theorem Coprime.pow_right (n : Nat) (H1 : Coprime k m) : Coprime k (m ^ n)
-- Mathlib/Order/Directed.lean
theorem directedOn_univ_iff : DirectedOn r Set.univ ↔ IsDirected α r
-- Mathlib/Analysis/SpecialFunctions/Exponential.lean
theorem hasStrictFDerivAt_exp_smul_const' (x : 𝔸) (t : 𝕊) :
    HasStrictFDerivAt (fun u : 𝕊 => exp 𝕂 (u • x))
      (((1 : 𝕊 →L[𝕂] 𝕊).smulRight x).smulRight (exp 𝕂 (t • x))) t
-- Mathlib/Computability/ContextFreeGrammar.lean
lemma ContextFreeRule.reverse_involutive {N : Type uN} :
    Function.Involutive (@ContextFreeRule.reverse T N)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mex_le_of_ne {ι} {f : ι → Ordinal} {a} (ha : ∀ i, f i ≠ a) : mex f ≤ a
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[fun_prop]
nonrec theorem HasFDerivWithinAt.prod (hf₁ : HasFDerivWithinAt f₁ f₁' s x)
    (hf₂ : HasFDerivWithinAt f₂ f₂' s x) :
    HasFDerivWithinAt (fun x => (f₁ x, f₂ x)) (f₁'.prod f₂') s x
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
protected theorem nsmul_mem {x : A} (hx : x ∈ S) (n : ℕ) : n • x ∈ S
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem out_embedding {c c' : Cardinal} : c ≤ c' ↔ Nonempty (c.out ↪ c'.out)
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
@[measurability]
theorem measurableSet_uIoc : MeasurableSet (uIoc a b)
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem oadd_add (e n a o) : oadd e n a + o = addAux e n (a + o)