ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/Interval/Set/OrdConnected.lean
@[instance]
theorem ordConnected_singleton {α : Type*} [PartialOrder α] {a : α} :
    OrdConnected ({a} : Set α)
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
@[simp]
theorem IsOrtho.map_iff (f : E ≃ₗᵢ[𝕜] F) {U V : Submodule 𝕜 E} : U.map f ⟂ V.map f ↔ U ⟂ V
-- Mathlib/GroupTheory/Perm/List.lean
theorem formPerm_rotate (l : List α) (h : Nodup l) (n : ℕ) :
    formPerm (l.rotate n) = formPerm l
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem upperCrossingTime_lt_nonempty (hN : 0 < N) :
    {n | upperCrossingTime a b f N n ω < N}.Nonempty
-- Mathlib/Algebra/Homology/DerivedCategory/Ext.lean
@[simp]
lemma homAddEquiv_apply (α : Ext X Y n) : homAddEquiv α = α.hom
-- Mathlib/Data/Set/Basic.lean
theorem union_left_comm (s₁ s₂ s₃ : Set α) : s₁ ∪ (s₂ ∪ s₃) = s₂ ∪ (s₁ ∪ s₃)
-- Mathlib/Topology/Order/LeftRightNhds.lean
lemma nhdsWithin_Ioi_basis [NoMaxOrder α] (a : α) : (𝓝[>] a).HasBasis (a < ·) (Ioo a)
-- Mathlib/RingTheory/Polynomial/Basic.lean
@[simp]
theorem coeff_restriction {p : R[X]} {n : ℕ} : ↑(coeff (restriction p) n) = coeff p n
-- Mathlib/MeasureTheory/Measure/Sub.lean
theorem sub_le : μ - ν ≤ μ
-- Mathlib/Algebra/BigOperators/Fin.lean
@[to_additive]
theorem prod_univ_add {M : Type*} [CommMonoid M] {a b : ℕ} (f : Fin (a + b) → M) :
    (∏ i : Fin (a + b), f i) = (∏ i : Fin a, f (castAdd b i)) * ∏ i : Fin b, f (natAdd a i)
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem lcm_dvd_lcm_mul_left [GCDMonoid α] (m n k : α) : lcm m n ∣ lcm (k * m) n
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
@[simp]
theorem LinearMap.BilinForm.toMatrixAux_stdBasis (B : BilinForm R₂ (n → R₂)) :
    -- Porting note: had to hint the base ring even though it should be clear from context...
    BilinForm.toMatrixAux (R₂ := R₂) (fun j => stdBasis R₂ (fun _ => R₂) j 1) B =
      BilinForm.toMatrix' B
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_linear_lt_degree_C_mul_X_sq (ha : a ≠ 0) :
    degree (C b * X + C c) < degree (C a * X ^ 2)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
lemma prod_ite_eq_ite_exists (p : ι → Prop) [DecidablePred p] (h : ∀ i j, p i → p j → i = j)
    (a : α) : ∏ i, ite (p i) a 1 = ite (∃ i, p i) a 1
-- Mathlib/Analysis/Calculus/TangentCone.lean
/-- The tangent cone of a product contains the tangent cone of each factor. -/
theorem mapsTo_tangentCone_pi {ι : Type*} [DecidableEq ι] {E : ι → Type*}
    [∀ i, NormedAddCommGroup (E i)] [∀ i, NormedSpace 𝕜 (E i)] {s : ∀ i, Set (E i)} {x : ∀ i, E i}
    {i : ι} (hi : ∀ j ≠ i, x j ∈ closure (s j)) :
    MapsTo (LinearMap.single i : E i →ₗ[𝕜] ∀ j, E j) (tangentConeAt 𝕜 (s i) (x i))
      (tangentConeAt 𝕜 (Set.pi univ s) x)
-- Mathlib/Data/Fin/Tuple/Sort.lean
/-- A permutation of a tuple `f` is `f` sorted if and only if it is monotone. -/
theorem comp_sort_eq_comp_iff_monotone : f ∘ σ = f ∘ sort f ↔ Monotone (f ∘ σ)
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
theorem IsUniform.mono {ε' : 𝕜} (h : ε ≤ ε') (hε : IsUniform G ε s t) : IsUniform G ε' s t
-- Mathlib/CategoryTheory/Adjunction/Restrict.lean
@[simp, reassoc]
lemma map_restrictFullyFaithful_counit_app (X : D) :
    iD.map ((adj.restrictFullyFaithful hiC hiD comm1 comm2).counit.app X) =
    comm1.inv.app (R.obj X) ≫ L'.map (comm2.inv.app X) ≫ adj.counit.app (iD.obj X)
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem iff_not_self : ¬(a ↔ ¬a)
-- Mathlib/Algebra/Polynomial/Coeff.lean
theorem update_eq_add_sub_coeff {R : Type*} [Ring R] (p : R[X]) (n : ℕ) (a : R) :
    p.update n a = p + Polynomial.C (a - p.coeff n) * Polynomial.X ^ n
-- Mathlib/Data/List/Enum.lean
theorem le_fst_of_mem_enumFrom {x : ℕ × α} {n : ℕ} {l : List α} (h : x ∈ enumFrom n l) :
    n ≤ x.1
-- Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean
/-- If `f ≫ g` is a strong epimorphism, then so is `g`. -/
theorem strongEpi_of_strongEpi [StrongEpi (f ≫ g)] : StrongEpi g
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[norm_cast] -- Porting note (#10618): Removed simp attribute, simp can prove this
theorem coe_inj {f g : MultilinearMap R M₁ M₂} : (f : (∀ i, M₁ i) → M₂) = g ↔ f = g
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem dual_comp (g : β →o γ) (f : α →o β) :
    OrderHom.dual (g.comp f) = (OrderHom.dual g).comp (OrderHom.dual f)
-- Mathlib/Data/Nat/Lattice.lean
theorem biInter_lt_succ (u : ℕ → Set α) (n : ℕ) : ⋂ k < n + 1, u k = (⋂ k < n, u k) ∩ u n
-- Mathlib/Data/Sigma/Lex.lean
theorem Lex.mono_left (hr : ∀ a b, r₁ a b → r₂ a b) {a b : Σ i, α i} (h : Lex r₁ s a b) :
    Lex r₂ s a b
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma eqOn_of_cfcₙ_eq_cfcₙ {f g : R → R} {a : A} (h : cfcₙ f a = cfcₙ g a) (ha : p a := by cfc_tac)
    (hf : ContinuousOn f (σₙ R a) := by cfc_cont_tac) (hf0 : f 0 = 0 := by cfc_zero_tac)
    (hg : ContinuousOn g (σₙ R a) := by cfc_cont_tac) (hg0 : g 0 = 0 := by cfc_zero_tac) :
    (σₙ R a).EqOn f g
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nadd_lt_nadd_of_lt_of_le : ∀ {a b c d}, a < b → c ≤ d → a ♯ c < b ♯ d
-- Mathlib/Order/SuccPred/Basic.lean
theorem isMax_iterate_succ_of_eq_of_lt {n m : ℕ} (h_eq : succ^[n] a = succ^[m] a)
    (h_lt : n < m) : IsMax (succ^[n] a)
-- Mathlib/Analysis/InnerProductSpace/OfNorm.lean
private theorem real_prop (r : ℝ) : innerProp' E (r : 𝕜)
-- Mathlib/Topology/Homotopy/Path.lean
theorem map_lift (P₀ : Path x₀ x₁) (f : C(X, Y)) : ⟦P₀.map f.continuous⟧ = Quotient.mapFn ⟦P₀⟧ f
-- Mathlib/Data/List/Sigma.lean
@[simp]
theorem kerase_cons_eq {a} {s : Sigma β} {l : List (Sigma β)} (h : a = s.1) :
    kerase a (s :: l) = l
-- Mathlib/AlgebraicGeometry/Morphisms/Constructors.lean
/-- If a property of maps of topological spaces is satisfied by all homeomorphisms,
every isomorphism of schemes satisfies the induced property. -/
lemma topologically_iso_le
    (hP : ∀ {α β : Type u} [TopologicalSpace α] [TopologicalSpace β] (f : α ≃ₜ β), P f) :
    MorphismProperty.isomorphisms Scheme ≤ (topologically P)
-- Mathlib/Topology/DerivedSet.lean
lemma preperfect_iff_subset_derivedSet {U : Set X} : Preperfect U ↔ U ⊆ derivedSet U
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[simp low+1]
theorem vsub_singleton (s : Set β) (b : β) : s -ᵥ {b} = (· -ᵥ b) '' s
-- Mathlib/Data/Matrix/Rank.lean
@[simp]
theorem rank_self_mul_transpose (A : Matrix m n R) : (A * Aᵀ).rank = A.rank
-- Mathlib/Analysis/Convex/Between.lean
@[simp]
theorem sbtw_vsub_const_iff {x y z : P} (p : P) :
    Sbtw R (x -ᵥ p) (y -ᵥ p) (z -ᵥ p) ↔ Sbtw R x y z
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem lineMap_vsub_right (p₀ p₁ : P1) (c : k) : lineMap p₀ p₁ c -ᵥ p₁ = (1 - c) • (p₀ -ᵥ p₁)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem not_mem_append {a : α} {s t : List α} (h₁ : a ∉ s) (h₂ : a ∉ t) : a ∉ s ++ t
-- Mathlib/Topology/Sets/Closeds.lean
@[simp]
lemma coe_sSup {S : Set (Closeds α)} : ((sSup S : Closeds α) : Set α) =
    closure (⋃₀ ((↑) '' S))
-- Mathlib/Algebra/GroupPower/IterateHom.lean
@[to_additive (attr := simp)]
theorem mul_right_iterate : (· * a)^[n] = (· * a ^ n)
-- Mathlib/Topology/Instances/ENNReal.lean
theorem inv_map_iSup {ι : Sort*} {x : ι → ℝ≥0∞} : (iSup x)⁻¹ = ⨅ i, (x i)⁻¹
-- Mathlib/Topology/DenseEmbedding.lean
theorem continuousAt_extend [T3Space γ] {b : β} {f : α → γ} (di : DenseInducing i)
    (hf : ∀ᶠ x in 𝓝 b, ∃ c, Tendsto f (comap i <| 𝓝 x) (𝓝 c)) : ContinuousAt (di.extend f) b
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
protected theorem Ordered.setBlack {t : RBNode α} : (setBlack t).Ordered cmp ↔ t.Ordered cmp
-- Mathlib/Topology/ContinuousOn.lean
theorem continuousOn_id {s : Set α} : ContinuousOn id s
-- Mathlib/RingTheory/AdjoinRoot.lean
theorem equiv'_symm_toAlgHom (h₁ : aeval (root g) (minpoly R pb.gen) = 0)
    (h₂ : aeval pb.gen g = 0) : (equiv' g pb h₁ h₂).symm.toAlgHom = pb.lift (root g) h₁
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem And.comm : a ∧ b ↔ b ∧ a
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem nullMeasurableSet_eq_fun {E} [TopologicalSpace E] [MetrizableSpace E] {f g : α → E}
    (hf : AEStronglyMeasurable f μ) (hg : AEStronglyMeasurable g μ) :
    NullMeasurableSet { x | f x = g x } μ
-- Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean
@[simp]
theorem IsTerminal.from_self {X : C} (t : IsTerminal X) : t.from X = 𝟙 X
-- Mathlib/Algebra/Polynomial/Mirror.lean
@[simp]
theorem mirror_inj : p.mirror = q.mirror ↔ p = q
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem lift_apply_inr (f : R →ₐ[S] A) (g : M →ₗ[S] A)
    (hg : ∀ x y, g x * g y = 0)
    (hfg : ∀ r x, g (r •> x) = f r * g x)
    (hgf : ∀ r x, g (x <• r) = g x * f r)
    (m : M) :
    lift f g hg hfg hgf (inr m) = g m
-- Mathlib/Data/Bool/Basic.lean
theorem toNat_le_toNat {b₀ b₁ : Bool} (h : b₀ ≤ b₁) : toNat b₀ ≤ toNat b₁
-- Mathlib/CategoryTheory/Subobject/Limits.lean
/-- Postcomposing by a monomorphism does not change the kernel subobject. -/
@[simp]
theorem kernelSubobject_comp_mono (f : X ⟶ Y) [HasKernel f] {Z : C} (h : Y ⟶ Z) [Mono h] :
    kernelSubobject (f ≫ h) = kernelSubobject f
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem DifferentiableOn.mul (ha : DifferentiableOn 𝕜 a s) (hb : DifferentiableOn 𝕜 b s) :
    DifferentiableOn 𝕜 (fun y => a y * b y) s
-- Mathlib/Data/Finset/Image.lean
theorem image_comm {β'} [DecidableEq β'] [DecidableEq γ] {f : β → γ} {g : α → β} {f' : α → β'}
    {g' : β' → γ} (h_comm : ∀ a, f (g a) = g' (f' a)) :
    (s.image g).image f = (s.image f').image g'
-- Mathlib/Data/Finset/Lattice.lean
theorem le_sup'_of_le {a : α} {b : β} (hb : b ∈ s) (h : a ≤ f b) : a ≤ s.sup' ⟨b, hb⟩ f
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
/-- Formula for `completedSinZeta` as a Dirichlet series in the convergence range
(second version, with sum over `ℕ`). -/
lemma hasSum_nat_completedSinZeta (a : ℝ) {s : ℂ} (hs : 1 < re s) :
    HasSum (fun n : ℕ ↦ Gammaℝ (s + 1) * Real.sin (2 * π * a * n) / (n : ℂ) ^ s)
    (completedSinZeta a s)
-- Mathlib/Data/List/Intervals.lean
@[simp]
theorem eq_empty_iff {n m : ℕ} : Ico n m = [] ↔ m ≤ n
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean
lemma map_add (f₁ f₂ : X ⟶ Y) :
    letI := addCommGroup L W (L.obj X) (L.obj Y)
    L.map (f₁ + f₂) = L.map f₁ + L.map f₂
-- Mathlib/Data/Int/Cast/Lemmas.lean
@[simp] lemma cast_eq_zero : (n : α) = 0 ↔ n = 0
-- Mathlib/Data/NNReal/Basic.lean
@[simp]
theorem toNNReal_zero : Real.toNNReal 0 = 0
-- .lake/packages/batteries/Batteries/Data/UInt.lean
@[simp] theorem UInt8.val_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt8).val = OfNat.ofNat n
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
theorem gcd_mul_right (m n k : Nat) : gcd (m * n) (k * n) = gcd m k * n
-- Mathlib/FieldTheory/PrimitiveElement.lean
@[simp]
theorem AlgHom.card_of_splits (L : Type*) [Field L] [Algebra F L]
    (hL : ∀ x : E, (minpoly F x).Splits (algebraMap F L)) :
    Fintype.card (E →ₐ[F] L) = finrank F E
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
lemma completedHurwitzZetaEven₀_neg (a : UnitAddCircle) (s : ℂ) :
    completedHurwitzZetaEven₀ (-a) s = completedHurwitzZetaEven₀ a s
-- Mathlib/Algebra/Algebra/Tower.lean
theorem restrictScalars_apply (f : A ≃ₐ[S] B) (x : A) : f.restrictScalars R x = f x
-- Mathlib/RingTheory/Valuation/Basic.lean
@[simp]
theorem map_add' : ∀ (x y : R), v x ≤ v (x + y) ∨ v y ≤ v (x + y)
-- Mathlib/Algebra/Ring/Commute.lean
lemma sq_eq_sq_iff_eq_or_eq_neg : a ^ 2 = b ^ 2 ↔ a = b ∨ a = -b
-- Mathlib/CategoryTheory/Sites/Closed.lean
/--
The sieve `S` is in the topology iff its closure is the maximal sieve. This shows that the closure
operator determines the topology.
-/
theorem close_eq_top_iff_mem {X : C} (S : Sieve X) : J₁.close S = ⊤ ↔ S ∈ J₁ X
-- Mathlib/Data/Multiset/Basic.lean
theorem replicate_le_coe {a : α} {n} {l : List α} : replicate n a ≤ l ↔ List.replicate n a <+ l
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem map_replicate : (replicate n a).map f = replicate n (f a)
-- Mathlib/Order/Filter/Basic.lean
theorem NeBot.nonempty_of_mem {f : Filter α} (hf : NeBot f) {s : Set α} (hs : s ∈ f) : s.Nonempty
-- Mathlib/FieldTheory/SeparableDegree.lean
/-- A monic polynomial over a field `F` of exponential characteristic `q` has separable degree one
if and only if it is of the form `(X ^ (q ^ n) - C y) ^ m` for some non-zero natural number `m`,
some natural number `n`, and some element `y` of `F`. -/
theorem natSepDegree_eq_one_iff (q : ℕ) [ExpChar F q] (hm : f.Monic) :
    f.natSepDegree = 1 ↔ ∃ (m n : ℕ) (y : F), m ≠ 0 ∧ f = (X ^ q ^ n - C y) ^ m
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[simp]
theorem BinaryFan.π_app_right {X Y : C} (s : BinaryFan X Y) : s.π.app ⟨WalkingPair.right⟩ = s.snd
-- Mathlib/Topology/Separation.lean
theorem Set.Subsingleton.closure [T1Space X] {s : Set X} (hs : s.Subsingleton) :
    (closure s).Subsingleton
-- Mathlib/RingTheory/Valuation/Basic.lean
@[simp]
theorem valuation_apply (r : R) : v.valuation r = Multiplicative.ofAdd (OrderDual.toDual (v r))
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
protected theorem _root_.Eq.sameCycle (h : x = y) (f : Perm α) : f.SameCycle x y
-- Mathlib/NumberTheory/NumberField/House.lean
@[simp] theorem house_intCast (x : ℤ) : house (x : K) = |x|
-- Mathlib/RingTheory/PowerSeries/Inverse.lean
@[simp]
theorem constantCoeff_inv (φ : k⟦X⟧) : constantCoeff k φ⁻¹ = (constantCoeff k φ)⁻¹
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
theorem IsSubordinate.mono' [Fintype ι] {π : TaggedPrepartition I} (hr₁ : π.IsSubordinate r₁)
    (h : ∀ J ∈ π, r₁ (π.tag J) ≤ r₂ (π.tag J)) : π.IsSubordinate r₂
-- Mathlib/Topology/UniformSpace/Cauchy.lean
/-- Every Cauchy sequence over `ℕ` is totally bounded. -/
theorem CauchySeq.totallyBounded_range {s : ℕ → α} (hs : CauchySeq s) :
    TotallyBounded (range s)
-- Mathlib/RingTheory/Polynomial/Bernstein.lean
theorem derivative_succ (n ν : ℕ) : Polynomial.derivative (bernsteinPolynomial R n (ν + 1)) =
    n * (bernsteinPolynomial R (n - 1) ν - bernsteinPolynomial R (n - 1) (ν + 1))
-- Mathlib/RingTheory/Perfection.lean
@[ext]
theorem ext {f g : Ring.Perfection R p} (h : ∀ n, coeff R p n f = coeff R p n g) : f = g
-- Mathlib/Topology/TietzeExtension.lean
/-- **Tietze extension theorem** for real-valued bounded continuous maps, a version for a closed
set. If `f` is a bounded continuous real-valued function defined on a closed set in a normal
topological space, then it can be extended to a bounded continuous function of the same norm defined
on the whole space. -/
theorem exists_norm_eq_restrict_eq_of_closed {s : Set Y} (f : s →ᵇ ℝ) (hs : IsClosed s) :
    ∃ g : Y →ᵇ ℝ, ‖g‖ = ‖f‖ ∧ g.restrict s = f
-- Mathlib/Topology/Inseparable.lean
@[refl]
theorem specializes_refl (x : X) : x ⤳ x
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
theorem gcd_cons_div_right' : (gcd (x::xs) : Int) ∣ (gcd xs : Int)
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem cond_false_right : ∀(c t : Bool), cond c t false = ( c && t)
-- Mathlib/CategoryTheory/Sites/Coherent/Equivalence.lean
/--
The regular sheaf condition can be checked after precomposing with the equivalence.
-/
theorem preregular_isSheaf_iff (F : Cᵒᵖ ⥤ A) : haveI := e.preregular
    IsSheaf (regularTopology C) F ↔ IsSheaf (regularTopology D) (e.inverse.op ⋙ F)
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
protected theorem add_lt_add_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤)
    (h : b < c) : b + a < c + a
-- Mathlib/Topology/ContinuousOn.lean
theorem Filter.EventuallyEq.eq_of_nhdsWithin {s : Set α} {f g : α → β} {a : α} (h : f =ᶠ[𝓝[s] a] g)
    (hmem : a ∈ s) : f a = g a
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem imCLM_apply : ((imCLM : K →L[ℝ] ℝ) : K → ℝ) = im
-- Mathlib/FieldTheory/SeparableDegree.lean
/-- The separable degree of any field extension `E / F` divides the degree of `E / F`. -/
theorem finSepDegree_dvd_finrank : finSepDegree F E ∣ finrank F E
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem smul_re [SMul S R] (s : S) : (s • a).re = s • a.re
-- Mathlib/Algebra/Algebra/Subalgebra/Rank.lean
theorem finrank_sup_eq_finrank_right_mul_finrank_of_free :
    finrank R ↥(A ⊔ B) = finrank R B * finrank B (Algebra.adjoin B (A : Set S))
-- .lake/packages/lean4/src/lean/Init/Data/Array/Basic.lean
theorem extLit {n : Nat}
    (a b : Array α)
    (hsz₁ : a.size = n) (hsz₂ : b.size = n)
    (h : (i : Nat) → (hi : i < n) → a.getLit i hsz₁ hi = b.getLit i hsz₂ hi) : a = b
-- Mathlib/Topology/Order/NhdsSet.lean
theorem Icc_mem_nhdsSet_Ico (h : a < b) (h' : c ≤ d) : Icc a d ∈ 𝓝ˢ (Ico b c)
-- Mathlib/Data/Finset/Basic.lean
theorem sdiff_inter_distrib_right (s t u : Finset α) : s \ (t ∩ u) = s \ t ∪ s \ u
-- Mathlib/Data/Fintype/Perm.lean
theorem Fintype.card_perm [Fintype α] : Fintype.card (Perm α) = (Fintype.card α)!
-- Mathlib/Topology/PartitionOfUnity.lean
theorem eventuallyEq_one (x : X) (hx : x ∈ s) : f (f.ind x hx) =ᶠ[𝓝 x] 1
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
theorem derivWithin_cexp (hf : DifferentiableWithinAt 𝕜 f s x) (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin (fun x => Complex.exp (f x)) s x = Complex.exp (f x) * derivWithin f s x
-- Mathlib/RingTheory/Filtration.lean
theorem Stable.of_le [IsNoetherianRing R] [Module.Finite R M] (hF : F.Stable)
    {F' : I.Filtration M} (hf : F' ≤ F) : F'.Stable
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[deprecated getElem_eq_data_getElem (since := "2024-06-12")]
theorem getElem_eq_data_get (a : Array α) (h : i < a.size) : a[i] = a.data.get ⟨i, h⟩
-- Mathlib/Data/Nat/GCD/Basic.lean
theorem not_coprime_zero_zero : ¬Coprime 0 0
-- Mathlib/Algebra/Group/Commute/Defs.lean
@[to_additive (attr := simp)]
theorem pow_left (h : Commute a b) (n : ℕ) : Commute (a ^ n) b
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
theorem toPMF_eq_iff_toMeasure_eq (μ : Measure α) [IsProbabilityMeasure μ] :
    μ.toPMF = p ↔ μ = p.toMeasure
-- Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean
@[reassoc]
lemma mapComp_id_right_inv (f : a ⟶ b) : (F.mapComp f (𝟙 b)).inv =
    F.map f ◁ (F.mapId b).hom ≫ (ρ_ (F.map f)).hom ≫ F.map₂ (ρ_ f).inv
-- Mathlib/Analysis/Convex/Combination.lean
/-- `stdSimplex 𝕜 ι` is the convex hull of the canonical basis in `ι → 𝕜`. -/
theorem convexHull_basis_eq_stdSimplex :
    convexHull R (range fun i j : ι => if i = j then (1 : R) else 0) = stdSimplex R ι
-- Mathlib/MeasureTheory/Constructions/Pi.lean
/-- The product σ-algebra is generated from boxes, i.e. `s ×ˢ t` for sets `s : set α` and
  `t : set β`. -/
theorem generateFrom_pi [∀ i, MeasurableSpace (α i)] :
    generateFrom (pi univ '' pi univ fun i => { s : Set (α i) | MeasurableSet s }) =
      MeasurableSpace.pi
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
@[to_additive]
theorem ContMDiff.inv {f : M → G} (hf : ContMDiff I' I n f) : ContMDiff I' I n fun x => (f x)⁻¹
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem vecMul_vecMul [Fintype n] [Fintype m] (v : m → α) (M : Matrix m n α) (N : Matrix n o α) :
    v ᵥ* M ᵥ* N = v ᵥ* (M * N)
-- Mathlib/Data/Rat/Cast/Defs.lean
@[simp, norm_cast]
theorem cast_zero : ((0 : ℚ) : α) = 0
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
@[simp, reassoc]
theorem braiding_inv_tensor_right (X Y Z : C) :
    (β_ X (Y ⊗ Z)).inv  =
      (α_ Y Z X).hom ≫ Y ◁ (β_ X Z).inv ≫ (α_ Y X Z).inv ≫
        (β_ X Y).inv ▷ Z ≫ (α_ X Y Z).hom
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem Nat.ne_of_beq_eq_false : {n m : Nat} → Eq (beq n m) false → Not (Eq n m)
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
/-- The results of applying `domDomCongr` to two maps are equal if and only if those maps are. -/
@[simp]
theorem domDomCongr_eq_iff (σ : ι ≃ ι') (f g : M [⋀^ι]→ₗ[R] N) :
    f.domDomCongr σ = g.domDomCongr σ ↔ f = g
-- Mathlib/Data/Multiset/Dedup.lean
theorem dedup_eq_zero {s : Multiset α} : dedup s = 0 ↔ s = 0
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
@[simp]
lemma fromColumns_mulVec_sum_elim (A₁ : Matrix m n₁ R) (A₂ : Matrix m n₂ R)
    (v₁ : n₁ → R) (v₂ : n₂ → R) :
    fromColumns A₁ A₂ *ᵥ Sum.elim v₁ v₂ = A₁ *ᵥ v₁ + A₂ *ᵥ v₂
-- Mathlib/Algebra/Group/Fin/Tuple.lean
@[simp] lemma smul_cons (x : M) (y : α) (v : Fin n → α) :
    x • vecCons y v = vecCons (x • y) (x • v)
-- Mathlib/Topology/MetricSpace/Gluing.lean
theorem le_glueDist_inl_inr (Φ : Z → X) (Ψ : Z → Y) (ε : ℝ) (x y) :
    ε ≤ glueDist Φ Ψ ε (.inl x) (.inr y)
-- Mathlib/Analysis/PSeries.lean
/-- for series of nonnegative real numbers. -/
theorem summable_schlomilch_iff_of_nonneg {C : ℕ} {u : ℕ → ℕ} {f : ℕ → ℝ} (h_nonneg : ∀ n, 0 ≤ f n)
    (hf : ∀ ⦃m n⦄, 0 < m → m ≤ n → f n ≤ f m) (h_pos : ∀ n, 0 < u n)
    (hu_strict : StrictMono u) (hC_nonzero : C ≠ 0) (h_succ_diff : SuccDiffBounded C u) :
    (Summable fun k : ℕ => (u (k + 1) - (u k : ℝ)) * f (u k)) ↔ Summable f
-- Mathlib/Topology/MetricSpace/Thickening.lean
/-- A set is contained in its own (open) thickening. -/
theorem self_subset_thickening {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) : E ⊆ thickening δ E
-- Mathlib/Data/Set/Card.lean
/-- We can shrink `s` to any smaller size. -/
@[deprecated exists_subset_card_eq (since := "2024-06-23")]
theorem exists_smaller_set (s : Set α) (i : ℕ) (h₁ : i ≤ s.ncard) :
    ∃ t : Set α, t ⊆ s ∧ t.ncard = i
-- Mathlib/RingTheory/Ideal/Operations.lean
@[simp]
theorem smul_bot : I • (⊥ : Submodule R M) = ⊥
-- Mathlib/Data/Rat/Defs.lean
lemma pow_eq_divInt (q : ℚ) (n : ℕ) : q ^ n = q.num ^ n /. q.den ^ n
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
theorem op_sup (S₁ S₂ : Subring R) : (S₁ ⊔ S₂).op = S₁.op ⊔ S₂.op
-- Mathlib/Data/List/Sublists.lean
@[deprecated map_pure_sublist_sublists (since := "2024-03-24")]
theorem map_ret_sublist_sublists (l : List α) : map List.ret l <+ sublists l
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem ne_zero_of_a_ne_zero (ha : P.a ≠ 0) : P.toPoly ≠ 0
-- Mathlib/Algebra/ContinuedFractions/ContinuantsRecurrence.lean
theorem contsAux_recurrence {gp ppred pred : Pair K} (nth_s_eq : g.s.get? n = some gp)
    (nth_contsAux_eq : g.contsAux n = ppred)
    (succ_nth_contsAux_eq : g.contsAux (n + 1) = pred) :
    g.contsAux (n + 2) = ⟨gp.b * pred.a + gp.a * ppred.a, gp.b * pred.b + gp.a * ppred.b⟩
-- Mathlib/Topology/IsLocalHomeomorph.lean
theorem isLocalHomeomorph_iff_isLocalHomeomorphOn_univ :
    IsLocalHomeomorph f ↔ IsLocalHomeomorphOn f Set.univ
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem dvd_mul_gcd_of_dvd_mul [GCDMonoid α] {m n k : α} (H : k ∣ m * n) : k ∣ m * gcd k n
-- Mathlib/Data/Nat/Cast/Basic.lean
@[simp, norm_cast]
lemma cast_pow (m : ℕ) : ∀ n : ℕ, ↑(m ^ n) = (m ^ n : α)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
@[simp]
theorem toLp_eq_toLp_iff {f g : α → E} (hf : Memℒp f p μ) (hg : Memℒp g p μ) :
    hf.toLp f = hg.toLp g ↔ f =ᵐ[μ] g
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Prod.lean
/-- The operator norm of the first projection `E × F → E` is at most 1. (It is 0 if `E` is zero, so
the inequality cannot be improved without further assumptions.) -/
lemma norm_fst_le : ‖fst 𝕜 E F‖ ≤ 1
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem UniformSpace.comap_mono {α γ} {f : α → γ} :
    Monotone fun u : UniformSpace γ => u.comap f
-- Mathlib/Tactic/Sat/FromLRAT.lean
/-- Asserts that `¬⟦l⟧_v` implies `p`. -/
structure Literal.reify (v : Valuation) (l : Literal) (p : Prop) : Prop where
  prop : v.neg l → p
-- Mathlib/LinearAlgebra/Matrix/DotProduct.lean
lemma vecMul_self_mul_conjTranspose_eq_zero (A : Matrix m n R) (v : m → R) :
    v ᵥ* (A * Aᴴ) = 0 ↔ v ᵥ* A = 0
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
theorem AEMeasurable.fst [SFinite ν] {f : α → γ} (hf : AEMeasurable f μ) :
    AEMeasurable (fun z : α × β => f z.1) (μ.prod ν)
-- Mathlib/SetTheory/ZFC/Basic.lean
/-- Two pre-sets are equivalent iff they have the same members. -/
theorem Equiv.eq {x y : PSet} : Equiv x y ↔ toSet x = toSet y
-- Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
@[simp]
lemma zero_app (X : Cᵒᵖ) : (0 : P ⟶ Q).app X = 0
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean
theorem eq_from (h : IsZero X) (f : Y ⟶ X) : f = h.from_ Y
-- Mathlib/Data/FunLike/Equiv.lean
/-- This is not an instance to avoid slowing down every single `Subsingleton` typeclass search. -/
lemma subsingleton_dom [Subsingleton β] : Subsingleton F