ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Probability/CondCount.lean
theorem condCount_of_univ (hs : s.Finite) (hs' : s.Nonempty) : condCount s Set.univ = 1
-- Mathlib/Algebra/Ring/BooleanRing.lean
theorem ofBoolAlg_inj {a b : AsBoolAlg α} : ofBoolAlg a = ofBoolAlg b ↔ a = b
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
theorem ofDual_inf [SemilatticeSup α] [OrderBot α] (s : Finset β) (f : β → αᵒᵈ) :
    ofDual (s.inf f) = s.sup (ofDual ∘ f)
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem nodup_coe_iff {l : List α} : Nodup (l : Cycle α) ↔ l.Nodup
-- Mathlib/NumberTheory/Primorial.lean
theorem primorial_add_dvd {m n : ℕ} (h : n ≤ m) : (m + n)# ∣ m# * choose (m + n) m
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
theorem alternatization_apply_apply (v : ι → M) :
    alternatization f v = ∑ σ : Equiv.Perm ι, Equiv.Perm.sign σ • f (v ∘ σ)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem Lp.norm_const_le : ‖Lp.const p μ c‖ ≤ ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)
-- Mathlib/Algebra/RingQuot.lean
private irreducible_def sub {R : Type uR} [Ring R] (r : R → R → Prop) :
  RingQuot r → RingQuot r → RingQuot r
-- Mathlib/Logic/Function/Iterate.lean
theorem iterate_add (m : ℕ) : ∀ n : ℕ, f^[m + n] = f^[m] ∘ f^[n]
-- Mathlib/Data/Fin/Basic.lean
protected lemma le_of_eq (hab : a = b) : a ≤ b
-- Mathlib/SetTheory/Game/Basic.lean
@[simp]
theorem quot_neg_mul (x y : PGame) : (⟦-x * y⟧ : Game) = -⟦x * y⟧
-- Mathlib/Data/Set/Function.lean
protected lemma LeftInvOn.extendDomain (h : LeftInvOn g₁ g₂ s) :
    LeftInvOn (g₁.extendDomain f) (g₂.extendDomain f) ((↑) ∘ f '' s)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
@[simp]
theorem coe_map (s : AffineSubspace k P₁) : (s.map f : Set P₂) = f '' s
-- Mathlib/Topology/StoneCech.lean
lemma eq_if_stoneCechUnit_eq {a b : α} {f : α → β} (hcf : Continuous f)
    (h : stoneCechUnit a = stoneCechUnit b) : f a = f b
-- Mathlib/LinearAlgebra/Matrix/SchurComplement.lean
@[simp]
theorem det_fromBlocks_one₂₂ (A : Matrix m m α) (B : Matrix m n α) (C : Matrix n m α) :
    (Matrix.fromBlocks A B C 1).det = det (A - B * C)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
@[simp]
theorem inner_zero_left (x : E) : ⟪0, x⟫ = 0
-- Mathlib/GroupTheory/Subgroup/Simple.lean
/-- An `AddGroup` is simple when it has exactly two normal `AddSubgroup`s. -/
class IsSimpleAddGroup extends Nontrivial A : Prop where
  /-- Any normal additive subgroup is either `⊥` or `⊤` -/
  eq_bot_or_eq_top_of_normal : ∀ H : AddSubgroup A, H.Normal → H = ⊥ ∨ H = ⊤
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem DifferentiableOn.add (hf : DifferentiableOn 𝕜 f s) (hg : DifferentiableOn 𝕜 g s) :
    DifferentiableOn 𝕜 (fun y => f y + g y) s
-- Mathlib/Analysis/RCLike/Basic.lean
theorem norm_sq_eq_def {z : K} : ‖z‖ ^ 2 = re z * re z + im z * im z
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Instances.lean
@[simp] theorem run_throw [Monad m] : run (throw e : ExceptT ε m β) = pure (Except.error e)
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- If `M` and `N` are linearly disjoint, if `M` is flat, then for any submodule `N'` of `N`,
`M` and `N'` are also linearly disjoint. -/
theorem of_le_right_of_flat (H : M.LinearDisjoint N) {N' : Submodule R S}
    (h : N' ≤ N) [Module.Flat R M] : M.LinearDisjoint N'
-- Mathlib/Algebra/Group/Semiconj/Units.lean
@[to_additive]
theorem units_of_val {a x y : Mˣ} (h : SemiconjBy (a : M) x y) : SemiconjBy a x y
-- Mathlib/Data/Finset/SMulAntidiagonal.lean
@[to_additive]
theorem smulAntidiagonal_mono_right {a : P} {hs : s.IsPWO} {ht : t.IsPWO} (h : v ⊆ t) :
    SMulAntidiagonal hs hv a ⊆ SMulAntidiagonal hs ht a
-- Mathlib/Computability/Primrec.lean
theorem _root_.PrimrecPred.or {p q : α → Prop} [DecidablePred p] [DecidablePred q]
    (hp : PrimrecPred p) (hq : PrimrecPred q) : PrimrecPred fun a => p a ∨ q a
-- Mathlib/Data/Matroid/Map.lean
lemma map_image_base_iff {hf} {B : Set α} (hB : B ⊆ M.E) :
    (M.map f hf).Base (f '' B) ↔ M.Base B
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
theorem fderivWithin_fst {s : Set (E × F)} (hs : UniqueDiffWithinAt 𝕜 s p) :
    fderivWithin 𝕜 Prod.fst s p = fst 𝕜 E F
-- Mathlib/Analysis/BoxIntegral/Partition/Filter.lean
@[mono]
theorem toFilter_mono (I : Box ι) {l₁ l₂ : IntegrationParams} (h : l₁ ≤ l₂) :
    l₁.toFilter I ≤ l₂.toFilter I
-- Mathlib/Data/Finset/NAry.lean
lemma inf_image₂_left (g : γ → δ) : inf (image₂ f s t) g = inf s fun x ↦ inf t (g ∘ f x)
-- Mathlib/Probability/Independence/Basic.lean
theorem iIndepSet_iff_meas_biInter {f : ι → Set Ω} (hf : ∀ i, MeasurableSet (f i)) :
    iIndepSet f μ ↔ ∀ s, μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i)
-- Mathlib/Order/WellFoundedSet.lean
theorem PartiallyWellOrderedOn.union (hs : s.PartiallyWellOrderedOn r)
    (ht : t.PartiallyWellOrderedOn r) : (s ∪ t).PartiallyWellOrderedOn r
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem toAffineIsometryEquiv_toAffineIsometry :
    e.toAffineIsometryEquiv.toAffineIsometry = e.toLinearIsometry.toAffineIsometry
-- Mathlib/RingTheory/Discriminant.lean
/-- If `b` is a basis of a finite separable field extension `L/K`, then `Algebra.discr K b ≠ 0`. -/
theorem discr_not_zero_of_basis [Algebra.IsSeparable K L] (b : Basis ι K L) :
    discr K b ≠ 0
-- Mathlib/Data/PNat/Xgcd.lean
theorem gcdA'_coe : (gcdA' a b : ℕ) = gcdW a b + gcdX a b
-- Mathlib/Order/Closure.lean
theorem not_mem_of_not_mem_closure {s : Set β} {P : β} (hP : P ∉ l s) : P ∉ s
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
@[simp] lemma dual_uIcc (a b : α) : [[toDual a, toDual b]] = ofDual ⁻¹' [[a, b]]
-- Mathlib/Geometry/Euclidean/MongePoint.lean
/-- `mongePointVSubFaceCentroidWeightsWithCircumcenter` sums to 0. -/
@[simp]
theorem sum_mongePointVSubFaceCentroidWeightsWithCircumcenter {n : ℕ} {i₁ i₂ : Fin (n + 3)}
    (h : i₁ ≠ i₂) : ∑ i, mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ i = 0
-- Mathlib/Data/Finset/Basic.lean
theorem empty_ssubset_singleton : (∅ : Finset α) ⊂ {a}
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isLittleO_norm_norm : ((fun x => ‖f' x‖) =o[l] fun x => ‖g' x‖) ↔ f' =o[l] g'
-- Mathlib/Data/Matroid/Map.lean
lemma comapOn_base_iff :
    (N.comapOn E f).Base B ↔ N.Basis' (f '' B) (f '' E) ∧ B.InjOn f ∧ B ⊆ E
-- Mathlib/RingTheory/Coalgebra/Hom.lean
/-- Identity map as a `CoalgHom`. -/
@[simps!] protected def id : A →ₗc[R] A
-- Mathlib/Topology/Sequences.lean
theorem IsSeqCompact.exists_tendsto_of_frequently_mem (hs : IsSeqCompact s) {u : ℕ → X}
    (hu : ∃ᶠ n in atTop, u n ∈ s) (huc : CauchySeq u) : ∃ x ∈ s, Tendsto u atTop (𝓝 x)
-- Mathlib/Analysis/Convolution.lean
theorem AEStronglyMeasurable.convolution_integrand_swap_snd
    (hf : AEStronglyMeasurable f μ) (hg : AEStronglyMeasurable g μ) (x : G) :
    AEStronglyMeasurable (fun t => L (f (x - t)) (g t)) μ
-- Mathlib/Analysis/NormedSpace/Pointwise.lean
/-- Any closed ball `Metric.closedBall x r`, `0 ≤ r` is the image of the unit closed ball under
`fun y ↦ x + r • y`. -/
theorem affinity_unitClosedBall {r : ℝ} (hr : 0 ≤ r) (x : E) :
    x +ᵥ r • closedBall (0 : E) 1 = closedBall x r
-- Mathlib/Logic/Encodable/Basic.lean
@[simp]
theorem down_eq_down {a b : α} : down a = down b ↔ a = b
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem mul_div_mul_comm : a * b / (c * d) = a / c * (b / d)
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive indicator_diff']
theorem mulIndicator_diff (h : s ⊆ t) (f : α → G) :
    mulIndicator (t \ s) f = mulIndicator t f * (mulIndicator s f)⁻¹
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem coe_trans (h₁ : M ≃ₘ^n⟮I, I'⟯ M') (h₂ : M' ≃ₘ^n⟮I', J⟯ N) : ⇑(h₁.trans h₂) = h₂ ∘ h₁
-- Mathlib/Analysis/Calculus/Deriv/ZPow.lean
theorem differentiableWithinAt_zpow (m : ℤ) (x : 𝕜) (h : x ≠ 0 ∨ 0 ≤ m) :
    DifferentiableWithinAt 𝕜 (fun x => x ^ m) s x
-- Mathlib/Order/Filter/Basic.lean
@[simp] theorem comap_inf : comap m (g₁ ⊓ g₂) = comap m g₁ ⊓ comap m g₂
-- Mathlib/RingTheory/Bialgebra/Equiv.lean
theorem toEquiv_injective : Function.Injective (toEquiv : (A ≃ₐc[R] B) → A ≃ B)
-- Mathlib/CategoryTheory/Limits/Types.lean
theorem isLimit_iff_bijective_sectionOfCone (c : Cone F) :
    Nonempty (IsLimit c) ↔ (Types.sectionOfCone c).Bijective
-- Mathlib/Algebra/Exact.lean
lemma Exact.iff_of_ladder_linearEquiv
    (h₁₂ : g₁₂ ∘ₗ e₁ = e₂ ∘ₗ f₁₂) (h₂₃ : g₂₃ ∘ₗ e₂ = e₃ ∘ₗ f₂₃) :
    Exact g₁₂ g₂₃ ↔ Exact f₁₂ f₂₃
-- Mathlib/Data/Fintype/Card.lean
/-- Construct an equivalence from functions that are inverse to each other. -/
@[simps]
def ofRightInverseOfCardLE (hαβ : card α ≤ card β) (f : α → β) (g : β → α) (h : RightInverse g f) :
    α ≃ β
-- Mathlib/RingTheory/OreLocalization/Basic.lean
@[to_additive (attr := simp)]
protected theorem mul_cancel {r : R} {s t : S} : ((s : R) /ₒ t) * (r /ₒ s) = r /ₒ t
-- Mathlib/SetTheory/Game/Basic.lean
theorem quot_mul_comm (x y : PGame.{u}) : (⟦x * y⟧ : Game) = ⟦y * x⟧
-- Mathlib/Algebra/Module/Submodule/Basic.lean
protected theorem neg_mem_iff : -x ∈ p ↔ x ∈ p
-- Mathlib/Data/Nat/Find.lean
lemma find_add {hₘ : ∃ m, p (m + n)} {hₙ : ∃ n, p n} (hn : n ≤ Nat.find hₙ) :
    Nat.find hₘ + n = Nat.find hₙ
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Mod.lean
@[simp 1100]
theorem mod_mul_right_mod (a b c : Nat) : a % (b * c) % b = a % b
-- Mathlib/Data/Sym/Basic.lean
@[simp, norm_cast]
theorem coe_inj {s₁ s₂ : Sym α n} : (s₁ : Multiset α) = s₂ ↔ s₁ = s₂
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
@[simp] -- Porting note (#10618): was @[simp]
theorem integral_comp_mul_right (hc : c ≠ 0) :
    (∫ x in a..b, f (x * c)) = c⁻¹ • ∫ x in a * c..b * c, f x
-- Mathlib/Analysis/Normed/Module/WeakDual.lean
@[simp]
theorem coe_toWeakDual (x' : Dual 𝕜 E) : toWeakDual x' = x'
-- Mathlib/Algebra/Lie/Submodule.lean
theorem injective_incl : Function.Injective N.incl
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[simp]
theorem sin_pi_over_two_pow_succ (n : ℕ) :
    sin (π / 2 ^ (n + 2)) = √(2 - sqrtTwoAddSeries 0 n) / 2
-- Mathlib/Algebra/Group/Semiconj/Units.lean
@[to_additive (attr := simp)]
theorem units_inv_symm_left_iff {a : Mˣ} {x y : M} : SemiconjBy (↑a⁻¹) y x ↔ SemiconjBy (↑a) x y
-- Mathlib/Data/Nat/Prime/Defs.lean
theorem not_prime_mul' {a b n : ℕ} (h : a * b = n) (h₁ : a ≠ 1) (h₂ : b ≠ 1) : ¬Prime n
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem castSucc_one {n : Nat} : castSucc (1 : Fin (n + 2)) = 1
-- Mathlib/Data/Finset/Sort.lean
@[simp]
theorem sort_toFinset [DecidableEq α] (s : Finset α) : (sort r s).toFinset = s
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem toList_eq_nil {s : Multiset α} : s.toList = [] ↔ s = 0
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp] theorem domCongr_symm (e : G ≃* H) : (domCongr k A e).symm = domCongr k A e.symm
-- Mathlib/Algebra/ContinuedFractions/Computation/TerminatesIffRat.lean
/-- Every finite convergent corresponds to a rational number. -/
theorem exists_rat_eq_nth_conv : ∃ q : ℚ, (of v).convs n = (q : K)
-- Mathlib/AlgebraicGeometry/Scheme.lean
lemma Spec.map_app (U) :
    (Spec.map f).app U = StructureSheaf.comap f U (Spec.map f ⁻¹ᵁ U) le_rfl
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[reassoc (attr := simp)]
theorem limit.w (F : J ⥤ C) [HasLimit F] {j j' : J} (f : j ⟶ j') :
    limit.π F j ≫ F.map f = limit.π F j'
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
@[reassoc (attr := simp)]
theorem Fork.IsLimit.lift_ι {s t : Fork f g} (hs : IsLimit s) : hs.lift t ≫ s.ι = t.ι
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
theorem snd_map_prod_mk {X : α → β} {Y : α → γ} {μ : Measure α} (hX : Measurable X) :
    (μ.map fun a => (X a, Y a)).snd = μ.map Y
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
@[mono]
theorem restrict_mono {π₁ π₂ : Prepartition I} (Hle : π₁ ≤ π₂) : π₁.restrict J ≤ π₂.restrict J
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
/-- Given an alternating map `f` in `n+1` variables, split the first variable to obtain
a linear map into alternating maps in `n` variables, given by `x ↦ (m ↦ f (Matrix.vecCons x m))`.
It can be thought of as a map $Hom(\bigwedge^{n+1} M, N) \to Hom(M, Hom(\bigwedge^n M, N))$.

This is `MultilinearMap.curryLeft` for `AlternatingMap`. See also
`AlternatingMap.curryLeftLinearMap`. -/
@[simps]
def curryLeft {n : ℕ} (f : M'' [⋀^Fin n.succ]→ₗ[R'] N'') :
    M'' →ₗ[R'] M'' [⋀^Fin n]→ₗ[R'] N''
-- Mathlib/NumberTheory/MulChar/Basic.lean
@[simp]
theorem equivToUnitHom_symm_coe (f : Rˣ →* R'ˣ) (a : Rˣ) : equivToUnitHom.symm f ↑a = f a
-- Mathlib/RingTheory/Multiplicity.lean
theorem eq_of_associated_right {a b c : α} (h : Associated b c) :
    multiplicity a b = multiplicity a c
-- Mathlib/FieldTheory/IsAlgClosed/Basic.lean
/-- Less general version of `lift`. -/
private noncomputable irreducible_def lift_aux : L →ₐ[K] M
-- Mathlib/GroupTheory/Perm/List.lean
theorem formPerm_eq_self_of_not_mem (l : List α) (x : α) (h : x ∉ l) : formPerm l x = x
-- Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean
@[simp]
protected theorem zero : expNegInvGlue 0 = 0
-- Mathlib/Topology/Instances/Real.lean
@[simp]
theorem Real.cobounded_eq : cobounded ℝ = atBot ⊔ atTop
-- Mathlib/Algebra/Ring/Subsemiring/MulOpposite.lean
/-- Pull a subsemiring back to an opposite subsemiring along `MulOpposite.unop` -/
@[simps toSubmonoid]
protected def op (S : Subsemiring R) : Subsemiring Rᵐᵒᵖ
-- Mathlib/Data/Nat/Defs.lean
/-- Two natural numbers are equal if and only if they have the same divisors. -/
lemma dvd_left_iff_eq : (∀ a : ℕ, a ∣ m ↔ a ∣ n) ↔ m = n
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem subgroupOf_eq_top {H K : Subgroup G} : H.subgroupOf K = ⊤ ↔ K ≤ H
-- Mathlib/Topology/Order/IsLUB.lean
theorem IsGLB.isGLB_of_tendsto [Preorder γ] [TopologicalSpace γ] [OrderClosedTopology γ] {f : α → γ}
    {s : Set α} {a : α} {b : γ} (hf : MonotoneOn f s) :
    IsGLB s a → s.Nonempty → Tendsto f (𝓝[s] a) (𝓝 b) → IsGLB (f '' s) b
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem ker_incl : I.incl.ker = ⊥
-- Mathlib/Topology/ContinuousFunction/Polynomial.lean
theorem polynomialFunctions.starClosure_le_equalizer {A : Type*} [StarRing R] [ContinuousStar R]
    [Semiring A] [StarRing A] [Algebra R A] (s : Set R) (φ ψ : C(s, R) →⋆ₐ[R] A)
    (h : φ (toContinuousMapOnAlgHom s X) = ψ (toContinuousMapOnAlgHom s X)) :
    (polynomialFunctions s).starClosure ≤ StarAlgHom.equalizer φ ψ
-- Mathlib/Order/Disjoint.lean
theorem Disjoint.inf_left (h : Disjoint a b) : Disjoint (a ⊓ c) b
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem neg_fuzzy_neg_iff {x y : PGame} : -x ‖ -y ↔ x ‖ y
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem cauchySeq_iff_tendsto [Nonempty β] [SemilatticeSup β] {u : β → α} :
    CauchySeq u ↔ Tendsto (Prod.map u u) atTop (𝓤 α)
-- Mathlib/Data/Finmap.lean
theorem insert_union {a} {b : β a} {s₁ s₂ : Finmap β} : insert a b (s₁ ∪ s₂) = insert a b s₁ ∪ s₂
-- Mathlib/Order/Interval/Set/Pi.lean
theorem image_update_uIcc_left (f : ∀ i, α i) (i : ι) (a : α i) :
    update f i '' uIcc a (f i) = uIcc (update f i a) f
-- Mathlib/Data/Finset/Basic.lean
theorem filter_comm (s : Finset α) : (s.filter p).filter q = (s.filter q).filter p
-- Mathlib/CategoryTheory/Functor/Category.lean
theorem id_hcomp_app {H : E ⥤ C} (α : F ⟶ G) (X : E) : (𝟙 H ◫ α).app X = α.app _
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem ofNat_comp (n : ℕ) [n.AtLeastTwo] : (no_index (OfNat.ofNat n) : R[X]).comp p = n
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atTop_atBot [Nonempty α] [SemilatticeSup α] [Preorder β] {f : α → β} :
    Tendsto f atTop atBot ↔ ∀ b : β, ∃ i : α, ∀ a : α, i ≤ a → f a ≤ b
-- Mathlib/Data/Nat/Factorization/Defs.lean
/-- For coprime `a` and `b`, the power of `p` in `a * b` is the sum of the powers in `a` and `b` -/
theorem factorization_mul_apply_of_coprime {p a b : ℕ} (hab : Coprime a b) :
    (a * b).factorization p = a.factorization p + b.factorization p
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem lift.unique {g : M ⊗[R] N →ₗ[R] P} (H : ∀ x y, g (x ⊗ₜ y) = f x y) : g = lift f
-- Mathlib/Data/List/Basic.lean
theorem ext_get?' {l₁ l₂ : List α} (h' : ∀ n < max l₁.length l₂.length, l₁.get? n = l₂.get? n) :
    l₁ = l₂
-- Mathlib/Data/List/Dedup.lean
theorem dedup_eq_self {l : List α} : dedup l = l ↔ Nodup l
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- The product of a strictly antitone function and an antitone function is strictly antitone. -/
@[to_additive add_antitone "The sum of a strictly antitone function and an antitone function is
strictly antitone."]
theorem StrictAntiOn.mul_antitone' (hf : StrictAntiOn f s) (hg : AntitoneOn g s) :
    StrictAntiOn (fun x => f x * g x) s
-- Mathlib/Data/Matroid/Dual.lean
@[simp] theorem dual_ground : M✶.E = M.E
-- Mathlib/Data/Finset/Card.lean
@[elab_as_elim]
theorem case_strong_induction_on [DecidableEq α] {p : Finset α → Prop} (s : Finset α) (h₀ : p ∅)
    (h₁ : ∀ a s, a ∉ s → (∀ t ⊆ s, p t) → p (insert a s)) : p s
-- Mathlib/CategoryTheory/Comma/Presheaf.lean
/-- This lemma will be key to establishing good simp normal forms. -/
lemma map_mkPrecomp_eqToHom {F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v} {X Y : C} {f : X ⟶ Y}
    {g g' : yoneda.obj Y ⟶ A} (h : g = g') {x : F.obj (op (CostructuredArrow.mk g'))} :
    F.map (CostructuredArrow.mkPrecomp g f).op (F.map (eqToHom (by rw [h])) x) =
      F.map (eqToHom (by rw [h])) (F.map (CostructuredArrow.mkPrecomp g' f).op x)
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
theorem continuous_testAgainstNN_eval (f : Ω →ᵇ ℝ≥0) :
    Continuous fun μ : ProbabilityMeasure Ω => μ.toFiniteMeasure.testAgainstNN f
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := simp)]
theorem isUnit_iff_singleton : IsUnit s ↔ ∃ a, s = {a}
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[simp]
theorem coe_inf (p p' : NonUnitalSubring R) :
    ((p ⊓ p' : NonUnitalSubring R) : Set R) = (p : Set R) ∩ p'
-- Mathlib/RingTheory/IntegralClosure/IsIntegral/Basic.lean
theorem IsIntegral.map {B C F : Type*} [Ring B] [Ring C] [Algebra R B] [Algebra A B] [Algebra R C]
    [IsScalarTower R A B] [Algebra A C] [IsScalarTower R A C] {b : B}
    [FunLike F B C] [AlgHomClass F A B C] (f : F)
    (hb : IsIntegral R b) : IsIntegral R (f b)
-- Mathlib/GroupTheory/Exponent.lean
@[to_additive AddMonoid.one_lt_exponent]
lemma one_lt_exponent [Nontrivial G] : 1 < Monoid.exponent G
-- Mathlib/Order/Hom/Lattice.lean
lemma toFun_eq_coe (f : SupBotHom α β) : f.toFun = f
-- Mathlib/NumberTheory/Divisors.lean
theorem divisors_prime_pow {p : ℕ} (pp : p.Prime) (k : ℕ) :
    divisors (p ^ k) = (Finset.range (k + 1)).map ⟨(p ^ ·), Nat.pow_right_injective pp.two_le⟩
-- Mathlib/Data/Nat/Nth.lean
@[simp]
theorem count_nth_zero : count p (nth p 0) = 0
-- Mathlib/Data/Set/Lattice.lean
theorem iInter₂_comm (s : ∀ i₁, κ₁ i₁ → ∀ i₂, κ₂ i₂ → Set α) :
    ⋂ (i₁) (j₁) (i₂) (j₂), s i₁ j₁ i₂ j₂ = ⋂ (i₂) (j₂) (i₁) (j₁), s i₁ j₁ i₂ j₂
-- Mathlib/AlgebraicGeometry/StructureSheaf.lean
theorem res_const' (f g : R) (V hv) :
    (structureSheaf R).1.map (homOfLE hv).op (const R f g (PrimeSpectrum.basicOpen g) fun _ => id) =
      const R f g V hv
-- Mathlib/Order/Bounds/Basic.lean
@[simp]
theorem isLeast_bot_iff [OrderBot α] : IsLeast s ⊥ ↔ ⊥ ∈ s
-- Mathlib/Data/Num/Lemmas.lean
theorem pred_to_nat {n : PosNum} (h : 1 < n) : (pred n : ℕ) = Nat.pred n
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addX_neg {P : Fin 3 → R} (hP : W'.Equation P) : W'.addX P (W'.neg P) = W'.dblZ P ^ 2
-- Mathlib/CategoryTheory/EffectiveEpi/Preserves.lean
/--
A class describing the property of reflecting finite effective epimorphic families.
-/
class ReflectsFiniteEffectiveEpiFamilies (F : C ⥤ D) : Prop where
  /--
  A functor reflects finite effective epimorphic families if finite families that are
  mapped to effective epimorphic families are themselves effective epimorphic families.
  -/
  reflects : ∀ {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B)),
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a)) →
    EffectiveEpiFamily X π
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
theorem continuousAt_const_cpow' {a b : ℂ} (h : b ≠ 0) : ContinuousAt (fun x : ℂ => a ^ x) b
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem PseudoMetricSpace.replaceUniformity_eq {α} [U : UniformSpace α] (m : PseudoMetricSpace α)
    (H : 𝓤[U] = 𝓤[PseudoEMetricSpace.toUniformSpace]) : m.replaceUniformity H = m
-- Mathlib/Analysis/Convex/Side.lean
theorem isPreconnected_setOf_wSameSide (s : AffineSubspace ℝ P) (x : P) :
    IsPreconnected { y | s.WSameSide x y }
-- Mathlib/Topology/Homotopy/Equiv.lean
theorem symm_trans (h₁ : X ≃ₕ Y) (h₂ : Y ≃ₕ Z) : (h₁.trans h₂).symm = h₂.symm.trans h₁.symm
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
/-- The splitting of the short complex `S.op` deduced from a splitting of `S`. -/
@[simps]
def op (h : Splitting S) : Splitting S.op
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean
/-- The degree of `cyclotomic' n R` is `totient n` if there is a primitive root of unity in `R`. -/
theorem degree_cyclotomic' {ζ : R} {n : ℕ} (h : IsPrimitiveRoot ζ n) :
    (cyclotomic' n R).degree = Nat.totient n
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem Iic_eq_Icc : Iic = Icc (⊥ : α)
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem pairwiseDisjoint_pi {ι' α : ι → Type*} {s : ∀ i, Set (ι' i)} {f : ∀ i, ι' i → Set (α i)}
    (hs : ∀ i, (s i).PairwiseDisjoint (f i)) :
    ((univ : Set ι).pi s).PairwiseDisjoint fun I => (univ : Set ι).pi fun i => f _ (I i)
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem canonicalEquiv_trans_canonicalEquiv (P'' : Type*) [CommRing P''] [Algebra R P'']
    [IsLocalization S P''] :
    (canonicalEquiv S P P').trans (canonicalEquiv S P' P'') = canonicalEquiv S P P''
-- Mathlib/Order/Heyting/Basic.lean
theorem Codisjoint.himp_eq_left (h : Codisjoint a b) : a ⇨ b = b
-- Mathlib/RingTheory/Ideal/Maps.lean
@[simp]
theorem ker_coe_equiv (f : R ≃+* S) : ker (f : R →+* S) = ⊥
-- Mathlib/CategoryTheory/Limits/Opposites.lean
theorem op_fst {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
    c.op.fst = c.inl.op
-- Mathlib/NumberTheory/MulChar/Basic.lean
/-- If `χ` is of odd order, then `χ(-1) = 1` -/
lemma val_neg_one_eq_one_of_odd_order {χ : MulChar R R'} {n : ℕ} (hn : Odd n) (hχ : χ ^ n = 1) :
    χ (-1) = 1
-- Mathlib/CategoryTheory/Galois/Prorepresentability.lean
@[simp]
lemma incl_map {A B : PointedGaloisObject F} (f : A ⟶ B) : (incl F).map f = f.val
-- Mathlib/Analysis/BoxIntegral/Partition/Filter.lean
theorem hasBasis_toFilteriUnion (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
    (l.toFilteriUnion I π₀).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c))
      fun r => { π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.iUnion = π₀.iUnion }
-- Mathlib/Analysis/Normed/Group/Basic.lean
theorem ennnorm_eq_ofReal_abs (r : ℝ) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal |r|
-- Mathlib/Algebra/Ring/BooleanRing.lean
theorem inf_sup_self (a b : α) : a ⊓ (a ⊔ b) = a
-- Mathlib/FieldTheory/IsAlgClosed/Basic.lean
/-- A (random) homomorphism from an algebraic extension of R into an algebraically
  closed extension of R. -/
noncomputable irreducible_def lift : S →ₐ[R] M
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive sub_one_nsmul_add]
lemma mul_pow_sub_one (hn : n ≠ 0) (a : M) : a * a ^ (n - 1) = a ^ n
-- Mathlib/Topology/ContinuousOn.lean
theorem nhdsWithin_eq_nhdsWithin {a : α} {s t u : Set α} (h₀ : a ∈ s) (h₁ : IsOpen s)
    (h₂ : t ∩ s = u ∩ s) : 𝓝[t] a = 𝓝[u] a
-- Mathlib/MeasureTheory/PiSystem.lean
theorem isPiSystem_iUnion_of_directed_le {α ι} (p : ι → Set (Set α))
    (hp_pi : ∀ n, IsPiSystem (p n)) (hp_directed : Directed (· ≤ ·) p) :
    IsPiSystem (⋃ n, p n)
-- Mathlib/Analysis/NormedSpace/Pointwise.lean
theorem ball_sub_closedBall (hε : 0 < ε) (hδ : 0 ≤ δ) (a b : E) :
    ball a ε - closedBall b δ = ball (a - b) (ε + δ)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
@[simp]
theorem range_arctan : range arctan = Ioo (-(π / 2)) (π / 2)
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem derivative_C_mul_X (a : R) : derivative (C a * X) = C a
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean
theorem condexp_nonneg {E} [NormedLatticeAddCommGroup E] [CompleteSpace E] [NormedSpace ℝ E]
    [OrderedSMul ℝ E] {f : α → E} (hf : 0 ≤ᵐ[μ] f) : 0 ≤ᵐ[μ] μ[f|m]