ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Action.lean
/-- A multiplicative action M ↻ X viewed as a functor mapping the single object of M to X
  and an element `m : M` to the map `X → X` given by multiplication by `m`. -/
@[simps]
def actionAsFunctor : SingleObj M ⥤ Type u
-- Mathlib/Computability/Encoding.lean
/-- An encoding of a type in a certain alphabet, together with a decoding. -/
structure Encoding (α : Type u) where
  Γ : Type v
  encode : α → List Γ
  decode : List Γ → Option α
  decode_encode : ∀ x, decode (encode x) = some x
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
protected theorem _root_.Finset.nullMeasurableSet (s : Finset α) : NullMeasurableSet (↑s) μ
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem nonpos_of_restrict_le_zero (hi₂ : v ≤[i] 0) : v i ≤ 0
-- Mathlib/Algebra/Ring/Parity.lean
lemma even_xor_odd (n : ℕ) : Xor' (Even n) (Odd n)
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
theorem mop_inj_iff (x y : C) : mop x = mop y ↔ x = y
-- Mathlib/Data/Finite/Defs.lean
theorem Equiv.infinite_iff (e : α ≃ β) : Infinite α ↔ Infinite β
-- Mathlib/Data/Nat/PartENat.lean
@[simp]
theorem natCast_lt_top (x : ℕ) : (x : PartENat) < ⊤
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
theorem diam_image (s : Set P) : Metric.diam (f '' s) = Metric.diam s
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
theorem subset_toMeasurable (μ : Measure α) (s : Set α) : s ⊆ toMeasurable μ s
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
/-- Given linear maps `f : M → Q`, `g : N → S`, and `h : P → T`, if we identify `M ⊗ (N ⊗ P)`
with `(M ⊗ N) ⊗ P` and `Q ⊗ (S ⊗ T)` with `(Q ⊗ S) ⊗ T`, then this lemma states that
`(f ⊗ g) ⊗ h = f ⊗ (g ⊗ h)`. -/
lemma map_map_comp_assoc_symm_eq (f : M →ₗ[R] Q) (g : N →ₗ[R] S) (h : P →ₗ[R] T) :
    map (map f g) h ∘ₗ (TensorProduct.assoc R M N P).symm =
      (TensorProduct.assoc R Q S T).symm ∘ₗ map f (map g h)
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
theorem equicontinuous_iInf_rng {u : κ → UniformSpace α'} {F : ι → X → α'} :
    Equicontinuous (uα := ⨅ k, u k) F ↔ ∀ k, Equicontinuous (uα := u k) F
-- Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean
theorem jordanDecomposition_add_withDensity_mutuallySingular {f : α → ℝ} (hf : Measurable f)
    (htμ : t ⟂ᵥ μ.toENNRealVectorMeasure) :
    (t.toJordanDecomposition.posPart + μ.withDensity fun x : α => ENNReal.ofReal (f x)) ⟂ₘ
      t.toJordanDecomposition.negPart + μ.withDensity fun x : α => ENNReal.ofReal (-f x)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem stronglyMeasurable_mk (hf : AEStronglyMeasurable f μ) : StronglyMeasurable (hf.mk f)
-- Mathlib/CategoryTheory/Sites/SheafOfTypes.lean
theorem isSheaf_of_yoneda {P : Cᵒᵖ ⥤ Type v}
    (h : ∀ {X} (S : Sieve X), S ∈ J X → YonedaSheafCondition P S) : IsSheaf J P
-- Mathlib/Algebra/Algebra/Subalgebra/Prod.lean
@[simp]
theorem prod_top : (prod ⊤ ⊤ : Subalgebra R (A × B)) = ⊤
-- Mathlib/ModelTheory/Algebra/Field/Basic.lean
theorem FieldAxiom.realize_toSentence_iff_toProp {K : Type*}
    [Add K] [Mul K] [Neg K] [Zero K] [One K] [CompatibleRing K]
    (ax : FieldAxiom) :
    (K ⊨ (ax.toSentence : Sentence Language.ring)) ↔ ax.toProp K
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
protected theorem Finset.multipliable (s : Finset β) (f : β → α) :
    Multipliable (f ∘ (↑) : (↑s : Set β) → α)
-- Mathlib/Analysis/Analytic/Within.lean
lemma AnalyticWithinAt.congr_of_eventuallyEq [CompleteSpace F] {f g : E → F} {s : Set E} {x : E}
    (hf : AnalyticWithinAt 𝕜 f s x) (hs : f =ᶠ[𝓝[s] x] g) (hx : f x = g x) :
    AnalyticWithinAt 𝕜 g s x
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[simp]
theorem hasFDerivWithinAt_pi' :
    HasFDerivWithinAt Φ Φ' s x ↔ ∀ i, HasFDerivWithinAt (fun x => Φ x i) ((proj i).comp Φ') s x
-- Mathlib/RingTheory/LaurentSeries.lean
@[simp, norm_cast]
theorem coe_smul {S : Type*} [Semiring S] [Module R S] (r : R) (x : PowerSeries S) :
    ((r • x : PowerSeries S) : LaurentSeries S) = r • (ofPowerSeries ℤ S x)
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
@[simp] theorem getRight?_swap (x : α ⊕ β) : x.swap.getRight? = x.getLeft?
-- Mathlib/CategoryTheory/Triangulated/Basic.lean
@[reassoc (attr := simp)]
lemma _root_.CategoryTheory.Iso.hom_inv_id_triangle_hom₂ {A B : Triangle C} (e : A ≅ B) :
    e.hom.hom₂ ≫ e.inv.hom₂ = 𝟙 _
-- Mathlib/Analysis/Fourier/AddCircle.lean
theorem fourierCoeffOn.const_smul {a b : ℝ} (f : ℝ → E) (c : ℂ) (n : ℤ) (hab : a < b) :
    fourierCoeffOn hab (c • f) n = c • fourierCoeffOn hab f n
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem coe_comp (f : BoundedOrderHom β γ) (g : BoundedOrderHom α β) : (f.comp g : α → γ) = f ∘ g
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem exists_forall_pow_toEnd_eq_zero [hM : IsNilpotent R L M] :
    ∃ k : ℕ, ∀ x : L, toEnd R L M x ^ k = 0
-- Mathlib/Analysis/MeanInequalities.lean
/-- **Weighted Hölder inequality**. -/
lemma inner_le_weight_mul_Lp (s : Finset ι) {p : ℝ} (hp : 1 ≤ p) (w f : ι → ℝ≥0) :
    ∑ i ∈ s, w i * f i ≤ (∑ i ∈ s, w i) ^ (1 - p⁻¹) * (∑ i ∈ s, w i * f i ^ p) ^ p⁻¹
-- Mathlib/Topology/Instances/Discrete.lean
theorem discreteTopology_iff_orderTopology_of_pred_succ [LinearOrder α] [PredOrder α]
    [SuccOrder α] : DiscreteTopology α ↔ OrderTopology α
-- Mathlib/Data/Seq/Computation.lean
theorem bind_congr {s1 s2 : Computation α} {f1 f2 : α → Computation β} (h1 : s1 ~ s2)
    (h2 : ∀ a, f1 a ~ f2 a) : bind s1 f1 ~ bind s2 f2
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem exists_length_eq_zero_iff {u v : V} : (∃ p : G.Walk u v, p.length = 0) ↔ u = v
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
theorem lpTrimToLpMeasSubgroup_ae_eq (hm : m ≤ m0) (f : Lp F p (μ.trim hm)) :
    lpTrimToLpMeasSubgroup F p μ hm f =ᵐ[μ] f
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
private theorem _root_.Nat.mod_eq_sub_of_lt_two_mul {x n} (h₁ : n ≤ x) (h₂ : x < 2 * n) :
    x % n = x - n
-- Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean
@[reassoc (attr := simp)]
theorem mapMono_comp (i' : Δ'' ⟶ Δ') (i : Δ' ⟶ Δ) [Mono i'] [Mono i] :
    mapMono K i ≫ mapMono K i' = mapMono K (i' ≫ i)
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
theorem decompose'_apply [DecidableEq M] (φ : MvPolynomial σ R) (m : M) :
    (decompose' R w φ m : MvPolynomial σ R) = weightedHomogeneousComponent w m φ
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
theorem ContDiff.exp {n} (hf : ContDiff ℝ n f) : ContDiff ℝ n fun x => Real.exp (f x)
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
theorem map_neg {f : M → M₂} (lin : IsLinearMap R f) (x : M) : f (-x) = -f x
-- Mathlib/LinearAlgebra/Dual.lean
theorem eval_range {ι : Type*} [Finite ι] (b : Basis ι R M) :
    LinearMap.range (Dual.eval R M) = ⊤
-- Mathlib/Algebra/Group/Basic.lean
/-- To show a property of all powers of `g` it suffices to show it is closed under multiplication
by `g` and `g⁻¹` on the right. For subgroups generated by more than one element, see
`Subgroup.closure_induction_right`. -/
@[to_additive "To show a property of all multiples of `g` it suffices to show it is closed under
addition by `g` and `-g` on the right. For additive subgroups generated by more than one element,
see `AddSubgroup.closure_induction_right`."]
lemma zpow_induction_right {g : G} {P : G → Prop} (h_one : P (1 : G))
    (h_mul : ∀ a, P a → P (a * g)) (h_inv : ∀ a, P a → P (a * g⁻¹)) (n : ℤ) : P (g ^ n)
-- Mathlib/Order/Bounds/Basic.lean
theorem IsLeast.isLeast_iff_eq (Ha : IsLeast s a) : IsLeast s b ↔ a = b
-- Mathlib/Algebra/Ring/Subsemiring/MulOpposite.lean
theorem unop_sSup (S : Set (Subsemiring Rᵐᵒᵖ)) : (sSup S).unop = sSup (.op ⁻¹' S)
-- Mathlib/Analysis/Calculus/TangentCone.lean
theorem tangentCone_univ : tangentConeAt 𝕜 univ x = univ
-- Mathlib/Topology/Order/ScottTopology.lean
lemma topology_eq : ‹_› = scottHausdorff α
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem empty_subset (s : Set α) : ∅ ⊆ s
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem swap_dist : Function.swap (@dist α _) = dist
-- Mathlib/Data/Int/GCD.lean
theorem gcd_eq_zero_iff {i j : ℤ} : gcd i j = 0 ↔ i = 0 ∧ j = 0
-- Mathlib/Data/Matroid/IndepAxioms.lean
@[simp] theorem ofExistsFiniteBase_base (E : Set α) Base exists_finite_base
    base_exchange subset_ground : (Matroid.ofExistsFiniteBase
      E Base exists_finite_base base_exchange subset_ground).Base = Base
-- Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean
@[simp] lemma exp_eq_zero_iff {x : EReal} : exp x = 0 ↔ x = ⊥
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem norm_map_le (hf : ψ.comp f₁ = f₂.comp φ) (hg : ψ.comp g₁ = g₂.comp φ) (C : ℝ)
    (hφ : ‖φ.comp (ι f₁ g₁)‖ ≤ C) : ‖map φ ψ hf hg‖ ≤ C
-- Mathlib/LinearAlgebra/Matrix/Hermitian.lean
@[simp]
theorem IsHermitian.sub {A B : Matrix n n α} (hA : A.IsHermitian) (hB : B.IsHermitian) :
    (A - B).IsHermitian
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem eq_of_dvd_of_natDegree_le_of_leadingCoeff {p q : R[X]} (hpq : p ∣ q)
    (h₁ : q.natDegree ≤ p.natDegree) (h₂ : p.leadingCoeff = q.leadingCoeff) :
    p = q
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
/-- Given an orthogonal basis with respect to a bilinear map, the bilinear map is left-separating if
the basis has no elements which are self-orthogonal. -/
theorem IsOrthoᵢ.separatingLeft_of_not_isOrtho_basis_self [NoZeroSMulDivisors R M₁]
    {B : M →ₗ[R] M →ₗ[R] M₁} (v : Basis n R M) (hO : B.IsOrthoᵢ v)
    (h : ∀ i, ¬B.IsOrtho (v i) (v i)) : B.SeparatingLeft
-- Mathlib/CategoryTheory/EqToHom.lean
/-- If we (perhaps unintentionally) perform equational rewriting on
the source object of a morphism,
we can replace the resulting `_.mpr f` term by a composition with an `eqToHom`.

It may be advisable to introduce any necessary `eqToHom` morphisms manually,
rather than relying on this lemma firing.
-/
theorem congrArg_mpr_hom_left {X Y Z : C} (p : X = Y) (q : Y ⟶ Z) :
    (congrArg (fun W : C => W ⟶ Z) p).mpr q = eqToHom p ≫ q
-- Mathlib/Data/Nat/SuccPred.lean
protected theorem covBy_iff_succ_eq {m n : ℕ} : m ⋖ n ↔ m + 1 = n
-- Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
/-- The Fréchet derivative of the Fourier transform of `f` is the Fourier transform of
    `fun v ↦ -2 * π * I ⟪v, ⬝⟫ f v`. -/
theorem hasFDerivAt_fourierIntegral
    (hf_int : Integrable f) (hvf_int : Integrable (fun v ↦ ‖v‖ * ‖f v‖)) (x : V) :
    HasFDerivAt (𝓕 f) (𝓕 (fourierSMulRight (innerSL ℝ) f) x) x
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
@[measurability]
nonrec theorem AEMeasurable.min {f g : δ → α} {μ : Measure δ} (hf : AEMeasurable f μ)
    (hg : AEMeasurable g μ) : AEMeasurable (fun a => min (f a) (g a)) μ
-- Mathlib/ModelTheory/Substructures.lean
/-- The substructure generated by a set includes the set. -/
@[simp]
theorem subset_closure : s ⊆ closure L s
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
@[simp, norm_cast]
theorem coe_pow (f : CauSeq β abv) (n : ℕ) : ⇑(f ^ n) = (f : ℕ → β) ^ n
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem map_inj : map f = map g ↔ f = g
-- Mathlib/Computability/TuringMachine.lean
theorem Tape.map_mk₁ {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ') (l : List Γ) :
    (Tape.mk₁ l).map f = Tape.mk₁ (l.map f)
-- Mathlib/Topology/Connected/PathConnected.lean
/-- For a path `γ`, `γ.truncate` gives a "continuous family of paths", by which we
  mean the uncurried function which maps `(t₀, t₁, s)` to `γ.truncate t₀ t₁ s` is continuous. -/
@[continuity]
theorem truncate_continuous_family {a b : X} (γ : Path a b) :
    Continuous (fun x => γ.truncate x.1 x.2.1 x.2.2 : ℝ × ℝ × I → X)
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem map_map : (p.map f).map f' = p.map (f'.comp f)
-- Mathlib/Data/Set/Image.lean
theorem image_diff_preimage {f : α → β} {s : Set α} {t : Set β} :
    f '' (s \ f ⁻¹' t) = f '' s \ t
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
@[simp]
theorem card_lt_of_card_iUnion_lt {ι : Type u} {α : Type u} {t : ι → Set α} {c : Cardinal}
    (h : #(⋃ i, t i) < c) (i : ι) : #(t i) < c
-- Mathlib/Data/Finset/Card.lean
theorem card_insert_le (a : α) (s : Finset α) : card (insert a s) ≤ s.card + 1
-- Mathlib/RingTheory/AdjoinRoot.lean
/-- Let `α` have minimal polynomial `f` over `R` and `I` be an ideal of `R`,
then `R[α] / (I) = (R[x] / (f)) / pS = (R/p)[x] / (f mod p)`. -/
@[simps!]
noncomputable def quotientEquivQuotientMinpolyMap (pb : PowerBasis R S) (I : Ideal R) :
    (S ⧸ I.map (algebraMap R S)) ≃ₐ[R]
      Polynomial (R ⧸ I) ⧸
        Ideal.span ({(minpoly R pb.gen).map (Ideal.Quotient.mk I)} : Set (Polynomial (R ⧸ I)))
-- Mathlib/Probability/Kernel/Composition.lean
theorem snd_apply (κ : Kernel α (β × γ)) (a : α) : snd κ a = (κ a).map Prod.snd
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp, bv_toNat] theorem toNat_mul (x y : BitVec n) : (x * y).toNat = (x.toNat * y.toNat) % 2 ^ n
-- Mathlib/CategoryTheory/GradedObject/Trifunctor.lean
lemma HasGoodTrifunctor₁₂Obj.hasMap :
    HasMap ((((mapTrifunctor (bifunctorComp₁₂ F₁₂ G) I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) r
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma asympBound_def {n : ℕ} : asympBound g a b n = n ^ p a b + sumTransform (p a b) g 0 n
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
theorem mul_cpow_ofReal_nonneg {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) (r : ℂ) :
    ((a : ℂ) * (b : ℂ)) ^ r = (a : ℂ) ^ r * (b : ℂ) ^ r
-- Mathlib/Algebra/Ring/Ext.lean
theorem toNonAssocRing_injective :
    Function.Injective (@toNonAssocRing R)
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem ContDiff.of_succ {n : ℕ} (h : ContDiff 𝕜 (n + 1) f) : ContDiff 𝕜 n f
-- Mathlib/CategoryTheory/FiberedCategory/HomLift.lean
/-- If `φ : a ⟶ b` lifts `𝟙 T` and `ψ : b ⟶ c` lifts `f`, then `φ  ≫ ψ` lifts `f` -/
lemma comp_lift_id_left' {a b c : 𝒳} (R : 𝒮) (φ : a ⟶ b) [p.IsHomLift (𝟙 R) φ]
    {S T : 𝒮} (f : S ⟶ T) (ψ : b ⟶ c) [p.IsHomLift f ψ] : p.IsHomLift f (φ ≫ ψ)
-- Mathlib/Logic/IsEmpty.lean
@[simp]
theorem isEmpty_psigma {α} {E : α → Sort*} : IsEmpty (PSigma E) ↔ ∀ a, IsEmpty (E a)
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
theorem le_biUnionIndex (hJ : J ∈ π.biUnion πi) : J ≤ π.biUnionIndex πi J
-- Mathlib/FieldTheory/Perfect.lean
@[simp]
theorem iterateFrobeniusEquiv_zero  : iterateFrobeniusEquiv R p 0 = RingEquiv.refl R
-- Mathlib/Order/CompleteLattice.lean
theorem snd_iSup [SupSet α] [SupSet β] (f : ι → α × β) : (iSup f).snd = ⨆ i, (f i).snd
-- Mathlib/CategoryTheory/GlueData.lean
@[simp]
theorem diagram_left : D.diagram.left = D.V
-- Mathlib/SetTheory/Surreal/Basic.lean
theorem lt_of_lf {x y : PGame} (h : x ⧏ y) (ox : Numeric x) (oy : Numeric y) : x < y
-- Mathlib/CategoryTheory/Preadditive/AdditiveFunctor.lean
@[simp]
theorem AdditiveFunctor.ofRightExact_obj_fst (F : C ⥤ᵣ D) :
    ((AdditiveFunctor.ofRightExact C D).obj F).obj = F.obj
-- Mathlib/Order/InitialSeg.lean
protected theorem eq [IsWellOrder β s] (f g : r ≼i s) (a) : f a = g a
-- Mathlib/Order/WithBot.lean
theorem strictAnti_iff {f : WithBot α → β} :
    StrictAnti f ↔ StrictAnti (fun a ↦ f a : α → β) ∧ ∀ x : α, f x < f ⊥
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem add (hT : FinMeasAdditive μ T) (hT' : FinMeasAdditive μ T') :
    FinMeasAdditive μ (T + T')
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
theorem isHomogeneous_zero (n : ℕ) : IsHomogeneous (0 : MvPolynomial σ R) n
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
theorem cycleOf_mul_of_apply_right_eq_self [DecidableRel (f * g).SameCycle]
    (h : Commute f g) (x : α) (hx : g x = x) : (f * g).cycleOf x = f.cycleOf x
-- Mathlib/CategoryTheory/GradedObject.lean
@[simp, reassoc]
lemma mapMap_comp : mapMap (φ ≫ ψ) p = mapMap φ p ≫ mapMap ψ p
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma cpow_inv_two_re (x : ℂ) : (x ^ (2⁻¹ : ℂ)).re = sqrt ((abs x + x.re) / 2)
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
theorem isBigO_id {f : E → F} (h : IsBoundedLinearMap 𝕜 f) (l : Filter E) : f =O[l] fun x => x
-- Mathlib/Topology/Algebra/Module/LinearPMap.lean
/-- A `LinearPMap` is contained in its closure. -/
theorem le_closure (f : E →ₗ.[R] F) : f ≤ f.closure
-- Mathlib/NumberTheory/LSeries/AbstractFuncEq.lean
/-- Compute the Mellin transform of the modifying term used to kill off the constants at
`0` and `∞`. -/
lemma f_modif_aux2 {s : ℂ} (hs : P.k < re s) :
    mellin (fun x ↦ P.f_modif x - P.f x + P.f₀) s = (1 / s) • P.f₀ + (P.ε  / (P.k - s)) • P.g₀
-- Mathlib/Data/Fintype/Card.lean
/-- Note: this lemma is specifically about `Fintype.ofSubsingleton`. For a statement about
arbitrary `Fintype` instances, use either `Fintype.card_le_one_iff_subsingleton` or
`Fintype.card_unique`. -/
@[simp]
theorem card_ofSubsingleton (a : α) [Subsingleton α] : @Fintype.card _ (ofSubsingleton a) = 1
-- Mathlib/Order/GaloisConnection.lean
theorem sInf_image2_eq_sSup_sInf (h₁ : ∀ b, GaloisConnection (toDual ∘ l₁ b) (swap u b ∘ ofDual))
    (h₂ : ∀ a, GaloisConnection (l₂ a) (u a)) : sInf (image2 u s t) = u (sSup s) (sInf t)
-- Mathlib/Data/Nat/Defs.lean
protected lemma eq_sub_of_add_eq (h : c + b = a) : c = a - b
-- Mathlib/Tactic/NormNum/Basic.lean
theorem isInt_add {α} [Ring α] : ∀ {f : α → α → α} {a b : α} {a' b' c : ℤ},
    f = HAdd.hAdd → IsInt a a' → IsInt b b' → Int.add a' b' = c → IsInt (f a b) c
-- Mathlib/Algebra/Group/Center.lean
@[to_additive (attr := simp) add_mem_addCenter]
theorem mul_mem_center {z₁ z₂ : M} (hz₁ : z₁ ∈ Set.center M) (hz₂ : z₂ ∈ Set.center M) :
    z₁ * z₂ ∈ Set.center M
-- Mathlib/Topology/Algebra/Module/FiniteDimension.lean
theorem ContinuousLinearMap.exists_right_inverse_of_surjective [FiniteDimensional 𝕜 F]
    (f : E →L[𝕜] F) (hf : LinearMap.range f = ⊤) :
    ∃ g : F →L[𝕜] E, f.comp g = ContinuousLinearMap.id 𝕜 F
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
theorem smul_ofFunction {c : ℝ≥0∞} (hc : c ≠ ∞) : c • OuterMeasure.ofFunction m m_empty =
    OuterMeasure.ofFunction (c • m) (by simp [m_empty])
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem exists_root_of_splits' {f : K[X]} (hs : Splits i f) (hf0 : degree (f.map i) ≠ 0) :
    ∃ x, eval₂ i x f = 0
-- Mathlib/Topology/UniformSpace/Completion.lean
theorem inseparable_iff_of_le_nhds {f g : CauchyFilter α} {a b : α}
    (ha : f.1 ≤ 𝓝 a) (hb : g.1 ≤ 𝓝 b) : Inseparable a b ↔ Inseparable f g
-- Mathlib/Topology/Constructions.lean
theorem isOpenMap_sigma_map {f₁ : ι → κ} {f₂ : ∀ i, σ i → τ (f₁ i)} :
    IsOpenMap (Sigma.map f₁ f₂) ↔ ∀ i, IsOpenMap (f₂ i)
-- Mathlib/Order/Ideal.lean
theorem top_of_top_mem (h : ⊤ ∈ I) : I = ⊤
-- Mathlib/CategoryTheory/Monoidal/Preadditive.lean
theorem add_tensor {W X Y Z : C} (f g : W ⟶ X) (h : Y ⟶ Z) : (f + g) ⊗ h = f ⊗ h + g ⊗ h
-- Mathlib/CategoryTheory/ConnectedComponents.lean
/-- This gives that any category is equivalent to a disjoint union of connected categories. -/
@[simps! functor]
def decomposedEquiv : Decomposed J ≌ J
-- Mathlib/SetTheory/Game/PGame.lean
theorem add_right_neg_le_zero (x : PGame) : x + -x ≤ 0
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
lemma NNReal.nndist_eq (a b : ℝ≥0) : nndist a b = max (a - b) (b - a)
-- Mathlib/Probability/Process/Filtration.lean
theorem measurableSet_filtrationOfSet' {s : ι → Set Ω} (hsm : ∀ n, MeasurableSet[m] (s n))
    (i : ι) : MeasurableSet[filtrationOfSet hsm i] (s i)
-- Mathlib/Data/ZMod/IntUnitsPower.lean
lemma ZMod.natCast_smul_units (n : ℕ) (au : Additive ℤˣ) : (n : ZMod 2) • au = n • au
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
/-- The `del` function preserves the ordering invariants. -/
protected theorem Ordered.del : ∀ {t : RBNode α}, t.Ordered cmp → (del cut t).Ordered cmp
-- Mathlib/LinearAlgebra/QuadraticForm/Isometry.lean
@[simp]
theorem toLinearMap_comp (g : Q₂ →qᵢ Q₃) (f : Q₁ →qᵢ Q₂) :
    (g.comp f).toLinearMap = g.toLinearMap.comp f.toLinearMap
-- Mathlib/Analysis/Complex/Asymptotics.lean
@[simp, norm_cast]
theorem isLittleO_ofReal_left {f : α → ℝ} {g : α → E} : (f · : α → ℂ) =o[l] g ↔ f =o[l] g
-- .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean
@[simp] theorem coprime_zero_right (n : Nat) : Coprime n 0 ↔ n = 1
-- Mathlib/RingTheory/AdicCompletion/Basic.lean
@[simp]
theorem val_sum {α : Type*} (s : Finset α) (f : α → AdicCompletion I M) (n : ℕ) :
    (Finset.sum s f).val n = Finset.sum s (fun a ↦ (f a).val n)
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
theorem piTensorHomMapFun₂_smul (r : R) (φ : ⨂[R] i, s i →ₗ[R] t i →ₗ[R] t' i) :
    piTensorHomMapFun₂ (r • φ) = r • piTensorHomMapFun₂ φ
-- Mathlib/Data/Finset/Basic.lean
/-- A `Finset` for an empty type is empty. -/
theorem eq_empty_of_isEmpty [IsEmpty α] (s : Finset α) : s = ∅
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.int_mul_sub_eq [Ring α] [Ring β] (h : Antiperiodic f c) (n : ℤ) :
    f (n * c - x) = (n.negOnePow : ℤ) * f (-x)
-- Mathlib/Data/Finset/Basic.lean
theorem insert_inter_distrib (s t : Finset α) (a : α) :
    insert a (s ∩ t) = insert a s ∩ insert a t
-- Mathlib/RingTheory/Valuation/ValuationRing.lean
theorem iff_dvd_total : ValuationRing R ↔ IsTotal R (· ∣ ·)
-- Mathlib/Data/Nat/Set.lean
theorem zero_union_range_succ : {0} ∪ range succ = univ
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem congr_symm_tmul (f : M ≃ₗ[R] P) (g : N ≃ₗ[R] Q) (p : P) (q : Q) :
    (congr f g).symm (p ⊗ₜ q) = f.symm p ⊗ₜ g.symm q
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem transpose_ofNat [DecidableEq n] [AddMonoidWithOne α] (d : ℕ) [d.AtLeastTwo] :
    (no_index (OfNat.ofNat d) : Matrix n n α)ᵀ = OfNat.ofNat d
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem HasDerivWithinAt.derivWithin (h : HasDerivWithinAt f f' s x)
    (hxs : UniqueDiffWithinAt 𝕜 s x) : derivWithin f s x = f'
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem spanSingleton_inv_mul {x : K} (hx : x ≠ 0) :
    (spanSingleton R₁⁰ x)⁻¹ * spanSingleton R₁⁰ x = 1
-- Mathlib/RingTheory/QuotSMulTop.lean
@[simp]
lemma map_id : map r (LinearMap.id : M →ₗ[R] M) = .id
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem indexOf_of_not_mem {l : List α} {a : α} : a ∉ l → indexOf a l = length l
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem map₂Left_nil_right : map₂Left f as [] = as.map fun a => f a none
-- Mathlib/LinearAlgebra/Prod.lean
theorem prodMap_comap_prod (f : M →ₗ[R] M₂) (g : M₃ →ₗ[R] M₄) (S : Submodule R M₂)
    (S' : Submodule R M₄) :
    (Submodule.prod S S').comap (LinearMap.prodMap f g) = (S.comap f).prod (S'.comap g)
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem val_inclusion {S T : NonUnitalStarSubalgebra R A} (h : S ≤ T) (s : S) :
    (inclusion h s : A) = s
-- Mathlib/Order/Interval/Multiset.lean
theorem card_Ioo_eq_card_Icc_sub_two (a b : α) : card (Ioo a b) = card (Icc a b) - 2
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem term_ord_aux {i : I} (ho : ord I i < Ordinal.type ((·<·) : I → I → Prop)) :
    term I ho = i
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
@[simp]
theorem map_id :
    map LinearMap.id = AlgHom.id R (ExteriorAlgebra R M)
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
theorem le_iff {i₁ i₂ : Pos} : i₁ ≤ i₂ ↔ i₁.byteIdx ≤ i₂.byteIdx
-- Mathlib/Topology/Constructions.lean
theorem mem_nhdsWithin_prod_iff {x : X} {y : Y} {s : Set (X × Y)} {tx : Set X} {ty : Set Y} :
    s ∈ 𝓝[tx ×ˢ ty] (x, y) ↔ ∃ u ∈ 𝓝[tx] x, ∃ v ∈ 𝓝[ty] y, u ×ˢ v ⊆ s
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem mapRange_id (h : ∀ i, id (0 : β₁ i) = 0 := fun i => rfl) (g : Π₀ i : ι, β₁ i) :
    mapRange (fun i => (id : β₁ i → β₁ i)) h g = g
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Series.lean
theorem Complex.sin_eq_tsum' (z : ℂ) :
    Complex.sin z = ∑' n : ℕ, (z * Complex.I) ^ (2 * n + 1) / ↑(2 * n + 1)! / Complex.I
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
nonrec theorem HasDerivWithinAt.add (hf : HasDerivWithinAt f f' s x)
    (hg : HasDerivWithinAt g g' s x) : HasDerivWithinAt (fun y => f y + g y) (f' + g') s x
-- Mathlib/Data/Nat/Fib/Basic.lean
@[simp] lemma fib_pos {n : ℕ} : 0 < fib n ↔ 0 < n
-- Mathlib/Analysis/Calculus/InverseFunctionTheorem/ApproximatesLinearOn.lean
theorem mono_set (hst : s ⊆ t) (hf : ApproximatesLinearOn f f' t c) :
    ApproximatesLinearOn f f' s c
-- Mathlib/CategoryTheory/Abelian/NonPreadditive.lean
theorem add_neg_self {X Y : C} (a : X ⟶ Y) : a + -a = 0
-- Mathlib/RingTheory/Multiplicity.lean
theorem pow_dvd_iff_le_multiplicity {a b : α} {k : ℕ} :
    a ^ k ∣ b ↔ (k : PartENat) ≤ multiplicity a b