ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Condensed/Equivalence.lean
lemma isSheafProfinite
    [∀ Y, HasLimitsOfShape (StructuredArrow Y profiniteToCompHaus.{u}.op) A] :
    Presheaf.IsSheaf (coherentTopology Profinite)
    (profiniteToCompHaus.op ⋙ X.val)
-- Mathlib/Algebra/Ring/Divisibility/Basic.lean
/-- An element `a` of a semigroup with a distributive negation divides the negation of an element
`b` iff `a` divides `b`. -/
@[simp]
theorem dvd_neg : a ∣ -b ↔ a ∣ b
-- Mathlib/Analysis/Analytic/Basic.lean
/-- Analytic everywhere implies continuous -/
theorem AnalyticOn.continuous {f : E → F} (fa : AnalyticOn 𝕜 f univ) : Continuous f
-- Mathlib/RingTheory/PowerSeries/Basic.lean
@[simp]
theorem X_ne_zero [Nontrivial R] : (X : R⟦X⟧) ≠ 0
-- Mathlib/Data/Finset/Prod.lean
theorem diag_inter : (s ∩ t).diag = s.diag ∩ t.diag
-- .lake/packages/lean4/src/lean/Init/Data/List/BasicAux.lean
theorem get_last {as : List α} {i : Fin (length (as ++ [a]))} (h : ¬ i.1 < as.length) : (as ++ [a] : List _).get i = a
-- Mathlib/Topology/Category/CompactlyGenerated.lean
lemma continuous_from_uCompactlyGeneratedSpace {X : Type w} [TopologicalSpace X]
    [UCompactlyGeneratedSpace.{u} X] {Y : Type*} [TopologicalSpace Y] (f : X → Y)
      (h : ∀ (S : CompHaus.{u}) (g : C(S, X)), Continuous (f ∘ g)) : Continuous f
-- Mathlib/GroupTheory/QuotientGroup.lean
@[to_additive (attr := simp)]
theorem mk_zpow (a : G) (n : ℤ) : ((a ^ n : G) : Q) = (a : Q) ^ n
-- Mathlib/RingTheory/Artinian.lean
/-- For any endomorphism of an Artinian module, any sufficiently high iterate has codisjoint kernel
and range. -/
theorem eventually_codisjoint_ker_pow_range_pow (f : M →ₗ[R] M) :
    ∀ᶠ n in atTop, Codisjoint (LinearMap.ker (f ^ n)) (LinearMap.range (f ^ n))
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
lemma δ_eq_zero {n : ℤ} (z : Cocycle F G n) (m : ℤ) : δ n m (z : Cochain F G n) = 0
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem measurable_spanningSets (μ : Measure α) [SigmaFinite μ] (i : ℕ) :
    MeasurableSet (spanningSets μ i)
-- Mathlib/Topology/Algebra/MulAction.lean
@[to_additive]
theorem ContinuousWithinAt.smul (hf : ContinuousWithinAt f s b) (hg : ContinuousWithinAt g s b) :
    ContinuousWithinAt (fun x => f x • g x) s b
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem nhdsWithin_coe (s : Set (OnePoint X)) (x : X) : 𝓝[s] ↑x = map (↑) (𝓝[(↑) ⁻¹' s] x)
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem dvd_of_ysq_dvd {n t} (h : yn a1 n * yn a1 n ∣ yn a1 t) : yn a1 n ∣ t
-- Mathlib/SetTheory/Game/PGame.lean
theorem moveLeft_lf {x : PGame} : ∀ i, x.moveLeft i ⧏ x
-- Mathlib/CategoryTheory/Monoidal/Types/Basic.lean
@[simp] theorem associator_inv_apply_2 {X Y Z : Type u} {x} :
    (((α_ X Y Z).inv : X ⊗ Y ⊗ Z → (X ⊗ Y) ⊗ Z) x).2 = x.2.2
-- Mathlib/Data/Set/Image.lean
theorem image_insert_eq {f : α → β} {a : α} {s : Set α} :
    f '' insert a s = insert (f a) (f '' s)
-- Mathlib/Data/ZMod/Basic.lean
lemma ringEquivCongr_intCast {a b : ℕ} (h : a = b) (z : ℤ) :
    ZMod.ringEquivCongr h z = z
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem size_reverse (a : Array α) : a.reverse.size = a.size
-- Mathlib/Data/Sym/Basic.lean
theorem coe_fill {a : α} {i : Fin (n + 1)} {m : Sym α (n - i)} :
    (fill a i m : Multiset α) = m + replicate i a
-- Mathlib/Data/Finset/NatAntidiagonal.lean
@[simp] lemma antidiagonal_filter_snd_le_of_le {n k : ℕ} (h : k ≤ n) :
    (antidiagonal n).filter (fun a ↦ a.snd ≤ k) = (antidiagonal k).map
      (Embedding.prodMap ⟨_, add_left_injective (n - k)⟩ (Embedding.refl ℕ))
-- Mathlib/Algebra/Ring/Ext.lean
theorem toNonUnitalSemiring_injective :
    Function.Injective (@toNonUnitalSemiring R)
-- Mathlib/CategoryTheory/Limits/TypesFiltered.lean
theorem colimit_eq_iff {i j : J} {xi : F.obj i} {xj : F.obj j} :
    colimit.ι F i xi = colimit.ι F j xj ↔
      ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f xi = F.map g xj
-- Mathlib/Data/Multiset/Dedup.lean
@[simp]
theorem dedup_cons_of_mem {a : α} {s : Multiset α} : a ∈ s → dedup (a ::ₘ s) = dedup s
-- Mathlib/CategoryTheory/GradedObject/Bifunctor.lean
/-- The isomorphism `mapBifunctorMapObj F p X₁ Y₁ ≅ mapBifunctorMapObj F p X₂ Y₂`
induced by isomorphisms `X₁ ≅ X₂` and `Y₁ ≅ Y₂`. -/
@[simps]
noncomputable def mapBifunctorMapMapIso (e : X₁ ≅ X₂) (e' : Y₁ ≅ Y₂) :
    mapBifunctorMapObj F p X₁ Y₁ ≅ mapBifunctorMapObj F p X₂ Y₂
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1SCLM_add_left (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (f : α →₁ₛ[μ] E) :
    setToL1SCLM α E μ (hT.add hT') f = setToL1SCLM α E μ hT f + setToL1SCLM α E μ hT' f
-- Mathlib/Topology/Instances/EReal.lean
theorem nhds_bot : 𝓝 (⊥ : EReal) = ⨅ (a) (_ : a ≠ ⊥), 𝓟 (Iio a)
-- Mathlib/Probability/ProbabilityMassFunction/Monad.lean
/-- `bindOnSupport` reduces to `bind` if `f` doesn't depend on the additional hypothesis. -/
@[simp]
theorem bindOnSupport_eq_bind (p : PMF α) (f : α → PMF β) :
    (p.bindOnSupport fun a _ => f a) = p.bind f
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem mul_sub_right_distrib (n m k : Nat) : (n - m) * k = n * k - m * k
-- Mathlib/GroupTheory/SpecificGroups/Cyclic.lean
@[to_additive]
theorem orderOf_eq_card_of_forall_mem_zpowers [Fintype α] {g : α} (hx : ∀ x, x ∈ zpowers g) :
    orderOf g = Fintype.card α
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_iUnion_ae [Countable ι] {s : ι → Set α} (hd : Pairwise (AEDisjoint μ on s))
    (hm : ∀ i, NullMeasurableSet (s i) μ) : μ.restrict (⋃ i, s i) = sum fun i => μ.restrict (s i)
-- Mathlib/Analysis/Normed/Group/Hom.lean
/-- For normed groups, an operator is zero iff its norm vanishes. -/
theorem opNorm_zero_iff {V₁ V₂ : Type*} [NormedAddCommGroup V₁] [NormedAddCommGroup V₂]
    {f : NormedAddGroupHom V₁ V₂} : ‖f‖ = 0 ↔ f = 0
-- Mathlib/Analysis/Fourier/AddCircle.lean
/-- Express Fourier coefficients of `f` on an interval in terms of those of its derivative. -/
theorem fourierCoeffOn_of_hasDeriv_right {a b : ℝ} (hab : a < b) {f f' : ℝ → ℂ}
    {n : ℤ} (hn : n ≠ 0)
    (hf : ContinuousOn f [[a, b]])
    (hff' : ∀ x, x ∈ Ioo (min a b) (max a b) → HasDerivWithinAt f (f' x) (Ioi x) x)
    (hf' : IntervalIntegrable f' volume a b) :
    fourierCoeffOn hab f n = 1 / (-2 * π * I * n) *
      (fourier (-n) (a : AddCircle (b - a)) * (f b - f a) - (b - a) * fourierCoeffOn hab f' n)
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
@[simp]
lemma rpow_ofNat (x : ℝ≥0) (n : ℕ) [n.AtLeastTwo] :
    x ^ (no_index (OfNat.ofNat n) : ℝ) = x ^ (OfNat.ofNat n : ℕ)
-- Mathlib/Analysis/Normed/Ring/SeminormFromConst.lean
/-- If `1 ≤ n`, then `seminormFromConst_seq c f 1 n = 1`. -/
theorem seminormFromConst_seq_one (n : ℕ) (hn : 1 ≤ n) : seminormFromConst_seq c f 1 n = 1
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem Adapted.isStoppingTime_crossing (hf : Adapted ℱ f) :
    IsStoppingTime ℱ (upperCrossingTime a b f N n) ∧
      IsStoppingTime ℱ (lowerCrossingTime a b f N n)
-- Mathlib/Algebra/Group/Commute/Basic.lean
@[to_additive (attr := simp)]
theorem inv_inv_iff : Commute a⁻¹ b⁻¹ ↔ Commute a b
-- Mathlib/Data/Set/Image.lean
@[simp]
theorem rangeFactorization_coe (f : ι → β) (a : ι) : (rangeFactorization f a : β) = f a
-- Mathlib/Data/Finset/Lattice.lean
theorem not_mem_of_max_lt {s : Finset α} {a b : α} (h₁ : b < a) (h₂ : s.max = ↑b) : a ∉ s
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem inr_top [LE α] [LE β] [OrderTop β] : toLex (inr ⊤ : α ⊕ β) = ⊤
-- Mathlib/NumberTheory/Liouville/Measure.lean
/-- The set of Liouville numbers has Lebesgue measure zero. -/
@[simp]
theorem volume_setOf_liouville : volume { x : ℝ | Liouville x } = 0
-- Mathlib/Order/Filter/Basic.lean
@[to_additive]
theorem EventuallyEq.div [Div β] {f f' g g' : α → β} {l : Filter α} (h : f =ᶠ[l] g)
    (h' : f' =ᶠ[l] g') : (fun x => f x / f' x) =ᶠ[l] fun x => g x / g' x
-- Mathlib/CategoryTheory/Functor/Currying.lean
/-- The currying functor, taking a functor `(C × D) ⥤ E` and producing a functor `C ⥤ (D ⥤ E)`.
-/
@[simps! obj_obj_obj obj_obj_map obj_map_app map_app_app]
def curry : (C × D ⥤ E) ⥤ C ⥤ D ⥤ E
-- Mathlib/GroupTheory/PushoutI.lean
/-- The data we need to pick a normal form for words in the pushout. We need to pick a
canonical element of each coset. We also need all the maps in the diagram to be injective  -/
structure Transversal : Type _ where
  /-- All maps in the diagram are injective -/
  injective : ∀ i, Injective (φ i)
  /-- The underlying set, containing exactly one element of each coset of the base group -/
  set : ∀ i, Set (G i)
  /-- The chosen element of the base group itself is the identity -/
  one_mem : ∀ i, 1 ∈ set i
  /-- We have exactly one element of each coset of the base group -/
  compl : ∀ i, IsComplement (φ i).range (set i)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem succ_pred_eq_of_pos : ∀ {n}, 0 < n → succ (pred n) = n
-- Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean
@[simps]
instance homCategory (𝒳 : BasedCategory.{v₂, u₂} 𝒮) (𝒴 : BasedCategory.{v₃, u₃} 𝒮) :
    Category (𝒳 ⥤ᵇ 𝒴)
-- Mathlib/MeasureTheory/Group/Integral.lean
@[to_additive]
theorem Integrable.comp_mul_left {f : G → F} [IsMulLeftInvariant μ] (hf : Integrable f μ) (g : G) :
    Integrable (fun t => f (g * t)) μ
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
@[simp]
theorem not_isComplex_iff_isReal {w : InfinitePlace K} : ¬IsComplex w ↔ IsReal w
-- Mathlib/Computability/ContextFreeGrammar.lean
/-- Add extra prefix to context-free producing. -/
lemma Produces.append_left {v w : List (Symbol T g.NT)}
    (hvw : g.Produces v w) (p : List (Symbol T g.NT)) :
    g.Produces (p ++ v) (p ++ w)
-- Mathlib/Data/Complex/Module.lean
@[simp]
theorem ofRealAm_coe : ⇑ofRealAm = ((↑) : ℝ → ℂ)
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem one_lt_of_lt_mul_right [ContravariantClass α α (· * ·) (· < ·)] {a b : α} (h : a < a * b) :
    1 < b
-- Mathlib/Data/Seq/WSeq.lean
theorem head_terminates_iff (s : WSeq α) : Terminates (head s) ↔ Terminates (destruct s)
-- Mathlib/RingTheory/HahnSeries/Summable.lean
theorem coe_injective : @Function.Injective (SummableFamily Γ R α) (α → HahnSeries Γ R) (⇑)
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem map_isPrime_of_surjective {f : F} (hf : Function.Surjective f) {I : Ideal R} [H : IsPrime I]
    (hk : RingHom.ker f ≤ I) : IsPrime (map f I)
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
theorem elim_const_const (c : γ) :
    Sum.elim (const _ c : α → γ) (const _ c : β → γ) = const _ c
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem mul_ne_zero : n ≠ 0 → m ≠ 0 → n * m ≠ 0
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
@[simp]
lemma sFiniteSeq_zero (n : ℕ) : sFiniteSeq (0 : Measure α) n = 0
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem posMulMono_iff_covariant_pos :
    PosMulMono α ↔ CovariantClass α>0 α (fun x y => x * y) (· ≤ ·)
-- Mathlib/Data/Nat/Factorial/Basic.lean
theorem dvd_factorial : ∀ {m n}, 0 < m → m ≤ n → m ∣ n !
-- Mathlib/NumberTheory/ArithmeticFunction.lean
lemma cardFactors_zero : Ω 0 = 0
-- Mathlib/Topology/UrysohnsLemma.lean
theorem approx_mono (c : CU P) (x : X) : Monotone fun n => c.approx n x
-- Mathlib/RingTheory/ReesAlgebra.lean
theorem mem_reesAlgebra_iff_support (f : R[X]) :
    f ∈ reesAlgebra I ↔ ∀ i ∈ f.support, f.coeff i ∈ I ^ i
-- Mathlib/Algebra/Order/Monoid/Unbundled/Defs.lean
theorem act_rel_of_rel_of_act_rel (ab : r a b) (rl : r (μ m b) c) : r (μ m a) c
-- Mathlib/AlgebraicTopology/DoldKan/FunctorN.lean
/-- The functor `SimplicialObject C ⥤ Karoubi (ChainComplex C ℕ)` which maps
`X` to the formal direct factor of `K[X]` defined by `PInfty`. -/
@[simps]
def N₁ : SimplicialObject C ⥤ Karoubi (ChainComplex C ℕ)
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem head?_nil : @head? α [] = none
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
@[simp]
theorem neg_pi_div_two_lt_arcsin {x : ℝ} : -(π / 2) < arcsin x ↔ -1 < x
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
/-- To construct an isomorphism of costructured arrows,
we need an isomorphism of the objects underlying the source,
and to check that the triangle commutes.
-/
@[simps!]
def isoMk {f f' : CostructuredArrow S T} (g : f.left ≅ f'.left)
    (w : S.map g.hom ≫ f'.hom = f.hom := by aesop_cat) : f ≅ f'
-- Mathlib/RingTheory/Coalgebra/Basic.lean
theorem comul_comp_fst :
    comul ∘ₗ .fst R A B = TensorProduct.map (.fst R A B) (.fst R A B) ∘ₗ comul
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem mem_span_singleton_sup {S : Type*} [CommSemiring S] {x y : S} {I : Ideal S} :
    x ∈ Ideal.span {y} ⊔ I ↔ ∃ a : S, ∃ b ∈ I, a * y + b = x
-- Mathlib/GroupTheory/CosetCover.lean
theorem Subspace.exists_eq_top_of_biUnion_eq_univ (hcovers : ⋃ p ∈ s, (p : Set E) = Set.univ) :
    ∃ p ∈ s, p = ⊤
-- Mathlib/Algebra/Group/Equiv/TypeTags.lean
/-- Reinterpret `G ≃+ H` as `Multiplicative G ≃* Multiplicative H`. -/
@[simps]
def AddEquiv.toMultiplicative [AddZeroClass G] [AddZeroClass H] :
    G ≃+ H ≃ (Multiplicative G ≃* Multiplicative H)
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
theorem coeFn_compQuasiMeasurePreserving (g : β →ₘ[ν] γ) (hf : QuasiMeasurePreserving f μ ν) :
    g.compQuasiMeasurePreserving f hf =ᵐ[μ] g ∘ f
-- Mathlib/Algebra/GCDMonoid/Basic.lean
@[simp]
theorem out_top : (⊤ : Associates α).out = 0
-- Mathlib/Topology/Order/LocalExtr.lean
theorem isLocalMaxOn_const {b : β} : IsLocalMaxOn (fun _ => b) s a
-- Mathlib/Data/Finsupp/Defs.lean
/-- If two additive homomorphisms from `α →₀ M` are equal on each `single a b`,
then they are equal.

We formulate this using equality of `AddMonoidHom`s so that `ext` tactic can apply a type-specific
extensionality lemma after this one.  E.g., if the fiber `M` is `ℕ` or `ℤ`, then it suffices to
verify `f (single a 1) = g (single a 1)`. -/
@[ext high]
theorem addHom_ext' [AddZeroClass N] ⦃f g : (α →₀ M) →+ N⦄
    (H : ∀ x, f.comp (singleAddHom x) = g.comp (singleAddHom x)) : f = g
-- Mathlib/Algebra/Polynomial/Smeval.lean
theorem leval_coe_eq_smeval {R : Type*} [Semiring R] (r : R) :
    ⇑(leval r) = fun p => p.smeval r
-- Mathlib/Data/List/Perm.lean
theorem Perm.foldr_eq {f : α → β → β} {l₁ l₂ : List α} (lcomm : LeftCommutative f) (p : l₁ ~ l₂) :
    ∀ b, foldr f b l₁ = foldr f b l₂
-- Mathlib/GroupTheory/SpecificGroups/Cyclic.lean
@[to_additive]
theorem powers_eq_top_of_prime_card {G : Type*} [Group G] {_ : Fintype G} {p : ℕ}
    [hp : Fact p.Prime] (h : Fintype.card G = p) {g : G} (hg : g ≠ 1) : Submonoid.powers g = ⊤
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive]
lemma fst_mem_orbit_of_mem_orbit {x y : α × β} (h : x ∈ MulAction.orbit M y) :
    x.1 ∈ MulAction.orbit M y.1
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem simpleFunc_bot' {α} [Nonempty β] (f : @SimpleFunc α ⊥ β) :
    ∃ c, f = @SimpleFunc.const α _ ⊥ c
-- Mathlib/Analysis/Complex/UnitDisc/Basic.lean
@[simp]
theorem conj_mul (z w : 𝔻) : (z * w).conj = z.conj * w.conj
-- Mathlib/Topology/Algebra/GroupWithZero.lean
/-- If a function converges to a nonzero value, its inverse converges to the inverse of this value.
We use the name `Filter.Tendsto.inv₀` as `Filter.Tendsto.inv` is already used in multiplicative
topological groups. -/
theorem Filter.Tendsto.inv₀ {a : G₀} (hf : Tendsto f l (𝓝 a)) (ha : a ≠ 0) :
    Tendsto (fun x => (f x)⁻¹) l (𝓝 a⁻¹)
-- Mathlib/Data/Option/Basic.lean
theorem elim_comp₂ (h : α → β → γ) {f : γ → α} {x : α} {g : γ → β} {y : β}
    {i : Option γ} : (i.elim (h x y) fun j => h (f j) (g j)) = h (i.elim x f) (i.elim y g)
-- Mathlib/Algebra/Ring/Subring/Pointwise.lean
@[simp]
theorem pointwise_smul_le_pointwise_smul_iff₀ {a : M} (ha : a ≠ 0) {S T : Subring R} :
    a • S ≤ a • T ↔ S ≤ T
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
/-- Formula for `hurwitzZetaOdd` as a Dirichlet series in the convergence range (sum over `ℤ`). -/
theorem hasSum_int_hurwitzZetaOdd (a : ℝ) {s : ℂ} (hs : 1 < re s) :
    HasSum (fun n : ℤ ↦ SignType.sign (n + a) / (↑|n + a| : ℂ) ^ s / 2) (hurwitzZetaOdd a s)
-- Mathlib/FieldTheory/Minpoly/Field.lean
/-- If an element `x` is a root of a polynomial `p`, then the minimal polynomial of `x` divides `p`.
See also `minpoly.isIntegrallyClosed_dvd` which relaxes the assumptions on `A` in exchange for
stronger assumptions on `B`. -/
theorem dvd {p : A[X]} (hp : Polynomial.aeval x p = 0) : minpoly A x ∣ p
-- Mathlib/Data/Set/Image.lean
theorem image_preimage_eq_of_subset {f : α → β} {s : Set β} (hs : s ⊆ range f) :
    f '' (f ⁻¹' s) = s
-- Mathlib/Analysis/Calculus/BumpFunction/Normed.lean
theorem support_normed_eq : Function.support (f.normed μ) = Metric.ball c f.rOut
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem count_inter (a : α) (s t : Multiset α) : count a (s ∩ t) = min (count a s) (count a t)
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
lemma differentiable_completedHurwitzZetaOdd (a : UnitAddCircle) :
    Differentiable ℂ (completedHurwitzZetaOdd a)
-- Mathlib/GroupTheory/Coset.lean
@[to_additive (attr := simp)]
lemma fiberEquivKer_symm_apply (f : α →* H) (a : α) (g : f.ker) :
    (f.fiberEquivKer a).symm g = a * g
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive (attr := simp)]
theorem mem_orbit (a : α) (m : M) : m • a ∈ orbit M a
-- .lake/packages/batteries/Batteries/Data/HashMap/WF.lean
theorem insert_WF [BEq α] [Hashable α] {m : Imp α β} {k v}
    (h : m.buckets.WF) : (insert m k v).buckets.WF
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
theorem lift_unique {j : N →* P} (hj : ∀ x, j (f.toMap x) = g x) : f.lift hg = j
-- Mathlib/RingTheory/Localization/FractionRing.lean
lemma surjective_iff_isField [IsDomain R] : Function.Surjective (algebraMap R K) ↔ IsField R
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
protected theorem not_iff : ¬IsPrimitiveRoot ζ k ↔ orderOf ζ ≠ k
-- Mathlib/CategoryTheory/MorphismProperty/Factorization.lean
/-- Auxiliary definition for `FunctorialFactorizationData.functorCategory`. -/
@[simps]
def functorCategory.Z : Arrow (J ⥤ C) ⥤ J ⥤ C
-- Mathlib/Topology/RestrictGenTopology.lean
/-- If `X` is a sequential space
and `S` contains each set of the form `insert x (Set.range u)`
where `u : ℕ → X` is a sequence and `x` is its limit,
then topology on `X` is generated by its restrictions to the sets of `S`. -/
lemma of_seq [SequentialSpace X]
    (h : ∀ ⦃u : ℕ → X⦄ ⦃x : X⦄, Tendsto u atTop (𝓝 x) → insert x (range u) ∈ S) :
    RestrictGenTopology S
-- Mathlib/Algebra/Group/TypeTags.lean
/-- Reinterpret `α →* β` as `Additive α →+ Additive β`. -/
@[simps]
def MonoidHom.toAdditive [MulOneClass α] [MulOneClass β] :
    (α →* β) ≃ (Additive α →+ Additive β)
-- Mathlib/Algebra/Quaternion.lean
@[simp] nonrec theorem sub_self_im : a - a.im = a.re
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem coe_sub_bot (x : ℝ) : (x : EReal) - ⊥ = ⊤
-- Mathlib/Geometry/Manifold/InteriorBoundary.lean
/-- If `I` is boundaryless, `M` has full interior. -/
lemma interior_eq_univ : I.interior M = univ
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem mk_embedding_le_arrow : #(α ↪ β') ≤ #(α → β')
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
@[simp]
lemma toColumns₂_fromColumns (A₁ : Matrix m n₁ R) (A₂ : Matrix m n₂ R) :
    toColumns₂ (fromColumns A₁ A₂) = A₂
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
@[simp]
theorem mul_le_mul_left_of_neg [ExistsAddOfLE α] [PosMulStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    {a b c : α} (h : c < 0) : c * a ≤ c * b ↔ b ≤ a
-- Mathlib/Analysis/Normed/Field/Basic.lean
@[simp]
theorem nnnorm_mul (a b : α) : ‖a * b‖₊ = ‖a‖₊ * ‖b‖₊
-- Mathlib/Data/Matrix/Kronecker.lean
theorem diagonal_kronecker_diagonal [MulZeroClass α] [DecidableEq m] [DecidableEq n] (a : m → α)
    (b : n → α) : diagonal a ⊗ₖ diagonal b = diagonal fun mn => a mn.1 * b mn.2
-- Mathlib/Analysis/BoxIntegral/Partition/Split.lean
theorem eventually_splitMany_inf_eq_filter (π : Prepartition I) :
    ∀ᶠ t : Finset (ι × ℝ) in atTop,
      π ⊓ splitMany I t = (splitMany I t).filter fun J => ↑J ⊆ π.iUnion
-- Mathlib/Analysis/PSeries.lean
theorem tsum_schlomilch_le {C : ℕ} (hf : ∀ ⦃m n⦄, 1 < m → m ≤ n → f n ≤ f m) (h_pos : ∀ n, 0 < u n)
    (h_nonneg : ∀ n, 0 ≤ f n) (hu : Monotone u) (h_succ_diff : SuccDiffBounded C u) :
    ∑' k : ℕ, (u (k + 1) - u k) * f (u k) ≤ (u 1 - u 0) * f (u 0) + C * ∑' k, f k
-- Mathlib/Algebra/Group/Action/Sigma.lean
@[to_additive (attr := simp)]
theorem smul_mk : a • mk i b = ⟨i, a • b⟩
-- Mathlib/Algebra/Free.lean
/-- The universal property of the free magma expressing its adjointness. -/
@[to_additive (attr := simps symm_apply)
"The universal property of the free additive magma expressing its adjointness."]
def lift : (α → β) ≃ (FreeMagma α →ₙ* β)
-- Mathlib/Data/Real/Sqrt.lean
theorem lt_sqrt (hx : 0 ≤ x) : x < √y ↔ x ^ 2 < y
-- Mathlib/Data/Nat/Log.lean
theorem pow_lt_iff_lt_clog {b : ℕ} (hb : 1 < b) {x y : ℕ} : b ^ y < x ↔ y < clog b x
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- `x ↦ fderivWithin 𝕜 (f x) t (g x) (k x)` is smooth at a point within a set. -/
theorem ContDiffWithinAt.fderivWithin_apply {f : E → F → G} {g k : E → F} {t : Set F} {n : ℕ∞}
    (hf : ContDiffWithinAt 𝕜 n (Function.uncurry f) (s ×ˢ t) (x₀, g x₀))
    (hg : ContDiffWithinAt 𝕜 m g s x₀) (hk : ContDiffWithinAt 𝕜 m k s x₀) (ht : UniqueDiffOn 𝕜 t)
    (hmn : m + 1 ≤ n) (hx₀ : x₀ ∈ s) (hst : s ⊆ g ⁻¹' t) :
    ContDiffWithinAt 𝕜 m (fun x => fderivWithin 𝕜 (f x) t (g x) (k x)) s x₀
-- Mathlib/Topology/Inseparable.lean
theorem inseparable_iff_mem_closure :
    (x ~ᵢ y) ↔ x ∈ closure ({y} : Set X) ∧ y ∈ closure ({x} : Set X)
-- Mathlib/GroupTheory/Complement.lean
@[to_additive]
theorem IsComplement'.symm (h : IsComplement' H K) : IsComplement' K H
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
@[simp]
theorem restrict_biUnion (πi : ∀ J, Prepartition J) (hJ : J ∈ π) :
    (π.biUnion πi).restrict J = πi J
-- Mathlib/Data/Int/Interval.lean
theorem card_Icc_of_le (h : a ≤ b + 1) : ((Icc a b).card : ℤ) = b + 1 - a
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[simp]
lemma DifferentiableOn.sub_iff_left (hg : DifferentiableOn 𝕜 g s) :
    DifferentiableOn 𝕜 (fun y => f y - g y) s ↔ DifferentiableOn 𝕜 f s
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem iteratedFDeriv_add_apply' {i : ℕ} {f g : E → F} (hf : ContDiff 𝕜 i f)
    (hg : ContDiff 𝕜 i g) :
    iteratedFDeriv 𝕜 i (fun x => f x + g x) x = iteratedFDeriv 𝕜 i f x + iteratedFDeriv 𝕜 i g x
-- Mathlib/Order/CompleteBooleanAlgebra.lean
lemma sInf_sup_eq : sInf s ⊔ b = ⨅ a ∈ s, a ⊔ b
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
@[simp]
theorem map_id : map (fun i ↦ (LinearMap.id : s i →ₗ[R] s i)) = .id
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma toMvPolynomial_mul (M : Matrix m n R) (N : Matrix n o R) (i : m) :
    (M * N).toMvPolynomial i = bind₁ N.toMvPolynomial (M.toMvPolynomial i)
-- Mathlib/Data/Set/Basic.lean
theorem diff_compl : s \ tᶜ = s ∩ t
-- Mathlib/Data/Finmap.lean
@[simp] lemma keysLookupEquiv_symm_apply_lookup :
    ∀ (f : {f : Finset α × (∀ a, Option (β a)) // ∀ i, (f.2 i).isSome ↔ i ∈ f.1}) a,
      (keysLookupEquiv.symm f).lookup a = f.1.2 a
-- Mathlib/Data/Nat/Factorial/DoubleFactorial.lean
lemma doubleFactorial_pos : ∀ n, 0 < n‼
-- Mathlib/Analysis/Calculus/Deriv/Polynomial.lean
protected theorem differentiableWithinAt : DifferentiableWithinAt 𝕜 (fun x => p.eval x) s x
-- Mathlib/LinearAlgebra/Matrix/ZPow.lean
theorem zpow_sub {A : M} (ha : IsUnit A.det) (z1 z2 : ℤ) : A ^ (z1 - z2) = A ^ z1 / A ^ z2
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem mem_lift_of_splits_of_roots_mem_range [Algebra R K] {f : K[X]}
    (hs : f.Splits (RingHom.id K)) (hm : f.Monic) (hr : ∀ a ∈ f.roots, a ∈ (algebraMap R K).range) :
    f ∈ Polynomial.lifts (algebraMap R K)
-- Mathlib/Topology/Algebra/Module/Basic.lean
theorem coe_apply (e : M₁ ≃SL[σ₁₂] M₂) (b : M₁) : (e : M₁ →SL[σ₁₂] M₂) b = e b
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem blockDiagonal'_diagonal [∀ i, DecidableEq (m' i)] (d : ∀ i, m' i → α) :
    (blockDiagonal' fun k => diagonal (d k)) = diagonal fun ik => d ik.1 ik.2
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
theorem op_sInf (S : Set (Subring R)) : (sInf S).op = sInf (.unop ⁻¹' S)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem toFin_sub (x y : BitVec n) : (x - y).toFin = toFin x - toFin y