ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem neg_limZero {f : CauSeq β abv} (hf : LimZero f) : LimZero (-f)
-- Mathlib/Algebra/BigOperators/Finsupp.lean
@[to_additive (attr := simp)]
theorem prod_inv [Zero M] [CommGroup G] {f : α →₀ M} {h : α → M → G} :
    (f.prod fun a b => (h a b)⁻¹) = (f.prod h)⁻¹
-- Mathlib/GroupTheory/GroupAction/SubMulAction.lean
theorem smul_mem_iff (s0 : s ≠ 0) : s • x ∈ p ↔ x ∈ p
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem contDiff_mul : ContDiff 𝕜 n fun p : 𝔸 × 𝔸 => p.1 * p.2
-- Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Symmetric.lean
theorem symmetry (X Y : C) :
    (Limits.BinaryFan.braiding (ℬ X Y).isLimit (ℬ Y X).isLimit).hom ≫
        (Limits.BinaryFan.braiding (ℬ Y X).isLimit (ℬ X Y).isLimit).hom =
      𝟙 (tensorObj ℬ X Y)
-- Mathlib/Data/Set/Basic.lean
theorem not_subset_iff_exists_mem_not_mem {α : Type*} {s t : Set α} :
    ¬s ⊆ t ↔ ∃ x, x ∈ s ∧ x ∉ t
-- Mathlib/Data/Set/Image.lean
theorem image_inter_preimage (f : α → β) (s : Set α) (t : Set β) :
    f '' (s ∩ f ⁻¹' t) = f '' s ∩ t
-- Mathlib/Topology/Category/CompHausLike/Basic.lean
/-- Construct a homeomorphism from an isomorphism. -/
@[simps!]
def homeoOfIso {X Y : CompHausLike.{u} P} (f : X ≅ Y) : X ≃ₜ Y
-- Mathlib/RingTheory/Localization/Basic.lean
theorem eq_iff_eq {x y} :
    algebraMap R S x = algebraMap R S y ↔ algebraMap R P x = algebraMap R P y
-- Mathlib/SetTheory/Game/PGame.lean
@[trans]
theorem fuzzy_of_equiv_of_fuzzy {x y z : PGame} (h₁ : x ≈ y) (h₂ : y ‖ z) : x ‖ z
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem neighborSet_subgraphOfAdj_of_ne_of_ne {u v w : V} (hvw : G.Adj v w) (hv : u ≠ v)
    (hw : u ≠ w) : (G.subgraphOfAdj hvw).neighborSet u = ∅
-- Mathlib/Analysis/NormedSpace/MatrixExponential.lean
theorem exp_conjTranspose [StarRing 𝔸] [ContinuousStar 𝔸] (A : Matrix m m 𝔸) :
    exp 𝕂 Aᴴ = (exp 𝕂 A)ᴴ
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
theorem IsAlt.self_eq_zero (x : M₁) : B x x = 0
-- Mathlib/CategoryTheory/Adjunction/FullyFaithful.lean
lemma isIso_unit_app_of_iso [R.Faithful] [R.Full] {X : D} {Y : C} (e : Y ≅ R.obj X) :
    IsIso (h.unit.app Y)
-- Mathlib/CategoryTheory/Limits/ConeCategory.lean
/-- Construct an object of the category `(F ↓ Δ)` from a cocone on `F`. This is part of an
    equivalence, see `Cocone.equivStructuredArrow`. -/
@[simps]
def Cocone.toStructuredArrow (F : J ⥤ C) : Cocone F ⥤ StructuredArrow F (const J)
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem comap_equiv_eq_map_symm (e : M ≃ₛₗ[τ₁₂] M₂) (K : Submodule R₂ M₂) :
    K.comap (e : M →ₛₗ[τ₁₂] M₂) = K.map (e.symm : M₂ →ₛₗ[τ₂₁] M)
-- Mathlib/Data/ENNReal/Real.lean
theorem toReal_iInf (hf : ∀ i, f i ≠ ∞) : (iInf f).toReal = ⨅ i, (f i).toReal
-- Mathlib/FieldTheory/Adjoin.lean
theorem adjoin_simple_eq_bot_iff : F⟮α⟯ = ⊥ ↔ α ∈ (⊥ : IntermediateField F E)
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp] lemma ofENat_eq_nat {m : ℕ∞} {n : ℕ} : (m : Cardinal) = n ↔ m = n
-- Mathlib/Algebra/GroupWithZero/Basic.lean
theorem right_ne_zero_of_mul : a * b ≠ 0 → b ≠ 0
-- Mathlib/NumberTheory/Cyclotomic/Basic.lean
theorem eq_adjoin_primitive_root {μ : CyclotomicField n K} (h : IsPrimitiveRoot μ n) :
    CyclotomicRing n A K = adjoin A ({μ} : Set (CyclotomicField n K))
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
@[simp]
theorem face_mk {n} (l u : Fin (n + 1) → ℝ) (h : ∀ i, l i < u i) (i : Fin (n + 1)) :
    face ⟨l, u, h⟩ i = ⟨l ∘ Fin.succAbove i, u ∘ Fin.succAbove i, fun _ ↦ h _⟩
-- Mathlib/SetTheory/Cardinal/Finite.lean
lemma card_image_of_injective {f : α → β} (hf : Injective f) (s : Set α) :
    Nat.card (f '' s) = Nat.card s
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
theorem isVonNBounded_iff (s : Set E) : IsVonNBounded 𝕜 s ↔ ∀ V ∈ 𝓝 (0 : E), Absorbs 𝕜 V s
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem im_re : a.im.re = 0
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem sub_le_sub_right {n m : Nat} (h : n ≤ m) : ∀ k, n - k ≤ m - k
-- Mathlib/Data/Set/Basic.lean
protected theorem eq_or_ssubset_of_subset (h : s ⊆ t) : s = t ∨ s ⊂ t
-- Mathlib/Analysis/Matrix.lean
theorem linfty_opNNNorm_mulVec (A : Matrix l m α) (v : m → α) : ‖A *ᵥ v‖₊ ≤ ‖A‖₊ * ‖v‖₊
-- Mathlib/Probability/Process/Filtration.lean
protected theorem le (f : Filtration ι m) (i : ι) : f i ≤ m
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem tmul_zero (m : M) : m ⊗ₜ[R] (0 : N) = 0
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousWithinAt.mem_closure {f : α → β} {s : Set α} {x : α} {A : Set β}
    (h : ContinuousWithinAt f s x) (hx : x ∈ closure s) (hA : MapsTo f s A) : f x ∈ closure A
-- Mathlib/Init/Algebra/Classes.lean
theorem not_lt_of_equiv' {a b : α} : a ≈ b → ¬b ≺ a
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
theorem nndist_eq_sum {p : ℝ≥0∞} [Fact (1 ≤ p)] {β : ι → Type*} [∀ i, PseudoMetricSpace (β i)]
    (hp : p ≠ ∞) (x y : PiLp p β) :
    nndist x y = (∑ i : ι, nndist (x i) (y i) ^ p.toReal) ^ (1 / p.toReal)
-- Mathlib/Topology/Algebra/InfiniteSum/Ring.lean
theorem tsum_div_const [T2Space α] : ∑' x, f x / a = (∑' x, f x) / a
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem map_extChartAt_nhds_of_boundaryless [I.Boundaryless] (x : M) :
    map (extChartAt I x) (𝓝 x) = 𝓝 (extChartAt I x x)
-- Mathlib/GroupTheory/Exponent.lean
/-- A nontrivial monoid has prime exponent `p` if and only if every non-identity element has
order `p`. -/
@[to_additive]
lemma exponent_eq_prime_iff {G : Type*} [Monoid G] [Nontrivial G] {p : ℕ} (hp : p.Prime) :
    Monoid.exponent G = p ↔ ∀ g : G, g ≠ 1 → orderOf g = p
-- Mathlib/Topology/Order.lean
theorem continuous_sSup_dom {T : Set (TopologicalSpace α)} {t₂ : TopologicalSpace β} :
    Continuous[sSup T, t₂] f ↔ ∀ t ∈ T, Continuous[t, t₂] f
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] protected theorem one_pow (n : Nat) : 1 ^ n = 1
-- Mathlib/Order/Interval/Set/Image.lean
@[simp]
lemma image_subtype_val_Ioi_Ici {a : α} (b : Ioi a) : Subtype.val '' Ici b = Ici b.1
-- Mathlib/LinearAlgebra/BilinearForm/Hom.lean
@[simp]
theorem linMulLin_apply (x y) : linMulLin f g x y = f x * g y
-- Mathlib/Geometry/Manifold/MFDeriv/UniqueDifferential.lean
theorem Trivialization.mdifferentiable (e : Trivialization F (π F Z)) [MemTrivializationAtlas e] :
    e.toPartialHomeomorph.MDifferentiable (I.prod 𝓘(𝕜, F)) (I.prod 𝓘(𝕜, F))
-- Mathlib/Algebra/Homology/SingleHomology.lean
@[reassoc (attr := simp)]
lemma singleObjOpcyclesSelfIso_inv_naturality :
    opcyclesMap ((single C c j).map f) j ≫ (singleObjOpcyclesSelfIso c j B).inv =
      (singleObjOpcyclesSelfIso c j A).inv ≫ f
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive]
protected theorem map_eq_one_iff (h : M ≃* N) {x : M} : h x = 1 ↔ x = 1
-- Mathlib/Data/Int/Cast/Basic.lean
@[simp, norm_cast]
theorem cast_sub (m n) : ((m - n : ℤ) : R) = m - n
-- Mathlib/Data/Nat/Dist.lean
theorem dist_tri_right' (n m : ℕ) : n ≤ m + dist n m
-- Mathlib/Algebra/Group/Submonoid/MulOpposite.lean
@[to_additive (attr := simp)]
theorem op_unop (S : Submonoid Mᵐᵒᵖ) : S.unop.op = S
-- Mathlib/Algebra/Polynomial/Identities.lean
private theorem poly_binom_aux2 (f : R[X]) (x y : R) :
    f.eval (x + y) =
      f.sum fun e a => a * (x ^ e + e * x ^ (e - 1) * y + (polyBinomAux1 x y e a).val * y ^ 2)
-- Mathlib/Analysis/NormedSpace/MStructure.lean
theorem compl_mul {P : { P : M // IsLprojection X P }} {Q : M} : ↑Pᶜ * Q = Q - ↑P * Q
-- Mathlib/Topology/Algebra/Monoid.lean
@[to_additive (attr := continuity)]
theorem continuous_list_prod {f : ι → X → M} (l : List ι) (h : ∀ i ∈ l, Continuous (f i)) :
    Continuous fun a => (l.map fun i => f i a).prod
-- Mathlib/Algebra/Module/Injective.lean
theorem ExtensionOfMaxAdjoin.extendIdealTo_wd' (h : Module.Baer R Q) {y : N} (r : R)
    (eq1 : r • y = 0) : ExtensionOfMaxAdjoin.extendIdealTo i f h y r = 0
-- Mathlib/CategoryTheory/GradedObject/Monoidal.lean
@[simp]
lemma tensor_id (X Y : GradedObject I C) [HasTensor X Y] :
    tensorHom (𝟙 X) (𝟙 Y) = 𝟙 _
-- Mathlib/CategoryTheory/Category/Factorisation.lean
/-- Morphisms of `Factorisation f` consist of morphism between their midpoints and the obvious
commutativity conditions. -/
@[ext]
protected structure Hom (d e : Factorisation f) : Type (max u v) where
  /-- The morphism between the midpoints of the factorizations. -/
  h : d.mid ⟶ e.mid
  /-- The left commuting triangle of the factorization morphism. -/
  ι_h : d.ι ≫ h = e.ι := by aesop_cat
  /-- The right commuting triangle of the factorization morphism. -/
  h_π : h ≫ e.π = d.π := by aesop_cat
-- Mathlib/Algebra/Category/ModuleCat/Kernels.lean
/-- The category of R-modules has kernels, given by the inclusion of the kernel submodule. -/
theorem hasKernels_moduleCat : HasKernels (ModuleCat R)
-- Mathlib/Algebra/Group/Support.lean
@[to_additive]
theorem mulSupport_curry (f : α × β → M) :
    (mulSupport f.curry) = (mulSupport f).image Prod.fst
-- Mathlib/Topology/Compactness/Compact.lean
/-- Cantor's intersection theorem for `iInter`:
the intersection of a directed family of nonempty compact closed sets is nonempty. -/
theorem IsCompact.nonempty_iInter_of_directed_nonempty_isCompact_isClosed
    {ι : Type v} [hι : Nonempty ι] (t : ι → Set X) (htd : Directed (· ⊇ ·) t)
    (htn : ∀ i, (t i).Nonempty) (htc : ∀ i, IsCompact (t i)) (htcl : ∀ i, IsClosed (t i)) :
    (⋂ i, t i).Nonempty
-- Mathlib/Data/Matrix/Invertible.lean
/-- A copy of `invOf_mul_self_assoc` for rectangular matrices. -/
protected theorem invOf_mul_self_assoc (A : Matrix n n α) (B : Matrix n m α) [Invertible A] :
    ⅟ A * (A * B) = B
-- Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean
/-- The functor `Γ₀ : ChainComplex C ℕ ⥤ SimplicialObject C`, on morphisms. -/
@[simps]
def map {K K' : ChainComplex C ℕ} (f : K ⟶ K') : obj K ⟶ obj K'
-- Mathlib/Data/Seq/WSeq.lean
theorem exists_dropn_of_mem {s : WSeq α} {a} (h : a ∈ s) :
    ∃ n s', some (a, s') ∈ destruct (drop s n)
-- Mathlib/Algebra/BigOperators/Finsupp.lean
@[to_additive]
theorem prod_mapRange_index {f : M → M'} {hf : f 0 = 0} {g : α →₀ M} {h : α → M' → N}
    (h0 : ∀ a, h a 0 = 1) : (mapRange f hf g).prod h = g.prod fun a b => h a (f b)
-- Mathlib/RingTheory/Localization/Basic.lean
theorem mk'_eq_iff_eq_mul {x} {y : M} {z} :
    mk' S x y = z ↔ algebraMap R S x = z * algebraMap R S y
-- Mathlib/CategoryTheory/Preadditive/AdditiveFunctor.lean
lemma additive_of_comp_faithful
    (F : C ⥤ D) (G : D ⥤ E) [G.Additive] [(F ⋙ G).Additive] [Faithful G] :
    F.Additive
-- Mathlib/CategoryTheory/Localization/Predicate.lean
@[reassoc (attr := simp)]
lemma isoOfHom_inv_hom_id {X Y : C} (f : X ⟶ Y) (hf : W f) :
    (isoOfHom L W f hf).inv ≫ L.map f = 𝟙 _
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma asympBound_pos (n : ℕ) (hn : 0 < n) : 0 < asympBound g a b n
-- Mathlib/Analysis/Normed/Field/UnitBall.lean
@[simp, norm_cast]
theorem coe_pow_unitSphere [NormedDivisionRing 𝕜] (x : sphere (0 : 𝕜) 1) (n : ℕ) :
    ↑(x ^ n) = (x : 𝕜) ^ n
-- Mathlib/Data/Real/EReal.lean
theorem abs_coe_lt_top (x : ℝ) : (x : EReal).abs < ⊤
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma not_equiv_of_X_ne {P Q : Fin 3 → R} (hx : P x * Q z ^ 2 ≠ Q x * P z ^ 2) : ¬P ≈ Q
-- Mathlib/RingTheory/Ideal/Norm.lean
theorem span_singleton_absNorm_le (I : Ideal S) : Ideal.span {(Ideal.absNorm I : S)} ≤ I
-- Mathlib/CategoryTheory/Adjunction/Unique.lean
@[simp]
lemma natTransEquiv_id_symm {F : C ⥤ D} {G : D ⥤ C} (adj : F ⊣ G) :
    (natTransEquiv adj adj).symm (𝟙 _) = 𝟙 _
-- Mathlib/Algebra/Lie/IdealOperations.lean
theorem comap_bracket_eq {J₁ J₂ : LieIdeal R L'} (h : f.IsIdealMorphism) :
    comap f ⁅f.idealRange ⊓ J₁, f.idealRange ⊓ J₂⁆ = ⁅comap f J₁, comap f J₂⁆ ⊔ f.ker
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
theorem homogeneousComponent_of_mem {m n : ℕ} {p : MvPolynomial σ R}
    (h : p ∈ homogeneousSubmodule σ R n) :
    homogeneousComponent m p = if m = n then p else 0
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
/-- If there are zero morphisms, any terminal object is a zero object. -/
theorem hasZeroObject_of_hasTerminal_object [HasZeroMorphisms C] [HasTerminal C] :
    HasZeroObject C
-- Mathlib/Data/List/Sublists.lean
theorem sublistsLen_one (l : List α) : sublistsLen 1 l = l.reverse.map ([·])
-- Mathlib/Data/Seq/Computation.lean
theorem LiftRelRec.lem {R : α → β → Prop} (C : Computation α → Computation β → Prop)
    (H : ∀ {ca cb}, C ca cb → LiftRelAux R C (destruct ca) (destruct cb)) (ca cb) (Hc : C ca cb) (a)
    (ha : a ∈ ca) : LiftRel R ca cb
-- Mathlib/Topology/MetricSpace/Basic.lean
@[simp] theorem dist_toAdd (a b : Multiplicative X) : dist (toAdd a) (toAdd b) = dist a b
-- Mathlib/LinearAlgebra/Ray.lean
/-- The ray given by the negation of a nonzero vector. -/
@[simp]
theorem neg_rayOfNeZero (v : M) (h : v ≠ 0) :
    -rayOfNeZero R _ h = rayOfNeZero R (-v) (neg_ne_zero.2 h)
-- Mathlib/Algebra/Associated/Basic.lean
theorem not_prime_pow {n : ℕ} (hn : n ≠ 1) : ¬Prime (a ^ n)
-- Mathlib/RingTheory/Localization/NormTrace.lean
/-- Let `S` be an extension of `R` and `Rₘ Sₘ` be localizations at `M` of `R S` respectively.
Then the trace of `a : Sₘ` over `Rₘ` is the trace of `a : S` over `R` if `S` is free as `R`-module.
-/
theorem Algebra.trace_localization [Module.Free R S] [Module.Finite R S] (a : S) :
    Algebra.trace Rₘ Sₘ (algebraMap S Sₘ a) = algebraMap R Rₘ (Algebra.trace R S a)
-- Mathlib/RingTheory/Localization/Basic.lean
theorem mk_eq_mk'_apply (x y) : mk x y = IsLocalization.mk' (Localization M) x y
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem succ_pred_prime {p : ℕ} (pp : Prime p) : succ (pred p) = p
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem setIntegral_trim {X} {m m0 : MeasurableSpace X} {μ : Measure X} (hm : m ≤ m0) {f : X → E}
    (hf_meas : StronglyMeasurable[m] f) {s : Set X} (hs : MeasurableSet[m] s) :
    ∫ x in s, f x ∂μ = ∫ x in s, f x ∂μ.trim hm
-- Mathlib/Analysis/BoxIntegral/Partition/Measure.lean
theorem measure_coe_lt_top (μ : Measure (ι → ℝ)) [IsLocallyFiniteMeasure μ] : μ I < ∞
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem type_eq_one_of_unique (r) [IsWellOrder α r] [Unique α] : type r = 1
-- Mathlib/Algebra/FreeMonoid/Basic.lean
@[to_additive (attr := simp)]
theorem toList_of (x : α) : toList (of x) = [x]
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem toSubsemiring_injective : Function.Injective (toSubsemiring : Subring R → Subsemiring R)
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
/-- The red-red invariant is monotonic in `p`. -/
protected theorem RedRed.imp (h : p → q) : RedRed p t n → RedRed q t n
-- Mathlib/Order/SuccPred/Basic.lean
theorem succ_eq_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) :
    succ a = succ b ↔ a = b
-- Mathlib/Data/Nat/ModEq.lean
lemma mod_eq_of_modEq {a b n} (h : a ≡ b [MOD n]) (hb : b < n) : a % n = b
-- Mathlib/Data/Nat/Defs.lean
@[simp, nolint simpNF] protected lemma add_eq_zero : m + n = 0 ↔ m = 0 ∧ n = 0
-- Mathlib/Analysis/Convex/Hull.lean
theorem AffineMap.image_convexHull (f : E →ᵃ[𝕜] F) (s : Set E) :
    f '' convexHull 𝕜 s = convexHull 𝕜 (f '' s)
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Images.lean
/-- If a functor preserves span and cospan, then it preserves images.
-/
@[simps!]
def iso {X Y : A} (f : X ⟶ Y) : image (L.map f) ≅ L.obj (image f)
-- Mathlib/Data/PNat/Prime.lean
theorem dvd_gcd {m n k : ℕ+} (hm : k ∣ m) (hn : k ∣ n) : k ∣ gcd m n
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive]
protected theorem NeBot.div : NeBot f → NeBot g → NeBot (f / g)
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean
protected lemma preconnected_iff {H : G.Subgraph} :
    H.Preconnected ↔ H.coe.Preconnected
-- Mathlib/RingTheory/Noetherian.lean
/-- For an endomorphism of a Noetherian module, any sufficiently large iterate has disjoint kernel
and range. -/
theorem LinearMap.eventually_disjoint_ker_pow_range_pow (f : M →ₗ[R] M) :
    ∀ᶠ n in atTop, Disjoint (LinearMap.ker (f ^ n)) (LinearMap.range (f ^ n))
-- Mathlib/Algebra/Homology/ShortComplex/FunctorEquivalence.lean
/-- The obvious functor `ShortComplex (J ⥤ C) ⥤ J ⥤ ShortComplex C`. -/
@[simps]
def functor : ShortComplex (J ⥤ C) ⥤ J ⥤ ShortComplex C
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
/-- The right fraction from `X` to `Y` given by a morphism `s : Y ⟶ X` such that `W s`. -/
@[simps]
def ofInv (s : Y ⟶ X) (hs : W s) :
    W.RightFraction X Y
-- Mathlib/SetTheory/Game/Nim.lean
theorem nim_one_moveRight (x) : (nim 1).moveRight x = nim 0
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem Matrix.toLinAlgEquiv_mul (A B : Matrix n n R) :
    Matrix.toLinAlgEquiv v₁ (A * B) =
      (Matrix.toLinAlgEquiv v₁ A).comp (Matrix.toLinAlgEquiv v₁ B)
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
theorem adjoin_eq_starClosure_adjoin (s : Set A) :
    adjoin R s = (NonUnitalAlgebra.adjoin R s).starClosure
-- Mathlib/Data/ZMod/Basic.lean
/-- This lemma works in the case in which `ZMod n` is not infinite, i.e. `n ≠ 0`.  The version
where `a ≠ 0` is `addOrderOf_coe'`. -/
@[simp]
theorem addOrderOf_coe (a : ℕ) {n : ℕ} (n0 : n ≠ 0) : addOrderOf (a : ZMod n) = n / n.gcd a
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[simp]
theorem _root_.aestronglyMeasurable_add_measure_iff [PseudoMetrizableSpace β] {ν : Measure α} :
    AEStronglyMeasurable f (μ + ν) ↔ AEStronglyMeasurable f μ ∧ AEStronglyMeasurable f ν
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
theorem map_comp : map (fun (i : ι) ↦ g i ∘ₗ f i) = map g ∘ₗ map f
-- Mathlib/Analysis/Convex/Function.lean
theorem StrictConvexOn.add_convexOn (hf : StrictConvexOn 𝕜 s f) (hg : ConvexOn 𝕜 s g) :
    StrictConvexOn 𝕜 s (f + g)
-- Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean
/-- The counit isomorphism of the equivalence `equivalence₂` between `A` and `B`. -/
@[simps!]
def equivalence₂CounitIso : (eB.functor ⋙ e'.inverse ⋙ eA.inverse) ⋙ F ⋙ eB.inverse ≅ 𝟭 B
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- The product of a monotone function and a strictly monotone function is strictly monotone. -/
@[to_additive add_strictMono "The sum of a monotone function and a strictly monotone function is
strictly monotone."]
theorem Monotone.mul_strictMono' [CovariantClass α α (· * ·) (· < ·)]
    [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {f g : β → α} (hf : Monotone f)
    (hg : StrictMono g) :
    StrictMono fun x => f x * g x
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem isEmpty : ∀ {s}, Valid s → (s.isEmpty ↔ s.toString = "")
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean
@[simp]
theorem finite_neighborSet_toSubgraph (p : G.Walk u v) : (p.toSubgraph.neighborSet w).Finite
-- Mathlib/GroupTheory/SemidirectProduct.lean
theorem lift_unique (F : N ⋊[φ] G →* H) :
    F = lift (F.comp inl) (F.comp inr) fun _ ↦ by ext; simp [inl_aut]
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_onTerm [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] (t : L.Term α)
    (v : α → M) : (φ.onTerm t).realize v = t.realize v
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem SurjectiveOnWith.surjOn {f : NormedAddGroupHom V₁ V₂} {K : AddSubgroup V₂} {C : ℝ}
    (h : f.SurjectiveOnWith K C) : Set.SurjOn f Set.univ K
-- Mathlib/Order/Bounds/Basic.lean
theorem mem_lowerBounds_image (Ha : a ∈ lowerBounds s) : f a ∈ lowerBounds (f '' s)
-- Mathlib/Data/Num/Lemmas.lean
theorem add_zero (n : ZNum) : n + 0 = n
-- Mathlib/Topology/NoetherianSpace.lean
/-- Type class for noetherian spaces. It is defined to be spaces whose open sets satisfies ACC. -/
@[mk_iff]
class NoetherianSpace : Prop where
  wellFounded_opens : WellFounded ((· > ·) : Opens α → Opens α → Prop)
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem inv_div_left : a⁻¹ / b = (b * a)⁻¹
-- Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean
@[simp]
theorem evenOdd_comap_reverse (n : ZMod 2) :
    (evenOdd Q n).comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) = evenOdd Q n
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
@[simp]
lemma isNClique_singleton : G.IsNClique n {a} ↔ n = 1
-- Mathlib/Data/Finsupp/Basic.lean
theorem sum_smul_index [Semiring R] [AddCommMonoid M] {g : α →₀ R} {b : R} {h : α → R → M}
    (h0 : ∀ i, h i 0 = 0) : (b • g).sum h = g.sum fun i a => h i (b * a)
-- Mathlib/Logic/Equiv/TransferInstance.lean
@[to_additive]
theorem div_def [Div β] (x y : α) :
    letI := Equiv.div e
    x / y = e.symm (e x / e y)
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
theorem of_mono {X Y : C} (f : X ⟶ Y) [Mono f] (i : IsZero Y) : IsZero X
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem bmod_def (x : Int) (m : Nat) : bmod x m =
  if (x % m) < (m + 1) / 2 then
    x % m
  else
    (x % m) - m
-- Mathlib/CategoryTheory/Functor/KanExtension/Pointwise.lean
lemma IsPointwiseRightKanExtension.hasPointwiseRightKanExtension :
    HasPointwiseRightKanExtension L F
-- Mathlib/Init/Algebra/Classes.lean
/-- `IsSymm X r` means the binary relation `r` on `X` is symmetric. -/
class IsSymm (α : Sort u) (r : α → α → Prop) : Prop where
  symm : ∀ a b, r a b → r b a
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem mem_join : ∀ {L : List (List α)}, a ∈ L.join ↔ ∃ l, l ∈ L ∧ a ∈ l
-- Mathlib/Order/UpperLower/Basic.lean
theorem not_bddAbove_Ici : ¬BddAbove (Ici a)
-- Mathlib/Topology/Constructions.lean
theorem ContinuousAt.restrictPreimage {f : X → Y} {s : Set Y} {x : f ⁻¹' s} (h : ContinuousAt f x) :
    ContinuousAt (s.restrictPreimage f) x
-- Mathlib/RingTheory/Artinian.lean
theorem Function.Surjective.isArtinianRing {R} [Ring R] {S} [Ring S] {F}
    [FunLike F R S] [RingHomClass F R S]
    {f : F} (hf : Function.Surjective f) [H : IsArtinianRing R] : IsArtinianRing S
-- Mathlib/CategoryTheory/Yoneda.lean
/-- A functor `F : C ⥤ Type v₁` is corepresentable if there is object `X` so `F ≅ coyoneda.obj X`.

See <https://stacks.math.columbia.edu/tag/001Q>.
-/
class Corepresentable (F : C ⥤ Type v₁) : Prop where
  /-- `Hom(X,-) ≅ F` via `f` -/
  has_corepresentation : ∃ (X : _), Nonempty (coyoneda.obj X ≅ F)
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
theorem IsOrtho.ge {U V : Submodule 𝕜 E} (h : U ⟂ V) : V ≤ Uᗮ
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp] theorem inv_divInt (n d : Int) : (n /. d).inv = d /. n
-- Mathlib/Analysis/SpecialFunctions/Gamma/Deligne.lean
@[simp]
lemma Gammaℝ_one : Gammaℝ 1 = 1
-- Mathlib/SetTheory/Game/Nim.lean
theorem grundyValue_eq_iff_equiv (G H : PGame) [G.Impartial] [H.Impartial] :
    grundyValue G = grundyValue H ↔ (G ≈ H)
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem le_inv_mul_iff_le : 1 ≤ b⁻¹ * a ↔ b ≤ a
-- Mathlib/Algebra/Polynomial/Taylor.lean
/-- Taylor's formula. -/
theorem sum_taylor_eq {R} [CommRing R] (f : R[X]) (r : R) :
    ((taylor r f).sum fun i a => C a * (X - C r) ^ i) = f
-- Mathlib/GroupTheory/Coxeter/Basic.lean
theorem prod_alternatingWord_eq_mul_pow (i i' : B) (m : ℕ) :
    π (alternatingWord i i' m) = (if Even m then 1 else s i') * (s i * s i') ^ (m / 2)
-- Mathlib/Order/Bounds/Basic.lean
theorem isLUB_Iic : IsLUB (Iic a) a
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma ΨSq_zero : W.ΨSq 0 = 0
-- Mathlib/Data/ENNReal/Basic.lean
@[simp, norm_cast] theorem coe_le_coe : (↑r : ℝ≥0∞) ≤ ↑q ↔ r ≤ q
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem id_comp (f : P1 →ᵃ[k] P2) : (id k P2).comp f = f
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem eq_nil_or_concat : ∀ l : List α, l = [] ∨ ∃ L b, l = concat L b
-- Mathlib/Order/Filter/Extr.lean
theorem IsMaxOn.sub (hf : IsMaxOn f s a) (hg : IsMinOn g s a) :
    IsMaxOn (fun x => f x - g x) s a
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
@[simp]
theorem areaForm_rightAngleRotation_right (x y : E) : ω x (J y) = ⟪x, y⟫
-- Mathlib/RingTheory/Ideal/Norm.lean
@[simp]
theorem absNorm_bot : absNorm (⊥ : Ideal S) = 0
-- Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean
/-- When a homology data `h` of a short complex `S` is such that both `h.left` and
`h.right` are preserved by a functor `F`, this is the induced homology data
`h.map F` for the short complex `S.map F`. -/
@[simps]
noncomputable def HomologyData.map (h : S.HomologyData) (F : C ⥤ D) [F.PreservesZeroMorphisms]
    [h.left.IsPreservedBy F] [h.right.IsPreservedBy F] :
    (S.map F).HomologyData