ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/Matrix/Symmetric.lean
theorem IsSymm.eq {A : Matrix n n α} (h : A.IsSymm) : Aᵀ = A
-- Mathlib/NumberTheory/SmoothNumbers.lean
/-- If `p ∉ s` is a prime and `n` is `s`-factored, then `p` and `n` are coprime. -/
lemma Prime.factoredNumbers_coprime {s : Finset ℕ} {p n : ℕ} (hp : p.Prime) (hs : p ∉ s)
    (hn : n ∈ factoredNumbers s) :
    Nat.Coprime p n
-- Mathlib/Topology/Algebra/UniformConvergence.lean
@[to_additive (attr := simp)]
lemma UniformFun.ofFun_div [Div β] (f g : α → β) : ofFun (f / g) = ofFun f / ofFun g
-- Mathlib/Init/Order/LinearOrder.lean
theorem le_min {a b c : α} (h₁ : c ≤ a) (h₂ : c ≤ b) : c ≤ min a b
-- Mathlib/Analysis/NormedSpace/MStructure.lean
theorem mul [FaithfulSMul M X] {P Q : M} (h₁ : IsLprojection X P) (h₂ : IsLprojection X Q) :
    IsLprojection X (P * Q)
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem num_dvd {x : RatFunc K} {p : K[X]} (hp : p ≠ 0) :
    num x ∣ p ↔ ∃ q : K[X], q ≠ 0 ∧ x = algebraMap _ _ p / algebraMap _ _ q
-- Mathlib/Algebra/Lie/Weights/Basic.lean
lemma posFittingCompOf_le_posFittingComp (x : L) :
    posFittingCompOf R M x ≤ posFittingComp R L M
-- Mathlib/CategoryTheory/Functor/FullyFaithful.lean
theorem map_surjective (F : C ⥤ D) [Full F] :
    Function.Surjective (F.map : (X ⟶ Y) → (F.obj X ⟶ F.obj Y))
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
@[simp]
theorem lift_self {c : Cone F} (t : IsLimit c) : t.lift c = 𝟙 c.pt
-- Mathlib/Analysis/Calculus/Deriv/Slope.lean
theorem isSeparable_range_derivWithin [SeparableSpace 𝕜] (f : 𝕜 → F) (s : Set 𝕜) :
    IsSeparable (range (derivWithin f s))
-- Mathlib/Data/Matroid/Map.lean
@[simp] lemma comap_basis'_iff {I X : Set α} :
    (N.comap f).Basis' I X ↔ N.Basis' (f '' I) (f '' X) ∧ I.InjOn f ∧ I ⊆ X
-- Mathlib/Order/Bounds/Basic.lean
theorem mem_lowerBounds_image2 (ha : a ∈ lowerBounds s) (hb : b ∈ lowerBounds t) :
    f a b ∈ lowerBounds (image2 f s t)
-- Mathlib/Order/Filter/Basic.lean
theorem map_le_map_iff {f g : Filter α} {m : α → β} (hm : Injective m) :
    map m f ≤ map m g ↔ f ≤ g
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem restrictDom_apply (s : Set α) (l : α →₀ M) [DecidablePred (· ∈ s)] :
    (restrictDom M R s l : α →₀ M) = Finsupp.filter (· ∈ s) l
-- Mathlib/Data/Int/GCD.lean
theorem xgcdAux_val (x y) : xgcdAux x 1 0 y 0 1 = (gcd x y, xgcd x y)
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem fract_neg_eq_zero {x : α} : fract (-x) = 0 ↔ fract x = 0
-- Mathlib/Order/PartialSups.lean
@[simp]
theorem partialSups_succ (f : ℕ → α) (n : ℕ) :
    partialSups f (n + 1) = partialSups f n ⊔ f (n + 1)
-- Mathlib/RingTheory/Int/Basic.lean
theorem gcd_eq_one_iff_coprime {a b : ℤ} : Int.gcd a b = 1 ↔ IsCoprime a b
-- Mathlib/Algebra/Associated/Basic.lean
@[simp]
theorem associated_mul_unit_left_iff {β : Type*} [Monoid β] {a b : β} {u : Units β} :
    Associated (a * u) b ↔ Associated a b
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Power2.lean
protected theorem two_pow_pos (w : Nat) : 0 < 2^w
-- Mathlib/Data/Fintype/Pi.lean
theorem piFinset_disjoint_of_disjoint (t₁ t₂ : ∀ a, Finset (δ a)) {a : α}
    (h : Disjoint (t₁ a) (t₂ a)) : Disjoint (piFinset t₁) (piFinset t₂)
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem Hereditarily.self (h : x.Hereditarily p) : p x
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
theorem eq_one_of_mul_left (h : a * b = 1) : b = 1
-- Mathlib/Analysis/Convex/StrictConvexSpace.lean
theorem abs_lt_norm_sub_of_not_sameRay (h : ¬SameRay ℝ x y) : |‖x‖ - ‖y‖| < ‖x - y‖
-- Mathlib/Data/Set/Basic.lean
theorem pair_diff_right (hne : a ≠ b) : ({a, b} : Set α) \ {b} = {a}
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
theorem isHomogeneous_C (r : R) : IsHomogeneous (C r : MvPolynomial σ R) 0
-- Mathlib/Data/Multiset/FinsetOps.lean
theorem subset_ndunion_left (s t : Multiset α) : s ⊆ ndunion s t
-- Mathlib/Combinatorics/SimpleGraph/Maps.lean
@[simp] lemma _root_.Equiv.simpleGraph_refl : (Equiv.refl V).simpleGraph = Equiv.refl _
-- Mathlib/Order/WithBot.lean
theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithTop α) :
    WithBot.map f (WithTop.toDual a) = a.map (toDual ∘ f)
-- Mathlib/Data/Finset/Piecewise.lean
lemma piecewise_cases {i} (p : π i → Prop) (hf : p (f i)) (hg : p (g i)) :
    p (s.piecewise f g i)
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_rw₁ {f f' : α → β} (h : f =ᵐ[μ] f') (g : β → ℝ≥0∞) :
    ∫⁻ a, g (f a) ∂μ = ∫⁻ a, g (f' a) ∂μ
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
/-- Given a tagged partition `π` of `I` and a (not tagged) partition `πi J hJ` of each `J ∈ π`,
returns the tagged partition of `I` into all the boxes of all `πi J hJ`. The tag of a box `J`
is defined to be the `π.tag` of the box of the partition `π` that includes `J`.

Note that usually the result is not a Henstock partition. -/
@[simps (config := .asFn) tag]
def biUnionPrepartition (π : TaggedPrepartition I) (πi : ∀ J : Box ι, Prepartition J) :
    TaggedPrepartition I
-- Mathlib/Algebra/Category/ModuleCat/Basic.lean
lemma forget₂_map_homMk :
    (forget₂ (ModuleCat R) AddCommGrp).map (homMk φ hφ) = φ
-- Mathlib/Algebra/Homology/Augment.lean
/-- The truncation of an `ℕ`-indexed chain complex,
deleting the object at `0` and shifting everything else down.
-/
@[simps]
def truncate [HasZeroMorphisms V] : ChainComplex V ℕ ⥤ ChainComplex V ℕ
-- Mathlib/Computability/Ackermann.lean
@[simp]
theorem ack_le_iff_left {m₁ m₂ n : ℕ} : ack m₁ n ≤ ack m₂ n ↔ m₁ ≤ m₂
-- Mathlib/Algebra/Bounds.lean
@[to_additive]
lemma BddAbove.range_inv {α : Type*} {f : α → G} (hf : BddAbove (range f)) :
    BddBelow (range (fun x => (f x)⁻¹))
-- Mathlib/Order/Bounds/Basic.lean
theorem bddBelow_iff_exists_le [SemilatticeInf γ] {s : Set γ} (x₀ : γ) :
    BddBelow s ↔ ∃ x, x ≤ x₀ ∧ ∀ y ∈ s, x ≤ y
-- Mathlib/RingTheory/WittVector/Teichmuller.lean
@[simp]
theorem teichmuller_coeff_pos (r : R) : ∀ (n : ℕ) (_ : 0 < n), (teichmuller p r).coeff n = 0
-- Mathlib/Data/Matroid/Map.lean
/-- `M.restrictSubtype M.E` is isomorphic to `M`. -/
lemma map_val_restrictSubtype_ground_eq (M : Matroid α) :
    (M.restrictSubtype M.E).map (↑) Subtype.val_injective.injOn = M
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- If the sign of the angle between three points is nonzero, the last two points are not
equal. -/
theorem right_ne_of_oangle_sign_ne_zero {p₁ p₂ p₃ : P} (h : (∡ p₁ p₂ p₃).sign ≠ 0) : p₃ ≠ p₂
-- Mathlib/MeasureTheory/Integral/Periodic.lean
protected theorem measure_univ : volume (Set.univ : Set UnitAddCircle) = 1
-- Mathlib/Order/Atoms/Finite.lean
theorem exists_covby_infinite_Iic_of_infinite_Iic [IsStronglyCoatomic α]
    (ha : (Set.Iic a).Infinite) (hfin : {x | x ⋖ a}.Finite) :
    ∃ b, b ⋖ a ∧ (Set.Iic b).Infinite
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
/-- The right-hand side of this equality can be parsed `star ∘ ⇑f` because of the
instance `Pi.instStarForAll`. Upon inspecting the goal, one sees `⊢ ↑(star f) = star ↑f`. -/
@[simp]
theorem coe_star (f : α →ᵇ β) : ⇑(star f) = star (⇑f)
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem gcd_mul_dvd_mul_gcd [GCDMonoid α] (k m n : α) : gcd k (m * n) ∣ gcd k m * gcd k n
-- Mathlib/Analysis/Calculus/ParametricIntegral.lean
/-- Differentiation under integral of `x ↦ ∫ F x a` at a given point `x₀`, assuming
`F x₀` is integrable, `x ↦ F x a` is locally Lipschitz on a ball around `x₀` for ae `a`
(with a ball radius independent of `a`) with integrable Lipschitz bound, and `F x` is ae-measurable
for `x` in a possibly smaller neighborhood of `x₀`. -/
theorem hasFDerivAt_integral_of_dominated_loc_of_lip {F' : α → H →L[𝕜] E}
    (ε_pos : 0 < ε) (hF_meas : ∀ᶠ x in 𝓝 x₀, AEStronglyMeasurable (F x) μ)
    (hF_int : Integrable (F x₀) μ) (hF'_meas : AEStronglyMeasurable F' μ)
    (h_lip : ∀ᵐ a ∂μ, LipschitzOnWith (Real.nnabs <| bound a) (F · a) (ball x₀ ε))
    (bound_integrable : Integrable (bound : α → ℝ) μ)
    (h_diff : ∀ᵐ a ∂μ, HasFDerivAt (F · a) (F' a) x₀) :
    Integrable F' μ ∧ HasFDerivAt (fun x ↦ ∫ a, F x a ∂μ) (∫ a, F' a ∂μ) x₀
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem conj_symm (e : α ≃ β) : e.conj.symm = e.symm.conj
-- Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean
theorem comap_eq_sup_ker_of_disjoint {p : Submodule K V} [FiniteDimensional K p] {f : V →ₗ[K] V}
    (h : ∀ x ∈ p, f x ∈ p) (h' : Disjoint p (ker f)) :
    p.comap f = p ⊔ ker f
-- Mathlib/Data/Nat/Defs.lean
/-- Two natural numbers are equal if and only if they have the same multiples. -/
lemma dvd_right_iff_eq : (∀ a : ℕ, m ∣ a ↔ n ∣ a) ↔ m = n
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- If a set of functions is uniformly equicontinuous, the same is true for its closure in *any*
topology for which evaluation at any point is continuous. Since this will be applied to
`DFunLike` types, we state it for any topological space whith a map to `β → α` satisfying the right
continuity conditions. See also `Set.UniformEquicontinuous.closure` for a more familiar statement.
-/
theorem UniformEquicontinuous.closure' {A : Set Y} {u : Y → β → α}
    (hA : UniformEquicontinuous (u ∘ (↑) : A → β → α)) (hu : Continuous u) :
    UniformEquicontinuous (u ∘ (↑) : closure A → β → α)
-- Mathlib/Data/Finsupp/Order.lean
@[simp]
theorem single_tsub : single i (a - b) = single i a - single i b
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem mk_neg [∀ i, AddGroup (β i)] {s : Finset ι} {x : ∀ i : (↑s : Set ι), β i.1} :
    mk s (-x) = -mk s x
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
lemma isRatCondKernelCDFAux_preCDF (ρ : Measure (α × ℝ)) [IsFiniteMeasure ρ] :
    IsRatCondKernelCDFAux (fun p r ↦ (preCDF ρ r p.2).toReal)
      (Kernel.const Unit ρ) (Kernel.const Unit ρ.fst)
-- Mathlib/SetTheory/Ordinal/Notation.lean
@[simp]
theorem zero_def : zero = 0
-- Mathlib/RingTheory/PolynomialAlgebra.lean
theorem matPolyEquiv_smul_one (p : R[X]) :
    matPolyEquiv (p • (1 : Matrix n n R[X])) = p.map (algebraMap R (Matrix n n R))
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[ext]
lemma rightHomology_ext {A : C} (f₁ f₂ : A ⟶ S.rightHomology)
    (h : f₁ ≫ S.rightHomologyι = f₂ ≫ S.rightHomologyι) : f₁ = f₂
-- Mathlib/Order/Filter/Germ/Basic.lean
@[elab_as_elim]
theorem inductionOn₃ (f : Germ l β) (g : Germ l γ) (h : Germ l δ)
    {p : Germ l β → Germ l γ → Germ l δ → Prop}
    (H : ∀ (f : α → β) (g : α → γ) (h : α → δ), p f g h) : p f g h
-- Mathlib/Analysis/MellinTransform.lean
theorem MellinConvergent.cpow_smul {f : ℝ → E} {s a : ℂ} :
    MellinConvergent (fun t => (t : ℂ) ^ a • f t) s ↔ MellinConvergent f (s + a)
-- Mathlib/LinearAlgebra/FreeModule/Finite/Matrix.lean
theorem card_algHom_le_finrank : Nat.card (M →ₐ[K] L) ≤ finrank K M
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.add_nat_mul_eq [Semiring α] [Ring β] (h : Antiperiodic f c) (n : ℕ) :
    f (x + n * c) = (-1) ^ n * f x
-- Mathlib/Analysis/Analytic/IsolatedZeros.lean
theorem eventually_eq_or_eventually_ne (hf : AnalyticAt 𝕜 f z₀) (hg : AnalyticAt 𝕜 g z₀) :
    (∀ᶠ z in 𝓝 z₀, f z = g z) ∨ ∀ᶠ z in 𝓝[≠] z₀, f z ≠ g z
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- Taking a product over `s : Finset α` is the same as multiplying the value on a single element
`f a` by the product of `s.erase a`.

See `Multiset.prod_map_erase` for the `Multiset` version. -/
@[to_additive "Taking a sum over `s : Finset α` is the same as adding the value on a single element
`f a` to the sum over `s.erase a`.

See `Multiset.sum_map_erase` for the `Multiset` version."]
theorem mul_prod_erase [DecidableEq α] (s : Finset α) (f : α → β) {a : α} (h : a ∈ s) :
    (f a * ∏ x ∈ s.erase a, f x) = ∏ x ∈ s, f x
-- Mathlib/Algebra/Order/Module/Defs.lean
@[gcongr] lemma smul_lt_smul_of_pos_right [SMulPosStrictMono α β] (ha : a₁ < a₂) (hb : 0 < b) :
    a₁ • b < a₂ • b
-- Mathlib/Logic/Basic.lean
theorem of_not_imp : ¬(a → b) → a
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
theorem X_pow_sub_one_mul_prod_cyclotomic_eq_X_pow_sub_one_of_dvd (R) [CommRing R] {d n : ℕ}
    (h : d ∈ n.properDivisors) :
    ((X ^ d - 1) * ∏ x ∈ n.divisors \ d.divisors, cyclotomic x R) = X ^ n - 1
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[simp]
lemma Scheme.iso_inv_val_base_hom_val_base_apply {X Y : Scheme.{u}} (e : X ≅ Y) (y : Y) :
    (e.hom.val.base (e.inv.val.base y)) = y
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem round_zero : round (0 : α) = 0
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem one_nonempty : (1 : Set α).Nonempty
-- Mathlib/Probability/Kernel/MeasurableIntegral.lean
theorem _root_.Measurable.lintegral_kernel_prod_right' {f : α × β → ℝ≥0∞} (hf : Measurable f) :
    Measurable fun a => ∫⁻ b, f (a, b) ∂κ a
-- Mathlib/Analysis/PSeries.lean
theorem sum_Ioc_inv_sq_le_sub {k n : ℕ} (hk : k ≠ 0) (h : k ≤ n) :
    (∑ i ∈ Ioc k n, ((i : α) ^ 2)⁻¹) ≤ (k : α)⁻¹ - (n : α)⁻¹
-- Mathlib/RingTheory/Coalgebra/Hom.lean
@[simp]
theorem coe_id : ⇑(CoalgHom.id R A) = id
-- Mathlib/Data/Nat/Bits.lean
lemma bodd_two : bodd 2 = false
-- Mathlib/CategoryTheory/Bicategory/NaturalTransformation/Strong.lean
/-- Vertical composition of strong natural transformations. -/
@[simps!]
def vcomp (η : StrongOplaxNatTrans F G) (θ : StrongOplaxNatTrans G H) : StrongOplaxNatTrans F H
-- .lake/packages/lean4/src/lean/Init/Omega/LinearCombo.lean
theorem sub_eq_add_neg (l₁ l₂ : LinearCombo) : l₁ - l₂ = l₁ + -l₂
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem isCycleOn_of_subsingleton [Subsingleton α] (f : Perm α) (s : Set α) : f.IsCycleOn s
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem generateFrom_singleton_empty : generateFrom {∅} = (⊥ : MeasurableSpace α)
-- Mathlib/Topology/Constructions.lean
lemma continuous_bool_rng [TopologicalSpace X] {f : X → Bool} (b : Bool) :
    Continuous f ↔ IsClopen (f ⁻¹' {b})
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_const_mul_pow_atTop (hn : n ≠ 0) (hc : 0 < c) :
    Tendsto (fun x => c * x ^ n) atTop atTop
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem HasFiniteFPowerSeriesOnBall.mk' {f : E → F} {p : FormalMultilinearSeries 𝕜 E F} {x : E}
    {n : ℕ} {r : ℝ≥0∞} (finite : ∀ (m : ℕ), n ≤ m → p m = 0) (pos : 0 < r)
    (sum_eq : ∀ y ∈ EMetric.ball 0 r, (∑ i ∈ Finset.range n, p i fun _ ↦ y) = f (x + y)) :
    HasFiniteFPowerSeriesOnBall f p x n r
-- Mathlib/Algebra/Module/Equiv/Defs.lean
@[ext]
theorem ext (h : ∀ x, e x = e' x) : e = e'
-- Mathlib/Algebra/Order/Sub/Defs.lean
/-- See `add_tsub_cancel_left` for the equality if `ContravariantClass α α (+) (≤)`. -/
theorem add_tsub_le_left : a + b - a ≤ b
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
@[simp]
lemma cfc_const_zero : cfc (fun _ : R ↦ 0) a = 0
-- Mathlib/Algebra/Field/Basic.lean
protected theorem Commute.inv_sub_inv (hab : Commute a b) (ha : a ≠ 0) (hb : b ≠ 0) :
    a⁻¹ - b⁻¹ = (b - a) / (a * b)
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- ε-δ characterization of uniform continuity on pseudoemetric spaces -/
theorem uniformContinuous_iff [PseudoEMetricSpace β] {f : α → β} :
    UniformContinuous f ↔ ∀ ε > 0, ∃ δ > 0, ∀ {a b : α}, edist a b < δ → edist (f a) (f b) < ε
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
/-- Converse to the mean value inequality: if `f` is differentiable at `x₀` and `C`-lipschitz
on a neighborhood of `x₀` then its derivative at `x₀` has norm bounded by `C`. -/
theorem HasDerivAt.le_of_lipschitzOn {f : 𝕜 → F} {f' : F} {x₀ : 𝕜} (hf : HasDerivAt f f' x₀)
    {s : Set 𝕜} (hs : s ∈ 𝓝 x₀) {C : ℝ≥0} (hlip : LipschitzOnWith C f s) : ‖f'‖ ≤ C
-- Mathlib/Probability/Kernel/Composition.lean
theorem comp_apply (η : Kernel β γ) (κ : Kernel α β) (a : α) : (η ∘ₖ κ) a = (κ a).bind η
-- Mathlib/CategoryTheory/Subterminal.lean
/-- If `A` is subterminal, its diagonal morphism is an isomorphism.
The converse of `isSubterminal_of_isIso_diag`.
-/
theorem IsSubterminal.isIso_diag (hA : IsSubterminal A) [HasBinaryProduct A A] : IsIso (diag A)
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
theorem surj (f : LocalizationMap S N) (z : N) : ∃ x : M × S, z * f.toMap x.2 = f.toMap x.1
-- Mathlib/Analysis/MeanInequalitiesPow.lean
theorem rpow_add_rpow_le_add {p : ℝ} (a b : ℝ≥0) (hp1 : 1 ≤ p) :
    (a ^ p + b ^ p) ^ (1 / p) ≤ a + b
-- Mathlib/RingTheory/Polynomial/Nilpotent.lean
@[simp] lemma isNilpotent_reverse_iff :
    IsNilpotent P.reverse ↔ IsNilpotent P
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem lsubtypeDomain_apply (f : α →₀ M) :
    (lsubtypeDomain s : (α →₀ M) →ₗ[R] s →₀ M) f = subtypeDomain (fun x => x ∈ s) f
-- Mathlib/Probability/Kernel/Composition.lean
theorem ae_null_of_compProd_null (h : (κ ⊗ₖ η) a s = 0) :
    (fun b => η (a, b) (Prod.mk b ⁻¹' s)) =ᵐ[κ a] 0
-- Mathlib/CategoryTheory/Sites/Grothendieck.lean
theorem transitive (hS : S ∈ J X) (R : Sieve X) (h : ∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄, S f → R.pullback f ∈ J Y) :
    R ∈ J X
-- Mathlib/Data/Set/Image.lean
theorem image_symmDiff (hf : Injective f) (s t : Set α) : f '' s ∆ t = (f '' s) ∆ (f '' t)
-- Mathlib/Data/Fin/SuccPred.lean
@[simp]
theorem pred_apply {n : ℕ} (a : Fin (n + 1)) : PredOrder.pred a = if a = 0 then 0 else a - 1
-- Mathlib/Order/Interval/Set/ProjIcc.lean
theorem monotone_projIcc : Monotone (projIcc a b h)
-- Mathlib/NumberTheory/Divisors.lean
theorem mem_properDivisors_prime_pow {p : ℕ} (pp : p.Prime) (k : ℕ) {x : ℕ} :
    x ∈ properDivisors (p ^ k) ↔ ∃ (j : ℕ) (_ : j < k), x = p ^ j
-- Mathlib/Algebra/Polynomial/Basic.lean
/-- `X` commutes with everything, even when the coefficients are noncommutative. -/
theorem X_mul : X * p = p * X
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[to_additive (attr := simp, norm_cast)]
lemma coe_div_coe [SetLike S G] [DivisionMonoid G] [SubgroupClass S G] (H : S) :
    H / H = (H : Set G)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The definition of `vectorSpan`, for rewriting. -/
theorem vectorSpan_def (s : Set P) : vectorSpan k s = Submodule.span k (s -ᵥ s)
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
theorem ne_zero_of_lt (h : b < a) : a ≠ 0
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem liftEquiv_apply : liftEquiv M i p j = lift i j p
-- Mathlib/Analysis/Convex/Function.lean
/-- For a function on a convex set in a linearly ordered space (where the order and the algebraic
structures aren't necessarily compatible), in order to prove that it is convex, it suffices to
verify the inequality `f (a • x + b • y) ≤ a • f x + b • f y` only for `x < y` and positive `a`,
`b`. The main use case is `E = 𝕜` however one can apply it, e.g., to `𝕜^n` with lexicographic order.
-/
theorem LinearOrder.convexOn_of_lt (hs : Convex 𝕜 s)
    (hf : ∀ ⦃x⦄, x ∈ s → ∀ ⦃y⦄, y ∈ s → x < y → ∀ ⦃a b : 𝕜⦄, 0 < a → 0 < b → a + b = 1 →
      f (a • x + b • y) ≤ a • f x + b • f y) :
    ConvexOn 𝕜 s f
-- Mathlib/Algebra/Homology/ShortComplex/Linear.lean
@[simp]
lemma leftHomologyMap'_smul :
    leftHomologyMap' (a • φ) h₁ h₂ = a • leftHomologyMap' φ h₁ h₂
-- Mathlib/RingTheory/OreLocalization/Ring.lean
protected theorem mul_inv_cancel (x : R[R⁰⁻¹]) (h : x ≠ 0) : x * x⁻¹ = 1
-- Mathlib/Topology/Semicontinuous.lean
theorem ContinuousAt.comp_upperSemicontinuousAt_antitone {g : γ → δ} {f : α → γ}
    (hg : ContinuousAt g (f x)) (hf : UpperSemicontinuousAt f x) (gmon : Antitone g) :
    LowerSemicontinuousAt (g ∘ f) x
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
@[simp]
theorem log_zero : log 0 = 0
-- Mathlib/Topology/Instances/AddCircle.lean
theorem coe_nsmul {n : ℕ} {x : 𝕜} : (↑(n • x) : AddCircle p) = n • (x : AddCircle p)
-- Mathlib/RingTheory/Localization/Basic.lean
@[simps]
instance invertible_mk'_one (s : M) : Invertible (IsLocalization.mk' S (1 : R) s)
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
/-- A weaker version of `Matrix.adjugate_adjugate` that uses `Nontrivial`. -/
theorem adjugate_adjugate' (A : Matrix n n α) [Nontrivial n] :
    adjugate (adjugate A) = det A ^ (Fintype.card n - 2) • A
-- Mathlib/Analysis/Convex/EGauge.lean
lemma div_le_egauge_ball (r : ℝ≥0) (x : E) : ‖x‖₊ / r ≤ egauge 𝕜 (ball 0 r) x
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- The determinant of `rotation` (as a linear equiv) is equal to `1`. -/
@[simp]
theorem linearEquiv_det_rotation (θ : Real.Angle) :
    LinearEquiv.det (o.rotation θ).toLinearEquiv = 1
-- Mathlib/RepresentationTheory/Rep.lean
/-- Porting note: if we generate this with `@[simps]` the linter complains some types in the LHS
simplify. -/
theorem homEquiv_symm_apply_hom (f : B ⟶ (Rep.ihom A).obj C) :
    ((homEquiv A B C).symm f).hom = TensorProduct.uncurry k A B C f.hom.flip
-- Mathlib/LinearAlgebra/Alternating/DomCoprod.lean
@[simp]
theorem domCoprod'_apply (a : Mᵢ [⋀^ιa]→ₗ[R'] N₁) (b : Mᵢ [⋀^ιb]→ₗ[R'] N₂) :
    domCoprod' (a ⊗ₜ[R'] b) = domCoprod a b
-- Mathlib/Algebra/Lie/Weights/Basic.lean
lemma weightSpace_le_weightSpaceOf (x : L) (χ : L → R) :
    weightSpace M χ ≤ weightSpaceOf M (χ x) x
-- Mathlib/Algebra/Homology/HomologicalBicomplex.lean
/-- Constructor for bicomplexes taking as inputs a graded object, horizontal differentials
and vertical differentials satisfying suitable relations. -/
@[simps]
def ofGradedObject :
    HomologicalComplex₂ C c₁ c₂
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem coe_range : (f.range : Set N) = Set.range f
-- Mathlib/Algebra/Order/Pointwise.lean
@[to_additive]
theorem csSup_inv (hs₀ : s.Nonempty) (hs₁ : BddBelow s) : sSup s⁻¹ = (sInf s)⁻¹
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem tropEquiv_symm_coe_fn : (tropEquiv.symm : Tropical R → R) = untrop
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
/-- Shiftright on successor with division moved inside. -/
theorem shiftRight_succ_inside : ∀m n, m >>> (n+1) = (m/2) >>> n
-- Mathlib/Topology/Order/MonotoneConvergence.lean
theorem tendsto_atBot_ciInf (h_mono : Monotone f) (hbdd : BddBelow <| range f) :
    Tendsto f atBot (𝓝 (⨅ i, f i))
-- Mathlib/Data/Real/Hyperreal.lean
nonrec theorem Infinitesimal.mul {x y : ℝ*} (hx : Infinitesimal x) (hy : Infinitesimal y) :
    Infinitesimal (x * y)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_mono {f g : R → R} {a : A} (h : ∀ x ∈ spectrum R a, f x ≤ g x)
    (hf : ContinuousOn f (spectrum R a) := by cfc_cont_tac)
    (hg : ContinuousOn g (spectrum R a) := by cfc_cont_tac) :
    cfc f a ≤ cfc g a
-- Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean
theorem integrableOn_Ioi_rpow_iff {s t : ℝ} (ht : 0 < t) :
    IntegrableOn (fun x ↦ x ^ s) (Ioi t) ↔ s < -1
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
/-- The conditional cdf tends to 0 at -∞ for all `a : α`. -/
theorem tendsto_condCDF_atBot (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCDF ρ a) atBot (𝓝 0)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem eval_mem {p : MvPolynomial σ S} {s : subS} (hs : ∀ i ∈ p.support, p.coeff i ∈ s) {v : σ → S}
    (hv : ∀ i, v i ∈ s) : MvPolynomial.eval v p ∈ s
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive (attr := simp)]
theorem mk'_self' (y : S) : f.mk' (y : M) y = 1
-- Mathlib/Data/Ordmap/Ordset.lean
theorem eraseMin.valid : ∀ {t}, @Valid α _ t → Valid (eraseMin t)
-- Mathlib/Algebra/Order/UpperLower.lean
@[to_additive]
private theorem one_mul (s : UpperSet α) : 1 * s = s
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
lemma coe_neg (z : Cocycle F G n) :
    (↑(-z) : Cochain F G n) = -(z : Cochain F G n)
-- Mathlib/Algebra/Module/Equiv/Basic.lean
@[simp]
theorem restrictScalars_inj (f g : M ≃ₗ[S] M₂) :
    f.restrictScalars R = g.restrictScalars R ↔ f = g
-- Mathlib/Data/Complex/Basic.lean
@[simp] lemma I_ne_zero : (I : ℂ) ≠ 0
-- Mathlib/Order/Lattice.lean
theorem inf_eq_min : a ⊓ b = min a b
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem of_map_of_injective [MonoidHomClass F M N] (h : IsPrimitiveRoot (f ζ) k)
    (hf : Injective f) : IsPrimitiveRoot ζ k
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atTop_of_add_const_left (C : β) (hf : Tendsto (fun x => C + f x) l atTop) :
    Tendsto f l atTop
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- To prove a property of a product, it suffices to prove that
the property is multiplicative and holds on factors. -/
@[to_additive "To prove a property of a sum, it suffices to prove that
the property is additive and holds on summands."]
theorem prod_induction_nonempty {M : Type*} [CommMonoid M] (f : α → M) (p : M → Prop)
    (hom : ∀ a b, p a → p b → p (a * b)) (nonempty : s.Nonempty) (base : ∀ x ∈ s, p <| f x) :
    p <| ∏ x ∈ s, f x