ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Subperm.antisymm {l₁ l₂ : List α} (h₁ : l₁ <+~ l₂) (h₂ : l₂ <+~ l₁) : l₁ ~ l₂
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Adding a multiple of the second vector passed to `oangle` to the first vector does not change
the sign of the angle. -/
@[simp]
theorem oangle_sign_add_smul_left (x y : V) (r : ℝ) :
    (o.oangle (x + r • y) y).sign = (o.oangle x y).sign
-- Mathlib/Algebra/Order/Group/MinMax.lean
@[to_additive (attr := simp)]
theorem max_one_div_max_inv_one_eq_self (a : α) : max a 1 / max a⁻¹ 1 = a
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `f` tends to infinity along a nontrivial filter,
`fun x ↦ r * f x` tends to negative infinity if and only if `r < 0. `-/
theorem tendsto_const_mul_atBot_iff_neg [NeBot l] (h : Tendsto f l atTop) :
    Tendsto (fun x => r * f x) l atBot ↔ r < 0
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
theorem IsCompact.measurableSet [T2Space α] (h : IsCompact s) : MeasurableSet s
-- Mathlib/CategoryTheory/Adjunction/Unique.lean
@[reassoc (attr := simp)]
theorem rightAdjointUniq_trans_app {F : C ⥤ D} {G G' G'' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G')
    (adj3 : F ⊣ G'') (x : D) :
    (rightAdjointUniq adj1 adj2).hom.app x ≫ (rightAdjointUniq adj2 adj3).hom.app x =
      (rightAdjointUniq adj1 adj3).hom.app x
-- Mathlib/Algebra/Star/Order.lean
theorem conjugate_lt_conjugate {a b : R} (hab : a < b) {c : R} (hc : IsRegular c) :
    star c * a * c < star c * b * c
-- Mathlib/Data/Matrix/PEquiv.lean
theorem toPEquiv_mul_matrix [Fintype m] [DecidableEq m] [Semiring α] (f : m ≃ m)
    (M : Matrix m n α) : f.toPEquiv.toMatrix * M = M.submatrix f id
-- Mathlib/RingTheory/PolynomialAlgebra.lean
@[simp]
theorem toFunLinear_tmul_apply (a : A) (p : R[X]) :
    toFunLinear R A (a ⊗ₜ[R] p) = toFunBilinear R A a p
-- Mathlib/GroupTheory/Complement.lean
@[to_additive]
theorem mk''_toEquiv (hS : S ∈ Subgroup.leftTransversals (H : Set G)) (q : G ⧸ H) :
    Quotient.mk'' (toEquiv hS q : G) = q
-- Mathlib/CategoryTheory/Sites/LocallyInjective.lean
lemma isLocallyInjective_of_isLocallyInjective [IsLocallyInjective J (φ ≫ ψ)] :
    IsLocallyInjective J φ
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
theorem LinearIsometry.map_orthogonalProjection' {E E' : Type*} [NormedAddCommGroup E]
    [NormedAddCommGroup E'] [InnerProductSpace 𝕜 E] [InnerProductSpace 𝕜 E'] (f : E →ₗᵢ[𝕜] E')
    (p : Submodule 𝕜 E) [HasOrthogonalProjection p] [HasOrthogonalProjection (p.map f)] (x : E) :
    f (orthogonalProjection p x) = orthogonalProjection (p.map f) (f x)
-- Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Basic.lean
@[simp]
theorem BinaryFan.swap_fst {P Q : C} (t : BinaryFan P Q) : t.swap.fst = t.snd
-- Mathlib/Order/Interval/Set/Image.lean
lemma StrictMono.mapsTo_Ioi (h : StrictMono f) : MapsTo f (Ioi a) (Ioi (f a))
-- Mathlib/Topology/Algebra/Module/Star.lean
/-- The skew-adjoint part of an element of a star module, as a continuous linear map. -/
@[simps!]
def skewAdjointPartL [ContinuousSub A] [ContinuousStar A] [ContinuousConstSMul R A] :
    A →L[R] skewAdjoint A
-- Mathlib/Probability/Kernel/Composition.lean
theorem comp_apply' (η : Kernel β γ) (κ : Kernel α β) (a : α) {s : Set γ} (hs : MeasurableSet s) :
    (η ∘ₖ κ) a s = ∫⁻ b, η b s ∂κ a
-- Mathlib/Algebra/Order/Group/Abs.lean
theorem abs_min_le_max_abs_abs : |min a b| ≤ max |a| |b|
-- Mathlib/Order/Category/BddDistLat.lean
@[simp]
theorem coe_toBddLat (X : BddDistLat) : ↥X.toBddLat = ↥X
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem coe_toLinearMap : ⇑f.toLinearMap = f
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean
@[simp]
theorem cospanCompIso_app_left : (cospanCompIso F f g).app WalkingCospan.left = Iso.refl _
-- Mathlib/Dynamics/PeriodicPts.lean
@[to_additive]
lemma isPeriodicPt_smul_iff {m : M} {a : α} {n : ℕ} :
    IsPeriodicPt (m • ·) n a ↔ m ^ n • a = a
-- Mathlib/Algebra/Polynomial/Derivation.lean
@[simp]
theorem mkDerivation_X (a : A) : mkDerivation R a X = a
-- Mathlib/CategoryTheory/Monoidal/End.lean
/-- Tensoring on the right gives a monoidal functor from `C` into endofunctors of `C`.
-/
@[simps!]
def tensoringRightMonoidal [MonoidalCategory.{v} C] : MonoidalFunctor C (C ⥤ C)
-- Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean
@[to_additive]
theorem le_mul_left (h : a ≤ c) : a ≤ b * c
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
protected lemma UniformContinuous.dist [UniformSpace β] {f g : β → α} (hf : UniformContinuous f)
    (hg : UniformContinuous g) : UniformContinuous fun b => dist (f b) (g b)
-- Mathlib/Logic/Equiv/Basic.lean
theorem prodUnique_apply [Unique β] (x : α × β) : prodUnique α β x = x.1
-- Mathlib/Algebra/Group/Action/Prod.lean
@[to_additive (attr := simp)] lemma smul_fst : (a • x).1 = a • x.1
-- Mathlib/Data/Multiset/Basic.lean
@[simp, norm_cast]
theorem coe_toList (s : Multiset α) : (s.toList : Multiset α) = s
-- Mathlib/Algebra/Order/Interval/Set/Monoid.lean
theorem Ioc_add_bij : BijOn (· + d) (Ioc a b) (Ioc (a + d) (b + d))
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
@[simp]
theorem innerSLFlip_apply (x y : E) : innerSLFlip 𝕜 x y = ⟪y, x⟫
-- Mathlib/Data/Semiquot.lean
theorem IsPure.mono {s t : Semiquot α} (st : s ≤ t) (h : IsPure t) : IsPure s
-- Mathlib/Analysis/Convex/Complex.lean
theorem convex_halfspace_im_lt (r : ℝ) : Convex ℝ { c : ℂ | c.im < r }
-- Mathlib/SetTheory/Game/Birthday.lean
theorem birthday_nat_add (n : ℕ) : (↑n + a).birthday = a.birthday + n
-- Mathlib/InformationTheory/Hamming.lean
/-- Corresponds to `zero_eq_dist`. -/
@[simp]
theorem hamming_zero_eq_dist {x y : ∀ i, β i} : 0 = hammingDist x y ↔ x = y
-- Mathlib/Algebra/Homology/HomotopyCategory/Shift.lean
@[simp]
lemma mapHomologicalComplex_commShiftIso_inv_app_f (K : CochainComplex C ℤ) (n i : ℤ) :
    (((F.mapHomologicalComplex (ComplexShape.up ℤ)).commShiftIso n).inv.app K).f i = 𝟙 _
-- Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean
private theorem eq_singularPart' (t : SignedMeasure α) {f : α → ℝ} (hf : Measurable f)
    (hfi : Integrable f μ) (htμ : t ⟂ᵥ μ.toENNRealVectorMeasure) (hadd : s = t + μ.withDensityᵥ f) :
    t = s.singularPart μ
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[simp]
theorem mem_map {f : F} {s : NonUnitalSubring R} {y : S} : y ∈ s.map f ↔ ∃ x ∈ s, f x = y
-- Mathlib/Analysis/BoxIntegral/Basic.lean
/-- A function `f` has Henstock (or `⊥`) integral over `I` is equal to the value of a box-additive
function `g` on `I` provided that `vol J (f x)` is sufficiently close to `g J` for sufficiently
small boxes `J ∋ x`. This lemma is useful to prove, e.g., to prove the Divergence theorem for
integral along `⊥`.

Let `l` be either `BoxIntegral.IntegrationParams.Henstock` or `⊥`. Let `g` a box-additive function
on subboxes of `I`. Suppose that there exists a nonnegative box-additive function `B` and a
countable set `s` with the following property.

For every `c : ℝ≥0`, a point `x ∈ I.Icc`, and a positive `ε` there exists `δ > 0` such that for any
box `J ≤ I` such that

- `x ∈ J.Icc ⊆ Metric.closedBall x δ`;
- if `l.bDistortion` (i.e., `l = ⊥`), then the distortion of `J` is less than or equal to `c`,

the distance between the term `vol J (f x)` of an integral sum corresponding to `J` and `g J` is
less than or equal to `ε` if `x ∈ s` and is less than or equal to `ε * B J` otherwise.

Then `f` is integrable on `I` along `l` with integral `g I`. -/
theorem HasIntegral.of_le_Henstock_of_forall_isLittleO (hl : l ≤ Henstock) (B : ι →ᵇᵃ[I] ℝ)
    (hB0 : ∀ J, 0 ≤ B J) (g : ι →ᵇᵃ[I] F) (s : Set ℝⁿ) (hs : s.Countable)
    (H₁ : ∀ (c : ℝ≥0), ∀ x ∈ Box.Icc I ∩ s, ∀ ε > (0 : ℝ),
      ∃ δ > 0, ∀ J ≤ I, Box.Icc J ⊆ Metric.closedBall x δ → x ∈ Box.Icc J →
        (l.bDistortion → J.distortion ≤ c) → dist (vol J (f x)) (g J) ≤ ε)
    (H₂ : ∀ (c : ℝ≥0), ∀ x ∈ Box.Icc I \ s, ∀ ε > (0 : ℝ),
      ∃ δ > 0, ∀ J ≤ I, Box.Icc J ⊆ Metric.closedBall x δ → x ∈ Box.Icc J →
        (l.bDistortion → J.distortion ≤ c) → dist (vol J (f x)) (g J) ≤ ε * B J) :
    HasIntegral I l f vol (g I)
-- Mathlib/CategoryTheory/IsConnected.lean
/-- If any functor to a discrete category is constant on objects, J is connected.
The converse of `any_functor_const_on_obj`.
-/
theorem IsPreconnected.of_any_functor_const_on_obj
    (h : ∀ {α : Type u₁} (F : J ⥤ Discrete α), ∀ j j' : J, F.obj j = F.obj j') :
    IsPreconnected J
-- Mathlib/CategoryTheory/Whiskering.lean
@[simp]
theorem isoWhiskerLeft_inv (F : C ⥤ D) {G H : D ⥤ E} (α : G ≅ H) :
    (isoWhiskerLeft F α).inv = whiskerLeft F α.inv
-- Mathlib/CategoryTheory/Idempotents/Basic.lean
/-- A category is idempotent complete iff for all idempotent endomorphisms,
the equalizer of the identity and this idempotent exists. -/
theorem isIdempotentComplete_iff_hasEqualizer_of_id_and_idempotent :
    IsIdempotentComplete C ↔ ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p
-- Mathlib/Order/Bounded.lean
theorem bounded_ge_Ici [Preorder α] (a : α) : Bounded (· ≥ ·) (Ici a)
-- Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean
/-- Auxiliary lemma for `betaIntegral_convergent`, showing convergence at the left endpoint. -/
theorem betaIntegral_convergent_left {u : ℂ} (hu : 0 < re u) (v : ℂ) :
    IntervalIntegrable (fun x =>
      (x : ℂ) ^ (u - 1) * (1 - (x : ℂ)) ^ (v - 1) : ℝ → ℂ) volume 0 (1 / 2)
-- Mathlib/Init/Logic.lean
theorem or_false_iff : p ∨ False ↔ p
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem mul_inv_eq_iff_eq_mul : a * b⁻¹ = c ↔ a = c * b
-- Mathlib/LinearAlgebra/CrossProduct.lean
/-- The scalar quadruple product identity, related to the Binet-Cauchy identity. -/
theorem cross_dot_cross (u v w x : Fin 3 → R) :
    u ×₃ v ⬝ᵥ w ×₃ x = u ⬝ᵥ w * v ⬝ᵥ x - u ⬝ᵥ x * v ⬝ᵥ w
-- Mathlib/Order/Fin/Basic.lean
/-- A function `f` on `Fin (n + 1)` is antitone if and only if `f (i + 1) ≤ f i` for all `i`. -/
lemma antitone_iff_succ_le : Antitone f ↔ ∀ i : Fin n, f i.succ ≤ f (castSucc i)
-- Mathlib/LinearAlgebra/Matrix/SchurComplement.lean
/-- LDU decomposition of a block matrix with an invertible bottom-right corner, using the
Schur complement. -/
theorem fromBlocks_eq_of_invertible₂₂ (A : Matrix l m α) (B : Matrix l n α) (C : Matrix n m α)
    (D : Matrix n n α) [Invertible D] :
    fromBlocks A B C D =
      fromBlocks 1 (B * ⅟ D) 0 1 * fromBlocks (A - B * ⅟ D * C) 0 0 D *
        fromBlocks 1 0 (⅟ D * C) 1
-- Mathlib/Algebra/Group/Commute/Defs.lean
@[to_additive] lemma mul_pow (h : Commute a b) : ∀ n, (a * b) ^ n = a ^ n * b ^ n
-- Mathlib/Algebra/Group/Semiconj/Units.lean
/-- `a` semiconjugates `x` to `a * x * a⁻¹`. -/
@[to_additive "`a` semiconjugates `x` to `a + x + -a`."]
lemma mk_semiconjBy (u : Mˣ) (x : M) : SemiconjBy (↑u) x (u * x * ↑u⁻¹)
-- Mathlib/RingTheory/Coalgebra/Hom.lean
@[simp]
theorem counitCoalgHom_toLinearMap :
    counitCoalgHom R A = counit (R := R) (A := A)
-- Mathlib/Algebra/BigOperators/Ring.lean
@[simp, norm_cast]
lemma cast_multiset_prod {R : Type*} [CommRing R] (s : Multiset ℤ) :
    (↑s.prod : R) = (s.map (↑)).prod
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem corec_eq (f : β → Option (α × β)) (b : β) :
    destruct (corec f b) = omap (corec f) (f b)
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
theorem subalgebra_top_rank_eq_submodule_top_rank :
    Module.rank F (⊤ : Subalgebra F E) = Module.rank F (⊤ : Submodule F E)
-- Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean
lemma _root_.IsIntegralClosure.of_isIntegrallyClosedIn
    [Algebra R B] [Algebra A B] [IsScalarTower R A B]
    [IsIntegrallyClosedIn A B] [Algebra.IsIntegral R A] :
    IsIntegralClosure A R B
-- Mathlib/Algebra/Polynomial/Derivative.lean
@[simp]
theorem derivative_natCast {n : ℕ} : derivative (n : R[X]) = 0
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
protected theorem MDifferentiableWithinAt.mfderivWithin (h : MDifferentiableWithinAt I I' f s x) :
    mfderivWithin I I' f s x =
      fderivWithin 𝕜 (writtenInExtChartAt I I' x f : _) ((extChartAt I x).symm ⁻¹' s ∩ range I)
        ((extChartAt I x) x)
-- Mathlib/Topology/Order.lean
theorem gc_coinduced_induced (f : α → β) :
    GaloisConnection (TopologicalSpace.coinduced f) (TopologicalSpace.induced f)
-- Mathlib/Logic/Equiv/TransferInstance.lean
@[to_additive]
theorem one_def [One β] :
    letI := e.one
    1 = e.symm 1
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
@[ext]
theorem ext {c1 c2 : NumDenSameDeg 𝒜 x} (hdeg : c1.deg = c2.deg) (hnum : (c1.num : A) = c2.num)
    (hden : (c1.den : A) = c2.den) : c1 = c2
-- Mathlib/Algebra/Divisibility/Basic.lean
theorem MulHom.map_dvd [Semigroup M] [Semigroup N] (f : M →ₙ* N) {a b} : a ∣ b → f a ∣ f b
-- Mathlib/Topology/Homotopy/Basic.lean
/-- Post-compose a homotopy relative to a set by a continuous function. -/
@[simps!] def compContinuousMap {f₀ f₁ : C(X, Y)} (F : f₀.HomotopyRel f₁ S) (g : C(Y, Z)) :
    (g.comp f₀).HomotopyRel (g.comp f₁) S
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem toInt_inj (x y : BitVec n) : x.toInt = y.toInt ↔ x = y
-- Mathlib/Logic/IsEmpty.lean
@[simp]
theorem isEmpty_Prop {p : Prop} : IsEmpty p ↔ ¬p
-- Mathlib/Order/Filter/Cocardinal.lean
@[simp]
theorem eventually_cocardinal {p : α → Prop} :
    (∀ᶠ x in cocardinal α hreg, p x) ↔ #{ x | ¬p x } < c
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem get?_zero (l : List α) : l.get? 0 = l.head?
-- Mathlib/RingTheory/Localization/Submodule.lean
@[mono]
theorem coeSubmodule_le_coeSubmodule (h : M ≤ nonZeroDivisors R) {I J : Ideal R} :
    coeSubmodule S I ≤ coeSubmodule S J ↔ I ≤ J
-- Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean
lemma mem_sup_right {I J : TwoSidedIdeal R} {x : R} (h : x ∈ J) :
    x ∈ I ⊔ J
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Integrable.mul_const {f : α → 𝕜} (h : Integrable f μ) (c : 𝕜) :
    Integrable (fun x => f x * c) μ
-- Mathlib/Probability/Kernel/Disintegration/Integral.lean
lemma setLIntegral_condKernel_univ_right (hf : Measurable f) {s : Set β}
    (hs : MeasurableSet s) :
    ∫⁻ b in s, ∫⁻ ω, f (b, ω) ∂(ρ.condKernel b) ∂ρ.fst
      = ∫⁻ x in s ×ˢ Set.univ, f x ∂ρ
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem mem_map_rangeS {p : S[X]} : p ∈ (mapRingHom f).rangeS ↔ ∀ n, p.coeff n ∈ f.rangeS
-- Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean
@[simp] lemma zero_lt_exp_iff {a : EReal} : 0 < exp a ↔ ⊥ < a
-- Mathlib/Algebra/Order/Ring/Abs.lean
lemma pow_eq_neg_pow_iff (hb : b ≠ 0) : a ^ n = -b ^ n ↔ a = -b ∧ Odd n
-- Mathlib/Algebra/GroupPower/IterateHom.lean
@[to_additive (attr := simp)]
theorem mul_left_iterate : (a * ·)^[n] = (a ^ n * ·)
-- Mathlib/Data/Int/Defs.lean
lemma natCast_ne_zero {n : ℕ} : (n : ℤ) ≠ 0 ↔ n ≠ 0
-- Mathlib/Data/Set/Finite.lean
theorem exists_finite_iff_finset {p : Set α → Prop} :
    (∃ s : Set α, s.Finite ∧ p s) ↔ ∃ s : Finset α, p ↑s
-- Mathlib/CategoryTheory/Shift/SingleFunctors.lean
lemma shiftIso_add'_hom_app (n m mn : A) (hnm : m + n = mn) (a a' a'' : A)
    (ha' : n + a = a') (ha'' : m + a' = a'') (X : C) :
    (F.shiftIso mn a a'' (by rw [← hnm, ← ha'', ← ha', add_assoc])).hom.app X =
      (shiftFunctorAdd' D m n mn hnm).hom.app ((F.functor a'').obj X) ≫
        ((F.shiftIso m a' a'' ha'').hom.app X)⟦n⟧' ≫ (F.shiftIso n a a' ha').hom.app X
-- Mathlib/Algebra/Module/LocalizedModuleIntegers.lean
/-- Each element `x : M'` has an `S`-multiple which is an integer. -/
theorem exists_integer_multiple (x : M') : ∃ a : S, IsInteger f (a.val • x)
-- Mathlib/Algebra/Order/Ring/Cast.lean
lemma cast_strictMono : StrictMono (fun x : ℤ => (x : R))
-- Mathlib/RingTheory/Polynomial/Basic.lean
theorem exists_irreducible_of_degree_pos {R : Type u} [CommRing R] [IsDomain R] [WfDvdMonoid R]
    {f : R[X]} (hf : 0 < f.degree) : ∃ g, Irreducible g ∧ g ∣ f
-- Mathlib/MeasureTheory/Function/SimpleFuncDense.lean
theorem edist_approxOn_y0_le {f : β → α} (hf : Measurable f) {s : Set α} {y₀ : α} (h₀ : y₀ ∈ s)
    [SeparableSpace s] (x : β) (n : ℕ) :
    edist y₀ (approxOn f hf s y₀ h₀ n x) ≤ edist y₀ (f x) + edist y₀ (f x)
-- Mathlib/Combinatorics/Colex.lean
@[simp] lemma cons_lt_cons (ha hb) : toColex (s.cons a ha) < toColex (s.cons b hb) ↔ a < b
-- Mathlib/Order/Irreducible.lean
protected theorem InfPrime.infIrred : InfPrime a → InfIrred a
-- Mathlib/Topology/Sets/Opens.lean
/-- The type of open subsets of a topological space. -/
structure Opens where
  /-- The underlying set of a bundled `TopologicalSpace.Opens` object. -/
  carrier : Set α
  /-- The `TopologicalSpace.Opens.carrier _` is an open set. -/
  is_open' : IsOpen carrier
-- Mathlib/RingTheory/Valuation/RankOne.lean
/-- If `v` is a rank one valuation, then`x : Γ₀` has image `0` under `RankOne.hom v` if and
  only if `x = 0`. -/
theorem hom_eq_zero_iff {x : Γ₀} : RankOne.hom v x = 0 ↔ x = 0
-- Mathlib/Data/Fin/Basic.lean
lemma predAbove_zero [NeZero n] {i : Fin (n + 1)} :
    predAbove (0 : Fin n) i = if hi : i = 0 then 0 else i.pred hi
-- Mathlib/Data/Finsupp/Basic.lean
theorem subtypeDomain_sum {s : Finset ι} {h : ι → α →₀ M} :
    (∑ c ∈ s, h c).subtypeDomain p = ∑ c ∈ s, (h c).subtypeDomain p
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem subNatNat_eq_coe {m n : Nat} : subNatNat m n = ↑m - ↑n
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
@[simp]
theorem toContinuousMultilinearMap_zero : (0 : M [⋀^ι]→L[R] N).toContinuousMultilinearMap = 0
-- Mathlib/LinearAlgebra/Dual.lean
@[simp]
lemma Dual.apply_one_mul_eq (f : Dual R R) (r : R) :
    f 1 * r = f r
-- Mathlib/NumberTheory/Dioph.lean
theorem const_dioph (n : ℕ) : DiophFn (const (α → ℕ) n)
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem le_of_forall_sub_le (h : ∀ ε > 0, b - ε ≤ a) : b ≤ a
-- Mathlib/Order/Basic.lean
theorem exists_between [LT α] [DenselyOrdered α] : ∀ {a₁ a₂ : α}, a₁ < a₂ → ∃ a, a₁ < a ∧ a < a₂
-- Mathlib/Order/Bounds/Basic.lean
@[simp] lemma bddBelow_preimage_ofDual {s : Set α} : BddBelow (ofDual ⁻¹' s) ↔ BddAbove s
-- Mathlib/Data/Nat/Defs.lean
lemma div_ne_zero_iff_of_dvd (hba : b ∣ a) : a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0
-- Mathlib/MeasureTheory/Measure/OpenPos.lean
theorem _root_.IsOpen.measure_eq_zero_iff (hU : IsOpen U) : μ U = 0 ↔ U = ∅
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem sub_nonpos_of_le {a b : Int} (h : a ≤ b) : a - b ≤ 0
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp] theorem assoc_toLinearEquiv :
  (Algebra.TensorProduct.assoc R A B C).toLinearEquiv = _root_.TensorProduct.assoc R A B C
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem toSignedMeasure_congr {μ ν : Measure α} [IsFiniteMeasure μ] [IsFiniteMeasure ν]
    (h : μ = ν) : μ.toSignedMeasure = ν.toSignedMeasure
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
/-- The linear map version of `Function.Injective.comp_left` -/
lemma _root_.Function.Injective.injective_linearMapComp_left (hf : Injective f) :
    Injective fun g : M₁ →ₛₗ[σ₁₂] M₂ ↦ f.comp g
-- Mathlib/Data/List/Perm.lean
theorem Perm.subset_congr_right {l₁ l₂ l₃ : List α} (h : l₁ ~ l₂) : l₃ ⊆ l₁ ↔ l₃ ⊆ l₂
-- Mathlib/Order/Hom/Basic.lean
/-- Convert an `OrderEmbedding` to an `OrderHom`. -/
@[simps (config := .asFn)]
def toOrderHom {X Y : Type*} [Preorder X] [Preorder Y] (f : X ↪o Y) : X →o Y
-- Mathlib/MeasureTheory/Constructions/Cylinders.lean
theorem measurableCylinders.measurableSet (ht : t ∈ measurableCylinders α) :
    MeasurableSet (measurableCylinders.set ht)
-- Mathlib/Order/Interval/Basic.lean
@[simp, norm_cast]
theorem coe_eq_pure : (s : Interval α) = Interval.pure a ↔ s = pure a
-- Mathlib/Topology/Algebra/Module/LinearPMap.lean
/-- If `f` is invertible and closable, then taking the closure and the inverse commute. -/
theorem inverse_closure (hf : LinearMap.ker f.toFun = ⊥) (hf' : f.IsClosable)
    (hcf : LinearMap.ker f.closure.toFun = ⊥) :
    f.inverse.closure = f.closure.inverse
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
@[to_additive]
theorem ContMDiff.div {f g : M → G} (hf : ContMDiff I' I n f) (hg : ContMDiff I' I n g) :
    ContMDiff I' I n fun x => f x / g x
-- Mathlib/Order/Hom/Basic.lean
@[simp] theorem coe_eq (f : α →o β) : OrderHomClass.toOrderHom f = f
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
@[simp]
theorem fract_fract (m : E) : fract b (fract b m) = fract b m
-- Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean
lemma nonsingular_affine_of_Z_ne_zero {P : Fin 3 → F} (h : W.Nonsingular P) (hPz : P z ≠ 0) :
    W.toAffine.Nonsingular (P x / P z) (P y / P z)
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
@[fun_prop]
theorem ContinuousOn.cexp (h : ContinuousOn f s) : ContinuousOn (fun y => exp (f y)) s
-- Mathlib/CategoryTheory/Galois/Basic.lean
/-- An epimorphism induces a surjective map on fibers. -/
lemma surjective_on_fiber_of_epi {X Y : C} (f : X ⟶ Y) [Epi f] : Function.Surjective (F.map f)
-- Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean
/-- A graph is strongly regular with parameters `n k ℓ μ` if
 * its vertex set has cardinality `n`
 * it is regular with degree `k`
 * every pair of adjacent vertices has `ℓ` common neighbors
 * every pair of nonadjacent vertices has `μ` common neighbors
-/
structure IsSRGWith (n k ℓ μ : ℕ) : Prop where
  card : Fintype.card V = n
  regular : G.IsRegularOfDegree k
  of_adj : ∀ v w : V, G.Adj v w → Fintype.card (G.commonNeighbors v w) = ℓ
  of_not_adj : Pairwise fun v w => ¬G.Adj v w → Fintype.card (G.commonNeighbors v w) = μ
-- Mathlib/Data/Fin/Tuple/Basic.lean
@[simp]
theorem insertNth_comp_succAbove (i : Fin (n + 1)) (x : β) (p : Fin n → β) :
    insertNth i x p ∘ i.succAbove = p
-- Mathlib/Analysis/Convex/Function.lean
theorem ConvexOn.lt_right_of_left_lt' (hf : ConvexOn 𝕜 s f) {x y : E} {a b : 𝕜} (hx : x ∈ s)
    (hy : y ∈ s) (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) (hfx : f x < f (a • x + b • y)) :
    f (a • x + b • y) < f y
-- Mathlib/Topology/LocallyConstant/Algebra.lean
/-- `LocallyConstant.congrRight` as a `RingEquiv`. -/
@[simps!]
def congrRightRingEquiv [Semiring Y] [Semiring Z] (e : Y ≃+* Z) :
    LocallyConstant X Y ≃+* LocallyConstant X Z
-- Mathlib/LinearAlgebra/Projectivization/Basic.lean
theorem submodule_eq (v : ℙ K V) : v.submodule = K ∙ v.rep
-- Mathlib/Combinatorics/Additive/ETransform.lean
/-- An **e-transform**. Turns `(s, t)` into `(s ∩ s • e, t ∪ e⁻¹ • t)`. This reduces the
product of the two sets. -/
@[to_additive (attr := simps) "An **e-transform**.
Turns `(s, t)` into `(s ∩ s +ᵥ e, t ∪ -e +ᵥ t)`. This reduces the sum of the two sets."]
def mulETransformLeft : Finset α × Finset α
-- Mathlib/Data/Matrix/Block.lean
@[simp]
lemma toBlocks₁₁_diagonal (v : l ⊕ m → α) :
    toBlocks₁₁ (diagonal v) = diagonal (fun i => v (Sum.inl i))
-- Mathlib/Logic/Equiv/Defs.lean
protected lemma forall_congr' (h : ∀ b, p (e.symm b) ↔ q b) : (∀ a, p a) ↔ ∀ b, q b
-- Mathlib/CategoryTheory/Galois/Basic.lean
lemma surjective_of_nonempty_fiber_of_isConnected {X A : C} [Nonempty (F.obj X)]
    [IsConnected A] (f : X ⟶ A) :
    Function.Surjective (F.map f)
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem DifferentiableOn.sum (h : ∀ i ∈ u, DifferentiableOn 𝕜 (A i) s) :
    DifferentiableOn 𝕜 (fun y => ∑ i ∈ u, A i y) s
-- Mathlib/CategoryTheory/Monoidal/Center.lean
@[ext]
theorem ext {X Y : Center C} (f g : X ⟶ Y) (w : f.f = g.f) : f = g
-- Mathlib/Topology/Maps/Basic.lean
theorem OpenEmbedding.continuous (hf : OpenEmbedding f) : Continuous f
-- Mathlib/GroupTheory/Perm/Sign.lean
/-- Like `swap_induction_on`, but with the composition on the right of `f`.

An induction principle for permutations. If `P` holds for the identity permutation, and
is preserved under composition with a non-trivial swap, then `P` holds for all permutations. -/
@[elab_as_elim]
theorem swap_induction_on' [Finite α] {P : Perm α → Prop} (f : Perm α) :
    P 1 → (∀ f x y, x ≠ y → P f → P (f * swap x y)) → P f
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem isField_of_isIntegral_of_isField' {R S : Type*} [CommRing R] [CommRing S] [IsDomain S]
    [Algebra R S] [Algebra.IsIntegral R S] (hR : IsField R) : IsField S
-- Mathlib/Algebra/Homology/BifunctorHomotopy.lean
lemma comm₁ (j : J) :
    (mapBifunctorMap f₁ f₂ F c).f j =
    (mapBifunctor K₁ K₂ F c).d j (c.next j) ≫
          mapBifunctorMapHomotopy.hom₁ h₁ f₂ F c (c.next j) j +
        mapBifunctorMapHomotopy.hom₁ h₁ f₂ F c j (c.prev j) ≫
          (mapBifunctor L₁ L₂ F c).d (c.prev j) j +
      (mapBifunctorMap f₁' f₂ F c).f j