ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/Interval/Finset/Defs.lean
@[simp, norm_cast]
theorem coe_Ico (a b : α) : (Ico a b : Set α) = Set.Ico a b
-- Mathlib/Data/Complex/Exponential.lean
theorem exp_add : exp (x + y) = exp x * exp y
-- Mathlib/Data/Fintype/Card.lean
theorem one_lt_card_iff : 1 < card α ↔ ∃ a b : α, a ≠ b
-- Mathlib/Data/Matrix/Kronecker.lean
@[simp]
theorem one_kroneckerTMul_one [DecidableEq m] [DecidableEq n] :
    (1 : Matrix m m α) ⊗ₖₜ[R] (1 : Matrix n n α) = 1
-- Mathlib/Topology/ContinuousFunction/Ideals.lean
theorem idealOfSet_ofIdeal_isClosed {I : Ideal C(X, 𝕜)} (hI : IsClosed (I : Set C(X, 𝕜))) :
    idealOfSet 𝕜 (setOfIdeal I) = I
-- Mathlib/Data/Nat/GCD/Basic.lean
@[simp]
theorem coprime_mul_right_add_right (m n k : ℕ) : Coprime m (k * m + n) ↔ Coprime m n
-- Mathlib/Algebra/Lie/Rank.lean
lemma isRegular_iff_natTrailingDegree_charpoly_eq_rank :
    IsRegular R M x ↔ (toEnd R L M x).charpoly.natTrailingDegree = rank R L M
-- Mathlib/Data/NNRat/Defs.lean
@[simp] lemma num_divNat_den (q : ℚ≥0) : divNat q.num q.den = q
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
theorem extend_iUnion_le_tsum_nat' (s : ℕ → Set α) :
    extend m (⋃ i, s i) ≤ ∑' i, extend m (s i)
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Unique.lean
/-- Let `m` be a sub-σ-algebra of `m0`, `f` an `m0`-measurable function and `g` an `m`-measurable
function, such that their integrals coincide on `m`-measurable sets with finite measure.
Then `∫ x in s, ‖g x‖ ∂μ ≤ ∫ x in s, ‖f x‖ ∂μ` on all `m`-measurable sets with finite measure. -/
theorem integral_norm_le_of_forall_fin_meas_integral_eq (hm : m ≤ m0) {f g : α → ℝ}
    (hf : StronglyMeasurable f) (hfi : IntegrableOn f s μ) (hg : StronglyMeasurable[m] g)
    (hgi : IntegrableOn g s μ)
    (hgf : ∀ t, MeasurableSet[m] t → μ t < ∞ → ∫ x in t, g x ∂μ = ∫ x in t, f x ∂μ)
    (hs : MeasurableSet[m] s) (hμs : μ s ≠ ∞) : (∫ x in s, ‖g x‖ ∂μ) ≤ ∫ x in s, ‖f x‖ ∂μ
-- Mathlib/Algebra/Group/Subgroup/Order.lean
@[simp]
theorem isCoatom_comap {H : Type*} [Group H] (f : G ≃* H) {K : Subgroup H} :
    IsCoatom (Subgroup.comap (f : G →* H) K) ↔ IsCoatom K
-- Mathlib/Analysis/Analytic/Composition.lean
@[simp]
theorem compChangeOfVariables_length (m M N : ℕ) {i : Σ n, Fin n → ℕ}
    (hi : i ∈ compPartialSumSource m M N) :
    Composition.length (compChangeOfVariables m M N i hi).2 = i.1
-- Mathlib/Data/Nat/PartENat.lean
theorem dom_of_le_some {x : PartENat} {y : ℕ} (h : x ≤ some y) : x.Dom
-- Mathlib/NumberTheory/NumberField/Units/Basic.lean
theorem NumberField.isUnit_iff_norm [NumberField K] {x : 𝓞 K} :
    IsUnit x ↔ |(RingOfIntegers.norm ℚ x : ℚ)| = 1
-- Mathlib/Data/PFunctor/Univariate/Basic.lean
@[simp]
theorem W.mk_dest (p : W P) : W.mk (W.dest p) = p
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
theorem HasLimit.mk {F : J ⥤ C} (d : LimitCone F) : HasLimit F
-- Mathlib/CategoryTheory/Bicategory/SingleObj.lean
/-- The monoidal functor from the endomorphisms of the single object
when we promote a monoidal category to a single object bicategory,
to the original monoidal category.

We subsequently show this is an equivalence.
-/
@[simps]
def endMonoidalStarFunctor : MonoidalFunctor (EndMonoidal (MonoidalSingleObj.star C)) C
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNorm_le_add_measure_right (f : α → F) (μ ν : Measure α) {p : ℝ≥0∞} :
    eLpNorm f p μ ≤ eLpNorm f p (μ + ν)
-- Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean
lemma of_isOpenImmersion [IsOpenImmersion f] : P f
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
lemma truncatedInf_union_of_not_mem (hs : a ∉ upperClosure s) (ht : a ∉ upperClosure t) :
    truncatedInf (s ∪ t) a = ⊥
-- Mathlib/Logic/Encodable/Basic.lean
@[simp]
theorem encode_star : encode PUnit.unit = 0
-- Mathlib/Algebra/Ring/Idempotents.lean
@[simp]
theorem coe_one : ↑(1 : { p : M₁ // IsIdempotentElem p }) = (1 : M₁)
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma isReal_smul_iff : IsReal (σ • w) ↔ IsReal w
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
theorem Filter.HasBasis.equicontinuousWithinAt_iff_right {p : κ → Prop}
    {s : κ → Set (α × α)} {F : ι → X → α} {S : Set X} {x₀ : X} (hα : (𝓤 α).HasBasis p s) :
    EquicontinuousWithinAt F S x₀ ↔ ∀ k, p k → ∀ᶠ x in 𝓝[S] x₀, ∀ i, (F i x₀, F i x) ∈ s k
-- Mathlib/Algebra/Ring/Subsemiring/Pointwise.lean
theorem mem_pointwise_smul_iff_inv_smul_mem {a : M} {S : Subsemiring R} {x : R} :
    x ∈ a • S ↔ a⁻¹ • x ∈ S
-- Mathlib/Data/List/Zip.lean
theorem get?_zipWith_eq_some (f : α → β → γ) (l₁ : List α) (l₂ : List β) (z : γ) (i : ℕ) :
    (zipWith f l₁ l₂).get? i = some z ↔
      ∃ x y, l₁.get? i = some x ∧ l₂.get? i = some y ∧ f x y = z
-- Mathlib/Logic/Equiv/Defs.lean
/-- `Sigma` type with a constant fiber is equivalent to the product. -/
@[simps (config := { attrs := [`mfld_simps] }) apply symm_apply]
def sigmaEquivProd (α β : Type*) : (Σ _ : α, β) ≃ α × β
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem singleton_ne_empty (a : α) : ({a} : Set α) ≠ ∅
-- Mathlib/Topology/Basic.lean
theorem Dense.interior_compl (h : Dense s) : interior sᶜ = ∅
-- Mathlib/Data/Matroid/Dual.lean
@[simp] theorem dual_base_iff (hB : B ⊆ M.E := by aesop_mat) : M✶.Base B ↔ M.Base (M.E \ B)
-- Mathlib/Analysis/LocallyConvex/Basic.lean
theorem Balanced.neg : Balanced 𝕜 s → Balanced 𝕜 (-s)
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem symm_apply_apply (e : α ≃o β) (x : α) : e.symm (e x) = x
-- Mathlib/RingTheory/Jacobson.lean
theorem comp_C_integral_of_surjective_of_jacobson {S : Type*} [Field S] (f : R[X] →+* S)
    (hf : Function.Surjective ↑f) : (f.comp C).IsIntegral
-- Mathlib/Order/CompleteLattice.lean
theorem iSup_or {p q : Prop} {s : p ∨ q → α} :
    ⨆ x, s x = (⨆ i, s (Or.inl i)) ⊔ ⨆ j, s (Or.inr j)
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
@[simp]
theorem toOrdinal_symm_eq : NatOrdinal.toOrdinal.symm = Ordinal.toNatOrdinal
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem monomial_finsupp_sum_index {α β : Type*} [Zero β] (f : α →₀ β) (g : α → β → σ →₀ ℕ)
    (a : R) : monomial (f.sum g) a = C a * f.prod fun a b => monomial (g a b) 1
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
theorem AddSubmonoid.toSubmonoid_closure (S : Set A) :
    (AddSubmonoid.toSubmonoid) (AddSubmonoid.closure S)
      = Submonoid.closure (Multiplicative.toAdd ⁻¹' S)
-- Mathlib/Algebra/Lie/Weights/Chain.lean
lemma lie_mem_weightSpaceChain_of_weightSpace_eq_bot_right [LieAlgebra.IsNilpotent R H]
    (hq : weightSpace M (q • α + χ) = ⊥)
    {x : L} (hx : x ∈ rootSpace H α)
    {y : M} (hy : y ∈ weightSpaceChain M α χ p q) :
    ⁅x, y⁆ ∈ weightSpaceChain M α χ p q
-- Mathlib/CategoryTheory/Sites/Grothendieck.lean
theorem Arrow.to_middle_condition {X : C} {S : J.Cover X} {T : ∀ I : S.Arrow, J.Cover I.Y}
    (I : (S.bind T).Arrow) : (T I.fromMiddle) I.toMiddleHom
-- Mathlib/Geometry/Manifold/IntegralCurve.lean
/-- If `γ` is an integral curve at each `t ∈ s`, it is an integral curve on `s`. -/
lemma IsIntegralCurveAt.isIntegralCurveOn (h : ∀ t ∈ s, IsIntegralCurveAt γ v t) :
    IsIntegralCurveOn γ v s
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem hasStrictDerivAt_rpow_const_of_ne {x : ℝ} (hx : x ≠ 0) (p : ℝ) :
    HasStrictDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem fastGrowing_zero' (o : ONote) (h : fundamentalSequence o = Sum.inl none) :
    fastGrowing o = Nat.succ
-- Mathlib/Data/Option/Basic.lean
theorem map_coe {α β} {a : α} {f : α → β} : f <$> (a : Option α) = ↑(f a)
-- Mathlib/FieldTheory/RatFunc/Defs.lean
theorem liftOn'_mk {P : Sort v} (p q : K[X]) (f : K[X] → K[X] → P) (f0 : ∀ p, f p 0 = f 0 1)
    (H : ∀ {p q a} (_hq : q ≠ 0) (_ha : a ≠ 0), f (a * p) (a * q) = f p q) :
    (RatFunc.mk p q).liftOn' f @H = f p q
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
@[reassoc (attr := simp)]
lemma lift_snd (hP : IsPullback fst snd f g) {W : C} (h : W ⟶ X) (k : W ⟶ Y)
    (w : h ≫ f = k ≫ g) : hP.lift h k w ≫ snd = k
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp] theorem eq_mpr_eq_cast (h : α = β) : Eq.mpr h = cast h.symm
-- Mathlib/RingTheory/Localization/Basic.lean
theorem mk'_eq_mul_mk'_one (x : R) (y : M) : mk' S x y = (algebraMap R S) x * mk' S 1 y
-- Mathlib/Data/Nat/Defs.lean
lemma succ_succ_ne_one (n : ℕ) : n.succ.succ ≠ 1
-- Mathlib/CategoryTheory/Subobject/Basic.lean
/-- An equality of subobjects gives an isomorphism of the corresponding objects. -/
@[simps]
def isoOfMkEqMk {B A₁ A₂ : C} (f : A₁ ⟶ B) (g : A₂ ⟶ B) [Mono f] [Mono g] (h : mk f = mk g) :
    A₁ ≅ A₂
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem le_of_eq_of_le {f g h : CauSeq α abs} (hfg : f ≈ g) (hgh : g ≤ h) : f ≤ h
-- Mathlib/Data/Seq/Computation.lean
theorem le_stable (s : Computation α) {a m n} (h : m ≤ n) : s.1 m = some a → s.1 n = some a
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma eq_of_mem_uIoc_of_mem_uIoc : a ∈ Ι b c → b ∈ Ι a c → a = b
-- Mathlib/SetTheory/Game/Basic.lean
theorem inv'_one_equiv : inv' 1 ≈ 1
-- Mathlib/MeasureTheory/Integral/Pi.lean
/-- On a finite product space in `n` variables, for a natural number `n`, a product of integrable
functions depending on each coordinate is integrable. -/
theorem Integrable.fin_nat_prod {n : ℕ} {E : Fin n → Type*}
    [∀ i, MeasureSpace (E i)] [∀ i, SigmaFinite (volume : Measure (E i))]
    {f : (i : Fin n) → E i → 𝕜} (hf : ∀ i, Integrable (f i)) :
    Integrable (fun (x : (i : Fin n) → E i) ↦ ∏ i, f i (x i))
-- Mathlib/RingTheory/Binomial.lean
/-- A binomial ring is a ring for which ascending Pochhammer evaluations are uniquely divisible by
suitable factorials. We define this notion as a mixin for additive commutative monoids with natural
number powers, but retain the ring name. We introduce `Ring.multichoose` as the uniquely defined
quotient. -/
class BinomialRing (R : Type*) [AddCommMonoid R] [Pow R ℕ] where
  /-- Scalar multiplication by positive integers is injective -/
  nsmul_right_injective (n : ℕ) (h : n ≠ 0) : Injective (n • · : R → R)
  /-- A multichoose function, giving the quotient of Pochhammer evaluations by factorials. -/
  multichoose : R → ℕ → R
  /-- The `n`th ascending Pochhammer polynomial evaluated at any element is divisible by `n!` -/
  factorial_nsmul_multichoose (r : R) (n : ℕ) :
    n.factorial • multichoose r n = (ascPochhammer ℕ n).smeval r
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
theorem convexBodySum_neg_mem {x : E K} (hx : x ∈ (convexBodySum K B)) :
    -x ∈ (convexBodySum K B)
-- Mathlib/Algebra/Star/StarRingHom.lean
@[simp]
theorem comp_id (f : A →⋆ₙ+* B) : f.comp (NonUnitalStarRingHom.id _) = f
-- Mathlib/GroupTheory/GroupAction/SubMulAction.lean
@[to_additive]
theorem smul_def (r : R) (x : s) : r • x = ⟨r • x, smul_mem r x.2⟩
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
theorem orderOf_dvd_card : orderOf x ∣ Fintype.card G
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma uIoc_injective_right (a : α) : Injective fun b => Ι b a
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc]
lemma whiskerLeft_whiskerLeft_associator_inv (X Y : C) {Z₁ Z₂ : C} (f : Z₁ ⟶ Z₂) :
    X ◁ Y ◁ f ≫ (α_ _ _ _).inv = (α_ _ _ _).inv ≫ _ ◁ f
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
/-- The constructed pushout cocone in the category of types. -/
@[simps!]
def cocone : PushoutCocone f g
-- Mathlib/Dynamics/BirkhoffSum/Basic.lean
theorem Function.IsFixedPt.birkhoffSum_eq {f : α → α} {x : α} (h : IsFixedPt f x) (g : α → M)
    (n : ℕ) : birkhoffSum f g n x = n • g x
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
theorem Red.enum.complete (H : Red L₁ L₂) : L₂ ∈ Red.enum L₁
-- Mathlib/Algebra/Order/Interval/Basic.lean
theorem length_add_le : ∀ s t : Interval α, (s + t).length ≤ s.length + t.length
-- Mathlib/Data/Complex/Order.lean
theorem not_le_iff {z w : ℂ} : ¬z ≤ w ↔ w.re < z.re ∨ z.im ≠ w.im
-- Mathlib/Order/SuccPred/LinearLocallyFinite.lean
theorem toZ_iterate_pred [NoMinOrder ι] (n : ℕ) : toZ i0 (pred^[n] i0) = -n
-- Mathlib/Data/Finsupp/Defs.lean
theorem neg_apply [NegZeroClass G] (g : α →₀ G) (a : α) : (-g) a = -g a
-- Mathlib/Data/List/AList.lean
theorem lookup_isSome {a : α} {s : AList β} : (s.lookup a).isSome ↔ a ∈ s
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem mul_lt_mul_of_pos_right {a b c : Int}
  (h₁ : a < b) (h₂ : 0 < c) : a * c < b * c
-- Mathlib/Order/Heyting/Basic.lean
/-- `p ∧ (p → q) ↔ p ∧ q` -/
@[simp]
theorem inf_himp (a b : α) : a ⊓ (a ⇨ b) = a ⊓ b
-- Mathlib/Order/WithBot.lean
protected theorem «exists» {p : WithTop α → Prop} : (∃ x, p x) ↔ p ⊤ ∨ ∃ x : α, p x
-- Mathlib/Analysis/Calculus/Deriv/Linear.lean
protected theorem ContinuousLinearMap.hasDerivAt : HasDerivAt e (e 1) x
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- The extended pseudodistance on a subset of a pseudoemetric space is the restriction of
the original pseudodistance, by definition -/
theorem Subtype.edist_eq {p : α → Prop} (x y : Subtype p) : edist x y = edist (x : α) y
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem symm_proj_apply (e : Pretrivialization F (π F E)) (z : TotalSpace F E)
    (hz : z.proj ∈ e.baseSet) : e.symm z.proj (e z).2 = z.2
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive] lemma mabs_sup_div_sup_le_mabs (a b c : α) : |(a ⊔ c) / (b ⊔ c)|ₘ ≤ |a / b|ₘ
-- Mathlib/Data/NNReal/Basic.lean
theorem toNNReal_lt_iff_lt_coe {r : ℝ} {p : ℝ≥0} (ha : 0 ≤ r) : Real.toNNReal r < p ↔ r < ↑p
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
lemma Group.isUnit [Group α] (a : α) : IsUnit a
-- Mathlib/CategoryTheory/Preadditive/AdditiveFunctor.lean
@[simp]
theorem AdditiveFunctor.ofRightExact_map {F G : C ⥤ᵣ D} (α : F ⟶ G) :
    (AdditiveFunctor.ofRightExact C D).map α = α
-- Mathlib/Combinatorics/Enumerative/Composition.lean
/-- When one splits a list along a composition `c`, the number of sublists thus created is
`c.length`. -/
@[simp]
theorem length_splitWrtComposition (l : List α) (c : Composition n) :
    length (l.splitWrtComposition c) = c.length
-- Mathlib/Analysis/InnerProductSpace/Orientation.lean
/-- Let `v` be an indexed family of `n` vectors in an oriented `n`-dimensional real inner
product space `E`. The output of the volume form of `E` when evaluated on `v` is bounded in absolute
value by the product of the norms of the vectors `v i`. -/
theorem abs_volumeForm_apply_le (v : Fin n → E) : |o.volumeForm v| ≤ ∏ i : Fin n, ‖v i‖
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem lt_mul_div_add (a) {b : Ordinal} (h : b ≠ 0) : a < b * (a / b) + b
-- Mathlib/Order/Filter/Germ/Basic.lean
@[simp, norm_cast]
theorem coe_ofNat [NatCast M] (n : ℕ) [n.AtLeastTwo] :
    ((no_index (OfNat.ofNat n : α → M)) : Germ l M) = OfNat.ofNat n
-- Mathlib/RepresentationTheory/Rep.lean
theorem MonoidalClosed.linearHomEquivComm_symm_hom (f : A ⟶ B ⟶[Rep k G] C) :
    ((MonoidalClosed.linearHomEquivComm A B C).symm f).hom
      = TensorProduct.uncurry k A B C f.hom
-- Mathlib/SetTheory/Surreal/Basic.lean
theorem Numeric.neg : ∀ {x : PGame} (_ : Numeric x), Numeric (-x)
-- Mathlib/Algebra/Order/Group/Abs.lean
@[simp]
theorem abs_eq_self : |a| = a ↔ 0 ≤ a
-- Mathlib/Algebra/CubicDiscriminant.lean
@[simp]
theorem natDegree_of_zero : (0 : Cubic R).toPoly.natDegree = 0
-- Mathlib/Data/Fintype/Sort.lean
@[simp]
theorem finSumEquivOfFinset_inl (hm : s.card = m) (hn : sᶜ.card = n) (i : Fin m) :
    finSumEquivOfFinset hm hn (Sum.inl i) = s.orderEmbOfFin hm i
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
@[simp, fun_prop]
theorem differentiableAt_const (c : F) : DifferentiableAt 𝕜 (fun _ => c) x
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
/-- The conditional cdf tends to 1 at +∞ for all `a : α`. -/
theorem tendsto_condCDF_atTop (ρ : Measure (α × ℝ)) (a : α) :
    Tendsto (condCDF ρ a) atTop (𝓝 1)
-- Mathlib/Topology/QuasiSeparated.lean
theorem isQuasiSeparated_univ {α : Type*} [TopologicalSpace α] [QuasiSeparatedSpace α] :
    IsQuasiSeparated (Set.univ : Set α)
-- Mathlib/LinearAlgebra/BilinearForm/Hom.lean
theorem congr_trans (e : M ≃ₗ[R] M') (f : M' ≃ₗ[R] M'') :
    (congr e).trans (congr f) = congr (e.trans f)
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem comap_iInf_map_of_injective (S : ι → Subsemigroup M) :
    (⨅ i, (S i).map f).comap f = iInf S
-- Mathlib/Data/Prod/Lex.lean
theorem toLex_strictMono : StrictMono (toLex : α × β → α ×ₗ β)
-- Mathlib/Topology/CompletelyRegular.lean
/-- A space is completely regular if points can be separated from closed sets via
  continuous functions to the unit interval. -/
@[mk_iff]
class CompletelyRegularSpace (X : Type u) [TopologicalSpace X] : Prop where
  completely_regular : ∀ (x : X), ∀ K : Set X, IsClosed K → x ∉ K →
    ∃ f : X → I, Continuous f ∧ f x = 0 ∧ EqOn f 1 K
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
/-- For an endomorphism of a Noetherian module, the maximal eigenspace is always of the form kernel
`(f - μ • id) ^ k` for some `k`. -/
theorem maxGenEigenspace_eq [h : IsNoetherian R M] (f : End R M) (μ : R) :
    maxGenEigenspace f μ =
      f.genEigenspace μ (maxGenEigenspaceIndex f μ)
-- Mathlib/Data/Rat/Defs.lean
@[simp, nolint simpNF, norm_cast] lemma natCast_eq_one {n : ℕ} : (n : ℚ) = 1 ↔ n = 1
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
lemma biproduct.whiskerEquiv_hom_eq_lift {f : J → C} {g : K → C} (e : J ≃ K)
    (w : ∀ j, g (e j) ≅ f j) [HasBiproduct f] [HasBiproduct g] :
    (biproduct.whiskerEquiv e w).hom =
      biproduct.lift fun k => biproduct.π f (e.symm k) ≫ (w _).inv ≫ eqToHom (by simp)
-- Mathlib/Algebra/FreeMonoid/Basic.lean
@[to_additive (attr := simp)]
theorem recOn_one {C : FreeMonoid α → Sort*} (h0 : C 1) (ih : ∀ x xs, C xs → C (of x * xs)) :
    @recOn α C 1 h0 ih = h0
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem range_comp (f : A →ₙₐ[R] B) (g : B →ₙₐ[R] C) :
    NonUnitalAlgHom.range (g.comp f) = (NonUnitalAlgHom.range f).map g
-- Mathlib/RingTheory/WittVector/FrobeniusFractionField.lean
theorem succNthVal_spec (n : ℕ) (a₁ a₂ : 𝕎 k) (bs : Fin (n + 1) → k) (ha₁ : a₁.coeff 0 ≠ 0)
    (ha₂ : a₂.coeff 0 ≠ 0) :
    (succNthDefiningPoly p n a₁ a₂ bs).IsRoot (succNthVal p n a₁ a₂ bs ha₁ ha₂)
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem castAdd_lt {m : Nat} (n : Nat) (i : Fin m) : (castAdd n i : Nat) < m
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp]
lemma mapDomainAlgHom_comp (k A) {G₁ G₂ G₃} [CommSemiring k] [Semiring A] [Algebra k A]
    [Monoid G₁] [Monoid G₂] [Monoid G₃] (f : G₁ →* G₂) (g : G₂ →* G₃) :
    mapDomainAlgHom k A (g.comp f) = (mapDomainAlgHom k A g).comp (mapDomainAlgHom k A f)
-- Mathlib/Data/Nat/Pairing.lean
@[simp]
theorem pair_eq_pair {a b c d : ℕ} : pair a b = pair c d ↔ a = c ∧ b = d
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The iterated derivative of the composition with a linear map on the left is
obtained by applying the linear map to the iterated derivative. -/
theorem ContinuousLinearMap.iteratedFDeriv_comp_left {f : E → F} (g : F →L[𝕜] G)
    (hf : ContDiff 𝕜 n f) (x : E) {i : ℕ} (hi : (i : ℕ∞) ≤ n) :
    iteratedFDeriv 𝕜 i (g ∘ f) x = g.compContinuousMultilinearMap (iteratedFDeriv 𝕜 i f x)
-- Mathlib/GroupTheory/GroupAction/Basic.lean
theorem Equiv.swap_mem_stabilizer {α : Type*} [DecidableEq α] {S : Set α} {a b : α} :
    Equiv.swap a b ∈ MulAction.stabilizer (Equiv.Perm α) S ↔ (a ∈ S ↔ b ∈ S)
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `E / F` is both purely inseparable and separable, then `algebraMap F E` is bijective. -/
theorem IsPurelyInseparable.bijective_algebraMap_of_isSeparable
    [IsPurelyInseparable F E] [Algebra.IsSeparable F E] : Function.Bijective (algebraMap F E)
-- Mathlib/Data/Finset/Card.lean
theorem lt_wf {α} : WellFounded (@LT.lt (Finset α) _)
-- Mathlib/Order/Interval/Set/Disjoint.lean
theorem IsGLB.biUnion_Ici_eq_Ioi (a_glb : IsGLB s a) (a_not_mem : a ∉ s) :
    ⋃ x ∈ s, Ici x = Ioi a
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive (attr := simp)]
theorem coe_srange (f : M →ₙ* N) : (f.srange : Set N) = Set.range f
-- Mathlib/Order/Bounds/Basic.lean
theorem BddAbove.dual (h : BddAbove s) : BddBelow (ofDual ⁻¹' s)
-- Mathlib/Order/UpperLower/Basic.lean
theorem isUpperSet_univ : IsUpperSet (univ : Set α)
-- Mathlib/CategoryTheory/Sums/Basic.lean
@[aesop norm -10 destruct (rule_sets := [CategoryTheory])]
theorem hom_inl_inr_false {X : C} {Y : D} (f : Sum.inl X ⟶ Sum.inr Y) : False
-- Mathlib/Data/Seq/WSeq.lean
theorem destruct_congr_iff {s t : WSeq α} :
    s ~ʷ t ↔ Computation.LiftRel (BisimO (· ~ʷ ·)) (destruct s) (destruct t)
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
theorem deriv_sub_const (c : F) : deriv (fun y => f y - c) x = deriv f x
-- Mathlib/Data/Complex/Exponential.lean
theorem sinh_add : sinh (x + y) = sinh x * cosh y + cosh x * sinh y
-- Mathlib/Topology/Algebra/ConstMulAction.lean
@[to_additive]
theorem continuous_const_smul_iff (c : G) : (Continuous fun x => c • f x) ↔ Continuous f
-- Mathlib/Topology/LocallyConstant/Basic.lean
protected theorem tfae (f : X → Y) :
    TFAE [IsLocallyConstant f,
      ∀ x, ∀ᶠ x' in 𝓝 x, f x' = f x,
      ∀ x, IsOpen { x' | f x' = f x },
      ∀ y, IsOpen (f ⁻¹' {y}),
      ∀ x, ∃ U : Set X, IsOpen U ∧ x ∈ U ∧ ∀ x' ∈ U, f x' = f x]
-- Mathlib/Analysis/BoxIntegral/Partition/SubboxInduction.lean
@[simp]
theorem distortion_unionComplToSubordinate (π₁ : TaggedPrepartition I) (π₂ : Prepartition I)
    (hU : π₂.iUnion = ↑I \ π₁.iUnion) (r : (ι → ℝ) → Ioi (0 : ℝ)) :
    (π₁.unionComplToSubordinate π₂ hU r).distortion = max π₁.distortion π₂.distortion
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
theorem coeFn_univ_ne_zero (ν : ProbabilityMeasure Ω) : ν univ ≠ 0
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
theorem nodup_toCycle (f : Perm α) (hf : IsCycle f) : (toCycle f hf).Nodup
-- Mathlib/CategoryTheory/FullSubcategory.lean
@[simp]
theorem FullSubcategory.lift_comp_inclusion_eq (F : C ⥤ D) (hF : ∀ X, P (F.obj X)) :
    FullSubcategory.lift P F hF ⋙ fullSubcategoryInclusion P = F
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem mapsTo_sUnion {S : Set (Set α)} {t : Set β} {f : α → β} :
    MapsTo f (⋃₀ S) t ↔ ∀ s ∈ S, MapsTo f s t
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem le_of_not_gt : ∀{a b : Nat}, ¬(b > a) → b ≤ a
-- Mathlib/CategoryTheory/Limits/Types.lean
theorem Colimit.ι_map_apply {F G : J ⥤ Type u} [HasColimitsOfShape J (Type u)] (α : F ⟶ G) (j : J)
    (x : F.obj j) : colim.map α (colimit.ι F j x) = colimit.ι G j (α.app j x)
-- Mathlib/Algebra/Module/LocalizedModuleIntegers.lean
lemma isInteger_zero : IsInteger f (0 : M')
-- Mathlib/Topology/Perfect.lean
/--
A topological space `X` is said to be perfect if its universe is a perfect set.
Equivalently, this means that `𝓝[≠] x ≠ ⊥` for every point `x : X`.
-/
@[mk_iff perfectSpace_def]
class PerfectSpace : Prop :=
  univ_preperfect : Preperfect (Set.univ : Set α)
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
@[gcongr]
theorem ball_subset_ball (h : ε₁ ≤ ε₂) : ball x ε₁ ⊆ ball x ε₂
-- Mathlib/RingTheory/Ideal/Basic.lean
@[simp]
theorem submodule_span_eq {s : Set α} : Submodule.span α s = Ideal.span s
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem coe_copy (f : BoundedOrderHom α β) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f'
-- Mathlib/Analysis/Complex/Basic.lean
theorem nnnorm_eq_one_of_pow_eq_one {ζ : ℂ} {n : ℕ} (h : ζ ^ n = 1) (hn : n ≠ 0) : ‖ζ‖₊ = 1
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma unit_of_mem_ofUnits_spec_mem (S : Subgroup Mˣ) {x : M} {h : x ∈ S.ofUnits} :
    S.unit_of_mem_ofUnits h ∈ S
-- Mathlib/Data/Int/Bitwise.lean
theorem one_shiftLeft (n : ℕ) : 1 <<< (n : ℤ) = (2 ^ n : ℕ)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma dblXYZ_smul (P : Fin 3 → R) (u : R) : W'.dblXYZ (u • P) = (u ^ 4) • W'.dblXYZ P
-- Mathlib/Analysis/CstarAlgebra/Matrix.lean
lemma l2_opNorm_def (A : Matrix m n 𝕜) :
    ‖A‖ = ‖(toEuclideanLin (𝕜 := 𝕜) (m := m) (n := n)).trans toContinuousLinearMap A‖
-- Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean
@[simp]
theorem alternatingFaceMapComplex_obj_X (X : SimplicialObject C) (n : ℕ) :
    ((alternatingFaceMapComplex C).obj X).X n = X _[n]
-- Mathlib/Probability/Martingale/Basic.lean
theorem condexp_ae_eq (hf : Martingale f ℱ μ) {i j : ι} (hij : i ≤ j) : μ[f j|ℱ i] =ᵐ[μ] f i
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem not_and : ¬(a ∧ b) ↔ (a → ¬b)