ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Algebra/Algebra.lean
protected theorem map_zero (f : A →A[R] B) : f (0 : A) = 0
-- Mathlib/Topology/Algebra/Monoid.lean
@[to_additive]
theorem eventuallyEq_prod {X M : Type*} [CommMonoid M] {s : Finset ι} {l : Filter X}
    {f g : ι → X → M} (hs : ∀ i ∈ s, f i =ᶠ[l] g i) : ∏ i ∈ s, f i =ᶠ[l] ∏ i ∈ s, g i
-- Mathlib/Data/ENNReal/Real.lean
theorem ofReal_nsmul {x : ℝ} {n : ℕ} : ENNReal.ofReal (n • x) = n • ENNReal.ofReal x
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem not_not_not : ¬¬¬a ↔ ¬a
-- Mathlib/Data/Nat/Count.lean
theorem count_succ_eq_count_iff {n : ℕ} : count p (n + 1) = count p n ↔ ¬p n
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
@[simp]
theorem isOrtho_orthogonal_right (U : Submodule 𝕜 E) : U ⟂ Uᗮ
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
theorem withDensity_smul (r : ℝ≥0∞) {f : α → ℝ≥0∞} (hf : Measurable f) :
    μ.withDensity (r • f) = r • μ.withDensity f
-- Mathlib/Algebra/Homology/Augment.lean
@[simp]
theorem augmentTruncate_inv_f_succ (C : ChainComplex V ℕ) (i : ℕ) :
    (augmentTruncate C).inv.f (i + 1) = 𝟙 (C.X (i + 1))
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
theorem norm_mkPiAlgebraFin_le_of_pos (hn : 0 < n) :
    ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 n A‖ ≤ 1
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousWithinAt.preimage_mem_nhdsWithin {f : α → β} {x : α} {s : Set α} {t : Set β}
    (h : ContinuousWithinAt f s x) (ht : t ∈ 𝓝 (f x)) : f ⁻¹' t ∈ 𝓝[s] x
-- Mathlib/Topology/UniformSpace/Ascoli.lean
/-- Let `X` be a topological space, `𝔖` a covering of `X` by compact subsets,
`α` a uniform space, `F : ι → (X → α)` a family equicontinuous on each `K ∈ 𝔖`, and `ℱ` a filter
on `ι`. Then, `F` tends to `f : X → α` along `ℱ` *uniformly on each `K ∈ 𝔖`* iff it tends to `f`
*pointwise* along `ℱ`.

This is a specialization of `EquicontinuousOn.tendsto_uniformOnFun_iff_pi'` to the case
where `𝔖` covers `X`. -/
theorem EquicontinuousOn.tendsto_uniformOnFun_iff_pi
    {𝔖 : Set (Set X)} (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K) (𝔖_covers : ⋃₀ 𝔖 = univ)
    (F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K) (ℱ : Filter ι) (f : X → α) :
    Tendsto (UniformOnFun.ofFun 𝔖 ∘ F) ℱ (𝓝 <| UniformOnFun.ofFun 𝔖 f) ↔
    Tendsto F ℱ (𝓝 f)
-- Mathlib/LinearAlgebra/Prod.lean
theorem inl_injective : Function.Injective (inl R M M₂)
-- Mathlib/Algebra/Homology/HomologicalComplexLimits.lean
/-- A cone for a functor `F : J ⥤ HomologicalComplex C c` which is given in degree `n` by
the limit `F ⋙ eval C c n`. -/
@[simps]
noncomputable def coneOfHasLimitEval : Cone F
-- Mathlib/CategoryTheory/Monad/Limits.lean
/-- The algebra structure which will be the apex of the new limit cone for `D`. -/
@[simps]
def conePoint : Algebra T
-- Mathlib/NumberTheory/ArithmeticFunction.lean
/-- A recapitulation of the definition of multiplicative that is simpler for proofs -/
theorem iff_ne_zero [MonoidWithZero R] {f : ArithmeticFunction R} :
    IsMultiplicative f ↔
      f 1 = 1 ∧ ∀ {m n : ℕ}, m ≠ 0 → n ≠ 0 → m.Coprime n → f (m * n) = f m * f n
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem IsRelPrime.prod_left : (∀ i ∈ t, IsRelPrime (s i) x) → IsRelPrime (∏ i ∈ t, s i) x
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem ae_eq_bot : ae μ = ⊥ ↔ μ = 0
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem and_iff_left_iff_imp  : ((a ∧ b) ↔ a) ↔ (a → b)
-- Mathlib/Probability/Martingale/BorelCantelli.lean
theorem Martingale.ae_not_tendsto_atTop_atTop [IsFiniteMeasure μ] (hf : Martingale f ℱ μ)
    (hbdd : ∀ᵐ ω ∂μ, ∀ i, |f (i + 1) ω - f i ω| ≤ R) :
    ∀ᵐ ω ∂μ, ¬Tendsto (fun n => f n ω) atTop atTop
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem LineDifferentiableWithinAt.congr (h : LineDifferentiableWithinAt 𝕜 f s x v)
    (ht : ∀ x ∈ s, f₁ x = f x) (hx : f₁ x = f x) :
    LineDifferentiableWithinAt 𝕜 f₁ s x v
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem ofFractionRing_mk' (x : K[X]) (y : K[X]⁰) :
    -- Porting note: I gave explicitly the argument `(FractionRing K[X])`
    ofFractionRing (IsLocalization.mk' (FractionRing K[X]) x y) =
      IsLocalization.mk' (RatFunc K) x y
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem Homeomorph.contDiff_unitBall : ContDiff ℝ n fun x : E => (unitBall x : E)
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem vadd_apply (f : P1 →ᵃ[k] V2) (g : P1 →ᵃ[k] P2) (p : P1) : (f +ᵥ g) p = f p +ᵥ g p
-- Mathlib/Topology/Order/DenselyOrdered.lean
theorem Ioc_subset_closure_interior (a b : α) : Ioc a b ⊆ closure (interior (Ioc a b))
-- Mathlib/Topology/Algebra/ProperConstSMul.lean
/-- `(c • ·)` is a proper map. -/
@[to_additive "`(c +ᵥ ·)` is a proper map."]
theorem isProperMap_smul {M : Type*} (c : M) (X : Type*) [SMul M X] [TopologicalSpace X]
    [h : ProperConstSMul M X] : IsProperMap ((c • ·) : X → X)
-- Mathlib/ModelTheory/Complexity.lean
theorem induction_on_all_ex {P : ∀ {m}, L.BoundedFormula α m → Prop} (φ : L.BoundedFormula α n)
    (hqf : ∀ {m} {ψ : L.BoundedFormula α m}, IsQF ψ → P ψ)
    (hall : ∀ {m} {ψ : L.BoundedFormula α (m + 1)}, P ψ → P ψ.all)
    (hex : ∀ {m} {φ : L.BoundedFormula α (m + 1)}, P φ → P φ.ex)
    (hse : ∀ {m} {φ₁ φ₂ : L.BoundedFormula α m},
      Theory.SemanticallyEquivalent ∅ φ₁ φ₂ → (P φ₁ ↔ P φ₂)) :
    P φ
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem coeff_neg (p : R[X]) (n : ℕ) : coeff (-p) n = -coeff p n
-- Mathlib/Algebra/Field/Subfield.lean
theorem zpow_mem {x : K} (hx : x ∈ s) (n : ℤ) : x ^ n ∈ s
-- Mathlib/Algebra/Group/Pi/Lemmas.lean
@[to_additive (attr := simp)]
theorem curry_mulSingle [DecidableEq α] [∀ a, DecidableEq (β a)] [∀ a b, One (γ a b)]
    (i : Σ a, β a) (x : γ i.1 i.2) :
    Sigma.curry (Pi.mulSingle i x) = Pi.mulSingle i.1 (Pi.mulSingle i.2 x)
-- Mathlib/Order/Interval/Finset/Nat.lean
theorem Nat.pow_imp_self_of_one_lt {M} [Monoid M] (k : ℕ) (hk : 1 < k)
    (P : M → Prop) (hmul : ∀ x y, P x → P (x * y) ∨ P (y * x))
    (hpow : ∀ x, P (x ^ k) → P x) : ∀ n x, P (x ^ n) → P x
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem polar_neg_left (x y : M) : polar Q (-x) y = -polar Q x y
-- Mathlib/Analysis/Calculus/Gradient/Basic.lean
theorem Filter.EventuallyEq.gradient_eq (hL : f₁ =ᶠ[𝓝 x] f) : ∇ f₁ x = ∇ f x
-- Mathlib/RingTheory/Nilpotent/Defs.lean
@[simp] theorem IsNilpotent.zero [MonoidWithZero R] : IsNilpotent (0 : R)
-- Mathlib/Probability/Kernel/Disintegration/Density.lean
lemma adapted_densityProcess (κ : Kernel α (γ × β)) (ν : Kernel α γ) (a : α)
    {s : Set β} (hs : MeasurableSet s) :
    Adapted (countableFiltration γ) (fun n x ↦ densityProcess κ ν n a x s)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_eq_zero_iff_cos_eq {z : ℂ} : sin z = 0 ↔ cos z = 1 ∨ cos z = -1
-- Mathlib/Topology/MetricSpace/GromovHausdorff.lean
/-- This is indeed an equivalence relation -/
private theorem equivalence_isometryRel : Equivalence IsometryRel
-- Mathlib/Algebra/Algebra/Subalgebra/MulOpposite.lean
/-- A subalgebra `S` of `A / R` determines a subring `S.op` of the opposite ring `Aᵐᵒᵖ / R`. -/
@[simps]
def opEquiv : Subalgebra R A ≃o Subalgebra R Aᵐᵒᵖ
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.add [AddGroup α] [InvolutiveNeg β] (h1 : Antiperiodic f c₁)
    (h2 : Antiperiodic f c₂) : Periodic f (c₁ + c₂)
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem symm_swap (a b : α) : (swap a b).symm = swap a b
-- Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean
@[simp]
theorem isInitialMul_inv (X : C) [HasBinaryProduct I X] (hI : IsInitial I) :
    (isInitialMul X hI).inv = hI.to _
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem nhdset_of_mem_uniformity {d : Set (α × α)} (s : Set (α × α)) (hd : d ∈ 𝓤 α) :
    ∃ t : Set (α × α), IsOpen t ∧ s ⊆ t ∧
      t ⊆ { p | ∃ x y, (p.1, x) ∈ d ∧ (x, y) ∈ s ∧ (y, p.2) ∈ d }
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The `<` order on subspaces is the same as that on the corresponding sets. -/
theorem lt_def (s1 s2 : AffineSubspace k P) : s1 < s2 ↔ (s1 : Set P) ⊂ s2
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean
@[simp]
lemma toNNReal_algebraMap (r : ℝ≥0) :
    (algebraMap ℝ C(X, ℝ) r).toNNReal = algebraMap ℝ≥0 C(X, ℝ≥0) r
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem _root_.MeasurableEmbedding.integrableOn_map_iff [MeasurableSpace β] {e : α → β}
    (he : MeasurableEmbedding e) {f : β → E} {μ : Measure α} {s : Set β} :
    IntegrableOn f s (μ.map e) ↔ IntegrableOn (f ∘ e) (e ⁻¹' s) μ
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem Measure.exists_isOpen_measure_lt_top [TopologicalSpace α] (μ : Measure α)
    [IsLocallyFiniteMeasure μ] (x : α) : ∃ s : Set α, x ∈ s ∧ IsOpen s ∧ μ s < ∞
-- Mathlib/CategoryTheory/Shift/CommShift.lean
/-- A functor `F` commutes with the shift by a monoid `A` if it is equipped with
commutation isomorphisms with the shifts by all `a : A`, and these isomorphisms
satisfy coherence properties with respect to `0 : A` and the addition in `A`. -/
class CommShift where
  iso (a : A) : shiftFunctor C a ⋙ F ≅ F ⋙ shiftFunctor D a
  zero : iso 0 = CommShift.isoZero F A := by aesop_cat
  add (a b : A) : iso (a + b) = CommShift.isoAdd (iso a) (iso b) := by aesop_cat
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem prefix_nil : l <+: [] ↔ l = []
-- Mathlib/ModelTheory/Complexity.lean
theorem isQF_bot : IsQF (⊥ : L.BoundedFormula α n)
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp, norm_cast]
theorem coe_sUnion (x : ZFSet.{u}) : ↑(⋃₀ x : ZFSet) = ⋃₀ (x : Class.{u})
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem two_mul (n) : 2 * n = n + n
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem Measurable.subtype_map {f : α → β} {p : α → Prop} {q : β → Prop} (hf : Measurable f)
    (hpq : ∀ x, p x → q (f x)) : Measurable (Subtype.map f hpq)
-- Mathlib/Algebra/Group/Action/Defs.lean
@[to_additive]
lemma exists_smul_eq (x y : α) : ∃ m : M, m • x = y
-- Mathlib/Probability/Process/Adapted.lean
protected theorem adapted (h : ProgMeasurable f u) : Adapted f u
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive FreeAddGroup.equivalence_join_red]
theorem equivalence_join_red : Equivalence (Join (@Red α))
-- Mathlib/Order/Basic.lean
theorem lt_of_lt_of_le' : b < c → a ≤ b → a < c
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem typein_one_out (x : (1 : Ordinal).out.α) :
    @typein _ (· < ·) (isWellOrder_out_lt _) x = 0
-- Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean
/-- A simple general sufficient condition for bounding `levyProkhorovEDist` from above. -/
lemma levyProkhorovEDist_le_of_forall (μ ν : Measure Ω) (δ : ℝ≥0∞)
    (h : ∀ ε B, δ < ε → ε < ∞ → MeasurableSet B →
        μ B ≤ ν (thickening ε.toReal B) + ε ∧ ν B ≤ μ (thickening ε.toReal B) + ε) :
    levyProkhorovEDist μ ν ≤ δ
-- Mathlib/RingTheory/HahnSeries/Basic.lean
theorem untop_orderTop_of_ne_zero {x : HahnSeries Γ R} (hx : x ≠ 0) :
    WithTop.untop x.orderTop (ne_zero_iff_orderTop.mp hx) =
      x.isWF_support.min (support_nonempty_iff.2 hx)
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem cast_mul' (a b : ZMod n) : (cast (a * b : ZMod n) : R) = cast a * cast b
-- Mathlib/RingTheory/Adjoin/FG.lean
theorem fg_of_fg_toSubmodule {S : Subalgebra R A} : S.toSubmodule.FG → S.FG
-- Mathlib/CategoryTheory/Monoidal/Internal/FunctorCategory.lean
/-- Functor translating a functor into the category of monoid objects
to a monoid object in the functor category
-/
@[simps]
def inverse : (C ⥤ Mon_ D) ⥤ Mon_ (C ⥤ D)
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive (attr := simp) coe_prodMap]
theorem coe_prodMap : ⇑(prodMap f g) = Prod.map f g
-- Mathlib/CategoryTheory/Limits/Types.lean
/-- Sections of `F ⋙ yoneda.obj X` identify to natural
transformations `(const J).obj X ⟶ F`. -/
@[simps]
def compYonedaSectionsEquiv (F : J ⥤ Cᵒᵖ) (X : C) :
    (F ⋙ yoneda.obj X).sections ≃ ((const J).obj (op X) ⟶ F)
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem round_nat_add (x : α) (y : ℕ) : round ((y : α) + x) = y + round x
-- Mathlib/Tactic/Ring/Basic.lean
theorem inv_congr {R} [DivisionRing R] {a a' b : R} (_ : a = a')
    (_ : a'⁻¹ = b) : (a⁻¹ : R) = b
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem id_comp (f : FrameHom α β) : (FrameHom.id β).comp f = f
-- Mathlib/Topology/Algebra/Order/Field.lean
@[simp]
lemma inv_atTop₀ : (atTop : Filter 𝕜)⁻¹ = 𝓝[>] 0
-- Mathlib/CategoryTheory/Adjunction/FullyFaithful.lean
/-- If the unit of an adjunction is an isomorphism, then its inverse on the image of L is given
by L whiskered with the counit. -/
@[simp]
theorem inv_map_unit {X : C} [IsIso (h.unit.app X)] :
    inv (L.map (h.unit.app X)) = h.counit.app (L.obj X)
-- Mathlib/Topology/ContinuousOn.lean
theorem preimage_coe_mem_nhds_subtype {s t : Set α} {a : s} : (↑) ⁻¹' t ∈ 𝓝 a ↔ t ∈ 𝓝[s] ↑a
-- Mathlib/CategoryTheory/Adjunction/Basic.lean
@[simp, nolint simpNF]
theorem homEquiv_naturality_right (f : F.obj X ⟶ Y) (g : Y ⟶ Y') :
    (adj.homEquiv X Y') (f ≫ g) = (adj.homEquiv X Y) f ≫ G.map g
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive]
theorem ne_one_of_mem_sphere (hr : r ≠ 0) (x : sphere (1 : E) r) : (x : E) ≠ 1
-- Mathlib/Order/Sublattice.lean
@[simp] lemma mem_iInf {f : ι → Sublattice α} : a ∈ ⨅ i, f i ↔ ∀ i, a ∈ f i
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mul_power {a b c : Cardinal} : (a * b) ^ c = a ^ c * b ^ c
-- Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
lemma eventually_atTop_le {b : ℝ} (hb : b ∈ Set.Ioo 0 1) (hf : GrowsPolynomially f) :
    ∃ c > 0, ∀ᶠ x in atTop, ∀ u ∈ Set.Icc (b * x) x, f u ≤ c * f x
-- Mathlib/LinearAlgebra/BilinearForm/TensorProduct.lean
/-- A tensor product of symmetric bilinear forms is symmetric. -/
lemma _root_.LinearMap.IsSymm.tmul {B₁ : BilinMap A M₁ A} {B₂ : BilinMap R M₂ R}
    (hB₁ : B₁.IsSymm) (hB₂ : B₂.IsSymm) : (B₁.tmul B₂).IsSymm
-- Mathlib/Algebra/Module/Defs.lean
@[simp]
theorem smul_eq_zero : c • x = 0 ↔ c = 0 ∨ x = 0
-- Mathlib/Algebra/Group/Opposite.lean
/-- A monoid homomorphism `f : M →* N` such that `f x` commutes with `f y` for all `x, y` defines
a monoid homomorphism to `Nᵐᵒᵖ`. -/
@[to_additive (attr := simps (config := .asFn))
      "An additive monoid homomorphism `f : M →+ N` such that `f x` additively commutes
      with `f y` for all `x, y` defines an additive monoid homomorphism to `Sᵃᵒᵖ`."]
def MonoidHom.toOpposite {M N : Type*} [MulOneClass M] [MulOneClass N] (f : M →* N)
    (hf : ∀ x y, Commute (f x) (f y)) : M →* Nᵐᵒᵖ
-- Mathlib/Analysis/Analytic/Basic.lean
/-- If `‖pₙ‖ rⁿ` is bounded in `n`, then the radius of `p` is at least `r`. -/
theorem le_radius_of_bound_nnreal (C : ℝ≥0) {r : ℝ≥0} (h : ∀ n : ℕ, ‖p n‖₊ * r ^ n ≤ C) :
    (r : ℝ≥0∞) ≤ p.radius
-- Mathlib/LinearAlgebra/AffineSpace/Matrix.lean
@[simp]
theorem toMatrix_self [DecidableEq ι] : b.toMatrix b = (1 : Matrix ι ι k)
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive (attr := simp)]
theorem self_eq_mul_left : b = a * b ↔ a = 1
-- Mathlib/Condensed/Epi.lean
lemma epi_iff_locallySurjective_on_compHaus : Epi f ↔
    ∀ (S : CompHaus) (y : Y.val.obj ⟨S⟩),
      (∃ (S' : CompHaus) (φ : S' ⟶ S) (_ : Function.Surjective φ) (x : X.val.obj ⟨S'⟩),
        f.val.app ⟨S'⟩ x = Y.val.map ⟨φ⟩ y)
-- Mathlib/Tactic/Ring/Basic.lean
nonrec theorem inv_zero {R} [DivisionRing R] : (0 : R)⁻¹ = 0
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
theorem HasColimit.mk {F : J ⥤ C} (d : ColimitCocone F) : HasColimit F
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
theorem setBlack_idem {t : RBNode α} : t.setBlack.setBlack = t.setBlack
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem seq_assoc (x : Filter α) (g : Filter (α → β)) (h : Filter (β → γ)) :
    seq h (seq g x) = seq (seq (map (· ∘ ·) h) g) x
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
/-- Auxiliary construction for `Orientation.rightAngleRotation`, rotation by 90 degrees in an
oriented real inner product space of dimension 2. -/
irreducible_def rightAngleRotationAux₁ : E →ₗ[ℝ] E
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem Memℒp.of_le {f : α → E} {g : α → F} (hg : Memℒp g p μ) (hf : AEStronglyMeasurable f μ)
    (hfg : ∀ᵐ x ∂μ, ‖f x‖ ≤ ‖g x‖) : Memℒp f p μ
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
theorem rank_fin_fun (n : ℕ) : Module.rank R (Fin n → R) = n
-- Mathlib/LinearAlgebra/Basis.lean
theorem isUnitSMul_apply {v : Basis ι R M} {w : ι → R} (hw : ∀ i, IsUnit (w i)) (i : ι) :
    v.isUnitSMul hw i = w i • v i
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem DifferentiableWithinAt.cpow (hf : DifferentiableWithinAt ℂ f s x)
    (hg : DifferentiableWithinAt ℂ g s x) (h0 : f x ∈ slitPlane) :
    DifferentiableWithinAt ℂ (fun x => f x ^ g x) s x
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
lemma coeSubgraph_restrict_eq {H : G.Subgraph} (H' : G.Subgraph) :
    Subgraph.coeSubgraph (H.restrict H') = H ⊓ H'
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
theorem FamilyOfElements.Compatible.to_sieveCompatible {x : FamilyOfElements P (S : Presieve X)}
    (t : x.Compatible) : x.SieveCompatible
-- Mathlib/Algebra/BigOperators/Fin.lean
@[to_additive]
theorem prod_Ioi_zero {M : Type*} [CommMonoid M] {n : ℕ} {v : Fin n.succ → M} :
    ∏ i ∈ Ioi 0, v i = ∏ j : Fin n, v j.succ
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem single_apply {a a' : G} {b : k} [Decidable (a = a')] :
    single a b a' = if a = a' then b else 0
-- Mathlib/Order/Monotone/Monovary.lean
theorem AntivaryOn.dual : AntivaryOn f g s → AntivaryOn (toDual ∘ f) (toDual ∘ g) s
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem IsCycleOn.range_zpow (h : f.IsCycleOn s) (ha : a ∈ s) :
    Set.range (fun n => (f ^ n) a : ℤ → α) = s
-- Mathlib/Algebra/Order/Rearrangement.lean
/-- **Rearrangement Inequality**: Pointwise scalar multiplication of `f` and `g` is minimized when
`f` and `g` antivary together. Stated by permuting the entries of `g`. -/
theorem Antivary.sum_smul_le_sum_smul_comp_perm (hfg : Antivary f g) :
    ∑ i, f i • g i ≤ ∑ i, f i • g (σ i)
-- Mathlib/Analysis/Normed/Operator/ContinuousLinearMap.lean
@[simp]
theorem LinearMap.mkContinuousOfExistsBound_apply (h : ∃ C, ∀ x, ‖f x‖ ≤ C * ‖x‖) (x : E) :
    f.mkContinuousOfExistsBound h x = f x
-- Mathlib/Data/Set/Image.lean
theorem image_compl_subset {f : α → β} {s : Set α} (H : Injective f) : f '' sᶜ ⊆ (f '' s)ᶜ
-- Mathlib/Logic/Unique.lean
theorem Unique.bijective {A B} [Unique A] [Unique B] {f : A → B} : Function.Bijective f
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma Exact.map_of_preservesRightHomologyOf (h : S.Exact) (F : C ⥤ D)
    [F.PreservesZeroMorphisms] [F.PreservesRightHomologyOf S]
    [(S.map F).HasHomology] : (S.map F).Exact
-- Mathlib/Data/Multiset/Basic.lean
theorem disjoint_of_subset_left {s t u : Multiset α} (h : s ⊆ u) (d : Disjoint u t) : Disjoint s t
-- Mathlib/Data/Holor.lean
@[simp]
nonrec theorem mul_zero {α : Type} [Ring α] (x : Holor α ds₁) : x ⊗ (0 : Holor α ds₂) = 0
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem coeSubtype : ⇑ H.subtype = ((↑) : H → G)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
theorem sum_filter_count_eq_countP [DecidableEq α] (p : α → Prop) [DecidablePred p] (l : List α) :
    ∑ x ∈ l.toFinset.filter p, l.count x = l.countP p
-- Mathlib/Data/Finset/Sigma.lean
@[mono]
theorem sigma_mono (hs : s₁ ⊆ s₂) (ht : ∀ i, t₁ i ⊆ t₂ i) : s₁.sigma t₁ ⊆ s₂.sigma t₂
-- Mathlib/Topology/Category/TopCat/Limits/Products.lean
theorem binaryCofan_isColimit_iff {X Y : TopCat} (c : BinaryCofan X Y) :
    Nonempty (IsColimit c) ↔
      OpenEmbedding c.inl ∧ OpenEmbedding c.inr ∧ IsCompl (Set.range c.inl) (Set.range c.inr)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
/-- A subgroup is closed under inverse. -/
@[to_additive "An `AddSubgroup` is closed under inverse."]
protected theorem inv_mem {x : G} : x ∈ H → x⁻¹ ∈ H
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
theorem memℒp_top (f : α →ₛ E) (μ : Measure α) : Memℒp f ∞ μ
-- Mathlib/Data/Nat/Choose/Basic.lean
theorem choose_le_succ (a c : ℕ) : choose a c ≤ choose a.succ c
-- Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean
@[to_additive]
theorem Multipliable.nat_tprod_vanishing {f : ℕ → G} (hf : Multipliable f) ⦃e : Set G⦄
    (he : e ∈ 𝓝 1) : ∃ N : ℕ, ∀ t ⊆ {n | N ≤ n}, (∏' n : t, f n) ∈ e
-- Mathlib/Data/Finset/Sort.lean
/-- An order embedding `f` from `Fin k` to a finset of cardinality `k` has to coincide with
the increasing bijection `orderEmbOfFin s h`. -/
theorem orderEmbOfFin_unique' {s : Finset α} {k : ℕ} (h : s.card = k) {f : Fin k ↪o α}
    (hfs : ∀ x, f x ∈ s) : f = s.orderEmbOfFin h
-- Mathlib/Data/Int/Cast/Lemmas.lean
lemma _root_.zsmul_eq_mul' (a : α) (n : ℤ) : n • a = a * n
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
@[simp]
theorem intervalIntegrable_inv (h : ∀ x : ℝ, x ∈ [[a, b]] → f x ≠ 0)
    (hf : ContinuousOn f [[a, b]]) : IntervalIntegrable (fun x => (f x)⁻¹) μ a b
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem not_or_self : ∀ (x : Bool), (!x || x) = true
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
theorem comp_fderivWithin {f : G → E} {s : Set G} {x : G} (hxs : UniqueDiffWithinAt 𝕜 s x) :
    fderivWithin 𝕜 (iso ∘ f) s x = (iso : E →L[𝕜] F).comp (fderivWithin 𝕜 f s x)
-- Mathlib/Order/RelClasses.lean
theorem transitive_of_trans (r : α → α → Prop) [IsTrans α r] : Transitive r
-- Mathlib/CategoryTheory/Triangulated/HomologicalFunctor.lean
lemma homologySequence_epi_shift_map_mor₂_iff :
    Epi ((F.shift n₀).map T.mor₂) ↔ F.homologySequenceδ T n₀ n₁ h = 0
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
@[simp]
theorem totalDegree_monomial (s : σ →₀ ℕ) {c : R} (hc : c ≠ 0) :
    (monomial s c : MvPolynomial σ R).totalDegree = s.sum fun _ e => e
-- Mathlib/Algebra/Ring/Parity.lean
lemma Even.pow_of_ne_zero (ha : Even a) : ∀ {n : ℕ}, n ≠ 0 → Even (a ^ n)
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem zero_ne_bot : (0 : EReal) ≠ ⊥
-- Mathlib/Algebra/Free.lean
@[to_additive (attr := simp)]
theorem lift_comp_of' (f : AssocQuotient α →ₙ* β) : lift (f.comp of) = f
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem le_div_iff_mul_le : a ≤ c / b ↔ a * b ≤ c
-- Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
/--
Implementation of the functor `PresheafOfModules R ⥤ Cᵒᵖ ⥤ ModuleCat (R.obj X)`
when `X` is initial.

The functor is implemented as, on object level `M ↦ (c ↦ M(c))` where the `R(X)`-module structure
on `M(c)` is given by restriction of scalars along the unique morphism `R(c) ⟶ R(X)`; and on
morphism level `(f : M ⟶ N) ↦ (c ↦ f(c))`.
-/
@[simps]
noncomputable def forgetToPresheafModuleCatObj
    (X : Cᵒᵖ) (hX : Limits.IsInitial X) (M : PresheafOfModules.{v} R) :
    Cᵒᵖ ⥤ ModuleCat (R.1.obj X)
-- Mathlib/Data/Rat/Defs.lean
theorem pos (a : ℚ) : 0 < a.den
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem dvd_to_int (m n : ZNum) : (m : ℤ) ∣ n ↔ m ∣ n
-- Mathlib/RingTheory/Bialgebra/Equiv.lean
@[simp]
theorem coe_mk {f h h₀ h₁ h₂ h₃ h₄ h₅ h₆} :
    (⟨⟨⟨⟨⟨f, h⟩, h₀⟩, h₁, h₂⟩, h₃, h₄, h₅⟩, h₆⟩ : A ≃ₐc[R] B) = f
-- Mathlib/CategoryTheory/Action.lean
@[simp]
theorem coe_back (x : X) : ActionCategory.back (x : ActionCategory M X) = x
-- Mathlib/Topology/Algebra/Monoid.lean
/-- Construct a unit from limits of units and their inverses. -/
@[to_additive (attr := simps)
  "Construct an additive unit from limits of additive units and their negatives."]
def Filter.Tendsto.units [TopologicalSpace N] [Monoid N] [ContinuousMul N] [T2Space N]
    {f : ι → Nˣ} {r₁ r₂ : N} {l : Filter ι} [l.NeBot] (h₁ : Tendsto (fun x => ↑(f x)) l (𝓝 r₁))
    (h₂ : Tendsto (fun x => ↑(f x)⁻¹) l (𝓝 r₂)) : Nˣ
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
/-- A morphism of bimodule objects. -/
@[ext]
structure Hom (M N : Bimod A B) where
  hom : M.X ⟶ N.X
  left_act_hom : M.actLeft ≫ hom = (A.X ◁ hom) ≫ N.actLeft := by aesop_cat
  right_act_hom : M.actRight ≫ hom = (hom ▷ B.X) ≫ N.actRight := by aesop_cat
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem get_set_eq (a : Array α) (i : Fin a.size) (v : α) :
    (a.set i v)[i.1] = v
-- Mathlib/Algebra/Ring/BooleanRing.lean
theorem ofBoolRing_inj {a b : AsBoolRing α} : ofBoolRing a = ofBoolRing b ↔ a = b