ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Adjunction/FullyFaithful.lean
/-- If the counit of an is an isomorphism, one has an isomorphism `(R ⋙ L ⋙ R) ≅ R`. -/
@[simps!]
noncomputable def whiskerLeftRUnitIsoOfIsIsoCounit [IsIso h.counit] : R ⋙ L ⋙ R ≅ R
-- Mathlib/RepresentationTheory/Rep.lean
/-- Given a `k`-linear `G`-representation `A`, there is a `k`-linear isomorphism between
representation morphisms `Hom(k[G], A)` and `A`. -/
@[simps]
noncomputable def leftRegularHomEquiv (A : Rep k G) : (Rep.ofMulAction k G G ⟶ A) ≃ₗ[k] A
-- Mathlib/SetTheory/Surreal/Multiplication.lean
/-- `ArgsRel` is well-founded. -/
theorem argsRel_wf : WellFounded ArgsRel
-- Mathlib/NumberTheory/PythagoreanTriples.lean
private theorem coprime_sq_sub_sq_add_of_even_odd {m n : ℤ} (h : Int.gcd m n = 1) (hm : m % 2 = 0)
    (hn : n % 2 = 1) : Int.gcd (m ^ 2 - n ^ 2) (m ^ 2 + n ^ 2) = 1
-- Mathlib/Order/CompleteLattice.lean
theorem le_iSup' (f : ι → α) (i : ι) : f i ≤ iSup f
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem nhds_basis_closedBall_pow {r : ℝ} (h0 : 0 < r) (h1 : r < 1) :
    (𝓝 x).HasBasis (fun _ => True) fun n : ℕ => closedBall x (r ^ n)
-- Mathlib/Algebra/Order/Interval/Set/Monoid.lean
@[simp]
theorem image_const_add_Ioo : (fun x => a + x) '' Ioo b c = Ioo (a + b) (a + c)
-- Mathlib/Algebra/Group/Support.lean
@[to_additive (attr := simp)]
theorem mulSupport_inv' : mulSupport f⁻¹ = mulSupport f
-- Mathlib/Data/Set/Card.lean
@[simp] theorem ncard_inter_add_ncard_diff_eq_ncard (s t : Set α)
    (hs : s.Finite := by toFinite_tac) : (s ∩ t).ncard + (s \ t).ncard = s.ncard
-- Mathlib/Data/Complex/Exponential.lean
theorem exp_int_mul (z : ℂ) (n : ℤ) : Complex.exp (n * z) = Complex.exp z ^ n
-- Mathlib/Algebra/Order/Ring/WithTop.lean
/-- A version of `WithTop.map` for `RingHom`s. -/
@[simps (config := .asFn)]
protected def _root_.RingHom.withTopMap {R S : Type*} [CanonicallyOrderedCommSemiring R]
    [DecidableEq R] [Nontrivial R] [CanonicallyOrderedCommSemiring S] [DecidableEq S] [Nontrivial S]
    (f : R →+* S) (hf : Function.Injective f) : WithTop R →+* WithTop S
-- Mathlib/SetTheory/Cardinal/Finite.lean
@[simp]
theorem card_ulift (α : Type*) : Nat.card (ULift α) = Nat.card α
-- Mathlib/Algebra/GCDMonoid/Finset.lean
theorem lcm_mono (h : s₁ ⊆ s₂) : s₁.lcm f ∣ s₂.lcm f
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma Y_ne_zero_of_Z_eq_zero [NoZeroDivisors R] {P : Fin 3 → R} (hP : W'.Nonsingular P)
    (hPz : P z = 0) : P y ≠ 0
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem map_comp_inl (f : M →* M') (g : N →* N') : (map f g).comp inl = inl.comp f
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem subset_interior_mul_left : interior s * t ⊆ interior (s * t)
-- Mathlib/Algebra/DualNumber.lean
@[simp]
theorem snd_eps [Zero R] [One R] : snd ε = (1 : R)
-- Mathlib/Order/Lattice.lean
theorem inf_sup_right (a b c : α) : (a ⊔ b) ⊓ c = a ⊓ c ⊔ b ⊓ c
-- Mathlib/Order/RelClasses.lean
theorem ssubset_iff_subset_not_subset : a ⊂ b ↔ a ⊆ b ∧ ¬b ⊆ a
-- Mathlib/Data/Nat/PartENat.lean
theorem not_isMax_natCast (x : ℕ) : ¬IsMax (x : PartENat)
-- Mathlib/Data/Matrix/Basic.lean
theorem conjTranspose_map [Star α] [Star β] {A : Matrix m n α} (f : α → β)
    (hf : Function.Semiconj f star star) : Aᴴ.map f = (A.map f)ᴴ
-- Mathlib/NumberTheory/ModularForms/Basic.lean
lemma toSlashInvariantForm_natCast (Γ : Subgroup SL(2, ℤ)) (n : ℕ) :
    (n : ModularForm Γ 0).toSlashInvariantForm = n
-- Mathlib/Analysis/Convex/Side.lean
theorem setOf_wOppSide_eq_image2 {s : AffineSubspace R P} {x p : P} (hx : x ∉ s) (hp : p ∈ s) :
    { y | s.WOppSide x y } = Set.image2 (fun (t : R) q => t • (x -ᵥ p) +ᵥ q) (Set.Iic 0) s
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem Poly.denote_le_cancel_eq (ctx : Context) (m₁ m₂ : Poly) : denote_le ctx (cancel m₁ m₂) = denote_le ctx (m₁, m₂)
-- Mathlib/Analysis/SpecialFunctions/Gamma/Deligne.lean
/-- Another formulation of the reflection formula in terms of `Gammaℝ`. -/
lemma Gammaℝ_div_Gammaℝ_one_sub {s : ℂ} (hs : ∀ (n : ℕ), s ≠ -(2 * n + 1)) :
    Gammaℝ s / Gammaℝ (1 - s) = Gammaℂ s * cos (π * s / 2)
-- Mathlib/Order/Heyting/Basic.lean
theorem sup_sdiff_distrib (a b c : α) : (a ⊔ b) \ c = a \ c ⊔ b \ c
-- Mathlib/Topology/Compactness/Compact.lean
theorem Tendsto.isCompact_insert_range {f : ℕ → X} {x} (hf : Tendsto f atTop (𝓝 x)) :
    IsCompact (insert x (range f))
-- Mathlib/CategoryTheory/Whiskering.lean
@[simp]
theorem isoWhiskerLeft_hom (F : C ⥤ D) {G H : D ⥤ E} (α : G ≅ H) :
    (isoWhiskerLeft F α).hom = whiskerLeft F α.hom
-- Mathlib/CategoryTheory/Monoidal/Internal/FunctorCategory.lean
/-- Functor translating a monoid object in a functor category
to a functor into the category of monoid objects.
-/
@[simps]
def functor : Mon_ (C ⥤ D) ⥤ C ⥤ Mon_ D
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem Nonempty.of_vsub_left : (s -ᵥ t : Set α).Nonempty → s.Nonempty
-- Mathlib/Data/Matroid/Sum.lean
@[simp] lemma sum'_ground_eq (M : ι → Matroid α) :
    (Matroid.sum' M).E = ⋃ i, Prod.mk i '' (M i).E
-- Mathlib/Topology/Compactness/Compact.lean
theorem Prod.noncompactSpace_iff :
    NoncompactSpace (X × Y) ↔ NoncompactSpace X ∧ Nonempty Y ∨ Nonempty X ∧ NoncompactSpace Y
-- Mathlib/Analysis/SpecificLimits/Normed.lean
@[simp]
theorem continuousAt_zpow {𝕜 : Type*} [NontriviallyNormedField 𝕜] {m : ℤ} {x : 𝕜} :
    ContinuousAt (fun x ↦ x ^ m) x ↔ x ≠ 0 ∨ 0 ≤ m
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem le_one_of_mul_le_right [ContravariantClass α α (· * ·) (· ≤ ·)] {a b : α} (h : a * b ≤ a) :
    b ≤ 1
-- Mathlib/Data/Matroid/Map.lean
@[simp] lemma map_dual {hf} : (M.map f hf)✶ = M✶.map f hf
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem tensorTensorTensorAssoc_symm_tmul (m : M) (n : N) (p : P) (q : Q) :
    (tensorTensorTensorAssoc R M N P Q).symm (m ⊗ₜ (n ⊗ₜ p) ⊗ₜ q) = m ⊗ₜ n ⊗ₜ (p ⊗ₜ q)
-- Mathlib/Algebra/Associated/Basic.lean
protected theorem Associated.irreducible [Monoid α] {p q : α} (h : p ~ᵤ q) (hp : Irreducible p) :
    Irreducible q
-- Mathlib/Order/CompleteBooleanAlgebra.lean
theorem sup_iInf_eq (a : α) (f : ι → α) : (a ⊔ ⨅ i, f i) = ⨅ i, a ⊔ f i
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
theorem addHaar_ball_of_pos (x : E) {r : ℝ} (hr : 0 < r) :
    μ (ball x r) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (ball 0 1)
-- Mathlib/Data/Set/Prod.lean
@[gcongr]
theorem prod_mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : s₁ ×ˢ t₁ ⊆ s₂ ×ˢ t₂
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- Adding a point to a finite-dimensional subspace increases the dimension by at most one. -/
theorem finrank_vectorSpan_insert_le (s : AffineSubspace k P) (p : P) :
    finrank k (vectorSpan k (insert p (s : Set P))) ≤ finrank k s.direction + 1
-- Mathlib/Order/Interval/Set/Monotone.lean
protected theorem Monotone.Ioi (hf : Monotone f) : Antitone fun x => Ioi (f x)
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
theorem fderiv_pi (h : ∀ i, DifferentiableAt 𝕜 (φ i) x) :
    fderiv 𝕜 (fun x i => φ i x) x = pi fun i => fderiv 𝕜 (φ i) x
-- Mathlib/Analysis/Normed/Group/AddTorsor.lean
/-- The distance equals the norm of subtracting two points. In this
lemma, it is necessary to have `V` as an explicit argument; otherwise
`rw dist_eq_norm_vsub'` sometimes doesn't work. -/
theorem dist_eq_norm_vsub' (x y : P) : dist x y = ‖y -ᵥ x‖
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Ioc_mem_nhds {a b x : α} (ha : a < x) (hb : x < b) : Ioc a b ∈ 𝓝 x
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem toLp_injective [μ.IsOpenPosMeasure] [NormedField 𝕜] [NormedSpace 𝕜 E] :
    Function.Injective (⇑(toLp p μ 𝕜 : (α →ᵇ E) →L[𝕜] Lp E p μ))
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
/-- The `erase` function preserves the ordering invariants. -/
protected theorem Ordered.erase {t : RBNode α} (h : t.Ordered cmp) : (erase cut t).Ordered cmp
-- Mathlib/Topology/Algebra/Monoid.lean
@[to_additive (attr := fun_prop)]
theorem ContinuousOn.mul {f g : X → M} {s : Set X} (hf : ContinuousOn f s) (hg : ContinuousOn g s) :
    ContinuousOn (fun x => f x * g x) s
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
theorem opNorm_le_of_nhds_zero {f : E →SL[σ₁₂] F} {C : ℝ} (hC : 0 ≤ C)
    (hf : ∀ᶠ x in 𝓝 (0 : E), ‖f x‖ ≤ C * ‖x‖) : ‖f‖ ≤ C
-- Mathlib/FieldTheory/Adjoin.lean
theorem rank_adjoin_simple_eq_one_iff :
    Module.rank F F⟮α⟯ = 1 ↔ α ∈ (⊥ : IntermediateField F E)
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
protected theorem le_add_left (h : μ ≤ ν) : μ ≤ ν' + ν
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
theorem kahler_mul (a x y : E) : o.kahler x a * o.kahler a y = ‖a‖ ^ 2 * o.kahler x y
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem eval₂_eq_zero_of_dvd_of_eval₂_eq_zero (h : p ∣ q) (h0 : eval₂ f x p = 0) :
    eval₂ f x q = 0
-- Mathlib/RingTheory/Polynomial/Basic.lean
theorem is_fg_degreeLE [IsNoetherianRing R] (I : Ideal R[X]) (n : ℕ) :
    Submodule.FG (I.degreeLE n)
-- Mathlib/Data/Seq/WSeq.lean
theorem destruct_congr {s t : WSeq α} :
    s ~ʷ t → Computation.LiftRel (BisimO (· ~ʷ ·)) (destruct s) (destruct t)
-- Mathlib/RingTheory/Coalgebra/Hom.lean
@[simp]
theorem counit_comp_apply (f : F) (x : A) : counit (f x) = counit (R := R) x
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
theorem drop_length_cons {l : List α} (h : l ≠ []) (a : α) :
    (a :: l).drop l.length = [l.getLast h]
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem modEq_iff_toIcoMod_ne_toIocMod : a ≡ b [PMOD p] ↔ toIcoMod hp a b ≠ toIocMod hp a b
-- Mathlib/Algebra/Order/Group/Int.lean
theorem abs_le_one_iff {a : ℤ} : |a| ≤ 1 ↔ a = 0 ∨ a = 1 ∨ a = -1
-- Mathlib/Algebra/Star/Basic.lean
@[simp]
theorem star_zpow [Group R] [StarMul R] (x : R) (z : ℤ) : star (x ^ z) = star x ^ z
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive (attr := simp, nolint simpNF)]
theorem mulEquivOfMulEquiv_mk' {k : LocalizationMap T Q} {j : M ≃* P} (H : S.map j.toMonoidHom = T)
    (x y) :
    f.mulEquivOfMulEquiv k H (f.mk' x y) = k.mk' (j x) ⟨j y, H ▸ Set.mem_image_of_mem j y.2⟩
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem norm_Integral_le_one : ‖Integral‖ ≤ 1
-- Mathlib/CategoryTheory/Filtered/Basic.lean
/-- If Cᵒᵖ is filtered, then C is cofiltered. -/
lemma isCofiltered_of_isFiltered_op [IsFiltered Cᵒᵖ] : IsCofiltered C
-- Mathlib/Algebra/Module/Equiv/Basic.lean
/--
The `R`-linear equivalence between additive morphisms `A →+ B` and `ℤ`-linear morphisms `A →ₗ[ℤ] B`.
-/
@[simps]
def addMonoidHomLequivInt {A B : Type*} (R : Type*) [Semiring R] [AddCommGroup A] [AddCommGroup B]
    [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℤ] B
-- Mathlib/Data/Finset/Sups.lean
theorem infs_infs_infs_comm : s ⊼ t ⊼ (u ⊼ v) = s ⊼ u ⊼ (t ⊼ v)
-- Mathlib/GroupTheory/Abelianization.lean
/-- See note [partially-applied ext lemmas]. -/
@[ext]
theorem hom_ext (φ ψ : Abelianization G →* A) (h : φ.comp of = ψ.comp of) : φ = ψ
-- Mathlib/AlgebraicTopology/DoldKan/PInfty.lean
@[simp]
theorem QInfty_f_0 : (QInfty.f 0 : X _[0] ⟶ X _[0]) = 0
-- Mathlib/Combinatorics/Colex.lean
/-- Strictly monotone functions preserve the colex ordering. -/
lemma toColex_image_lt_toColex_image (hf : StrictMono f) :
    toColex (s.image f) < toColex (t.image f) ↔ toColex s < toColex t
-- Mathlib/Dynamics/PeriodicPts.lean
protected theorem add (hn : IsPeriodicPt f n x) (hm : IsPeriodicPt f m x) :
    IsPeriodicPt f (n + m) x
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem coe_toDiffeomorph : ⇑e.toDiffeomorph = e
-- Mathlib/Topology/Algebra/Nonarchimedean/Bases.lean
theorem of_comm {A ι : Type*} [CommRing A] (B : ι → AddSubgroup A)
    (inter : ∀ i j, ∃ k, B k ≤ B i ⊓ B j) (mul : ∀ i, ∃ j, (B j : Set A) * B j ⊆ B i)
    (leftMul : ∀ x : A, ∀ i, ∃ j, (B j : Set A) ⊆ (fun y : A => x * y) ⁻¹' B i) :
    RingSubgroupsBasis B
-- Mathlib/Data/Fin/Tuple/Finset.lean
lemma cons_mem_piFinset_cons {x₀ : α 0} {x : ∀ i : Fin n, α i.succ}
    {s₀ : Finset (α 0)} {s : ∀ i : Fin n, Finset (α i.succ)} :
    cons x₀ x ∈ piFinset (cons s₀ s) ↔ x₀ ∈ s₀ ∧ x ∈ piFinset s
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
@[simp] theorem le_toNat {n : Nat} {z : Int} (h : 0 ≤ z) : n ≤ z.toNat ↔ (n : Int) ≤ z
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem swap_apply_left (a b : α) : swap a b a = b
-- Mathlib/Topology/Order/IntermediateValue.lean
/-- A continuous function which tendsto `Filter.atTop` along `Filter.atTop` and to `atBot` along
`at_bot` is surjective. -/
theorem Continuous.surjective {f : α → δ} (hf : Continuous f) (h_top : Tendsto f atTop atTop)
    (h_bot : Tendsto f atBot atBot) : Function.Surjective f
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
protected theorem coe_add (x y : S) : (↑(x + y) : A) = ↑x + ↑y
-- Mathlib/Analysis/Convex/Function.lean
theorem StrictConcaveOn.convex_gt (hf : StrictConcaveOn 𝕜 s f) (r : β) :
    Convex 𝕜 ({ x ∈ s | r < f x })
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem twoCocycles_map_one_snd (f : twoCocycles A) (g : G) :
    f.1 (g, 1) = A.ρ g (f.1 (1, 1))
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
/-- (Implementation). Use `openCoverOfBase` instead. -/
@[simps! map]
def openCoverOfBase' (𝒰 : OpenCover Z) (f : X ⟶ Z) (g : Y ⟶ Z) : OpenCover (pullback f g)
-- Mathlib/Probability/Kernel/RadonNikodym.lean
lemma singularPart_of_subset_compl_mutuallySingularSetSlice [IsFiniteKernel κ]
    [IsFiniteKernel η] {a : α} {s : Set γ} (hs : s ⊆ (mutuallySingularSetSlice κ η a)ᶜ) :
    singularPart κ η a s = 0
-- Mathlib/Data/DFinsupp/Lex.lean
theorem lex_def {r : ι → ι → Prop} {s : ∀ i, α i → α i → Prop} {a b : Π₀ i, α i} :
    DFinsupp.Lex r s a b ↔ ∃ j, (∀ d, r d j → a d = b d) ∧ s j (a j) (b j)
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem closure_empty : closure (∅ : Set K) = ⊥
-- Mathlib/Logic/Equiv/Basic.lean
/-- A family of equivalences between fibers gives an equivalence between domains. -/
@[simps!]
def ofFiberEquiv {f : α → γ} {g : β → γ} (e : ∀ c, { a // f a = c } ≃ { b // g b = c }) : α ≃ β
-- Mathlib/Topology/DenseEmbedding.lean
theorem isClosed_property2 [TopologicalSpace β] {e : α → β} {p : β → β → Prop} (he : DenseRange e)
    (hp : IsClosed { q : β × β | p q.1 q.2 }) (h : ∀ a₁ a₂, p (e a₁) (e a₂)) : ∀ b₁ b₂, p b₁ b₂
-- Mathlib/Data/Int/Bitwise.lean
@[simp]
theorem bit_coe_nat (b) (n : ℕ) : bit b n = Nat.bit b n
-- Mathlib/Order/Antisymmetrization.lean
@[symm]
theorem AntisymmRel.symm {a b : α} : AntisymmRel r a b → AntisymmRel r b a
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive (attr := simp)]
theorem coe_comap (S : Submonoid N) (f : F) : (S.comap f : Set M) = f ⁻¹' S
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
@[simp]
theorem Matrix.toLin_symm : (Matrix.toLin v₁ v₂).symm = LinearMap.toMatrix v₁ v₂
-- Mathlib/Topology/ContinuousOn.lean
theorem mem_nhdsWithin_iff_eventually {s t : Set α} {x : α} :
    t ∈ 𝓝[s] x ↔ ∀ᶠ y in 𝓝 x, y ∈ s → y ∈ t
-- Mathlib/Topology/Algebra/Module/LinearPMap.lean
/-- If `f` is invertible and closable as well as its closure being invertible, then
the graph of the inverse of the closure is given by the closure of the graph of the inverse. -/
theorem closure_inverse_graph (hf : LinearMap.ker f.toFun = ⊥) (hf' : f.IsClosable)
    (hcf : LinearMap.ker f.closure.toFun = ⊥) :
    f.closure.inverse.graph = f.inverse.graph.topologicalClosure
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
/-- If you add multiples of previous columns to the next columns, the determinant doesn't change. -/
theorem det_eq_of_forall_col_eq_smul_add_pred {n : ℕ} {A B : Matrix (Fin (n + 1)) (Fin (n + 1)) R}
    (c : Fin n → R) (A_zero : ∀ i, A i 0 = B i 0)
    (A_succ : ∀ (i) (j : Fin n), A i j.succ = B i j.succ + c j * A i (Fin.castSucc j)) :
    det A = det B
-- Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean
theorem ContMDiff.clm_prodMap {g : M → F₁ →L[𝕜] F₃} {f : M → F₂ →L[𝕜] F₄}
    (hg : ContMDiff I 𝓘(𝕜, F₁ →L[𝕜] F₃) n g) (hf : ContMDiff I 𝓘(𝕜, F₂ →L[𝕜] F₄) n f) :
    ContMDiff I 𝓘(𝕜, F₁ × F₂ →L[𝕜] F₃ × F₄) n fun x => (g x).prodMap (f x)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[deprecated getElem?_reverse (since := "2024-06-12")]
theorem get?_reverse {l : List α} {i} (h : i < length l) :
    get? l.reverse i = get? l (l.length - 1 - i)
-- Mathlib/Algebra/CharZero/Lemmas.lean
@[simp] theorem neg_eq_self_iff {a : R} : -a = a ↔ a = 0
-- Mathlib/Algebra/Free.lean
@[to_additive (attr := simp, nolint simpNF)]
theorem mul_map_seq (x y : FreeSemigroup α) :
    ((· * ·) <$> x <*> y : Id (FreeSemigroup α)) = (x * y : FreeSemigroup α)
-- Mathlib/Geometry/Manifold/ContMDiffMFDeriv.lean
/-- The function that sends `x` to the `y`-derivative of `f(x,y)` at `g(x)` applied to `g₂(x)` is
`C^n` at `x₀`, where the derivative is taken as a continuous linear map.
We have to assume that `f` is `C^(n+1)` at `(x₀, g(x₀))` and `g` is `C^n` at `x₀`.
We have to insert a coordinate change from `x₀` to `g₁(x)` to make the derivative sensible.

This is similar to `ContMDiffAt.mfderiv`, but where the continuous linear map is applied to a
(variable) vector.
-/
theorem ContMDiffAt.mfderiv_apply {x₀ : N'} (f : N → M → M') (g : N → M) (g₁ : N' → N) (g₂ : N' → E)
    (hf : ContMDiffAt (J.prod I) I' n (Function.uncurry f) (g₁ x₀, g (g₁ x₀)))
    (hg : ContMDiffAt J I m g (g₁ x₀)) (hg₁ : ContMDiffAt J' J m g₁ x₀)
    (hg₂ : ContMDiffAt J' 𝓘(𝕜, E) m g₂ x₀) (hmn : m + 1 ≤ n) :
    ContMDiffAt J' 𝓘(𝕜, E') m
      (fun x => inTangentCoordinates I I' g (fun x => f x (g x))
        (fun x => mfderiv I I' (f x) (g x)) (g₁ x₀) (g₁ x) (g₂ x)) x₀
-- Mathlib/LinearAlgebra/BilinearMap.lean
@[simp]
theorem flip_flip (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) : f.flip.flip = f
-- Mathlib/Data/List/Basic.lean
theorem cons_head!_tail [Inhabited α] {l : List α} (h : l ≠ []) : head! l :: tail l = l
-- Mathlib/Topology/ContinuousOn.lean
theorem nhdsWithin_subtype (s : Set α) (a : { x // x ∈ s }) (t : Set { x // x ∈ s }) :
    𝓝[t] a = comap ((↑) : s → α) (𝓝[(↑) '' t] a)
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem smul [Monoid 𝕜] [DistribMulAction 𝕜 β] (hT : FinMeasAdditive μ T) (c : 𝕜) :
    FinMeasAdditive μ fun s => c • T s
-- Mathlib/CategoryTheory/Sites/Grothendieck.lean
/-- See <https://stacks.math.columbia.edu/tag/00Z7> -/
theorem isGLB_sInf (s : Set (GrothendieckTopology C)) : IsGLB s (sInf s)
-- Mathlib/Data/NNRat/Defs.lean
theorem ext_num_den (hn : p.num = q.num) (hd : p.den = q.den) : p = q
-- Mathlib/CategoryTheory/Localization/Resolution.lean
/-- The identity of a object in `Φ.RightResolution X₂`. -/
@[simps]
def Hom.id [W₁.ContainsIdentities] (R : Φ.RightResolution X₂) : Hom R R
-- Mathlib/NumberTheory/Divisors.lean
@[to_additive (attr := simp) sum_divisors_prime_pow]
theorem prod_divisors_prime_pow {α : Type*} [CommMonoid α] {k p : ℕ} {f : ℕ → α} (h : p.Prime) :
    (∏ x ∈ (p ^ k).divisors, f x) = ∏ x ∈ range (k + 1), f (p ^ x)
-- Mathlib/RingTheory/DedekindDomain/Different.lean
lemma coeSubmodule_differentIdeal [NoZeroSMulDivisors A B] :
    coeSubmodule L (differentIdeal A B) = 1 / Submodule.traceDual A K 1
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
@[simp]
theorem coe_eval (n : ℕ) :
    (eval I M n : AdicCompletion I M → M ⧸ (I ^ n • ⊤ : Submodule R M)) = fun f => f.1 n
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem sum_equiv_comp_eval_eq_elim : eval C ∘ (sum_equiv C hsC ho).toFun =
    (Sum.elim (fun (l : GoodProducts (π C (ord I · < o))) ↦ Products.eval C l.1)
    (fun (l : MaxProducts C ho) ↦ Products.eval C l.1))
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem mul_re (z w : ℤ√d) : (z * w).re = z.re * w.re + d * z.im * w.im
-- Mathlib/NumberTheory/Padics/PadicNorm.lean
/-- If `q ≠ 0`, then `padicNorm p q ≠ 0`. -/
protected theorem nonzero {q : ℚ} (hq : q ≠ 0) : padicNorm p q ≠ 0
-- Mathlib/Analysis/Convolution.lean
theorem _root_.HasCompactSupport.convolutionExistsAt {x₀ : G}
    (h : HasCompactSupport fun t => L (f t) (g (x₀ - t))) (hf : LocallyIntegrable f μ)
    (hg : Continuous g) : ConvolutionExistsAt f g x₀ L μ
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
@[simp, norm_cast] lemma coe_lt_one [One α] : (a : WithZero α) < 1 ↔ a < 1
-- Mathlib/Data/Seq/Computation.lean
theorem not_terminates_empty : ¬Terminates (empty α)
-- Mathlib/MeasureTheory/Integral/TorusIntegral.lean
@[simp]
theorem torusIntegral_dim0 (f : ℂ⁰ → E) (c : ℂ⁰) (R : ℝ⁰) : (∯ x in T(c, R), f x) = f c
-- Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean
lemma smul_basis_mul_Y (p q : R[X]) : (p • (1 : W.CoordinateRing) + q • mk W Y) * mk W Y =
    (q * (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) • (1 : W.CoordinateRing) +
      (p - q * (C W.a₁ * X + C W.a₃)) • mk W Y
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := aesop safe apply (rule_sets := [SetLike]))]
theorem zpow_mem {x : M} (hx : x ∈ K) : ∀ n : ℤ, x ^ n ∈ K
-- Mathlib/LinearAlgebra/Eigenspace/Minpoly.lean
/-- An n x n matrix over a field has a finite spectrum. -/
theorem Matrix.finite_spectrum (A : Matrix n n R) : Set.Finite (spectrum R A)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
protected theorem div_eq_of_eq_mul_left (H1 : 0 < n) (H2 : m = k * n) : m / n = k
-- Mathlib/Analysis/BoxIntegral/Partition/Additive.lean
@[simp]
theorem toSMul_apply (f : ι →ᵇᵃ[I₀] ℝ) (I : Box ι) (x : E) : f.toSMul I x = f I • x
-- Mathlib/Data/Nat/Find.lean
@[simp] lemma find_lt_iff (h : ∃ n : ℕ, p n) (n : ℕ) : Nat.find h < n ↔ ∃ m < n, p m
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
theorem join_eq_some : x.join = some a ↔ x = some (some a)
-- Mathlib/GroupTheory/Coprod/Basic.lean
/-- A `MulEquiv` version of `Coprod.swap`. -/
@[to_additive (attr := simps! (config := .asFn))
  "An `AddEquiv` version of `AddMonoid.Coprod.swap`."]
def coprodComm : M ∗ N ≃* N ∗ M
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.even_nsmul_periodic [AddMonoid α] [InvolutiveNeg β] (h : Antiperiodic f c)
    (n : ℕ) : Periodic f ((2 * n) • c)
-- Mathlib/Computability/Primrec.lean
theorem uncurry {f : α → β → σ} : Primrec (Function.uncurry f) ↔ Primrec₂ f
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem _root_.LinearMap.annihilator_le_of_injective (f : M →ₗ[R] M') (hf : Function.Injective f) :
    Module.annihilator R M' ≤ Module.annihilator R M
-- Mathlib/Topology/PartitionOfUnity.lean
theorem sum_finsupport_smul_eq_finsum {M : Type*} [AddCommGroup M] [Module ℝ M] (φ : ι → X → M) :
    ∑ i ∈ ρ.finsupport x₀, ρ i x₀ • φ i x₀ = ∑ᶠ i, ρ i x₀ • φ i x₀
-- Mathlib/Combinatorics/Young/SemistandardTableau.lean
theorem col_strict {μ : YoungDiagram} (T : SemistandardYoungTableau μ) {i1 i2 j : ℕ} (hi : i1 < i2)
    (hcell : (i2, j) ∈ μ) : T i1 j < T i2 j
-- Mathlib/Data/Matrix/Basis.lean
@[simp]
theorem diag_same : diag (stdBasisMatrix i i c) = Pi.single i c
-- Mathlib/Analysis/Complex/Basic.lean
theorem equivRealProd_apply_le' (z : ℂ) : ‖equivRealProd z‖ ≤ 1 * abs z
-- Mathlib/Data/Set/Image.lean
theorem preimage_comp_eq : preimage (g ∘ f) = preimage f ∘ preimage g
-- Mathlib/MeasureTheory/SetAlgebra.lean
/-- An algebra of sets is closed by finite unions. -/
theorem biUnion_mem {ι : Type*} (h𝒜 : IsSetAlgebra 𝒜) {s : ι → Set α} (S : Finset ι)
    (hs : ∀ i ∈ S, s i ∈ 𝒜) : ⋃ i ∈ S, s i ∈ 𝒜
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- Rotating the first vector by the angle between the two vectors and swapping the vectors
results in an angle of 0. -/
@[simp]
theorem oangle_rotation_oangle_right (x y : V) : o.oangle y (o.rotation (o.oangle x y) x) = 0
-- Mathlib/FieldTheory/IntermediateField.lean
/-- An intermediate field contains the ring's 1. -/
protected theorem one_mem : (1 : L) ∈ S
-- Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean
/-- Every Yoneda-presheaf is a sheaf for the regular topology. -/
lemma isSheaf_yoneda_obj [Preregular C] (W : C)  :
    Presieve.IsSheaf (regularTopology C) (yoneda.obj W)
-- Mathlib/Data/Nat/Factorization/Basic.lean
lemma factorizationLCMRight_pos :
    0 < factorizationLCMRight a b