ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Basic.lean
/-- If `x` is not an isolated point of a topological space, then the closure of `{x}ᶜ` is the whole
space. -/
-- Porting note (#10618): was a `@[simp]` lemma but `simp` can prove it
theorem closure_compl_singleton (x : X) [NeBot (𝓝[≠] x)] : closure {x}ᶜ = (univ : Set X)
-- Mathlib/Order/Bounds/Basic.lean
theorem image2_upperBounds_upperBounds_subset :
    image2 f (upperBounds s) (upperBounds t) ⊆ upperBounds (image2 f s t)
-- Mathlib/Algebra/BigOperators/Fin.lean
/-- A product of a function `f : Fin 0 → β` is `1` because `Fin 0` is empty -/
@[to_additive "A sum of a function `f : Fin 0 → β` is `0` because `Fin 0` is empty"]
theorem prod_univ_zero [CommMonoid β] (f : Fin 0 → β) : ∏ i, f i = 1
-- Mathlib/Probability/Independence/Conditional.lean
theorem iCondIndepSets.condIndepSets {s : ι → Set (Set Ω)}
    (h_indep : iCondIndepSets m' hm' s μ) {i j : ι} (hij : i ≠ j) :
    CondIndepSets m' hm' (s i) (s j) μ
-- Mathlib/Data/QPF/Multivariate/Basic.lean
/-- Multivariate quotients of polynomial functors.
-/
class MvQPF {n : ℕ} (F : TypeVec.{u} n → Type*) extends MvFunctor F where
  P : MvPFunctor.{u} n
  abs : ∀ {α}, P α → F α
  repr : ∀ {α}, F α → P α
  abs_repr : ∀ {α} (x : F α), abs (repr x) = x
  abs_map : ∀ {α β} (f : α ⟹ β) (p : P α), abs (f <$$> p) = f <$$> abs p
-- Mathlib/Data/Holor.lean
theorem mul_left_distrib [Distrib α] (x : Holor α ds₁) (y : Holor α ds₂) (z : Holor α ds₂) :
    x ⊗ (y + z) = x ⊗ y + x ⊗ z
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
@[simp]
lemma rpow_eq_zero (hx : 0 ≤ x) (hy : y ≠ 0) : x ^ y = 0 ↔ x = 0
-- Mathlib/CategoryTheory/Extensive.lean
lemma FinitaryExtensive.mono_ι [FinitaryExtensive C] {ι : Type*} [Finite ι] {F : Discrete ι ⥤ C}
    {c : Cocone F} (hc : IsColimit c) (i : Discrete ι) :
    Mono (c.ι.app i)
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
/-- Bijection between a subring `S` and its opposite. -/
@[simps!]
def addEquivOp (S : Subring R) : S ≃+ S.op
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
theorem orderOf_mul_dvd_lcm (h : Commute x y) :
    orderOf (x * y) ∣ Nat.lcm (orderOf x) (orderOf y)
-- Mathlib/Order/Filter/Bases.lean
theorem mem_filterBasis_iff {U : Set α} : U ∈ h.filterBasis ↔ ∃ i, p i ∧ s i = U
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem ofLeftInverse_symm_apply {f : G →* N} {g : N →* G} (h : Function.LeftInverse g f)
    (x : f.range) : (ofLeftInverse h).symm x = g x
-- Mathlib/Order/Filter/Basic.lean
theorem le_comap_map : f ≤ comap m (map m f)
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt64.toNat_add (x y : UInt64) : (x + y).toNat = (x.toNat + y.toNat) % UInt64.size
-- Mathlib/Algebra/Lie/DirectSum.lean
@[simp]
theorem lie_module_bracket_apply (x : L) (m : ⨁ i, M i) (i : ι) : ⁅x, m⁆ i = ⁅x, m i⁆
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem range_one : range 1 = {0}
-- Mathlib/Order/UpperLower/Hom.lean
@[simp]
theorem icisSupHom_apply (a : α) : icisSupHom a = Ici a
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[reassoc (attr := simp)]
theorem HasColimit.isoOfNatIso_hom_desc {F G : J ⥤ C} [HasColimit F] [HasColimit G] (t : Cocone G)
    (w : F ≅ G) :
    (HasColimit.isoOfNatIso w).hom ≫ colimit.desc G t =
      colimit.desc F ((Cocones.precompose w.hom).obj _)
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem IsRegular.cof_eq {c : Cardinal} (H : c.IsRegular) : c.ord.cof = c
-- Mathlib/Topology/Constructions.lean
/-- A map defined on a sigma type (a.k.a. the disjoint union of an indexed family of topological
spaces) is inducing iff its restriction to each component is inducing and each the image of each
component under `f` can be separated from the images of all other components by an open set. -/
theorem inducing_sigma {f : Sigma σ → X} :
    Inducing f ↔ (∀ i, Inducing (f ∘ Sigma.mk i)) ∧
      (∀ i, ∃ U, IsOpen U ∧ ∀ x, f x ∈ U ↔ x.1 = i)
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem HasDerivAt.div_const (hc : HasDerivAt c c' x) (d : 𝕜') :
    HasDerivAt (fun x => c x / d) (c' / d) x
-- Mathlib/Algebra/Category/BialgebraCat/Basic.lean
@[simp]
theorem forget₂_coalgebra_obj (X : BialgebraCat R) :
    (forget₂ (BialgebraCat R) (CoalgebraCat R)).obj X = CoalgebraCat.of R X
-- Mathlib/Data/Complex/Basic.lean
@[simp] lemma div_intCast_im (z : ℂ) (n : ℤ) : (z / n).im = z.im / n
-- Mathlib/Dynamics/OmegaLimit.lean
theorem omegaLimit_eq_iInter : ω f ϕ s = ⋂ u : ↥f.sets, closure (image2 ϕ u s)
-- Mathlib/Order/Max.lean
@[simp]
theorem isMax_ofDual_iff {a : αᵒᵈ} : IsMax (ofDual a) ↔ IsMin a
-- Mathlib/Data/Seq/Computation.lean
theorem of_think_terminates {s : Computation α} : Terminates (think s) → Terminates s
-- Mathlib/Algebra/Module/Submodule/Equiv.lean
@[simp]
theorem ofBijective_apply [RingHomInvPair σ₁₂ σ₂₁] [RingHomInvPair σ₂₁ σ₁₂] {hf} (x : M) :
    ofBijective f hf x = f x
-- Mathlib/Algebra/CharP/MixedCharZero.lean
/-- Not mixed characteristic implies equal characteristic. -/
theorem of_not_mixedCharZero [CharZero R] (h : ∀ p > 0, ¬MixedCharZero R p) :
    ∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I)
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem symm_dual_id : OrderHom.dual.symm OrderHom.id = (OrderHom.id : α →o α)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Pythagorean theorem, vector inner product form. -/
theorem norm_add_sq_eq_norm_sq_add_norm_sq_real {x y : F} (h : ⟪x, y⟫_ℝ = 0) :
    ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖
-- Mathlib/Analysis/Convex/Side.lean
theorem wSameSide_vadd_right_iff {s : AffineSubspace R P} {x y : P} {v : V} (hv : v ∈ s.direction) :
    s.WSameSide x (v +ᵥ y) ↔ s.WSameSide x y
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The Hausdorff distances from `s` to `t` and from `t` to `s` coincide. -/
theorem hausdorffDist_comm : hausdorffDist s t = hausdorffDist t s
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem inclusion.injective {x y : Subgraph G} (h : x ≤ y) : Function.Injective (inclusion h)
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma isUnramified_smul_iff :
    IsUnramified k (σ • w) ↔ IsUnramified k w
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace/ResidueField.lean
@[reassoc]
lemma evaluation_naturality {V : Opens Y} (x : (Opens.map f.1.base).obj V) :
    Y.evaluation ⟨f.val.base x, x.property⟩ ≫ residueFieldMap f x.val =
      f.val.c.app (op V) ≫ X.evaluation x
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
/-- A variant of `of_isColimit` that is more useful with `apply`. -/
theorem of_isColimit' (w : CommSq f g inl inr) (h : Limits.IsColimit w.cocone) :
    IsPushout f g inl inr
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
theorem coe_nonneg (x : Ico (0 : α) 1) : 0 ≤ (x : α)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
theorem negOfNat_add (m n : Nat) : negOfNat m + negOfNat n = negOfNat (m + n)
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
theorem colorable_chromaticNumber {m : ℕ} (hc : G.Colorable m) :
    G.Colorable (ENat.toNat G.chromaticNumber)
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
@[measurability]
protected theorem iUnion [Countable ι] {s : ι → Set α}
    (h : ∀ i, AEMeasurable f (μ.restrict (s i))) : AEMeasurable f (μ.restrict (⋃ i, s i))
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Roots.lean
/-- If `n ≠ m`, then `(cyclotomic n ℚ)` and `(cyclotomic m ℚ)` are coprime. -/
theorem cyclotomic.isCoprime_rat {n m : ℕ} (h : n ≠ m) :
    IsCoprime (cyclotomic n ℚ) (cyclotomic m ℚ)
-- Mathlib/Algebra/MvPolynomial/Rename.lean
@[simp]
theorem killCompl_rename_app (p : MvPolynomial σ R) : killCompl hf (rename f p) = p
-- Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean
lemma quasiIso_map_iff_of_preservesLeftHomology
    [F.PreservesLeftHomologyOf S₁] [F.PreservesLeftHomologyOf S₂]
    [F.ReflectsIsomorphisms] :
    QuasiIso (F.mapShortComplex.map φ) ↔ QuasiIso φ
-- Mathlib/Algebra/Algebra/Hom.lean
theorem comp_apply (φ₁ : B →ₐ[R] C) (φ₂ : A →ₐ[R] B) (p : A) : φ₁.comp φ₂ p = φ₁ (φ₂ p)
-- Mathlib/Topology/Algebra/ContinuousAffineMap.lean
@[simp]
theorem coe_mk (f : P →ᵃ[R] Q) (h) : ((⟨f, h⟩ : P →ᴬ[R] Q) : P → Q) = f
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_finset_coe (f : α → β) (s : Finset α) : (∏ i : (s : Set α), f i) = ∏ i ∈ s, f i
-- Mathlib/Data/Finset/Image.lean
theorem image_biUnion [DecidableEq γ] {f : α → β} {s : Finset α} {t : β → Finset γ} :
    (s.image f).biUnion t = s.biUnion fun a => t (f a)
-- Mathlib/RingTheory/Nilpotent/Defs.lean
@[simp]
lemma IsNilpotent.pow_iff_pos {n} {S : Type*} [MonoidWithZero S] {x : S}
    (hn : n ≠ 0) : IsNilpotent (x ^ n) ↔ IsNilpotent x
-- Mathlib/Topology/Order/OrderClosed.lean
theorem ContinuousWithinAt.closure_le [TopologicalSpace β] {f g : β → α} {s : Set β} {x : β}
    (hx : x ∈ closure s) (hf : ContinuousWithinAt f s x) (hg : ContinuousWithinAt g s x)
    (h : ∀ y ∈ s, f y ≤ g y) : f x ≤ g x
-- Mathlib/MeasureTheory/Order/Group/Lattice.lean
@[to_additive (attr := measurability)]
protected theorem Measurable.oneLePart : Measurable fun x ↦ oneLePart (f x)
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem not_limZero_of_pos {f : CauSeq α abs} : Pos f → ¬LimZero f
-- Mathlib/Analysis/Convex/Cone/InnerDual.lean
theorem ConvexCone.pointed_of_nonempty_of_isClosed (K : ConvexCone ℝ H) (ne : (K : Set H).Nonempty)
    (hc : IsClosed (K : Set H)) : K.Pointed
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem singleton_inj : ({a} : Finset α) = {b} ↔ a = b
-- Mathlib/Data/Fin/Basic.lean
protected lemma lt_or_le (a b : Fin n) : a < b ∨ b ≤ a
-- Mathlib/Analysis/Calculus/Deriv/Polynomial.lean
@[simp]
protected theorem fderiv :
    fderiv 𝕜 (fun x => p.eval x) x = smulRight (1 : 𝕜 →L[𝕜] 𝕜) (p.derivative.eval x)
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem splits_of_splits_of_dvd {f g : K[X]} (hf0 : f ≠ 0) (hf : Splits i f) (hgf : g ∣ f) :
    Splits i g
-- Mathlib/Algebra/Order/Field/Basic.lean
@[gcongr]
lemma div_lt_div_of_pos_left (ha : 0 < a) (hc : 0 < c) (h : c < b) : a / b < a / c
-- Mathlib/RingTheory/OreLocalization/Ring.lean
theorem numeratorHom_inj (hS : S ≤ nonZeroDivisorsRight R) :
    Function.Injective (numeratorHom : R → R[S⁻¹])
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma Y_eq_iff' {P Q : Fin 3 → F} (hPz : P z ≠ 0) (hQz : Q z ≠ 0) :
    P y * Q z ^ 3 = W.negY Q * P z ^ 3 ↔
      P y / P z ^ 3 = W.toAffine.negY (Q x / Q z ^ 2) (Q y / Q z ^ 3)
-- Mathlib/Data/Seq/Seq.lean
theorem not_terminates_iff {s : Seq α} : ¬s.Terminates ↔ ∀ n, (s.get? n).isSome
-- Mathlib/Analysis/Calculus/FDeriv/Comp.lean
theorem fderivWithin.comp {g : F → G} {t : Set F} (hg : DifferentiableWithinAt 𝕜 g t (f x))
    (hf : DifferentiableWithinAt 𝕜 f s x) (h : MapsTo f s t) (hxs : UniqueDiffWithinAt 𝕜 s x) :
    fderivWithin 𝕜 (g ∘ f) s x = (fderivWithin 𝕜 g t (f x)).comp (fderivWithin 𝕜 f s x)
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive]
theorem comp_mulIndicator_const (c : M) (f : M → N) (hf : f 1 = 1) :
    (fun x => f (s.mulIndicator (fun _ => c) x)) = s.mulIndicator fun _ => f c
-- Mathlib/Data/DFinsupp/Basic.lean
theorem support_update_ne_zero (f : Π₀ i, β i) (i : ι) {b : β i} (h : b ≠ 0) :
    support (f.update i b) = insert i f.support
-- Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean
lemma hasLeftExtension_iff_of_iso₂ : HasLeftKanExtension L F ↔ HasLeftKanExtension L F'
-- Mathlib/Algebra/Polynomial/Reverse.lean
@[simp] lemma reflect_one_X : reflect 1 (X : R[X]) = 1
-- Mathlib/Data/List/OfFn.lean
theorem mem_ofFn {n} (f : Fin n → α) (a : α) : a ∈ ofFn f ↔ a ∈ Set.range f
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem cauchy_complete_ℒp [CompleteSpace E] (hp : 1 ≤ p) {f : ℕ → α → E}
    (hf : ∀ n, Memℒp (f n) p μ) {B : ℕ → ℝ≥0∞} (hB : ∑' i, B i ≠ ∞)
    (h_cau : ∀ N n m : ℕ, N ≤ n → N ≤ m → eLpNorm (f n - f m) p μ < B N) :
    ∃ (f_lim : α → E), Memℒp f_lim p μ ∧
      atTop.Tendsto (fun n => eLpNorm (f n - f_lim) p μ) (𝓝 0)
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
@[simp]
theorem mapRange_apply {f : M →+ N} (hf : Continuous f) {s : Set α} : v.mapRange f hf s = f (v s)
-- Mathlib/Algebra/BigOperators/Finsupp.lean
theorem comp_liftAddHom [AddCommMonoid M] [AddCommMonoid N] [AddCommMonoid P] (g : N →+ P)
    (f : α → M →+ N) :
    g.comp ((liftAddHom (α := α) (M := M) (N := N)) f) =
      (liftAddHom (α := α) (M := M) (N := P)) fun a => g.comp (f a)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem zipWith_distrib_drop : (zipWith f l l').drop n = zipWith f (l.drop n) (l'.drop n)
-- Mathlib/RingTheory/PrincipalIdealDomain.lean
theorem generator_submoduleImage_dvd_of_mem {N O : Submodule R M} (hNO : N ≤ O) (ϕ : O →ₗ[R] R)
    [(ϕ.submoduleImage N).IsPrincipal] {x : M} (hx : x ∈ N) :
    generator (ϕ.submoduleImage N) ∣ ϕ ⟨x, hNO hx⟩
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean
theorem to_eq (h : IsZero X) (f : X ⟶ Y) : h.to_ Y = f
-- Mathlib/Data/Nat/Defs.lean
lemma lt_succ_sqrt (n : ℕ) : n < succ (sqrt n) * succ (sqrt n)
-- Mathlib/Data/ENNReal/Basic.lean
theorem toReal_eq_toReal_iff' {x y : ℝ≥0∞} (hx : x ≠ ⊤) (hy : y ≠ ⊤) :
    x.toReal = y.toReal ↔ x = y
-- Mathlib/Data/Nat/Factorization/Root.lean
@[simp] lemma ceilRoot_one_right (hn : n ≠ 0) : ceilRoot n 1 = 1
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem generateFrom_le {s : Set (Set α)} {m : MeasurableSpace α}
    (h : ∀ t ∈ s, MeasurableSet[m] t) : generateFrom s ≤ m
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_finset_of_fintype [Fintype α] : #(Finset α) = 2 ^ Fintype.card α
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem monotone_mul_right_of_nonneg [MulPosMono α]
    (ha : 0 ≤ a) : Monotone fun x => x * a
-- Mathlib/Algebra/Group/Support.lean
@[to_additive]
theorem mulSupport_mulSingle_disjoint {b' : B} (hb : b ≠ 1) (hb' : b' ≠ 1) {i j : A} :
    Disjoint (mulSupport (mulSingle i b)) (mulSupport (mulSingle j b')) ↔ i ≠ j
-- Mathlib/Data/Set/Lattice.lean
theorem Iic_iInf₂ (f : ∀ i, κ i → α) : Iic (⨅ (i) (j), f i j) = ⋂ (i) (j), Iic (f i j)
-- Mathlib/Data/DFinsupp/Basic.lean
@[to_additive]
theorem prod_finset_sum_index {γ : Type w} {α : Type x} [∀ i, AddCommMonoid (β i)]
    [∀ (i) (x : β i), Decidable (x ≠ 0)] [CommMonoid γ] {s : Finset α} {g : α → Π₀ i, β i}
    {h : ∀ i, β i → γ} (h_zero : ∀ i, h i 0 = 1)
    (h_add : ∀ i b₁ b₂, h i (b₁ + b₂) = h i b₁ * h i b₂) :
    (∏ i ∈ s, (g i).prod h) = (∑ i ∈ s, g i).prod h
-- Mathlib/Analysis/CstarAlgebra/GelfandDuality.lean
/-- The functorial map taking `ψ : A →⋆ₐ[ℂ] B` to a continuous function
`characterSpace ℂ B → characterSpace ℂ A` obtained by pre-composition with `ψ`. -/
@[simps]
noncomputable def compContinuousMap (ψ : A →⋆ₐ[𝕜] B) :
    C(characterSpace 𝕜 B, characterSpace 𝕜 A)
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
@[simp]
theorem mem_op {x : Rᵐᵒᵖ} {S : Subring R} : x ∈ S.op ↔ x.unop ∈ S
-- Mathlib/Computability/TMToPartrec.lean
@[simp]
theorem codeSupp_fix (f k) :
    codeSupp (Code.fix f) k = trStmts₁ (trNormal (Code.fix f) k) ∪ codeSupp f (Cont'.fix f k)
-- Mathlib/Data/Finset/Basic.lean
lemma filter_inj' : s.filter p = s.filter q ↔ ∀ ⦃a⦄, a ∈ s → (p a ↔ q a)
-- Mathlib/Data/Setoid/Basic.lean
/-- Given a map `f : N → M` and an equivalence relation `r` on `β`, the equivalence relation
    induced on `α` by `f` equals the kernel of `r`'s quotient map composed with `f`. -/
theorem comap_eq {f : α → β} {r : Setoid β} : comap f r = ker (@Quotient.mk'' _ r ∘ f)
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
/-- Alias for `Or.inr`. -/
theorem Or.intro_right (a : Prop) (h : b) : Or a b
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem eq_top_of_isUnit_mem {x} (hx : x ∈ I) (h : IsUnit x) : I = ⊤
-- Mathlib/CategoryTheory/Comma/Over.lean
@[simp]
theorem map_obj_hom : ((map f).obj U).hom = U.hom ≫ f
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem algebraicIndependent_empty_type [IsEmpty ι] [Nontrivial A] : AlgebraicIndependent K x
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive (attr := simp)]
theorem swap_mul [Mul M] [Mul N] (p q : M × N) : (p * q).swap = p.swap * q.swap
-- Mathlib/Order/CompleteLattice.lean
@[simp]
theorem sSup_insert {a : α} {s : Set α} : sSup (insert a s) = a ⊔ sSup s
-- Mathlib/AlgebraicTopology/Quasicategory.lean
lemma Quasicategory.hornFilling {S : SSet} [Quasicategory S] ⦃n : ℕ⦄ ⦃i : Fin (n+1)⦄
    (h0 : 0 < i) (hn : i < Fin.last n)
    (σ₀ : Λ[n, i] ⟶ S) : ∃ σ : Δ[n] ⟶ S, σ₀ = hornInclusion n i ≫ σ
-- Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean
@[reassoc]
theorem pentagon_inv_inv_hom (W X Y Z : C) :
    (α_ W (X ⊗ Y) Z).inv ≫ ((α_ W X Y).inv ⊗ 𝟙 Z) ≫ (α_ (W ⊗ X) Y Z).hom =
      (𝟙 W ⊗ (α_ X Y Z).hom) ≫ (α_ W X (Y ⊗ Z)).inv
-- Mathlib/FieldTheory/PerfectClosure.lean
@[simp]
theorem liftOn_mk {L : Sort _} (f : ℕ × K → L) (hf : ∀ x y, R K p x y → f x = f y) (x : ℕ × K) :
    (mk K p x).liftOn f hf = f x
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- The product of an antitone function and a strictly antitone function is strictly antitone. -/
@[to_additive add_strictAnti "The sum of an antitone function and a strictly antitone function is
strictly antitone."]
theorem AntitoneOn.mul_strictAnti' [CovariantClass α α (· * ·) (· < ·)]
    [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {f g : β → α} (hf : AntitoneOn f s)
    (hg : StrictAntiOn g s) :
    StrictAntiOn (fun x => f x * g x) s
-- Mathlib/LinearAlgebra/DirectSum/Finsupp.lean
theorem finsuppTensorFinsupp'_symm_single_eq_single_one_tmul (i : ι × κ) (r : R) :
    (finsuppTensorFinsupp' R ι κ).symm (Finsupp.single i r) =
      Finsupp.single i.1 1 ⊗ₜ Finsupp.single i.2 r
-- Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean
theorem ringQuot_mkAlgHom_freeAlgebra_ι_eq_ι (m : M) :
    RingQuot.mkAlgHom R (Rel R M) (FreeAlgebra.ι R m) = ι R m
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem iUnion_Icc_add_zsmul : ⋃ n : ℤ, Icc (a + n • p) (a + (n + 1) • p) = univ
-- Mathlib/Topology/Order/OrderClosed.lean
theorem eventually_ge_nhds (hab : b < a) : ∀ᶠ x in 𝓝 a, b ≤ x
-- Mathlib/Data/String/Lemmas.lean
lemma leftpad_suffix (n : ℕ) (c : Char) : ∀ s, IsSuffix s (leftpad n c s)
-- Mathlib/Algebra/Tropical/BigOperators.lean
theorem Finset.trop_inf [LinearOrder R] [OrderTop R] (s : Finset S) (f : S → R) :
    trop (s.inf f) = ∑ i ∈ s, trop (f i)
-- Mathlib/Combinatorics/Quiver/SingleObj.lean
theorem listToPath_pathToList {x : SingleObj α} (p : Path (star α) x) :
    listToPath (pathToList p) = p.cast rfl ext
-- Mathlib/RingTheory/HahnSeries/Addition.lean
/-- `single` as a linear map -/
@[simps]
def single.linearMap (a : Γ) : V →ₗ[R] HahnSeries Γ V
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
protected lemma eq_inv_mul_iff_mul_eq (h : IsUnit b) : a = b⁻¹ * c ↔ b * a = c
-- Mathlib/Topology/Order/NhdsSet.lean
@[simp]
theorem Ioi_mem_nhdsSet_Ici_iff : Ioi a ∈ 𝓝ˢ (Ici b) ↔ a < b
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive succ_nsmul'] lemma pow_succ' (a : M) : ∀ n, a ^ (n + 1) = a * a ^ n
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma stieltjesOfMeasurableRat_eq (hf : Measurable f) (a : α) (r : ℚ) :
    stieltjesOfMeasurableRat f hf a r = toRatCDF f a r
-- Mathlib/Algebra/Order/Sub/Defs.lean
protected theorem tsub_eq_of_eq_add_rev (hb : AddLECancellable b) (h : a = b + c) : a - b = c
-- Mathlib/FieldTheory/Separable.lean
theorem isUnit_or_eq_zero_of_separable_expand {f : F[X]} (n : ℕ) (hp : 0 < p)
    (hf : (expand F (p ^ n) f).Separable) : IsUnit f ∨ n = 0
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem Or.neg_resolve_left  (h : Or (Not a) b) (ha : a) : b
-- Mathlib/Order/Filter/Curry.lean
theorem frequently_curry_prod_iff {α β : Type*} {l : Filter α} {m : Filter β}
    (s : Set α) (t : Set β) : (∃ᶠ x in l.curry m, x ∈ s ×ˢ t) ↔ sᶜ ∉ l ∧ tᶜ ∉ m
-- Mathlib/Data/Int/Cast/Lemmas.lean
@[simp] lemma zmultiplesAddHom_apply (x : β) (n : ℤ) : zmultiplesAddHom β x n = n • x
-- Mathlib/Order/RelClasses.lean
@[trans]
lemma ssubset_trans [IsTrans α (· ⊂ ·)] {a b c : α} : a ⊂ b → b ⊂ c → a ⊂ c
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean
theorem differentiable_arctan : Differentiable ℝ arctan
-- Mathlib/Algebra/Homology/ComplexShapeSigns.lean
lemma rel_π₂ (i₁ : I₁) {i₂ i₂' : I₂} (h : c₂.Rel i₂ i₂') :
    c₁₂.Rel (π c₁ c₂ c₁₂ ⟨i₁, i₂⟩) (π c₁ c₂ c₁₂ ⟨i₁, i₂'⟩)
-- Mathlib/Analysis/Normed/Group/Basic.lean
theorem ofReal_le_ennnorm (r : ℝ) : ENNReal.ofReal r ≤ ‖r‖₊
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem monotone_rpow_of_nonneg {z : ℝ} (h : 0 ≤ z) : Monotone fun x : ℝ≥0 => x ^ z
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
/-- Two families of seminorms `p` and `q` on the same space generate the same topology
if each `p i` is bounded by some `C • Finset.sup s q` and vice-versa.

We formulate these boundedness assumptions as `Seminorm.IsBounded q p LinearMap.id` (and
vice-versa) to reuse the API. Furthermore, we don't actually state it as an equality of topologies
but as a way to deduce `WithSeminorms q` from `WithSeminorms p`, since this should be more
useful in practice. -/
protected theorem congr {p : SeminormFamily 𝕜 E ι} {q : SeminormFamily 𝕜 E ι'}
    [t : TopologicalSpace E] (hp : WithSeminorms p) (hpq : Seminorm.IsBounded p q LinearMap.id)
    (hqp : Seminorm.IsBounded q p LinearMap.id) : WithSeminorms q
-- Mathlib/Algebra/Associated/Basic.lean
theorem not_irreducible_of_not_unit_dvdNotUnit [CommMonoidWithZero α] {p q : α} (hp : ¬IsUnit p)
    (h : DvdNotUnit p q) : ¬Irreducible q
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem uIcc_eq [LocallyFiniteOrder α] [LocallyFiniteOrder β]
    [DecidableRel ((· ≤ ·) : α × β → α × β → Prop)] (p q : α × β) :
    Finset.uIcc p q = Finset.uIcc p.1 q.1 ×ˢ Finset.uIcc p.2 q.2
-- Mathlib/Geometry/Manifold/ContMDiff/Atlas.lean
theorem contMDiffAt_symm_of_mem_maximalAtlas {x : H} (h : e ∈ maximalAtlas I M)
    (hx : x ∈ e.target) : ContMDiffAt I I n e.symm x
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem bind_map (f : α → β) (g : β → List γ) (l : List α) : (map f l).bind g = l.bind (fun a => g (f a))
-- Mathlib/MeasureTheory/SetAlgebra.lean
/-- If a family of sets is countable then so is the algebra of sets generated by it. -/
theorem countable_generateSetAlgebra (h : 𝒜.Countable) :
    (generateSetAlgebra 𝒜).Countable
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
lemma NNReal.dist_eq (a b : ℝ≥0) : dist a b = |(a : ℝ) - b|
-- Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean
theorem arg_expMapCircle {x : ℝ} (h₁ : -π < x) (h₂ : x ≤ π) : arg (expMapCircle x) = x
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
@[fun_prop]
theorem ContinuousOn.log (hf : ContinuousOn f s) (h₀ : ∀ x ∈ s, f x ≠ 0) :
    ContinuousOn (fun x => log (f x)) s
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
theorem UniqueDiffOn.image {f' : E → E →L[𝕜] F} (hs : UniqueDiffOn 𝕜 s)
    (hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) (hd : ∀ x ∈ s, DenseRange (f' x)) :
    UniqueDiffOn 𝕜 (f '' s)
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- Over a characteristic-zero division ring, the centroids given by
two subsets of the points of a simplex are equal if and only if those
faces are given by the same subset of points. -/
@[simp]
theorem centroid_eq_iff [CharZero k] {n : ℕ} (s : Simplex k P n) {fs₁ fs₂ : Finset (Fin (n + 1))}
    {m₁ m₂ : ℕ} (h₁ : fs₁.card = m₁ + 1) (h₂ : fs₂.card = m₂ + 1) :
    fs₁.centroid k s.points = fs₂.centroid k s.points ↔ fs₁ = fs₂
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem lt_add_right (c : Nat) (h : a < b) : a < b + c
-- Mathlib/Order/Lattice.lean
theorem sup_assoc (a b c : α) : a ⊔ b ⊔ c = a ⊔ (b ⊔ c)
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
/-- This is also available as `_root_.div_eq_mul_inv`, using the
`Semifield` instance defined below.
-/
protected theorem div_eq_mul_inv [IsDedekindDomain A] (I J : FractionalIdeal A⁰ K) :
    I / J = I * J⁻¹
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem coe_homothetyUnitsMulHom_eq_homothetyHom_coe (p : P) :
    ((↑) : (P ≃ᵃ[R] P) → P →ᵃ[R] P) ∘ homothetyUnitsMulHom p =
      AffineMap.homothetyHom p ∘ ((↑) : Rˣ → R)
-- Mathlib/Data/Set/Function.lean
lemma _root_.Set.leftInvOn_id (s : Set α) : LeftInvOn id id s
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem ceil_zero : ⌈(0 : α)⌉₊ = 0
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem Matrix.coe_mulVecLin [Fintype n] (M : Matrix m n R) :
    (M.mulVecLin : _ → _) = M.mulVec