ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Bialgebra/Hom.lean
theorem coe_coalgHom_injective : Function.Injective ((↑) : (A →ₐc[R] B) → A →ₗc[R] B)
-- Mathlib/Topology/Algebra/Module/Multilinear/Topology.lean
@[simp]
lemma apply_apply [ContinuousConstSMul 𝕜 F] {m : Π i, E i} {c : ContinuousMultilinearMap 𝕜 E F} :
    apply 𝕜 E F m c = c m
-- Mathlib/SetTheory/Game/Nim.lean
theorem grundyValue_add (G H : PGame) [G.Impartial] [H.Impartial] {n m : ℕ} (hG : grundyValue G = n)
    (hH : grundyValue H = m) : grundyValue (G + H) = n ^^^ m
-- Mathlib/CategoryTheory/Abelian/Exact.lean
lemma reflects_exact_of_faithful [F.Faithful] (S : ShortComplex C) (hS : (S.map F).Exact) :
    S.Exact
-- Mathlib/Topology/PartitionOfUnity.lean
theorem support_toPartitionOfUnity_subset (i : ι) :
    support (f.toPartitionOfUnity i) ⊆ support (f i)
-- Mathlib/Data/Finset/Powerset.lean
theorem mem_powerset_self (s : Finset α) : s ∈ powerset s
-- Mathlib/Data/Nat/Fib/Basic.lean
theorem fib_le_fib_succ {n : ℕ} : fib n ≤ fib (n + 1)
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem mem_iff (S : Subgroupoid C) (F : Σ c d, c ⟶ d) : F ∈ S ↔ F.2.2 ∈ S.arrows F.1 F.2.1
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_add_le_of_le {a b : WithBot ℕ} (hp : degree p ≤ a) (hq : degree q ≤ b) :
    degree (p + q) ≤ max a b
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
@[continuity]
theorem prod_continuous_equiv_symm : Continuous (WithLp.equiv p (α × β)).symm
-- Mathlib/Data/Nat/Defs.lean
lemma sub_one_add_self (n : ℕ) : (n - 1) + n = 2 * n - 1
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem derivWithin_of_mem (st : t ∈ 𝓝[s] x) (ht : UniqueDiffWithinAt 𝕜 s x)
    (h : DifferentiableWithinAt 𝕜 f t x) : derivWithin f s x = derivWithin f t x
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
@[elementwise (attr := simp)]
theorem equalizerIso_inv_comp_ι : (equalizerIso g h).inv ≫ equalizer.ι g h = Subtype.val
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
theorem len_lt_of_mono {Δ' Δ : SimplexCategory} (i : Δ' ⟶ Δ) [hi : Mono i] (hi' : Δ ≠ Δ') :
    Δ'.len < Δ.len
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
/-- Variant of `homMk'` where both objects are applications of `mk`. -/
@[simps]
def mkPrecomp (f : S.obj Y ⟶ T) (g : Y' ⟶ Y) : mk (S.map g ≫ f) ⟶ mk f
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp] lemma deleteEdges_adj : (G.deleteEdges s).Adj v w ↔ G.Adj v w ∧ ¬s(v, w) ∈ s
-- Mathlib/Analysis/Convex/Mul.lean
/-- `x^n`, `n : ℕ` is convex on `[0, +∞)` for all `n`. -/
lemma convexOn_pow : ∀ n, ConvexOn 𝕜 (Ici 0) fun x : 𝕜 ↦ x ^ n
-- Mathlib/GroupTheory/SpecificGroups/Cyclic.lean
@[to_additive]
private theorem card_pow_eq_one_eq_orderOf_aux (a : α) :
    (Finset.univ.filter fun b : α => b ^ orderOf a = 1).card = orderOf a
-- Mathlib/Analysis/Convex/Function.lean
/-- A strictly convex function on an open segment is strictly upper-bounded by the max of its
endpoints. -/
theorem StrictConvexOn.lt_on_openSegment (hf : StrictConvexOn 𝕜 s f) {x y z : E} (hx : x ∈ s)
    (hy : y ∈ s) (hxy : x ≠ y) (hz : z ∈ openSegment 𝕜 x y) : f z < max (f x) (f y)
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem reverse_append {u v w : V} (p : G.Walk u v) (q : G.Walk v w) :
    (p.append q).reverse = q.reverse.append p.reverse
-- Mathlib/Analysis/Normed/Group/Constructions.lean
lemma norm_def (x : ULift E) : ‖x‖ = ‖x.down‖
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma toAffine_of_equiv {P Q : Fin 3 → F} (h : P ≈ Q) : toAffine W P = toAffine W Q
-- Mathlib/Analysis/LocallyConvex/Basic.lean
theorem balanced_zero : Balanced 𝕜 (0 : Set E)
-- Mathlib/ModelTheory/Definability.lean
@[simp]
theorem mem_sdiff : x ∈ s \ t ↔ x ∈ s ∧ ¬x ∈ t
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
/-- The norm of a bounded continuous function is the supremum of `‖f x‖`.
We use `sInf` to ensure that the definition works if `α` has no elements. -/
theorem norm_eq (f : α →ᵇ β) : ‖f‖ = sInf { C : ℝ | 0 ≤ C ∧ ∀ x : α, ‖f x‖ ≤ C }
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[reassoc (attr := simp)]
theorem prod.map_map {A₁ A₂ A₃ B₁ B₂ B₃ : C} [HasBinaryProduct A₁ B₁] [HasBinaryProduct A₂ B₂]
    [HasBinaryProduct A₃ B₃] (f : A₁ ⟶ A₂) (g : B₁ ⟶ B₂) (h : A₂ ⟶ A₃) (k : B₂ ⟶ B₃) :
    prod.map f g ≫ prod.map h k = prod.map (f ≫ h) (g ≫ k)
-- Mathlib/Topology/Algebra/UniformRing.lean
@[norm_cast]
theorem coe_mul (a b : α) : ((a * b : α) : Completion α) = a * b
-- Mathlib/Order/WithBot.lean
@[simp]
theorem ofDual_lt_ofDual_iff {a b : WithTop αᵒᵈ} : WithTop.ofDual a < WithTop.ofDual b ↔ b < a
-- Mathlib/Order/Height.lean
@[simp]
theorem chainHeight_eq_zero_iff : s.chainHeight = 0 ↔ s = ∅
-- Mathlib/FieldTheory/Cardinality.lean
/-- There is a field structure on type if and only if its cardinality is a prime power. -/
theorem Field.nonempty_iff {α : Type u} : Nonempty (Field α) ↔ IsPrimePow #α
-- Mathlib/Init/Order/LinearOrder.lean
@[simp]
theorem min_self (a : α) : min a a = a
-- Mathlib/LinearAlgebra/TensorProduct/Finiteness.lean
/-- Variation of `TensorProduct.exists_finite_submodule_left_of_finite` where `M` and `N` are
already submodules. -/
theorem exists_finite_submodule_left_of_finite' (s : Set (M₁ ⊗[R] N₁)) (hs : s.Finite) :
    ∃ (M' : Submodule R M) (hM : M' ≤ M₁), Module.Finite R M' ∧
      s ⊆ LinearMap.range ((inclusion hM).rTensor N₁)
-- Mathlib/Data/Nat/Log.lean
theorem lt_pow_of_log_lt {b x y : ℕ} (hb : 1 < b) : log b y < x → y < b ^ x
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem exists_root_of_degree_eq_one (h : degree p = 1) : ∃ x, IsRoot p x
-- Mathlib/Order/Filter/Basic.lean
theorem frequently_iff_forall_eventually_exists_and {p : α → Prop} {f : Filter α} :
    (∃ᶠ x in f, p x) ↔ ∀ {q : α → Prop}, (∀ᶠ x in f, q x) → ∃ x, p x ∧ q x
-- Mathlib/Data/Finset/Pointwise.lean
@[simp]
protected theorem smul_neg : s • -t = -(s • t)
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
theorem Equiv.multipliable_iff (e : γ ≃ β) : Multipliable (f ∘ e) ↔ Multipliable f
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem MeasurePreserving.integrable_comp_emb {f : α → δ} {ν} (h₁ : MeasurePreserving f μ ν)
    (h₂ : MeasurableEmbedding f) {g : δ → β} : Integrable (g ∘ f) μ ↔ Integrable g ν
-- Mathlib/Geometry/RingedSpace/Basic.lean
lemma zeroLocus_isClosed {U : Opens X} (s : Set (X.presheaf.obj (op U))) :
    IsClosed (X.zeroLocus s)
-- Mathlib/LinearAlgebra/AffineSpace/Combination.lean
/-- Suppose an indexed family of points is given, along with a subset
of the index type.  A vector can be expressed as
`weightedVSubOfPoint` using a `Finset` lying within that subset and
with a given sum of weights if and only if it can be expressed as
`weightedVSubOfPoint` with that sum of weights for the
corresponding indexed family whose index type is the subtype
corresponding to that subset. -/
theorem eq_weightedVSubOfPoint_subset_iff_eq_weightedVSubOfPoint_subtype {v : V} {x : k} {s : Set ι}
    {p : ι → P} {b : P} :
    (∃ fs : Finset ι, ↑fs ⊆ s ∧ ∃ w : ι → k, ∑ i ∈ fs, w i = x ∧
        v = fs.weightedVSubOfPoint p b w) ↔
      ∃ (fs : Finset s) (w : s → k), ∑ i ∈ fs, w i = x ∧
        v = fs.weightedVSubOfPoint (fun i : s => p i) b w
-- Mathlib/RingTheory/HahnSeries/Addition.lean
theorem orderTop_add_eq_left {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R}
    (hxy : x.orderTop < y.orderTop) : (x + y).orderTop = x.orderTop
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
protected theorem MDifferentiableAt.mfderiv (h : MDifferentiableAt I I' f x) :
    mfderiv I I' f x =
      fderivWithin 𝕜 (writtenInExtChartAt I I' x f : _) (range I) ((extChartAt I x) x)
-- Mathlib/LinearAlgebra/Matrix/Hermitian.lean
/-- A diagonal matrix is hermitian if the entries are self-adjoint (as a vector) -/
theorem isHermitian_diagonal_of_self_adjoint [DecidableEq n] (v : n → α) (h : IsSelfAdjoint v) :
    (diagonal v).IsHermitian
-- Mathlib/Analysis/Convex/Deriv.lean
theorem StrictMonoOn.exists_deriv_lt_slope_aux {x y : ℝ} {f : ℝ → ℝ} (hf : ContinuousOn f (Icc x y))
    (hxy : x < y) (hf'_mono : StrictMonoOn (deriv f) (Ioo x y)) (h : ∀ w ∈ Ioo x y, deriv f w ≠ 0) :
    ∃ a ∈ Ioo x y, deriv f a < (f y - f x) / (y - x)
-- Mathlib/GroupTheory/NoncommPiCoprod.lean
@[to_additive]
theorem noncommPiCoprod_mrange :
    MonoidHom.mrange (noncommPiCoprod ϕ hcomm) = ⨆ i : ι, MonoidHom.mrange (ϕ i)
-- Mathlib/CategoryTheory/Abelian/Opposite.lean
/-- The kernel of `f.op` is the opposite of `cokernel f`. -/
@[simps]
def kernelOpUnop : (kernel f.op).unop ≅ cokernel f
-- Mathlib/Order/Filter/Archimedean.lean
@[simp] theorem Int.comap_cast_atTop [StrictOrderedRing R] [Archimedean R] :
    comap ((↑) : ℤ → R) atTop = atTop
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ico_inter_Iio : Ico a b ∩ Iio c = Ico a (min b c)
-- Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean
/-- Given a natural transformation `τ : F ⟶ G` between functors `C ⥤ D` which preserve
the left homology of a short complex `S`, and a left homology data for `S`,
this is the left homology map data for the morphism `S.mapNatTrans τ`
obtained by evaluating `τ`. -/
@[simps]
def LeftHomologyMapData.natTransApp (h : LeftHomologyData S) (τ : F ⟶ G) :
    LeftHomologyMapData (S.mapNatTrans τ) (h.map F) (h.map G)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem mk'_toSubmonoid {s : Set R} {sm : Submonoid R} (hm : ↑sm = s) {sa : AddSubgroup R}
    (ha : ↑sa = s) : (Subring.mk' s sm sa hm ha).toSubmonoid = sm
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp, norm_cast]
theorem toEnd_natCast (n : ℕ) : (n : CentroidHom α).toEnd = ↑n
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] theorem bmod_emod : bmod x m % m = x % m
-- Mathlib/Topology/Sequences.lean
/-- A sequentially compact set in a uniform space is totally bounded. -/
protected theorem IsSeqCompact.totallyBounded (h : IsSeqCompact s) : TotallyBounded s
-- Mathlib/CategoryTheory/Monoidal/Comon_.lean
/-- The trivial comonoid object. We later show this is terminal in `Comon_ C`.
-/
@[simps]
def trivial : Comon_ C
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem disjoint_iff_mul_eq_one {H₁ H₂ : Subgroup G} :
    Disjoint H₁ H₂ ↔ ∀ {x y : G}, x ∈ H₁ → y ∈ H₂ → x * y = 1 → x = 1 ∧ y = 1
-- Mathlib/Analysis/Normed/Group/Constructions.lean
@[to_additive pi_nnnorm_le_iff]
lemma pi_nnnorm_le_iff' {r : ℝ≥0} : ‖x‖₊ ≤ r ↔ ∀ i, ‖x i‖₊ ≤ r
-- Mathlib/LinearAlgebra/Span.lean
/-- A version of `Submodule.span_eq` for when the span is by a smaller ring. -/
@[simp]
theorem span_coe_eq_restrictScalars [Semiring S] [SMul S R] [Module S M] [IsScalarTower S R M] :
    span S (p : Set M) = p.restrictScalars S
-- Mathlib/Topology/Sequences.lean
/-- The sequential closure of a set is contained in the closure of that set.
The converse is not true. -/
theorem seqClosure_subset_closure {s : Set X} : seqClosure s ⊆ closure s
-- Mathlib/Logic/Basic.lean
theorem beq_eq_decide {α : Type*} [BEq α] [LawfulBEq α] {a b : α} : (a == b) = decide (a = b)
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp]
theorem toEnd_pow (x : CentroidHom α) (n : ℕ) : (x ^ n).toEnd = x.toEnd ^ n
-- Mathlib/Probability/Independence/Kernel.lean
theorem iIndepSet_iff_meas_biInter {_mΩ : MeasurableSpace Ω} {κ : Kernel α Ω}
    [IsMarkovKernel κ] {μ : Measure α} {f : ι → Set Ω} (hf : ∀ i, MeasurableSet (f i)) :
    iIndepSet f κ μ ↔ ∀ s, ∀ᵐ a ∂μ, κ a (⋂ i ∈ s, f i) = ∏ i ∈ s, κ a (f i)
-- Mathlib/RingTheory/Polynomial/Eisenstein/Basic.lean
theorem pow_natDegree_le_of_root_of_monic_mem {x : R} (hroot : IsRoot f x) (hmo : f.Monic) :
    ∀ i, f.natDegree ≤ i → x ^ i ∈ 𝓟
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[simp]
theorem coe_map (g : β → γ) (f : α →ₛ β) : (f.map g : α → γ) = g ∘ f
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
/-- A submonoid contains the monoid's 1. -/
@[to_additive "An `AddSubmonoid` contains the monoid's 0."]
protected theorem one_mem : (1 : M) ∈ S
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem inf_coe : (↑(N ⊓ N') : Set M) = ↑N ∩ ↑N'
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem rpow_eq_zero_iff_of_nonneg (hx : 0 ≤ x) : x ^ y = 0 ↔ x = 0 ∧ y ≠ 0
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem LHom.onTheory_model [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] (T : L.Theory) :
    M ⊨ φ.onTheory T ↔ M ⊨ T
-- Mathlib/Data/Multiset/Fintype.lean
@[simp]
theorem Multiset.card_toEnumFinset (m : Multiset α) : m.toEnumFinset.card = Multiset.card m
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem xn_modEq_x4n_sub {n j} (h : j ≤ 2 * n) : xn a1 (4 * n - j) ≡ xn a1 j [MOD xn a1 n]
-- Mathlib/Init/Logic.lean
theorem ExistsUnique.intro {p : α → Prop} (w : α)
    (h₁ : p w) (h₂ : ∀ y, p y → y = w) : ∃! x, p x
-- Mathlib/Data/Set/Function.lean
theorem MapsTo.image_subset (h : MapsTo f s t) : f '' s ⊆ t
-- Mathlib/NumberTheory/Divisors.lean
@[simp]
theorem mem_properDivisors {m : ℕ} : n ∈ properDivisors m ↔ n ∣ m ∧ n < m
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_Iic_atBot [SemilatticeInf α] {a : α} {f : β → Iic a} {l : Filter β} :
    Tendsto f l atBot ↔ Tendsto (fun x => (f x : α)) l atBot
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
theorem measure_fundamentalDomain_ne_zero [Finite ι] [MeasurableSpace E] [BorelSpace E]
    {μ : Measure E} [Measure.IsAddHaarMeasure μ] :
    μ (fundamentalDomain b) ≠ 0
-- Mathlib/Topology/Connected/TotallyDisconnected.lean
lemma Embedding.isTotallyDisconnected_range [TopologicalSpace β] {f : α → β} (hf : Embedding f) :
    IsTotallyDisconnected (range f) ↔ TotallyDisconnectedSpace α
-- Mathlib/Algebra/Polynomial/RingDivision.lean
/-- The multiplicity of `p + q` is at least the minimum of the multiplicities. -/
theorem rootMultiplicity_add {p q : R[X]} (a : R) (hzero : p + q ≠ 0) :
    min (rootMultiplicity a p) (rootMultiplicity a q) ≤ rootMultiplicity a (p + q)
-- Mathlib/Algebra/Order/Ring/WithTop.lean
@[simp] lemma top_mul_top : (⊤ * ⊤ : WithTop α) = ⊤
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_subtype' {p : ι → Prop} {f : ∀ i, p i → α} :
    ⨅ (i) (h : p i), f i h = ⨅ x : Subtype p, f x x.property
-- Mathlib/Algebra/Module/Submodule/Range.lean
theorem range_le_ker_iff {f : M →ₛₗ[τ₁₂] M₂} {g : M₂ →ₛₗ[τ₂₃] M₃} :
    range f ≤ ker g ↔ (g.comp f : M →ₛₗ[τ₁₃] M₃) = 0
-- Mathlib/Order/WithBot.lean
@[simp]
theorem bot_lt_coe (a : α) : ⊥ < (a : WithBot α)
-- Mathlib/Algebra/Module/Torsion.lean
@[simp]
theorem mem_torsionBySet_iff (x : M) : x ∈ torsionBySet R M s ↔ ∀ a : s, (a : R) • x = 0
-- Mathlib/Data/Set/Lattice.lean
theorem sInter_eq_empty_iff {c : Set (Set α)} : ⋂₀ c = ∅ ↔ ∀ a, ∃ b ∈ c, a ∉ b
-- Mathlib/NumberTheory/NumberField/Basic.lean
/-- The canonical map from `𝓞 K` to `K` is injective.

This is a convenient abbreviation for `map_eq_zero_iff` applied to
`NoZeroSMulDivisors.algebraMap_injective`.
-/
@[simp] lemma coe_eq_zero_iff {x : 𝓞 K} : algebraMap _ K x = 0 ↔ x = 0
-- Mathlib/Data/ENNReal/Operations.lean
/-- A sum of numbers is infinite iff one of them is infinite -/
theorem sum_eq_top_iff {s : Finset α} {f : α → ℝ≥0∞} : ∑ x ∈ s, f x = ∞ ↔ ∃ a ∈ s, f a = ∞
-- Mathlib/Algebra/Homology/DifferentialObject.lean
/-- The category of differential graded objects in `V` is equivalent
to the category of homological complexes in `V`.
-/
@[simps]
def dgoEquivHomologicalComplex :
    DifferentialObject ℤ (GradedObjectWithShift b V) ≌
      HomologicalComplex V (ComplexShape.up' b)
-- Mathlib/Data/Complex/Basic.lean
theorem conj_eq_iff_im {z : ℂ} : conj z = z ↔ z.im = 0
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem coe_toSubsemiring (S : Subalgebra R A) : (↑S.toSubsemiring : Set A) = S
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem mem_map {f : α ≃o β} {b : β} : b ∈ map f s ↔ f.symm b ∈ s
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
/-- A semilinear isometric equivalence between two normed vector spaces. -/
structure LinearIsometryEquiv (σ₁₂ : R →+* R₂) {σ₂₁ : R₂ →+* R} [RingHomInvPair σ₁₂ σ₂₁]
  [RingHomInvPair σ₂₁ σ₁₂] (E E₂ : Type*) [SeminormedAddCommGroup E] [SeminormedAddCommGroup E₂]
  [Module R E] [Module R₂ E₂] extends E ≃ₛₗ[σ₁₂] E₂ where
  norm_map' : ∀ x, ‖toLinearEquiv x‖ = ‖x‖
-- Mathlib/Topology/Algebra/Order/Compact.lean
/-- The **extreme value theorem**: if a function `f` is continuous on a closed set `s` and it is
smaller than a value in its image away from compact sets, then it has a maximum on this set. -/
@[deprecated ContinuousOn.exists_isMaxOn' (since := "2023-02-06")]
theorem ContinuousOn.exists_forall_ge' [ClosedIciTopology α] {s : Set β} {f : β → α}
    (hf : ContinuousOn f s) (hsc : IsClosed s) {x₀ : β} (h₀ : x₀ ∈ s)
    (hc : ∀ᶠ x in cocompact β ⊓ 𝓟 s, f x ≤ f x₀) : ∃ x ∈ s, ∀ y ∈ s, f y ≤ f x
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
@[simp]
theorem factorization_zero : factorization (0 : α) = 0
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem self_trans_symm (e : P₁ ≃ᵃ[k] P₂) : e.trans e.symm = refl k P₁
-- Mathlib/Data/Fin/Tuple/Reflection.lean
/-- This can be use to prove
```lean
example (a : Fin 2 → α) : a = ![a 0, a 1] :=
  (etaExpand_eq _).symm
```
-/
@[simp]
theorem etaExpand_eq {m} (v : Fin m → α) : etaExpand v = v
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
theorem derivWithin.scomp (hg : DifferentiableWithinAt 𝕜' g₁ t' (h x))
    (hh : DifferentiableWithinAt 𝕜 h s x) (hs : MapsTo h s t') (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin (g₁ ∘ h) s x = derivWithin h s x • derivWithin g₁ t' (h x)
-- Mathlib/RingTheory/Perfection.lean
theorem comp_equiv {π : P →+* R} (m : PerfectionMap p π) (x : P) :
    Perfection.coeff R p 0 (m.equiv x) = π x
-- Mathlib/FieldTheory/IntermediateField.lean
private theorem eq_of_le_of_finrank_le'' [FiniteDimensional K L] (h_le : F ≤ E)
    (h_finrank : finrank F L ≤ finrank E L) : F = E
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- The topology of uniform convergence indeed gives the same notion of convergence as
`TendstoUniformly`. -/
protected theorem tendsto_iff_tendstoUniformly {F : ι → α →ᵤ β} {f : α →ᵤ β} :
    Tendsto F p (𝓝 f) ↔ TendstoUniformly (toFun ∘ F) (toFun f) p
-- Mathlib/CategoryTheory/Comma/Presheaf.lean
@[simp]
lemma val_mk {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) {X : C} (s : yoneda.obj X ⟶ A) (u : F.obj (op X))
    (h : MakesOverArrow η s u) : val ⟨u, h⟩ = u
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem one_lt_div_of_neg (hb : b < 0) : 1 < a / b ↔ a < b
-- Mathlib/Data/Set/Basic.lean
@[simp] lemma disjoint_univ : Disjoint s univ ↔ s = ∅
-- Mathlib/Data/Seq/Computation.lean
@[simp]
theorem length_thinkN (s : Computation α) [_h : Terminates s] (n) :
    length (thinkN s n) = length s + n
-- Mathlib/Combinatorics/Enumerative/Composition.lean
/-- If one joins a list of lists and then splits the join along the right composition, one gets
back the original list of lists. -/
@[simp]
theorem splitWrtComposition_join (L : List (List α)) (c : Composition L.join.length)
    (h : map length L = c.blocks) : splitWrtComposition (join L) c = L
-- Mathlib/LinearAlgebra/Dual.lean
@[simp]
theorem LinearEquiv.dualMap_refl :
    (LinearEquiv.refl R M₁).dualMap = LinearEquiv.refl R (Dual R M₁)
-- Mathlib/Algebra/Homology/Embedding/Restriction.lean
/-- Given `K : HomologicalComplex C c'` and `e : c.Embedding c'` (satisfying `[e.IsRelIff]`),
this is the homological complex in `HomologicalComplex C c` obtained by restriction. -/
@[simps]
def restriction : HomologicalComplex C c
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- Whisker a bicone with an equivalence between the indexing types. -/
@[simps]
def whisker {f : J → C} (c : Bicone f) (g : K ≃ J) : Bicone (f ∘ g)
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem mem_range (v : V₂) : v ∈ f.range ↔ ∃ w, f w = v
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem univ_pi_eq_empty_iff : pi univ t = ∅ ↔ ∃ i, t i = ∅
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Perm.union_right {l₁ l₂ : List α} (t₁ : List α) (h : l₁ ~ l₂) : l₁ ∪ t₁ ~ l₂ ∪ t₁
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
protected theorem uniformInducing : UniformInducing ((↑) : Lp.simpleFunc E p μ → Lp E p μ)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[to_additive]
theorem mul_iff_left [CommGroup β] [TopologicalGroup β] (hf : StronglyMeasurable f) :
    StronglyMeasurable (g * f) ↔ StronglyMeasurable g
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/EulerSineProd.lean
/-- Euler's infinite product formula for the real sine function. -/
theorem _root_.Real.tendsto_euler_sin_prod (x : ℝ) :
    Tendsto (fun n : ℕ => π * x * ∏ j ∈ Finset.range n, ((1 : ℝ) - x ^ 2 / ((j : ℝ) + 1) ^ 2))
      atTop (𝓝 <| sin (π * x))
-- Mathlib/AlgebraicTopology/CechNerve.lean
/-- The Čech conerve construction, as a functor from `Arrow C`. -/
@[simps]
def cechConerve : Arrow C ⥤ CosimplicialObject C
-- Mathlib/Order/Compare.lean
@[simp]
theorem cmp_swap [Preorder α] [@DecidableRel α (· < ·)] (a b : α) : (cmp a b).swap = cmp b a
-- Mathlib/Order/Bounds/Basic.lean
theorem bddBelow_Ico : BddBelow (Ico a b)
-- Mathlib/MeasureTheory/Decomposition/SignedHahn.lean
private theorem someExistsOneDivLT_subset' : someExistsOneDivLT s (i \ j) ⊆ i
-- Mathlib/LinearAlgebra/Basis.lean
theorem Basis.repr_sum_self [Fintype ι] (b : Basis ι R M) (c : ι → R) :
    b.repr (∑ i, c i • b i) = c
-- Mathlib/CategoryTheory/Comma/Basic.lean
/-- The functor `Comma L R ⥤ Comma L' R'` induced by three functors `F₁`, `F₂`, `F`
and two natural transformations `F₁ ⋙ L' ⟶ L ⋙ F` and `R ⋙ F ⟶ F₂ ⋙ R'`. -/
@[simps]
def map : Comma L R ⥤ Comma L' R'
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
/-- Postcomposition of a 1-morphism as a functor from the category of 1-morphisms `b ⟶ c` into the
category of functors `(a ⟶ b) ⥤ (a ⟶ c)`. -/
@[simps]
def postcomposing (a b c : B) : (b ⟶ c) ⥤ (a ⟶ b) ⥤ (a ⟶ c)
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive (attr := simp)]
theorem MonoidHom.coe_mk [MulOneClass M] [MulOneClass N] (f hmul) :
    (MonoidHom.mk f hmul : M → N) = f
-- Mathlib/Order/Filter/Germ/Basic.lean
@[to_additive (attr := simp)]
theorem coe_coeMulHom [Monoid M] : (coeMulHom l : (α → M) → Germ l M) = ofFun
-- Mathlib/Algebra/Group/Units/Equiv.lean
@[to_additive]
theorem mulRight_bijective (a : Mˣ) : Function.Bijective ((· * a) : M → M)
-- Mathlib/Order/Heyting/Basic.lean
@[simp] theorem ne_compl_self [Nontrivial α] : a ≠ aᶜ
-- Mathlib/NumberTheory/ModularForms/Basic.lean
@[simp]
theorem smul_apply (f : CuspForm Γ k) (n : α) {z : ℍ} : (n • f) z = n • f z
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
theorem le_boundedBy {μ : OuterMeasure α} : μ ≤ boundedBy m ↔ ∀ s, μ s ≤ m s
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_sum_measure {ι} {_ : MeasurableSpace α} {f : α → G} {μ : ι → Measure α}
    (hf : Integrable f (Measure.sum μ)) : ∫ a, f a ∂Measure.sum μ = ∑' i, ∫ a, f a ∂μ i
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nadd_lt_nadd_right (h : b < c) (a) : b ♯ a < c ♯ a
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
theorem tprod_dite_left (P : Prop) [Decidable P] (x : β → P → α) :
    ∏' b : β, (if h : P then x b h else 1) = if h : P then ∏' b : β, x b h else 1
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem sup_limZero {f g : CauSeq α abs} (hf : LimZero f) (hg : LimZero g) : LimZero (f ⊔ g)
-- Mathlib/AlgebraicGeometry/Morphisms/Constructors.lean
theorem universally_isLocalAtTarget (P : MorphismProperty Scheme)
    (hP₂ : ∀ {X Y : Scheme.{u}} (f : X ⟶ Y) {ι : Type u} (U : ι → Y.Opens)
      (_ : iSup U = ⊤), (∀ i, P (f ∣_ U i)) → P f) : IsLocalAtTarget P.universally
-- Mathlib/Data/Int/Interval.lean
theorem card_fintype_Icc : Fintype.card (Set.Icc a b) = (b + 1 - a).toNat
-- Mathlib/Topology/Algebra/Monoid.lean
/-- Right-multiplication by a right-invertible element of a topological monoid is proper, i.e.,
inverse images of compact sets are compact. -/
theorem Filter.tendsto_cocompact_mul_right {a b : M} (ha : a * b = 1) :
    Filter.Tendsto (fun x : M => x * a) (Filter.cocompact M) (Filter.cocompact M)
-- Mathlib/Combinatorics/SetFamily/Intersecting.lean
/-- Maximal intersecting families are upper sets. -/
protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
    (h : ∀ t : Set α, t.Intersecting → s ⊆ t → s = t) : IsUpperSet s
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := simp)]
theorem preimage_mul_right_singleton : (· * a) ⁻¹' {b} = {b * a⁻¹}