ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
/--
Accessing bits in `x.rotateLeft r` the range `[0, r)` is equal to
accessing bits `x` in the range `[w - r, w)`.

Proof by example:
Let x := <6 5 4 3 2 1 0> : BitVec 7.
x.rotateLeft 2 = (<6 5 | 4 3 2 1 0>).rotateLeft 2 = <3 2 1 0 | 6 5>

(x.rotateLeft 2).getLsb ⟨i, i < 2⟩
= <3 2 1 0 | 6 5>.getLsb ⟨i, i < 2⟩
= <6 5>[i]
= <6 5 | 4 3 2 1 0>[i + len(<4 3 2 1 0>)]
= <6 5 | 4 3 2 1 0>[i + 7 - 2]
-/
theorem getLsb_rotateLeftAux_of_le {x : BitVec w} {r : Nat} {i : Nat} (hi : i < r) :
    (x.rotateLeftAux r).getLsb i = x.getLsb (w - r + i)
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
/-- For a continuous real linear map `f`, if one controls the norm of every `f x`, `‖x‖ = 1`, then
one controls the norm of `f`. -/
theorem opNorm_le_of_unit_norm [NormedSpace ℝ E] [NormedSpace ℝ F] {f : E →L[ℝ] F} {C : ℝ}
    (hC : 0 ≤ C) (hf : ∀ x, ‖x‖ = 1 → ‖f x‖ ≤ C) : ‖f‖ ≤ C
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem mul_mem_nthRootsFinset
    {η₁ η₂ : R} (hη₁ : η₁ ∈ nthRootsFinset n R) (hη₂ : η₂ ∈ nthRootsFinset n R) :
    η₁ * η₂ ∈ nthRootsFinset n R
-- Mathlib/Topology/Algebra/InfiniteSum/Real.lean
theorem dist_le_tsum_of_dist_le_of_tendsto (d : ℕ → ℝ) (hf : ∀ n, dist (f n) (f n.succ) ≤ d n)
    (hd : Summable d) {a : α} (ha : Tendsto f atTop (𝓝 a)) (n : ℕ) :
    dist (f n) a ≤ ∑' m, d (n + m)
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
lemma δ_ofHomotopy {φ₁ φ₂ : F ⟶ G} (h : Homotopy φ₁ φ₂) :
    δ (-1) 0 (Cochain.ofHomotopy h) = Cochain.ofHom φ₁ - Cochain.ofHom φ₂
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := simp)]
theorem mul_empty : s * ∅ = ∅
-- Mathlib/NumberTheory/LSeries/AbstractFuncEq.lean
/-- Functional equation formulated for `Λ₀`. -/
theorem functional_equation₀ (s : ℂ) : P.Λ₀ (P.k - s) = P.ε • P.symm.Λ₀ s
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem closedBall_subset_ball (h : ε₁ < ε₂) : closedBall x ε₁ ⊆ ball x ε₂
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
theorem map_eq (x) : f.map hy k (f.toMap x) = k.toMap (g x)
-- Mathlib/Data/Complex/Abs.lean
theorem mul_self_abs (z : ℂ) : Complex.abs z * Complex.abs z = normSq z
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem subtype_Ico_eq : Ico a b = (Ico (a : α) b).subtype p
-- Mathlib/Data/DFinsupp/Basic.lean
theorem _root_.AddSubmonoid.mem_bsupr_iff_exists_dfinsupp (p : ι → Prop) [DecidablePred p]
    [AddCommMonoid γ] (S : ι → AddSubmonoid γ) (x : γ) :
    (x ∈ ⨆ (i) (_ : p i), S i) ↔
      ∃ f : Π₀ i, S i, DFinsupp.sumAddHom (fun i => (S i).subtype) (f.filter p) = x
-- Mathlib/MeasureTheory/Function/L2Space.lean
/-- The inner product in `L2` of the indicator of a set `indicatorConstLp 2 hs hμs c` and `f` is
equal to the inner product of the constant `c` and the integral of `f` over `s`. -/
theorem inner_indicatorConstLp_eq_inner_setIntegral [CompleteSpace E] [NormedSpace ℝ E]
    (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (c : E) (f : Lp E 2 μ) :
    (⟪indicatorConstLp 2 hs hμs c, f⟫ : 𝕜) = ⟪c, ∫ x in s, f x ∂μ⟫
-- Mathlib/Analysis/Calculus/Implicit.lean
/-- Any point in some neighborhood of `a` can be represented as `HasStrictFDerivAt.implicitFunction`
of some point. -/
theorem eq_implicitFunction (hf : HasStrictFDerivAt f f' a) (hf' : range f' = ⊤) :
    ∀ᶠ x in 𝓝 a,
      hf.implicitFunction f f' hf' (f x) (hf.implicitToPartialHomeomorph f f' hf' x).snd = x
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
theorem gcd_dvd (xs : IntList) {a : Int} (m : a ∈ xs) : (xs.gcd : Int) ∣ a
-- Mathlib/RingTheory/Localization/Away/Basic.lean
@[simp]
theorem AwayMap.lift_comp (hg : IsUnit (g x)) : (lift x hg).comp (algebraMap R S) = g
-- Mathlib/Data/Int/Cast/Lemmas.lean
lemma MonoidHom.apply_mint (f : Multiplicative ℤ →* α) (n : Multiplicative ℤ) :
    f n = f (ofAdd 1) ^ (toAdd n)
-- Mathlib/Topology/MetricSpace/Completion.lean
theorem Isometry.completion_extension [MetricSpace β] [CompleteSpace β] {f : α → β}
    (h : Isometry f) : Isometry (Completion.extension f)
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nmul_comm : ∀ a b, a ⨳ b = b ⨳ a
-- Mathlib/Topology/Bornology/Basic.lean
theorem isCobounded_ofBounded_iff (B : Set (Set α)) {empty_mem subset_mem union_mem sUnion_univ} :
    @IsCobounded _ (ofBounded B empty_mem subset_mem union_mem sUnion_univ) s ↔ sᶜ ∈ B
-- Mathlib/RingTheory/PowerSeries/Trunc.lean
theorem trunc_trunc_mul_trunc {n} (f g : R⟦X⟧) :
    trunc n (trunc n f * trunc n g : R⟦X⟧) = trunc n (f * g)
-- Mathlib/NumberTheory/Dioph.lean
@[simp]
theorem one_apply (x) : (1 : Poly α) x = 1
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem zero_lie : ⁅(0 : L), m⁆ = 0
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem measure_iUnion₀ [Countable ι] {f : ι → Set α} (hd : Pairwise (AEDisjoint μ on f))
    (h : ∀ i, NullMeasurableSet (f i) μ) : μ (⋃ i, f i) = ∑' i, μ (f i)
-- Mathlib/Combinatorics/SetFamily/Compression/UV.lean
/-- UV-compression is injective on the sets that are not UV-compressed. -/
theorem compress_injOn : Set.InjOn (compress u v) ↑(s.filter (compress u v · ∉ s))
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem bihimp_eq_inf : a ⇔ b = a ⊓ b ↔ Codisjoint a b
-- Mathlib/ModelTheory/Syntax.lean
/-- Maps a bounded formula's symbols along a language equivalence. -/
@[simps]
def onBoundedFormula (φ : L ≃ᴸ L') : L.BoundedFormula α n ≃ L'.BoundedFormula α n
-- Mathlib/RingTheory/DedekindDomain/Different.lean
lemma one_le_dual_one :
    1 ≤ dual A K (1 : FractionalIdeal B⁰ L)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
protected theorem mul_mem_cancel_left {x y : G} (h : x ∈ H) : x * y ∈ H ↔ y ∈ H
-- Mathlib/Analysis/ODE/PicardLindelof.lean
protected theorem nonempty_Icc : (Icc v.tMin v.tMax).Nonempty
-- Mathlib/Topology/Order/LocalExtr.lean
theorem Filter.EventuallyEq.isLocalMax_iff {f g : α → β} {a : α} (heq : f =ᶠ[𝓝 a] g) :
    IsLocalMax f a ↔ IsLocalMax g a
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem mem_top (x : M) : x ∈ (⊤ : LieSubmodule R L M)
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma norm_log_natCast_le_rpow_div (n : ℕ) {ε : ℝ} (hε : 0 < ε) : ‖log n‖ ≤ n ^ ε / ε
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem nhds_basis_closedBall : (𝓝 x).HasBasis (fun ε : ℝ => 0 < ε) (closedBall x)
-- Mathlib/Order/Hom/Basic.lean
/-- A preorder which embeds into a well-founded preorder is itself well-founded. -/
protected theorem wellFoundedLT [WellFoundedLT β] (f : α ↪o β) : WellFoundedLT α
-- Mathlib/Data/Finite/Set.lean
theorem Finite.of_injective_finite_range {f : ι → α} (hf : Function.Injective f)
    [Finite (range f)] : Finite ι
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem size_mapIdx (a : Array α) (f : Fin a.size → α → β) : (a.mapIdx f).size = a.size
-- Mathlib/CategoryTheory/Shift/ShiftedHom.lean
lemma comp_mk₀ {a : M} (f : ShiftedHom X Y a) (m₀ : M) (hm₀ : m₀ = 0) (g : Y ⟶ Z) :
    f.comp (mk₀ m₀ hm₀ g) (by rw [hm₀, zero_add]) = f ≫ g⟦a⟧'
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsLittleO.prod_rightr (h : f =o[l] g') : f =o[l] fun x => (f' x, g' x)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem tan_coe (x : ℝ) : tan (x : Angle) = Real.tan x
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[simp]
theorem norm_eq_abs (r : ℝ) : ‖r‖ = |r|
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem bihimp_apply [∀ i, GeneralizedHeytingAlgebra (π i)] (a b : ∀ i, π i) (i : ι) :
    (a ⇔ b) i = a i ⇔ b i
-- Mathlib/Algebra/Star/SelfAdjoint.lean
@[simp, norm_cast]
theorem val_div (x y : selfAdjoint R) : ↑(x / y) = (x / y : R)
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem mem_cons : a ∈ b ::ₛ s ↔ a = b ∨ a ∈ s
-- Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean
theorem IsTerminal.isIso_from (hI : IsTerminal I) {A : C} (f : I ⟶ A) : IsIso f
-- Mathlib/Topology/Order/Monotone.lean
/-- A continuous antitone function sends indexed infimum to indexed supremum in conditionally
complete linear order, under a boundedness assumption. -/
theorem Antitone.map_ciInf_of_continuousAt {f : α → β} {g : γ → α} (Cf : ContinuousAt f (⨅ i, g i))
    (Af : Antitone f) (H : BddBelow (range g)) : f (⨅ i, g i) = ⨆ i, f (g i)
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem mul_inter_subset : s * (t₁ ∩ t₂) ⊆ s * t₁ ∩ (s * t₂)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem atEnd_of_valid (cs : List Char) (cs' : List Char) :
    atEnd ⟨cs ++ cs'⟩ ⟨utf8Len cs⟩ ↔ cs' = []
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem map_filterMap (f : α → Option β) (g : β → γ) (l : List α) :
    map g (filterMap f l) = filterMap (fun x => (f x).map g) l
-- Mathlib/Algebra/ContinuedFractions/ConvergentsEquiv.lean
/-- Shows that the recurrence relation (`convs`) and direct evaluation (`convs'`) of the
generalized continued fraction coincide at position `n` if the sequence of fractions contains
strictly positive values only.
Requiring positivity of all values is just one possible condition to obtain this result.
For example, the dual - sequences with strictly negative values only - would also work.

In practice, one most commonly deals with regular continued fractions, which satisfy the
positivity criterion required here. The analogous result for them
(see `ContFract.convs_eq_convs`) hence follows directly from this theorem.
-/
theorem convs_eq_convs' [LinearOrderedField K]
    (s_pos : ∀ {gp : Pair K} {m : ℕ}, m < n → g.s.get? m = some gp → 0 < gp.a ∧ 0 < gp.b) :
    g.convs n = g.convs' n
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem coe_smul [SMulZeroClass S R] (s : S) (r : R) :
    (↑(s • r) : ℍ[R,c₁,c₂]) = s • (r : ℍ[R,c₁,c₂])
-- Mathlib/Data/Real/EReal.lean
@[simp, norm_cast]
theorem coe_ennreal_le_coe_ennreal_iff {x y : ℝ≥0∞} : (x : EReal) ≤ (y : EReal) ↔ x ≤ y
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive (attr := simp)]
theorem mul_pure : f * pure b = f.map (· * b)
-- Mathlib/Order/Bounds/Basic.lean
lemma bddAbove_pi {s : Set (∀ a, π a)} :
    BddAbove s ↔ ∀ a, BddAbove (Function.eval a '' s)
-- Mathlib/Order/BoundedOrder.lean
theorem Monotone.exists {P : β → α → Prop} (hP : ∀ x, Monotone (P x)) :
    Monotone fun y => ∃ x, P x y
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
theorem norm_int_lt_one_iff_dvd (k : ℤ) : ‖(k : ℤ_[p])‖ < 1 ↔ (p : ℤ) ∣ k
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNorm'_eq_zero_of_ae_zero' (hq0_ne : q ≠ 0) (hμ : μ ≠ 0) {f : α → F}
    (hf_zero : f =ᵐ[μ] 0) :
    eLpNorm' f q μ = 0
-- Mathlib/Analysis/Convex/Function.lean
theorem StrictConcaveOn.sub_convexOn (hf : StrictConcaveOn 𝕜 s f) (hg : ConvexOn 𝕜 s g) :
    StrictConcaveOn 𝕜 s (f - g)
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem pos_of_mem_ball (hy : y ∈ ball x ε) : 0 < ε
-- Mathlib/Probability/Process/Stopping.lean
theorem integrable_stoppedProcess_of_mem_finset (hτ : IsStoppingTime ℱ τ)
    (hu : ∀ n, Integrable (u n) μ) (n : ι) {s : Finset ι} (hbdd : ∀ ω, τ ω < n → τ ω ∈ s) :
    Integrable (stoppedProcess u τ n) μ
-- Mathlib/CategoryTheory/Adjunction/Basic.lean
@[simp]
theorem homEquiv_naturality_right_symm_aux (f : X ⟶ G.obj Y) (g : Y ⟶ Y') :
    F.map f ≫ (adj.homEquiv (G.obj Y) Y').symm (G.map g) = (adj.homEquiv X Y).symm f ≫ g
-- Mathlib/Algebra/MvPolynomial/Equiv.lean
theorem finSuccEquiv_X_zero : finSuccEquiv R n (X 0) = Polynomial.X
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
nonrec theorem SmoothAt.mdifferentiableAt (hf : SmoothAt I I' f x) : MDifferentiableAt I I' f x
-- Mathlib/Topology/MetricSpace/Isometry.lean
theorem antilipschitz (h : Isometry f) : AntilipschitzWith 1 f
-- Mathlib/Probability/Distributions/Gaussian.lean
/-- The gaussian distribution pdf integrates to 1 when the variance is not zero.  -/
lemma integral_gaussianPDFReal_eq_one (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) :
    ∫ x, gaussianPDFReal μ v x = 1
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma rpow_inv_eq (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : z ≠ 0) : x ^ z⁻¹ = y ↔ x = y ^ z
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem mul_comm (a b : Int) : a * b = b * a
-- Mathlib/Topology/Order/ExtendFrom.lean
theorem continuousOn_Icc_extendFrom_Ioo [TopologicalSpace α] [LinearOrder α] [DenselyOrdered α]
    [OrderTopology α] [TopologicalSpace β] [RegularSpace β] {f : α → β} {a b : α} {la lb : β}
    (hab : a ≠ b) (hf : ContinuousOn f (Ioo a b)) (ha : Tendsto f (𝓝[>] a) (𝓝 la))
    (hb : Tendsto f (𝓝[<] b) (𝓝 lb)) : ContinuousOn (extendFrom (Ioo a b) f) (Icc a b)
-- Mathlib/Topology/Basic.lean
theorem ClusterPt.map {lx : Filter X} {ly : Filter Y} (H : ClusterPt x lx)
    (hfc : ContinuousAt f x) (hf : Tendsto f lx ly) : ClusterPt (f x) ly
-- Mathlib/LinearAlgebra/Span.lean
theorem coord_apply_smul (y : Submodule.span R ({x} : Set M)) : coord R M x h y • x = y
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem inv_antitoneOn_Icc_left (hb : b < 0) :
    AntitoneOn (fun x : α ↦ x⁻¹) (Set.Icc a b)
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
theorem integral_sin_pow_pos : 0 < ∫ x in (0)..π, sin x ^ n
-- Mathlib/Algebra/TrivSqZeroExt.lean
theorem algebraMap_eq_inl' (s : S) : algebraMap S (tsze R M) s = inl (algebraMap S R s)
-- Mathlib/Analysis/Calculus/BumpFunction/Basic.lean
/-- `f : ContDiffBump c`, where `c` is a point in a normed vector space, is a
bundled smooth function such that

- `f` is equal to `1` in `Metric.closedBall c f.rIn`;
- `support f = Metric.ball c f.rOut`;
- `0 ≤ f x ≤ 1` for all `x`.

The structure `ContDiffBump` contains the data required to construct the function:
real numbers `rIn`, `rOut`, and proofs of `0 < rIn < rOut`. The function itself is available through
`CoeFun` when the space is nice enough, i.e., satisfies the `HasContDiffBump` typeclass. -/
structure ContDiffBump (c : E) where
  /-- real numbers `0 < rIn < rOut` -/
  (rIn rOut : ℝ)
  rIn_pos : 0 < rIn
  rIn_lt_rOut : rIn < rOut
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
@[simp, measurability]
theorem measurableSet_Ici : MeasurableSet (Ici a)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem preimage_ball (x : E₂) (r : ℝ) : e ⁻¹' Metric.ball x r = Metric.ball (e.symm x) r
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
theorem fst_prod (f : A →⋆ₐ[R] B) (g : A →⋆ₐ[R] C) : (fst R B C).comp (prod f g) = f
-- Mathlib/Analysis/Matrix.lean
@[simp]
theorem linfty_opNNNorm_col (v : m → α) : ‖col ι v‖₊ = ‖v‖₊
-- Mathlib/Data/Set/Image.lean
lemma Codisjoint.preimage (f : α → β) {s t : Set β} (h : Codisjoint s t) :
    Codisjoint (f ⁻¹' s) (f ⁻¹' t)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
@[simp]
theorem deriv_cos (hc : DifferentiableAt ℝ f x) :
    deriv (fun x => Real.cos (f x)) x = -Real.sin (f x) * deriv f x
-- Mathlib/CategoryTheory/Monoidal/NaturalTransformation.lean
@[simp]
theorem comp_toNatTrans {F G H : MonoidalFunctor C D} {α : F ⟶ G} {β : G ⟶ H} :
    (α ≫ β).toNatTrans = @CategoryStruct.comp (C ⥤ D) _ _ _ _ α.toNatTrans β.toNatTrans
-- Mathlib/Data/Finset/Lattice.lean
/-- See also `Finset.sup'_prodMap`. -/
lemma prodMk_sup'_sup' (hs : s.Nonempty) (ht : t.Nonempty) (f : ι → α) (g : κ → β) :
    (sup' s hs f, sup' t ht g) = sup' (s ×ˢ t) (hs.product ht) (Prod.map f g)
-- Mathlib/LinearAlgebra/FreeModule/Basic.lean
theorem Module.free_iff_set : Module.Free R M ↔ ∃ S : Set M, Nonempty (Basis S R M)
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
theorem join_eq_none : o.join = none ↔ o = none ∨ o = some none
-- Mathlib/Topology/Category/CompHausLike/Basic.lean
/-- Any continuous function on compact Hausdorff spaces is a closed map. -/
theorem isClosedMap {X Y : CompHausLike.{u} P} (f : X ⟶ Y) : IsClosedMap f
-- Mathlib/CategoryTheory/Opposites.lean
/-- The isomorphism between `F.rightOp.leftOp` and `F`. -/
@[simps!]
def rightOpLeftOpIso (F : Cᵒᵖ ⥤ D) : F.rightOp.leftOp ≅ F
-- Mathlib/Order/Disjoint.lean
theorem of_le (h₁ : x ⊓ y ≤ ⊥) (h₂ : ⊤ ≤ x ⊔ y) : IsCompl x y
-- Mathlib/RingTheory/PrimeSpectrum.lean
@[simp]
theorem primeSpectrumProd_symm_inr_asIdeal (x : PrimeSpectrum S) :
    ((primeSpectrumProd R S).symm <| Sum.inr x).asIdeal = Ideal.prod ⊤ x.asIdeal
-- Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
lemma tensorQuotEquivQuotSMul_comp_mk (I : Ideal R) :
    tensorQuotEquivQuotSMul M I ∘ₗ (TensorProduct.mk R M (R ⧸ I)).flip 1 =
      Submodule.mkQ (I • ⊤)
-- Mathlib/Data/Matroid/Map.lean
@[simp] lemma restrictSubtype_ground : (M.restrictSubtype X).E = univ
-- Mathlib/LinearAlgebra/Reflection.lean
lemma bijOn_reflection_of_mapsTo {Φ : Set M} (h : f x = 2) (h' : MapsTo (reflection h) Φ Φ) :
    BijOn (reflection h) Φ Φ
-- Mathlib/Algebra/Group/Subgroup/ZPowers.lean
theorem zpow_mem_zpowers (g : G) (k : ℤ) : g ^ k ∈ zpowers g
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma changeLevel_def {m : ℕ} (hm : n ∣ m) :
    changeLevel hm χ = MulChar.ofUnitHom (χ.toUnitHom.comp (ZMod.unitsMap hm))
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[csimp] theorem append_eq_appendTR : @List.append = @appendTR
-- Mathlib/Topology/MetricSpace/CantorScheme.lean
theorem VanishingDiam.dist_lt (hA : VanishingDiam A) (ε : ℝ) (ε_pos : 0 < ε) (x : ℕ → β) :
    ∃ n : ℕ, ∀ (y) (_ : y ∈ A (res x n)) (z) (_ : z ∈ A (res x n)), dist y z < ε
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem map_comap_le {S : Submonoid N} {f : F} : (S.comap f).map f ≤ S
-- Mathlib/Data/Set/Image.lean
theorem _root_.Function.Commute.set_image {f g : α → α} (h : Function.Commute f g) :
    Function.Commute (image f) (image g)
-- Mathlib/Algebra/BigOperators/Ring/Multiset.lean
lemma prod_map_add {s : Multiset ι} {f g : ι → α} :
    prod (s.map fun i ↦ f i + g i) =
      sum ((antidiagonal s).map fun p ↦ (p.1.map f).prod * (p.2.map g).prod)
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
theorem prod_edist_eq_add (hp : 0 < p.toReal) (f g : WithLp p (α × β)) :
    edist f g = (edist f.fst g.fst ^ p.toReal + edist f.snd g.snd ^ p.toReal) ^ (1 / p.toReal)
-- Mathlib/Algebra/Algebra/Unitization.lean
theorem algebraMap_eq_inl_comp : ⇑(algebraMap S (Unitization R A)) = inl ∘ algebraMap S R
-- Mathlib/Order/Defs.lean
theorem not_lt_of_gt {a b : α} (h : a > b) : ¬a < b
-- Mathlib/Topology/Algebra/Module/StrongTopology.lean
@[simp] lemma toLinearMap₂_apply (L : E →L[𝕜] F →L[𝕜] G) (v : E) (w : F) :
    L.toLinearMap₂ v w = L v w
-- Mathlib/RingTheory/WittVector/StructurePolynomial.lean
theorem bind₁_rename_expand_wittPolynomial (Φ : MvPolynomial idx ℤ) (n : ℕ)
    (IH :
      ∀ m : ℕ,
        m < n + 1 →
          map (Int.castRingHom ℚ) (wittStructureInt p Φ m) =
            wittStructureRat p (map (Int.castRingHom ℚ) Φ) m) :
    bind₁ (fun b => rename (fun i => (b, i)) (expand p (W_ ℤ n))) Φ =
      bind₁ (fun i => expand p (wittStructureInt p Φ i)) (W_ ℤ n)
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem add_eq_sup : N + N' = N ⊔ N'
-- Mathlib/Order/Category/FinPartOrd.lean
/-- The equivalence between `FinPartOrd` and itself induced by `OrderDual` both ways. -/
@[simps! functor inverse]
def dualEquiv : FinPartOrd ≌ FinPartOrd
-- Mathlib/Topology/Basic.lean
@[simp]
theorem interior_interior : interior (interior s) = interior s
-- Mathlib/Topology/MetricSpace/MetricSeparated.lean
@[simp]
theorem finset_iUnion_left_iff {ι : Type*} {I : Finset ι} {s : ι → Set X} {t : Set X} :
    IsMetricSeparated (⋃ i ∈ I, s i) t ↔ ∀ i ∈ I, IsMetricSeparated (s i) t
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem conjTranspose_neg [AddGroup α] [StarAddMonoid α] (M : Matrix m n α) : (-M)ᴴ = -Mᴴ
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[simp]
theorem differentiableWithinAt_sub_const_iff (c : F) :
    DifferentiableWithinAt 𝕜 (fun y => f y - c) s x ↔ DifferentiableWithinAt 𝕜 f s x
-- Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean
theorem adjMatrix_mulVec_const_apply [NonAssocSemiring α] {a : α} {v : V} :
    (G.adjMatrix α *ᵥ Function.const _ a) v = G.degree v * a
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
/-- A Weierstrass curve is nonsingular at every point if its discriminant is non-zero. -/
lemma nonsingular_of_Δ_ne_zero {x y : R} (h : W.Equation x y) (hΔ : W.Δ ≠ 0) : W.Nonsingular x y
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
theorem symm_range {a b : X} (γ : Path a b) : range γ.symm = range γ
-- Mathlib/Data/Real/Irrational.lean
theorem div_int (h : Irrational x) {m : ℤ} (hm : m ≠ 0) : Irrational (x / m)
-- .lake/packages/lean4/src/lean/Init/Data/Option/Instances.lean
@[simp] theorem isNone_iff_eq_none {o : Option α} : o.isNone ↔ o = none
-- Mathlib/Order/Disjoint.lean
@[simp]
theorem isCompl_ofDual_iff {a b : αᵒᵈ} : IsCompl (ofDual a) (ofDual b) ↔ IsCompl a b
-- Mathlib/Algebra/BigOperators/Group/List.lean
lemma countP_bind (p : β → Bool) (l : List α) (f : α → List β) :
    countP p (l.bind f) = sum (map (countP p ∘ f) l)
-- Mathlib/Algebra/BigOperators/Finsupp.lean
@[simp]
theorem sum_ite_self_eq_aux [DecidableEq α] {N : Type*} [AddCommMonoid N] (f : α →₀ N) (a : α) :
    (if a ∈ f.support then f a else 0) = f a
-- Mathlib/Data/List/Permutation.lean
theorem map_permutations' (f : α → β) (ts : List α) :
    map (map f) (permutations' ts) = permutations' (map f ts)
-- Mathlib/Algebra/Order/Monovary.lean
lemma antivaryOn_inv₀ (hf : ∀ i ∈ s, 0 < f i) (hg : ∀ i ∈ s, 0 < g i) :
    AntivaryOn f⁻¹ g⁻¹ s ↔ AntivaryOn f g s
-- Mathlib/Algebra/Module/LinearMap/End.lean
theorem iterate_succ (n : ℕ) : f' ^ (n + 1) = comp (f' ^ n) f'
-- Mathlib/Topology/Irreducible.lean
theorem IsPreirreducible.image (H : IsPreirreducible s) (f : X → Y) (hf : ContinuousOn f s) :
    IsPreirreducible (f '' s)
-- Mathlib/Data/Real/Irrational.lean
theorem ne_int (h : Irrational x) (m : ℤ) : x ≠ m
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem comp_id : f.comp id = f
-- Mathlib/Order/LiminfLimsup.lean
theorem bliminf_eq_liminf_subtype {f : Filter β} {u : β → α} {p : β → Prop} :
    bliminf u f p = liminf (u ∘ ((↑) : { x | p x } → β)) (comap (↑) f)
-- Mathlib/Order/Category/PartOrd.lean
@[simp]
theorem coe_of (α : Type*) [PartialOrder α] : ↥(of α) = α
-- Mathlib/Topology/Constructions.lean
theorem prod_mem_nhds_iff {s : Set X} {t : Set Y} {x : X} {y : Y} :
    s ×ˢ t ∈ 𝓝 (x, y) ↔ s ∈ 𝓝 x ∧ t ∈ 𝓝 y
-- Mathlib/Logic/Equiv/Defs.lean
@[simps]
instance : Trans Equiv Equiv Equiv
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
@[simp, norm_cast]
theorem coeFn_univ (ν : ProbabilityMeasure Ω) : ν univ = 1
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
@[simp] lemma mk_neg (i : NumDenSameDeg 𝒜 x) : mk (-i) = -mk i
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem apply_lt_nfpBFamily (H : ∀ i hi, IsNormal (f i hi)) {a b} (hb : b < nfpBFamily.{u, v} o f a)
    (i hi) : f i hi b < nfpBFamily.{u, v} o f a
-- Mathlib/Algebra/Order/Antidiag/Pi.lean
lemma pairwiseDisjoint_piAntidiag_map_addRightEmbedding (hi : i ∉ s) (n : μ) :
    (antidiagonal n : Set (μ × μ)).PairwiseDisjoint fun p ↦
      map (addRightEmbedding fun j ↦ if j = i then p.1 else 0) (s.piAntidiag p.2)
-- Mathlib/Algebra/Group/Submonoid/MulOpposite.lean
@[to_additive (attr := simp)]
theorem op_bot : (⊥ : Submonoid M).op = ⊥
-- Mathlib/Order/RelClasses.lean
theorem ssubset_of_ssubset_of_subset [IsTrans α (· ⊆ ·)] (h₁ : a ⊂ b) (h₂ : b ⊆ c) : a ⊂ c
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
private lemma nonsingular_neg_of_Z_ne_zero {P : Fin 3 → F} (hP : W.Nonsingular P) (hPz : P z ≠ 0) :
    W.Nonsingular ![P x / P z ^ 2, W.toAffine.negY (P x / P z ^ 2) (P y / P z ^ 3), 1]
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
theorem IsBoundedBilinearMap.continuous_left (h : IsBoundedBilinearMap 𝕜 f) {e₂ : F} :
    Continuous fun e₁ => f (e₁, e₂)
-- Mathlib/Computability/Primrec.lean
theorem nat_mul : Primrec₂ ((· * ·) : ℕ → ℕ → ℕ)
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
theorem map_bot (f : X ⟶ Y) [Mono f] : (map f).obj ⊥ = ⊥
-- Mathlib/Algebra/Lie/SkewAdjoint.lean
theorem skewAdjointMatricesLieSubalgebraEquiv_apply (P : Matrix n n R) (h : Invertible P)
    (A : skewAdjointMatricesLieSubalgebra J) :
    ↑(skewAdjointMatricesLieSubalgebraEquiv J P h A) = P⁻¹ * (A : Matrix n n R) * P
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive]
theorem measure_ne_zero [Countable G] [SMulInvariantMeasure G α μ]
    (hμ : μ ≠ 0) (h : IsFundamentalDomain G s μ) : μ s ≠ 0