ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem mapIso_symm (F : C ⥤ D) {X Y : C} (i : X ≅ Y) : F.mapIso i.symm = (F.mapIso i).symm
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem DifferentiableAt.smul_const (hc : DifferentiableAt 𝕜 c x) (f : F) :
    DifferentiableAt 𝕜 (fun y => c y • f) x
-- Mathlib/RingTheory/PowerSeries/Order.lean
theorem order_finite_iff_ne_zero : (order φ).Dom ↔ φ ≠ 0
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem add_imK : (a + b).imK = a.imK + b.imK
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
theorem mem_toList_iff {y : α} : y ∈ toList p x ↔ SameCycle p x y ∧ x ∈ p.support
-- Mathlib/Data/Finset/Pointwise.lean
theorem Nonempty.zero_mul (hs : s.Nonempty) : 0 * s = 0
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem heq_of_heq_of_eq (h₁ : HEq a b) (h₂ : b = b') : HEq a b'
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem sigma_zero_apply_prime_pow {p i : ℕ} (hp : p.Prime) : σ 0 (p ^ i) = i + 1
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem self_symm_id_assoc (α : X ≅ Y) (β : X ≅ Z) : α ≪≫ α.symm ≪≫ β = β
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem round_add_ofNat (x : α) (n : ℕ) [n.AtLeastTwo] :
    round (x + (no_index (OfNat.ofNat n))) = round x + OfNat.ofNat n
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem le.dest : ∀ {n m : Nat}, n ≤ m → Exists (fun k => n + k = m)
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem extend_of_empty [IsEmpty α] (f : α ↪ δ) (g : α →ᵇ β) (h : δ →ᵇ β) : extend f g h = h
-- Mathlib/Data/Real/Basic.lean
theorem mk_neg {f : CauSeq ℚ abs} : mk (-f) = -mk f
-- Mathlib/Algebra/Polynomial/Expand.lean
theorem expand_eq_zero {p : ℕ} (hp : 0 < p) {f : R[X]} : expand R p f = 0 ↔ f = 0
-- Mathlib/Data/List/Basic.lean
@[simp] theorem length_erase_add_one {a : α} {l : List α} (h : a ∈ l) :
    (l.erase a).length + 1 = l.length
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_const_add_Ico : (fun x => a + x) ⁻¹' Ico b c = Ico (b - a) (c - a)
-- Mathlib/Topology/RestrictGenTopology.lean
protected theorem enlarge {T} (hS : RestrictGenTopology S) (hT : ∀ s ∈ S, ∃ t ∈ T, s ⊆ t) :
    RestrictGenTopology T
-- Mathlib/Analysis/Convex/Join.lean
theorem convexJoin_assoc (s t u : Set E) :
    convexJoin 𝕜 (convexJoin 𝕜 s t) u = convexJoin 𝕜 s (convexJoin 𝕜 t u)
-- Mathlib/Order/Filter/CardinalInter.lean
theorem EventuallyLE.cardinal_bUnion {S : Set ι} (hS : #S < c)
    {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi ≤ᶠ[l] t i hi) :
    ⋃ i ∈ S, s i ‹_› ≤ᶠ[l] ⋃ i ∈ S, t i ‹_›
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem mapM'_cons [Monad m] {f : α → m β} :
    mapM' f (a :: l) = return ((← f a) :: (← l.mapM' f))
-- Mathlib/MeasureTheory/Integral/Average.lean
theorem average_pair {f : α → E} {g : α → F} (hfi : Integrable f μ) (hgi : Integrable g μ) :
    ⨍ x, (f x, g x) ∂μ = (⨍ x, f x ∂μ, ⨍ x, g x ∂μ)
-- Mathlib/Topology/Algebra/InfiniteSum/Ring.lean
theorem HasSum.mul_left (a₂) (h : HasSum f a₁) : HasSum (fun i ↦ a₂ * f i) (a₂ * a₁)
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem support_smul_subset_vadd_support' [MulZeroClass R] [SMulWithZero R V] {x : HahnSeries Γ R}
    {y : HahnModule Γ' R V} :
    ((of R).symm (x • y)).support ⊆ x.support +ᵥ ((of R).symm y).support
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem toList_singleton : ∀ a, ({a} : Finset α).toList = [a]
-- Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean
theorem explicitCokernelDesc_norm_le_of_norm_le {X Y Z : SemiNormedGrp.{u}} {f : X ⟶ Y}
    {g : Y ⟶ Z} (w : f ≫ g = 0) (c : ℝ≥0) (h : ‖g‖ ≤ c) : ‖explicitCokernelDesc w‖ ≤ c
-- Mathlib/NumberTheory/EulerProduct/DirichletLSeries.lean
lemma tsum_riemannZetaSummand (hs : 1 < s.re) :
    ∑' (n : ℕ), riemannZetaSummandHom (ne_zero_of_one_lt_re hs) n = riemannZeta s
-- Mathlib/CategoryTheory/GuitartExact/VerticalComposition.lean
/-- The vertical composition of 2-squares. -/
@[simps!]
def vComp : TwoSquare H₁ (L₁ ⋙ L₂) (R₁ ⋙ R₂) H₃
-- Mathlib/Algebra/Lie/Basic.lean
theorem zero_apply (x : L₁) : (0 : L₁ →ₗ⁅R⁆ L₂) x = 0
-- Mathlib/Data/Nat/Choose/Basic.lean
theorem choose_eq_asc_factorial_div_factorial' (n k : ℕ) :
    (n + k - 1).choose k = n.ascFactorial k / k !
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nadd_right_cancel : ∀ {a b c}, a ♯ b = c ♯ b → a = c
-- Mathlib/Order/Monotone/Basic.lean
/-- If `α` is a preorder with no maximal elements, then there exists a strictly antitone function
`ℕ → α` with any prescribed value of `f 0`. -/
theorem exists_strictAnti' [NoMinOrder α] (a : α) : ∃ f : ℕ → α, StrictAnti f ∧ f 0 = a
-- Mathlib/Data/Set/Countable.lean
@[simp]
theorem countable_coe_iff {s : Set α} : Countable s ↔ s.Countable
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma polyCharpoly_coeff_nilRank_ne_zero :
    (polyCharpoly φ b).coeff (nilRank φ) ≠ 0
-- Mathlib/CategoryTheory/Generator.lean
theorem IsCoseparating.isCodetecting [Balanced C] {𝒢 : Set C} :
    IsCoseparating 𝒢 → IsCodetecting 𝒢
-- Mathlib/Topology/Inseparable.lean
theorem specializes_iff_forall_open : x ⤳ y ↔ ∀ s : Set X, IsOpen s → y ∈ s → x ∈ s
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
theorem gcd_dvd_gcd_mul_right_right (m n k : Nat) : gcd m n ∣ gcd m (n * k)
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
/-- The L-series of the twist of the von Mangoldt function `Λ` by a Dirichlet character `χ`
converges at `s` when `re s > 1`. -/
lemma LSeriesSummable_twist_vonMangoldt {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ}
    (hs : 1 < s.re) :
    LSeriesSummable (↗χ * ↗Λ) s
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
@[simp]
theorem dist_equiv_symm_snd (y₁ y₂ : β) :
    dist ((WithLp.equiv p (α × β)).symm (0, y₁)) ((WithLp.equiv p (α × β)).symm (0, y₂)) =
      dist y₁ y₂
-- Mathlib/Logic/Embedding/Basic.lean
@[simp]
theorem setValue_eq {α β} (f : α ↪ β) (a : α) (b : β) [∀ a', Decidable (a' = a)]
    [∀ a', Decidable (f a' = b)] : setValue f a b a = b
-- Mathlib/RingTheory/Polynomial/Quotient.lean
theorem eval₂_C_mk_eq_zero {I : Ideal R} {a : MvPolynomial σ R}
    (ha : a ∈ (Ideal.map (C : R →+* MvPolynomial σ R) I : Ideal (MvPolynomial σ R))) :
    eval₂Hom (C.comp (Ideal.Quotient.mk I)) X a = 0
-- Mathlib/RingTheory/Ideal/Over.lean
theorem comap_ne_bot_of_algebraic_mem [IsDomain S] {x : S} (x_ne_zero : x ≠ 0) (x_mem : x ∈ I)
    (hx : IsAlgebraic R x) : I.comap (algebraMap R S) ≠ ⊥
-- Mathlib/CategoryTheory/Conj.lean
theorem map_conjAut (F : C ⥤ D) {X Y : C} (α : X ≅ Y) (f : Aut X) :
    F.mapIso (α.conjAut f) = (F.mapIso α).conjAut (F.mapIso f)
-- Mathlib/Analysis/Calculus/Deriv/Slope.lean
theorem HasDerivAt.tendsto_slope_zero_right [PartialOrder 𝕜] (h : HasDerivAt f f' x) :
    Tendsto (fun t ↦ t⁻¹ • (f (x + t) - f x)) (𝓝[>] 0) (𝓝 f')
-- Mathlib/RingTheory/Polynomial/Basic.lean
@[simp]
theorem natDegree_toSubring : (toSubring p T hp).natDegree = p.natDegree
-- Mathlib/RingTheory/LaurentSeries.lean
/-- The Hasse derivative of Laurent series, as a linear map. -/
@[simps]
def hasseDeriv (R : Type*) {V : Type*} [AddCommGroup V] [Semiring R] [Module R V] (k : ℕ) :
    LaurentSeries V →ₗ[R] LaurentSeries V
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem nonneg_mul {a b : ℤ√d} (ha : Nonneg a) (hb : Nonneg b) : Nonneg (a * b)
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
theorem IsWeightedHomogeneous.weightedHomogeneousComponent_ne {m : M} (n : M)
    {p : MvPolynomial σ R} (hp : IsWeightedHomogeneous w p m) :
    n ≠ m → weightedHomogeneousComponent w n p = 0
-- Mathlib/Data/Multiset/Functor.lean
theorem naturality {G H : Type _ → Type _} [Applicative G] [Applicative H] [CommApplicative G]
    [CommApplicative H] (eta : ApplicativeTransformation G H) {α β : Type _} (f : α → G β)
    (x : Multiset α) : eta (traverse f x) = traverse (@eta _ ∘ f) x
-- Mathlib/Data/Fintype/Basic.lean
theorem rightInverse_bijInv (f_bij : Bijective f) : RightInverse (bijInv f_bij) f
-- Mathlib/Topology/Sets/Compacts.lean
@[simp, norm_cast] lemma coe_sdiff (s t : CompactOpens α) : ↑(s \ t) = (s \ t : Set α)
-- Mathlib/Analysis/Convex/Between.lean
theorem wbtw_smul_vadd_smul_vadd_of_nonneg_of_le (x : P) (v : V) {r₁ r₂ : R} (hr₁ : 0 ≤ r₁)
    (hr₂ : r₁ ≤ r₂) : Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x)
-- Mathlib/Data/Finset/Lattice.lean
theorem le_max_of_eq {s : Finset α} {a b : α} (h₁ : a ∈ s) (h₂ : s.max = b) : a ≤ b
-- Mathlib/Data/Finset/Pointwise/Interval.lean
@[to_additive Iio_add_Iic_subset]
theorem Iio_mul_Iic_subset' [LocallyFiniteOrderBot α] (a b : α) : Iio a * Iic b ⊆ Iio (a * b)
-- Mathlib/Data/Fintype/Card.lean
@[congr]
theorem card_congr' {α β} [Fintype α] [Fintype β] (h : α = β) : card α = card β
-- Mathlib/Order/Interval/Multiset.lean
theorem right_mem_Ioc : b ∈ Ioc a b ↔ a < b
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.trans (hfg : IsBigOWith c l f g) (hgk : IsBigOWith c' l g k) (hc : 0 ≤ c) :
    IsBigOWith (c * c') l f k
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem mem_range_of_measure_ne_zero {f : α →ₛ β} {x : β} {μ : Measure α} (H : μ (f ⁻¹' {x}) ≠ 0) :
    x ∈ f.range
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem singleton_injective : Function.Injective (@singleton ZFSet ZFSet _)
-- Mathlib/Order/Bounded.lean
theorem bounded_le_inter_not_le [SemilatticeSup α] (a : α) :
    Bounded (· ≤ ·) (s ∩ { b | ¬b ≤ a }) ↔ Bounded (· ≤ ·) s
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem mk_val (i : Fin n) : (⟨i, i.isLt⟩ : Fin n) = i
-- Mathlib/NumberTheory/NumberField/Units/Basic.lean
theorem coe_neg_one : ((-1 : (𝓞 K)ˣ) : K) = (-1 : K)
-- Mathlib/Topology/Constructions.lean
protected theorem IsOpenMap.prod {f : X → Y} {g : Z → W} (hf : IsOpenMap f) (hg : IsOpenMap g) :
    IsOpenMap fun p : X × Z => (f p.1, g p.2)
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
theorem smooth_inclusion {U V : Opens M} (h : U ≤ V) : Smooth I I (Set.inclusion h : U → V)
-- Mathlib/Logic/Denumerable.lean
@[simp]
theorem ofNat_nat (n) : ofNat ℕ n = n
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem HasFDerivAt.norm_sq {f : G → F} {f' : G →L[ℝ] F} (hf : HasFDerivAt f f' x) :
    HasFDerivAt (‖f ·‖ ^ 2) (2 • (innerSL ℝ (f x)).comp f') x
-- Mathlib/FieldTheory/Separable.lean
theorem Algebra.isSeparable_tower_top_of_isSeparable [Algebra.IsSeparable F E] :
    Algebra.IsSeparable K E
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem mul_inv_le_inv_mul_iff : a * b⁻¹ ≤ d⁻¹ * c ↔ d * a ≤ c * b
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem mul_lt_one_of_nonneg_of_lt_one_left [PosMulMono α]
    (ha₀ : 0 ≤ a) (ha : a < 1) (hb : b ≤ 1) : a * b < 1
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem isPrimitiveRoot_iff' {k : ℕ+} {ζ ξ : Rˣ} (h : IsPrimitiveRoot ζ k) :
    IsPrimitiveRoot ξ k ↔ ∃ i < (k : ℕ), i.Coprime k ∧ ζ ^ i = ξ
-- Mathlib/Algebra/Group/Support.lean
@[to_additive]
theorem nmem_mulSupport {f : α → M} {x : α} : x ∉ mulSupport f ↔ f x = 1
-- Mathlib/Data/Finsupp/ToDFinsupp.lean
/-- The additive version of `finsupp.toFinsupp`. Note that this is `noncomputable` because
`Finsupp.add` is noncomputable. -/
@[simps (config := .asFn)]
def finsuppAddEquivDFinsupp [DecidableEq ι] [AddZeroClass M] [∀ m : M, Decidable (m ≠ 0)] :
    (ι →₀ M) ≃+ Π₀ _ : ι, M
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem linearIndependent_image {ι} {s : Set ι} {f : ι → M} (hf : Set.InjOn f s) :
    (LinearIndependent R fun x : s => f x) ↔ LinearIndependent R fun x : f '' s => (x : M)
-- Mathlib/CategoryTheory/Idempotents/FunctorExtension.lean
theorem karoubiUniversal₂_functor_eq : (karoubiUniversal₂ C D).functor = functorExtension₂ C D
-- Mathlib/Analysis/Complex/UpperHalfPlane/Manifold.lean
/-- The inclusion map `ℍ → ℂ` is a differentiable map of manifolds. -/
theorem mdifferentiable_coe : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) ((↑) : ℍ → ℂ)
-- Mathlib/Order/Hom/Lattice.lean
/-- Reinterpret a supremum homomorphism as an infimum homomorphism between the dual lattices. -/
@[simps]
protected def dual : SupHom α β ≃ InfHom αᵒᵈ βᵒᵈ
-- Mathlib/RingTheory/Generators.lean
lemma Hom.toAlgHom_C (f : Hom P P') (r) : f.toAlgHom (.C r) = .C (algebraMap _ _ r)
-- Mathlib/Algebra/DirectSum/Algebra.lean
theorem algHom_ext ⦃f g : (⨁ i, A i) →ₐ[R] B⦄ (h : ∀ i x, f (of A i x) = g (of A i x)) : f = g
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
protected theorem ContMDiffWithinAt.coordChange
    (hf : ContMDiffWithinAt IM IB n f s x) (hg : ContMDiffWithinAt IM 𝓘(𝕜, F) n g s x)
    (he : f x ∈ e.baseSet) (he' : f x ∈ e'.baseSet) :
    ContMDiffWithinAt IM 𝓘(𝕜, F) n (fun y ↦ e.coordChange e' (f y) (g y)) s x
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem LieIdeal.coe_bracket_of_module {R L : Type*} [CommRing R] [LieRing L] [LieAlgebra R L]
    (I : LieIdeal R L) [LieRingModule L M] (x : I) (m : M) : ⁅x, m⁆ = ⁅(↑x : L), m⁆
-- Mathlib/Order/Basic.lean
theorem Ne.lt_of_le' : b ≠ a → a ≤ b → a < b
-- Mathlib/RingTheory/Ideal/Prod.lean
@[simp]
theorem map_fst_prod (I : Ideal R) (J : Ideal S) : map (RingHom.fst R S) (prod I J) = I
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem getLsb_ofFin (x : Fin (2^n)) (i : Nat) :
  getLsb (BitVec.ofFin x) i = x.val.testBit i
-- Mathlib/Data/Nat/Defs.lean
@[gcongr]
protected lemma div_le_div_right (h : a ≤ b) : a / c ≤ b / c
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
@[simp]
theorem op_unop (S : Subring Rᵐᵒᵖ) : S.unop.op = S
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigO.smul_isLittleO (h₁ : k₁ =O[l] k₂) (h₂ : f' =o[l] g') :
    (fun x => k₁ x • f' x) =o[l] fun x => k₂ x • g' x
-- .lake/packages/lean4/src/lean/Init/Data/Int/Gcd.lean
theorem gcd_dvd_left {a b : Int} : (gcd a b : Int) ∣ a
-- Mathlib/Topology/MetricSpace/Isometry.lean
/-- On pseudometric spaces, a map is an isometry if and only if it preserves nonnegative
distances. -/
theorem isometry_iff_nndist_eq [PseudoMetricSpace α] [PseudoMetricSpace β] {f : α → β} :
    Isometry f ↔ ∀ x y, nndist (f x) (f y) = nndist x y
-- Mathlib/NumberTheory/FLT/Three.lean
/-- Given `S' : Solution'`, we may assume that `λ ^ 2` divides `S'.a + S'.b ∨ λ ^ 2` (see also the
result below). -/
lemma ex_cube_add_cube_eq_and_isCoprime_and_not_dvd_and_dvd :
    ∃ (a' b' : 𝓞 K), a' ^ 3 + b' ^ 3 = S'.u * S'.c ^ 3 ∧ IsCoprime a' b' ∧ ¬ λ ∣ a' ∧
      ¬ λ ∣ b' ∧ λ ^ 2 ∣ a' + b'
-- Mathlib/Analysis/BoxIntegral/Partition/SubboxInduction.lean
@[simp]
theorem mem_splitCenter : J ∈ splitCenter I ↔ ∃ s, I.splitCenterBox s = J
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem aecover_Ioc_of_Ioo (ha : Tendsto a l (𝓝 A)) (hb : Tendsto b l (𝓝 B)) :
    AECover (μ.restrict <| Ioc A B) l fun i => Ioo (a i) (b i)
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
@[simp]
theorem unop_op (S : Subring R) : S.op.unop = S
-- Mathlib/Topology/LocallyConstant/Basic.lean
theorem of_constant (f : X → Y) (h : ∀ x y, f x = f y) : IsLocallyConstant f
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem right_inv_of_invOfMemRange (a : α) : hf.invOfMemRange ⟨f a, Set.mem_range_self a⟩ = a
-- Mathlib/CategoryTheory/Limits/ConcreteCategory.lean
theorem limit_ext [HasLimit F] (x y : ↑(limit F)) :
    (∀ j, limit.π F j x = limit.π F j y) → x = y
-- Mathlib/Algebra/Order/Group/Synonym.lean
@[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) toDual_smul]
theorem toDual_pow [Pow α β] (a : α) (b : β) : toDual (a ^ b) = toDual a ^ b
-- Mathlib/Logic/Basic.lean
theorem ExistsUnique.intro₂ {α : Sort*} {p : α → Sort*} [∀ x, Subsingleton (p x)]
    {q : ∀ (x : α) (_ : p x), Prop} (w : α) (hp : p w) (hq : q w hp)
    (H : ∀ (y) (hy : p y), q y hy → y = w) : ∃! x, ∃! hx : p x, q x hx
-- Mathlib/Data/String/Basic.lean
@[simp]
theorem toList_empty : "".toList = []
-- Mathlib/Tactic/CategoryTheory/BicategoricalComp.lean
@[simps]
instance tensorRight' (f : a ⟶ b) (g : b ⟶ b)
    [BicategoricalCoherence g (𝟙 b)] : BicategoricalCoherence (f ≫ g) f
-- Mathlib/Topology/Maps/Proper/Basic.lean
/-- By definition, a proper map is continuous. -/
@[fun_prop]
lemma IsProperMap.continuous (h : IsProperMap f) : Continuous f
-- Mathlib/Data/List/Nodup.lean
theorem inj_on_of_nodup_map {f : α → β} {l : List α} (d : Nodup (map f l)) :
    ∀ ⦃x⦄, x ∈ l → ∀ ⦃y⦄, y ∈ l → f x = f y → x = y
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem exists_fixed_point_of_prime {p n : ℕ} [hp : Fact p.Prime] (hα : ¬p ∣ Fintype.card α)
    {σ : Perm α} (hσ : σ ^ p ^ n = 1) : ∃ a : α, σ a = a
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIocDiv_add_right' (a b : α) : toIocDiv hp (a + p) b = toIocDiv hp a b - 1
-- Mathlib/Algebra/Polynomial/Smeval.lean
theorem smeval_neg_nat (S : Type*) [NonAssocRing S] [Pow S ℕ] [NatPowAssoc S] (q : ℕ[X])
    (n : ℕ) : q.smeval (-(n : S)) = q.smeval (-n : ℤ)
-- Mathlib/Algebra/Polynomial/Coeff.lean
/-- Decomposes the coefficient of the product `p * q` as a sum
over `antidiagonal`. A version which sums over `range (n + 1)` can be obtained
by using `Finset.Nat.sum_antidiagonal_eq_sum_range_succ`. -/
theorem coeff_mul (p q : R[X]) (n : ℕ) :
    coeff (p * q) n = ∑ x ∈ antidiagonal n, coeff p x.1 * coeff q x.2
-- Mathlib/Data/Set/Lattice.lean
theorem mem_iUnion₂_of_mem {s : ∀ i, κ i → Set α} {a : α} {i : ι} (j : κ i) (ha : a ∈ s i j) :
    a ∈ ⋃ (i) (j), s i j
-- Mathlib/Data/PEquiv.lean
@[simp]
theorem symm_symm (f : α ≃. β) : f.symm.symm = f
-- Mathlib/Data/Matrix/Block.lean
/-- Two block matrices are equal if their blocks are equal. -/
theorem ext_iff_blocks {A B : Matrix (n ⊕ o) (l ⊕ m) α} :
    A = B ↔
      A.toBlocks₁₁ = B.toBlocks₁₁ ∧
        A.toBlocks₁₂ = B.toBlocks₁₂ ∧ A.toBlocks₂₁ = B.toBlocks₂₁ ∧ A.toBlocks₂₂ = B.toBlocks₂₂
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[simp]
theorem colimit.isColimit_desc {F : J ⥤ C} [HasColimit F] (c : Cocone F) :
    (colimit.isColimit F).desc c = colimit.desc F c
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
theorem mul_associator {M N P : Mon_ C} :
    (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
          (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
        (α_ M.X N.X P.X).hom =
      ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
        tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
          (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
@[simp]
theorem Matrix.toLinearMapₛₗ₂'_symm :
    ((Matrix.toLinearMapₛₗ₂' R σ₁ σ₂).symm : _ ≃ₗ[R] Matrix n m N₂) = LinearMap.toMatrixₛₗ₂' R
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
theorem Coloring.colorable [Fintype α] (C : G.Coloring α) : G.Colorable (Fintype.card α)
-- Mathlib/Analysis/Analytic/Basic.lean
theorem HasFPowerSeriesAt.eventually_hasSum_sub (hf : HasFPowerSeriesAt f p x) :
    ∀ᶠ y in 𝓝 x, HasSum (fun n : ℕ => p n fun _ : Fin n => y - x) (f y)
-- Mathlib/Order/Antisymmetrization.lean
@[elab_as_elim]
protected theorem Antisymmetrization.ind {p : Antisymmetrization α r → Prop} :
    (∀ a, p <| toAntisymmetrization r a) → ∀ q, p q
-- .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean
theorem foldr_succ (f : Fin (n+1) → α → α) (x) :
    foldr (n+1) f x = f 0 (foldr n (fun i => f i.succ) x)
-- Mathlib/CategoryTheory/Subobject/Limits.lean
@[simp]
theorem imageSubobject_zero_arrow : (imageSubobject (0 : X ⟶ Y)).arrow = 0
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem mul_apply (x) : (f * g) x = f (g x)
-- Mathlib/Combinatorics/SimpleGraph/Hamiltonian.lean
lemma isHamiltonianCycle_isCycle_and_isHamiltonian_tail  :
    p.IsHamiltonianCycle ↔ ∃ h : p.IsCycle, (p.tail h.not_nil).IsHamiltonian
-- Mathlib/Computability/Reduce.lean
theorem disjoin_le {α β γ} [Primcodable α] [Primcodable β] [Primcodable γ] {p : α → Prop}
    {q : β → Prop} {r : γ → Prop} : (p ⊕' q) ≤₀ r ↔ p ≤₀ r ∧ q ≤₀ r
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- If the `affineSpan` of a finite affinely independent family lies
in an affine subspace whose direction has dimension one less than its
cardinality, it equals that subspace. -/
theorem AffineIndependent.affineSpan_eq_of_le_of_card_eq_finrank_add_one [Fintype ι] {p : ι → P}
    (hi : AffineIndependent k p) {sp : AffineSubspace k P} [FiniteDimensional k sp.direction]
    (hle : affineSpan k (Set.range p) ≤ sp) (hc : Fintype.card ι = finrank k sp.direction + 1) :
    affineSpan k (Set.range p) = sp
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
@[simp]
lemma unmop_inv_braiding (X Y : Cᴹᵒᵖ) : (β_ X Y).inv.unmop = (β_ (unmop Y) (unmop X)).inv
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem withTopCongr_symm (e : α ≃o β) : e.withTopCongr.symm = e.symm.withTopCongr
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem add_lintegral (f g : α →ₛ ℝ≥0∞) : (f + g).lintegral μ = f.lintegral μ + g.lintegral μ
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
theorem paste_vert_iff {X₁₁ X₁₂ X₂₁ X₂₂ X₃₁ X₃₂ : C} {h₁₁ : X₁₁ ⟶ X₁₂} {h₂₁ : X₂₁ ⟶ X₂₂}
    {h₃₁ : X₃₁ ⟶ X₃₂} {v₁₁ : X₁₁ ⟶ X₂₁} {v₁₂ : X₁₂ ⟶ X₂₂} {v₂₁ : X₂₁ ⟶ X₃₁} {v₂₂ : X₂₂ ⟶ X₃₂}
    (s : IsPushout h₁₁ v₁₁ v₁₂ h₂₁) (e : h₂₁ ≫ v₂₂ = v₂₁ ≫ h₃₁) :
    IsPushout h₁₁ (v₁₁ ≫ v₂₁) (v₁₂ ≫ v₂₂) h₃₁ ↔ IsPushout h₂₁ v₂₁ v₂₂ h₃₁
-- Mathlib/CategoryTheory/Bicategory/Free.lean
@[simp]
theorem mk_id : Quot.mk _ (Hom₂.id f) = 𝟙 f
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem sigmaCurry_smul [Monoid γ] [∀ i j, AddMonoid (δ i j)] [∀ i j, DistribMulAction γ (δ i j)]
    (r : γ) (f : Π₀ (i : Σ _, _), δ i.1 i.2) :
    sigmaCurry (r • f) = r • sigmaCurry f
-- Mathlib/CategoryTheory/Sites/Spaces.lean
/-- The pretopology associated to a space is the largest pretopology that
    generates the Grothendieck topology associated to the space. -/
@[simp]
theorem pretopology_ofGrothendieck :
    Pretopology.ofGrothendieck _ (Opens.grothendieckTopology T) = Opens.pretopology T
-- Mathlib/Topology/LocallyConstant/Basic.lean
theorem toContinuousMap_injective :
    Function.Injective (toContinuousMap : LocallyConstant X Y → C(X, Y))
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
/-- For `f : Lp E p μ`, we can define an element of `Lp E p (μ.restrict s)` by
`(Lp.memℒp f).restrict s).toLp f`. This map is non-expansive. -/
theorem norm_Lp_toLp_restrict_le (s : Set X) (f : Lp E p μ) :
    ‖((Lp.memℒp f).restrict s).toLp f‖ ≤ ‖f‖
-- Mathlib/Algebra/Lie/Weights/Basic.lean
@[simp]
lemma trace_toEnd_weightSpace [IsDomain R] [IsPrincipalIdealRing R]
    [Module.Free R M] [Module.Finite R M] (χ : L → R) (x : L) :
    trace R _ (toEnd R L (weightSpace M χ) x) = finrank R (weightSpace M χ) • χ x
-- Mathlib/Order/LiminfLimsup.lean
theorem IsBoundedUnder.isCoboundedUnder_ge {u : γ → α} {l : Filter γ} [Preorder α] [NeBot l]
    (h : l.IsBoundedUnder (· ≤ ·) u) : l.IsCoboundedUnder (· ≥ ·) u
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem tsub_lt_of_lt (h : a < b) : a - c < b
-- Mathlib/Data/PNat/Xgcd.lean
theorem finish_isReduced : u.finish.IsReduced
-- Mathlib/Algebra/TrivSqZeroExt.lean
theorem algHom_ext {A} [Semiring A] [Algebra R' A] ⦃f g : tsze R' M →ₐ[R'] A⦄
    (h : ∀ m, f (inr m) = g (inr m)) : f = g
-- Mathlib/Data/Set/Card.lean
theorem encard_eq_encard_iff_encard_diff_eq_encard_diff (h : (s ∩ t).Finite) :
    s.encard = t.encard ↔ (s \ t).encard = (t \ s).encard
-- Mathlib/SetTheory/Cardinal/UnivLE.lean
/-- Together with transitivity, this shows UnivLE "IsTotalPreorder". -/
theorem univLE_total : UnivLE.{u, v} ∨ UnivLE.{v, u}
-- Mathlib/Data/List/Perm.lean
lemma subperm_iff : l₁ <+~ l₂ ↔ ∃ l, l ~ l₂ ∧ l₁ <+ l
-- Mathlib/Data/Matrix/Basic.lean
/-- The `AlgEquiv` between spaces of square matrices induced by an `AlgEquiv` between their
coefficients. This is `Matrix.map` as an `AlgEquiv`. -/
@[simps apply]
def mapMatrix (f : α ≃ₐ[R] β) : Matrix m m α ≃ₐ[R] Matrix m m β
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
@[reassoc (attr := simp 1100)]
theorem wideEqualizer.lift_ι [Nonempty J] {W : C} (k : W ⟶ X)
    (h : ∀ j₁ j₂, k ≫ f j₁ = k ≫ f j₂) :
    wideEqualizer.lift k h ≫ wideEqualizer.ι f = k
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem tan_add_nat_mul_pi (x : ℂ) (n : ℕ) : tan (x + n * π) = tan x
-- Mathlib/MeasureTheory/Measure/Dirac.lean
/-- Dirac delta measures at two points are different if and only if there is a measurable set
containing one of the points but not the other. -/
lemma dirac_ne_dirac_iff_exists_measurableSet {x y : α} :
    Measure.dirac x ≠ Measure.dirac y ↔ ∃ A, MeasurableSet A ∧ x ∈ A ∧ y ∉ A