ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[elab_as_elim]
theorem closure_induction' {s : Set R} {p : ∀ x, x ∈ closure s → Prop}
    (mem : ∀ (x) (h : x ∈ s), p x (subset_closure h))
    (zero : p 0 (zero_mem _)) (one : p 1 (one_mem _))
    (add : ∀ x hx y hy, p x hx → p y hy → p (x + y) (add_mem hx hy))
    (mul : ∀ x hx y hy, p x hx → p y hy → p (x * y) (mul_mem hx hy))
    {a : R} (ha : a ∈ closure s) : p a ha
-- Mathlib/Data/List/Cycle.lean
theorem nextOr_mem {xs : List α} {x d : α} (hd : d ∈ xs) : nextOr xs x d ∈ xs
-- Mathlib/Algebra/Order/Floor/Div.lean
lemma ceilDiv_eq_add_pred_div (a b : ℕ) : a ⌈/⌉ b = (a + b - 1) / b
-- Mathlib/Topology/Maps/Basic.lean
protected theorem continuous_iff (hf : QuotientMap f) : Continuous g ↔ Continuous (g ∘ f)
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- If `M` and `N` are linearly disjoint, if `M` is flat, then any two commutative
elements of `↥(M ⊓ N)` are not `R`-linearly independent (namely, their span is not `R ^ 2`). -/
theorem not_linearIndependent_pair_of_commute_of_flat_left [Module.Flat R M]
    (a b : ↥(M ⊓ N)) (hc : Commute a.1 b.1) : ¬LinearIndependent R ![a, b]
-- Mathlib/Algebra/Order/Antidiag/Finsupp.lean
lemma mapRange_finsuppAntidiag_eq {e : μ ≃+ μ'} {s : Finset ι} {n : μ} :
    (finsuppAntidiag s n).map (mapRange.addEquiv e).toEmbedding = finsuppAntidiag s (e n)
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
@[simp]
theorem coeFn_neg (f : lp E p) : ⇑(-f) = -f
-- Mathlib/Topology/ContinuousFunction/CocompactMap.lean
@[simp]
theorem coe_mk (f : C(α, β)) (h : Tendsto f (cocompact α) (cocompact β)) :
    ⇑(⟨f, h⟩ : CocompactMap α β) = f
-- Mathlib/Topology/LocallyConstant/Algebra.lean
@[simp]
theorem coe_algebraMap (r : R) : ⇑(algebraMap R (LocallyConstant X Y) r) = algebraMap R (X → Y) r
-- Mathlib/Data/List/Sym.lean
theorem right_mem_of_mk_mem_sym2 {xs : List α} {a b : α}
    (h : s(a, b) ∈ xs.sym2) : b ∈ xs
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
@[simp]
theorem mul_le_mul_left [PosMulMono α] [PosMulReflectLE α] (a0 : 0 < a) : a * b ≤ a * c ↔ b ≤ c
-- Mathlib/Analysis/Normed/Lp/LpEquiv.lean
theorem coe_equiv_lpPiLp (f : lp E p) : Equiv.lpPiLp f = ⇑f
-- Mathlib/FieldTheory/Adjoin.lean
@[simp, norm_cast]
theorem coe_inf (S T : IntermediateField F E) : (↑(S ⊓ T) : Set E) = (S : Set E) ∩ T
-- Mathlib/Probability/Kernel/IntegralCompProd.lean
theorem _root_.MeasureTheory.Integrable.integral_norm_compProd ⦃f : β × γ → E⦄
    (hf : Integrable f ((κ ⊗ₖ η) a)) : Integrable (fun x => ∫ y, ‖f (x, y)‖ ∂η (a, x)) (κ a)
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp] theorem two_nsmul_associated : 2 • associatedHom S Q = Q.polarBilin
-- Mathlib/Order/SuccPred/Relation.lean
/-- For `m < n`, `(n, m)` is in the transitive closure of a relation `~` if `succ i ~ i`
  for all `i` between `n` and `m`. -/
theorem transGen_of_succ_of_gt (r : α → α → Prop) {n m : α} (h : ∀ i ∈ Ico m n, r (succ i) i)
    (hmn : m < n) : TransGen r n m
-- Mathlib/Analysis/Normed/Group/Hom.lean
/-- continuous linear maps are Lipschitz continuous. -/
theorem lipschitz : LipschitzWith ⟨‖f‖, opNorm_nonneg f⟩ f
-- Mathlib/Algebra/Order/Module/Defs.lean
private theorem smul_ne_zero_of_ne_zero_of_pos [Preorder β] (ha : a ≠ 0) (hb : 0 < b) : a • b ≠ 0
-- Mathlib/Algebra/DirectSum/Decomposition.lean
@[simp]
theorem decompose_zero : decompose ℳ (0 : M) = 0
-- Mathlib/RingTheory/IsTensorProduct.lean
@[simp]
theorem IsTensorProduct.equiv_toLinearMap (h : IsTensorProduct f) :
    h.equiv.toLinearMap = TensorProduct.lift f
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma changeLevel_factorsThrough {m : ℕ} (hm : n ∣ m) : FactorsThrough (changeLevel hm χ) n
-- Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean
/-- We say `C` has strict initial objects if every initial object is strict, ie given any morphism
`f : A ⟶ I` where `I` is initial, then `f` is an isomorphism.

Strictly speaking, this says that *any* initial object must be strict, rather than that strict
initial objects exist.
-/
class HasStrictInitialObjects : Prop where
  out : ∀ {I A : C} (f : A ⟶ I), IsInitial I → IsIso f
-- Mathlib/Order/Lattice.lean
/-- A `SemilatticeInf` is a meet-semilattice, that is, a partial order
  with a meet (a.k.a. glb / greatest lower bound, inf / infimum) operation
  `⊓` which is the greatest element smaller than both factors. -/
class SemilatticeInf (α : Type u) extends Inf α, PartialOrder α where
  /-- The infimum is a lower bound on the first argument -/
  protected inf_le_left : ∀ a b : α, a ⊓ b ≤ a
  /-- The infimum is a lower bound on the second argument -/
  protected inf_le_right : ∀ a b : α, a ⊓ b ≤ b
  /-- The infimum is the *greatest* lower bound -/
  protected le_inf : ∀ a b c : α, a ≤ b → a ≤ c → a ≤ b ⊓ c
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
theorem extChartAt_transDiffeomorph_target (x : M) :
    (extChartAt (I.transDiffeomorph e) x).target = e.symm ⁻¹' (extChartAt I x).target
-- Mathlib/RingTheory/Localization/Basic.lean
protected theorem injective (hM : M ≤ nonZeroDivisors R) : Injective (algebraMap R S)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem map_sup (f : A →ₐ[R] B) (S T : Subalgebra R A) : (S ⊔ T).map f = S.map f ⊔ T.map f
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ico_subset_Ico_union_Ico : Ico a c ⊆ Ico a b ∪ Ico b c
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- The `Submodule.LinearDisjoint.not_linearIndependent_pair_of_commute_of_flat_right`
for commutative rings. -/
theorem not_linearIndependent_pair_of_flat_right [Module.Flat R N]
    (a b : ↥(M ⊓ N)) : ¬LinearIndependent R ![a, b]
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
theorem gcd_succ (x y : Nat) : gcd (succ x) y = gcd (y % succ x) (succ x)
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
theorem is_compatible_of_exists_amalgamation (x : FamilyOfElements P R)
    (h : ∃ t, x.IsAmalgamation t) : x.Compatible
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem cosh_sq_sub_sinh_sq : cosh x ^ 2 - sinh x ^ 2 = 1
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, norm_cast]
lemma ofReal_le_ofReal {x y : ℝ} : (x : K) ≤ (y : K) ↔ x ≤ y
-- Mathlib/Topology/ContinuousOn.lean
theorem IsOpen.ite' {s s' t : Set α} (hs : IsOpen s) (hs' : IsOpen s')
    (ht : ∀ x ∈ frontier t, x ∈ s ↔ x ∈ s') : IsOpen (t.ite s s')
-- Mathlib/LinearAlgebra/TensorProduct/Tower.lean
/-- Heterobasic version of `TensorProduct.mk`:

The canonical bilinear map `M →[A] N →[R] M ⊗[R] N`. -/
@[simps! apply]
nonrec def mk : M →ₗ[A] N →ₗ[R] M ⊗[R] N
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
@[simp]
theorem map_comp_ι (f : M →ₗ[R] N) : (map f).toLinearMap ∘ₗ ι R = ι R ∘ₗ f
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
@[simp]
theorem mem_full_objs_iff {c : C} : c ∈ (full D).objs ↔ c ∈ D
-- Mathlib/Data/Fintype/Card.lean
theorem injective_iff_surjective {f : α → α} : Injective f ↔ Surjective f
-- Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean
lemma mem_inf {I J : TwoSidedIdeal R} {x : R} :
    x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J
-- Mathlib/Order/Bounds/OrderIso.lean
theorem upperBounds_image {s : Set α} : upperBounds (f '' s) = f '' upperBounds s
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean
theorem map_add_add (f : E →L[𝕜] Fₗ →L[𝕜] Gₗ) (x x' : E) (y y' : Fₗ) :
    f (x + x') (y + y') = f x y + f.deriv₂ (x, y) (x', y') + f x' y'
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem coe_trans_symm : ((e.trans e').symm : Z → X) = e.symm ∘ e'.symm
-- Mathlib/Analysis/Complex/Basic.lean
protected lemma compl_Iic_zero : (Set.Iic 0)ᶜ = slitPlane
-- Mathlib/Algebra/Associated/Basic.lean
theorem Associated.neg_left [Monoid α] [HasDistribNeg α] {a b : α} (h : Associated a b) :
    Associated (-a) b
-- Mathlib/Data/PFunctor/Multivariate/W.lean
theorem wMk_eq {α : TypeVec n} (a : P.A) (f : P.last.B a → P.last.W) (g' : P.drop.B a ⟹ α)
    (g : ∀ j : P.last.B a, P.WPath (f j) ⟹ α) :
    (P.wMk a g' fun i => ⟨f i, g i⟩) = ⟨⟨a, f⟩, P.wPathCasesOn g' g⟩
-- Mathlib/Data/Nat/Defs.lean
lemma mul_self_lt_mul_self (h : m < n) : m * m < n * n
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem not_append {x : BitVec w} {y : BitVec v} : ~~~ (x ++ y) = (~~~ x) ++ (~~~ y)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem toNat_and (x y : BitVec v) :
    BitVec.toNat (x &&& y) = BitVec.toNat x &&& BitVec.toNat y
-- Mathlib/Data/List/Perm.lean
@[simp]
theorem length_permutations'Aux (s : List α) (x : α) :
    length (permutations'Aux x s) = length s + 1
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[simp]
theorem tensorHom_id {X₁ X₂ : C} (f : X₁ ⟶ X₂) (Y : C) :
    f ⊗ 𝟙 Y = f ▷ Y
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
/-- The volume of `(ConvexBodyLt K f)` where `convexBodyLT K f` is the set of points `x`
such that `‖x w‖ < f w` for all infinite places `w`. -/
theorem convexBodyLT_volume :
    volume (convexBodyLT K f) = (convexBodyLTFactor K) * ∏ w, (f w) ^ (mult w)
-- Mathlib/Data/PNat/Xgcd.lean
theorem reduce_isSpecial : ∀ u : XgcdType, u.IsSpecial → u.reduce.IsSpecial
-- Mathlib/Algebra/CharP/Defs.lean
lemma charP_to_charZero [CharP R 0] : CharZero R
-- Mathlib/RepresentationTheory/Basic.lean
@[simp]
theorem ofModule_asAlgebraHom_apply_apply (r : MonoidAlgebra k G)
    (m : RestrictScalars k (MonoidAlgebra k G) M) :
    ((ofModule M).asAlgebraHom r) m =
      (RestrictScalars.addEquiv _ _ _).symm (r • RestrictScalars.addEquiv _ _ _ m)
-- Mathlib/MeasureTheory/SetAlgebra.lean
/-- If `𝒜` is an algebra of sets, then it contains the algebra generated by itself. -/
theorem generateSetAlgebra_subset_self (h𝒜 : IsSetAlgebra 𝒜) :
    generateSetAlgebra 𝒜 ⊆ 𝒜
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem IsNormal.conjugation_bij (Sn : IsNormal S) {c d} (p : c ⟶ d) :
    Set.BijOn (fun γ : c ⟶ c => Groupoid.inv p ≫ γ ≫ p) (S.arrows c c) (S.arrows d d)
-- Mathlib/Analysis/Seminorm.lean
theorem smul_inf [SMul R ℝ] [SMul R ℝ≥0] [IsScalarTower R ℝ≥0 ℝ] (r : R) (p q : Seminorm 𝕜 E) :
    r • (p ⊓ q) = r • p ⊓ r • q
-- Mathlib/Data/Fin/Basic.lean
@[simp] lemma one_succAbove_one {n : ℕ} : (1 : Fin (n + 3)).succAbove 1 = 2
-- Mathlib/Topology/CompactOpen.lean
/-- Definition of `ContinuousMap.compactOpen`. -/
theorem compactOpen_eq : @compactOpen X Y _ _ =
    .generateFrom (image2 (fun K U ↦ {f | MapsTo f K U}) {K | IsCompact K} {t | IsOpen t})
-- Mathlib/RingTheory/AdicCompletion/Algebra.lean
theorem smul_mk {m n : ℕ} (hmn : m ≤ n) (r : AdicCauchySequence I R)
    (x : AdicCauchySequence I M) :
    r.val n • Submodule.Quotient.mk (p := (I ^ m • ⊤ : Submodule R M)) (x.val n) =
      r.val m • Submodule.Quotient.mk (p := (I ^ m • ⊤ : Submodule R M)) (x.val m)
-- Mathlib/Data/Nat/Log.lean
theorem log_monotone {b : ℕ} : Monotone (log b)
-- Mathlib/Topology/Algebra/Algebra.lean
theorem ext_iff {f g : A →A[R] B} : f = g ↔ ∀ x, f x = g x
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem degree_neg (p : R[X]) : degree (-p) = degree p
-- Mathlib/Algebra/Lie/Character.lean
@[simp]
theorem lieCharacter_apply_lie' (χ : LieCharacter R L) (x y : L) : ⁅χ x, χ y⁆ = 0
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addXYZ_of_X_eq {P Q : Fin 3 → F} (hP : W.Equation P) (hQ : W.Equation Q) (hPz : P z ≠ 0)
    (hQz : Q z ≠ 0) (hx : P x * Q z ^ 2 = Q x * P z ^ 2) :
    W.addXYZ P Q = addU P Q • ![1, 1, 0]
-- Mathlib/Data/Num/Lemmas.lean
@[norm_cast]
theorem to_nat_inj {m n : PosNum} : (m : ℕ) = n ↔ m = n
-- Mathlib/RingTheory/Algebraic.lean
/-- A subalgebra is algebraic if and only if it is algebraic as an algebra. -/
theorem Subalgebra.isAlgebraic_iff (S : Subalgebra R A) :
    S.IsAlgebraic ↔ @Algebra.IsAlgebraic R S _ _ S.algebra
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive (attr := simp)]
theorem quot_mk_eq_mk : Quot.mk Red.Step L = mk L
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem coeff_add_mul_monomial (a : R) :
    coeff R (m + n) (φ * monomial R n a) = coeff R m φ * a
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] theorem emod_self_add_one {x : Int} (h : 0 ≤ x) : x % (x + 1) = x
-- Mathlib/CategoryTheory/Abelian/NonPreadditive.lean
theorem add_def {X Y : C} (a b : X ⟶ Y) : a + b = a - -b
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem differentiableOn_of_locally_differentiableOn
    (h : ∀ x ∈ s, ∃ u, IsOpen u ∧ x ∈ u ∧ DifferentiableOn 𝕜 f (s ∩ u)) :
    DifferentiableOn 𝕜 f s
-- Mathlib/Data/Nat/Defs.lean
lemma add_pos_iff_pos_or_pos : 0 < m + n ↔ 0 < m ∨ 0 < n
-- Mathlib/Topology/Sheaves/Stalks.lean
@[ext]
lemma pullback_obj_obj_ext {Z : C} {f : X ⟶ Y} {F : Y.Presheaf C} (U : (Opens X)ᵒᵖ)
    {φ ψ : ((pullback C f).obj F).obj U ⟶ Z}
    (h : ∀ (V : Opens Y) (hV : U.unop ≤ (Opens.map f).obj V),
      ((pushforwardPullbackAdjunction C f).unit.app F).app (op V) ≫
        ((pullback C f).obj F).map (homOfLE hV).op ≫ φ =
      ((pushforwardPullbackAdjunction C f).unit.app F).app (op V) ≫
        ((pullback C f).obj F).map (homOfLE hV).op ≫ ψ) : φ = ψ
-- Mathlib/Topology/Constructions.lean
theorem isClosed_range_sigmaMk {i : ι} : IsClosed (range (@Sigma.mk ι σ i))
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
theorem count_le_count_cons (a b : α) (l : List α) : count a l ≤ count a (b :: l)
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc]
theorem associator_inv_conjugation {X X' Y Y' Z Z' : C} (f : X ⟶ X') (g : Y ⟶ Y') (h : Z ⟶ Z') :
    f ⊗ g ⊗ h = (α_ X Y Z).inv ≫ ((f ⊗ g) ⊗ h) ≫ (α_ X' Y' Z').hom
-- Mathlib/Data/Multiset/FinsetOps.lean
theorem ndinsert_le {a : α} {s t : Multiset α} : ndinsert a s ≤ t ↔ s ≤ t ∧ a ∈ t
-- Mathlib/Data/Finset/Basic.lean
theorem filter_singleton (a : α) : filter p {a} = if p a then {a} else ∅
-- Mathlib/Analysis/Calculus/Deriv/Inv.lean
@[simp]
theorem Differentiable.div (hc : Differentiable 𝕜 c) (hd : Differentiable 𝕜 d) (hx : ∀ x, d x ≠ 0) :
    Differentiable 𝕜 fun x => c x / d x
-- Mathlib/LinearAlgebra/Pi.lean
/-- If `ι` has a unique element, then `ι → M` is linearly equivalent to `M`. -/
@[simps (config := { simpRhs := true, fullyApplied := false }) symm_apply]
def funUnique (ι R M : Type*) [Unique ι] [Semiring R] [AddCommMonoid M] [Module R M] :
    (ι → M) ≃ₗ[R] M
-- Mathlib/Data/Matroid/Sum.lean
lemma Finitary.sigma (h : ∀ i, (M i).Finitary) : (Matroid.sigma M).Finitary
-- Mathlib/Algebra/Lie/Subalgebra.lean
theorem map_le_iff_le_comap {K : LieSubalgebra R L} {K' : LieSubalgebra R L₂} :
    map f K ≤ K' ↔ K ≤ comap f K'
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem orderIsoPUnitSumLex_bot : @orderIsoPUnitSumLex α _ ⊥ = toLex (inl PUnit.unit)
-- Mathlib/NumberTheory/PrimeCounting.lean
@[simp]
theorem zeroth_prime_eq_two : nth Prime 0 = 2
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
/-- Given a structured arrow `X ⟶ T(Y)`, and an arrow `Y ⟶ Y'`, we can construct a morphism of
    structured arrows given by `(X ⟶ T(Y)) ⟶ (X ⟶ T(Y) ⟶ T(Y'))`.  -/
@[simps]
def homMk' (f : StructuredArrow S T) (g : f.right ⟶ Y') : f ⟶ mk (f.hom ≫ T.map g)
-- Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean
@[simp, mfld_simps]
theorem trivializationAt_baseSet (x : M) :
    (trivializationAt E (TangentSpace I) x).baseSet = (chartAt H x).source
-- Mathlib/Order/WithBot.lean
@[simp]
theorem untop'_top {α} (d : α) : untop' d ⊤ = d
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
theorem rat_dense (q : ℚ_[p]) {ε : ℝ} (hε : 0 < ε) : ∃ r : ℚ, ‖q - r‖ < ε
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
theorem nrRealPlaces_eq_one_of_finrank_eq_one (h : finrank ℚ K = 1) :
    NrRealPlaces K = 1
-- Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean
/-- Empty graphs are strongly regular. Note that `ℓ` can take any value
for empty graphs, since there are no pairs of adjacent vertices. -/
theorem bot_strongly_regular : (⊥ : SimpleGraph V).IsSRGWith (Fintype.card V) 0 ℓ 0
-- Mathlib/Logic/Small/Group.lean
@[simp]
lemma equivShrink_add [Add α] [Small α] (x y : α) :
    equivShrink α (x + y) = equivShrink α x + equivShrink α y
-- Mathlib/Probability/IdentDistrib.lean
@[to_additive]
lemma inv [Inv γ] [MeasurableInv γ] (h : IdentDistrib f g μ ν) :
    IdentDistrib f⁻¹ g⁻¹ μ ν
-- Mathlib/Algebra/Polynomial/Reverse.lean
@[simp]
theorem reflect_C_mul (f : R[X]) (r : R) (N : ℕ) : reflect N (C r * f) = C r * reflect N f
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem get!_eq_get? [Inhabited α] (a : Array α) : a.get! n = (a.get? n).getD default
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem norm_setToSimpleFunc_le_sum_opNorm {m : MeasurableSpace α} (T : Set α → F' →L[ℝ] F)
    (f : α →ₛ F') : ‖f.setToSimpleFunc T‖ ≤ ∑ x ∈ f.range, ‖T (f ⁻¹' {x})‖ * ‖x‖
-- Mathlib/Computability/Primrec.lean
theorem vector_ofFn {n} {f : Fin n → α → σ} (hf : ∀ i, Primrec (f i)) :
    Primrec fun a => Vector.ofFn fun i => f i a
-- Mathlib/Analysis/Analytic/Within.lean
/-- If `f` is `AnalyticWithinOn` near each point in a set, it is `AnalyticWithinOn` the set -/
lemma analyticWithinOn_of_locally_analyticWithinOn {f : E → F} {s : Set E}
    (h : ∀ x ∈ s, ∃ u, IsOpen u ∧ x ∈ u ∧ AnalyticWithinOn 𝕜 f (s ∩ u)) :
    AnalyticWithinOn 𝕜 f s
-- Mathlib/Algebra/MonoidAlgebra/Grading.lean
theorem mem_gradeBy_iff (f : M → ι) (i : ι) (a : R[M]) :
    a ∈ gradeBy R f i ↔ (a.support : Set M) ⊆ f ⁻¹' {i}
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem lt_inv_of_neg (ha : a < 0) (hb : b < 0) : a < b⁻¹ ↔ b < a⁻¹
-- Mathlib/Algebra/Star/SelfAdjoint.lean
/-- All elements are self-adjoint when `star` is trivial. -/
theorem all [Star R] [TrivialStar R] (r : R) : IsSelfAdjoint r
-- Mathlib/Data/ENNReal/Operations.lean
@[simp, norm_cast]
theorem natCast_sub (m n : ℕ) : ↑(m - n) = (m - n : ℝ≥0∞)
-- Mathlib/Data/Sum/Basic.lean
@[simp] theorem isSome_getLeft?_iff_isLeft : x.getLeft?.isSome ↔ x.isLeft
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem FiberBundle.chartedSpace'_chartAt (x : TotalSpace F E) :
    chartAt (B × F) x = (trivializationAt F E x.proj).toPartialHomeomorph
-- Mathlib/Data/NNReal/Basic.lean
theorem _root_.Real.toNNReal_div' {x y : ℝ} (hy : 0 ≤ y) :
    Real.toNNReal (x / y) = Real.toNNReal x / Real.toNNReal y
-- Mathlib/Order/Interval/Finset/Fin.lean
theorem card_fintypeIio : Fintype.card (Set.Iio b) = b
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
theorem LinearMap.mul_toMatrix₂_mul (B : M₁ →ₗ[R] M₂ →ₗ[R] R) (M : Matrix n' n R)
    (N : Matrix m m' R) :
    M * LinearMap.toMatrix₂ b₁ b₂ B * N =
      LinearMap.toMatrix₂ b₁' b₂' (B.compl₁₂ (toLin b₁' b₁ Mᵀ) (toLin b₂' b₂ N))
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasDerivWithinAt.const_cpow (hf : HasDerivWithinAt f f' s x) (h0 : c ≠ 0 ∨ f x ≠ 0) :
    HasDerivWithinAt (fun x => c ^ f x) (c ^ f x * Complex.log c * f') s x
-- Mathlib/Order/Interval/Set/Image.lean
@[simp]
lemma image_subtype_val_Iio_Ioi {a : α} (b : Iio a) : Subtype.val '' Ioi b = Ioo b.1 a
-- Mathlib/Algebra/Polynomial/BigOperators.lean
/-- The degree of a product of polynomials is equal to
the sum of the degrees, provided that the product of leading coefficients is nonzero.

See `Polynomial.natDegree_multiset_prod` (without the `'`) for a version for integral domains,
where this condition is automatically satisfied.
-/
theorem natDegree_multiset_prod' (h : (t.map fun f => leadingCoeff f).prod ≠ 0) :
    t.prod.natDegree = (t.map fun f => natDegree f).sum
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- The `vectorSpan` of `n + 1` points in an indexed family has
dimension at most `n`. -/
theorem finrank_vectorSpan_image_finset_le [DecidableEq P] (p : ι → P) (s : Finset ι) {n : ℕ}
    (hc : Finset.card s = n + 1) : finrank k (vectorSpan k (s.image p : Set P)) ≤ n
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
theorem map_id : map id p = p
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
protected lemma div_left_inj (h : IsUnit c) : a / c = b / c ↔ a = b
-- Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean
@[reassoc]
lemma mapComp_assoc_right_hom {c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d) :
    (F.mapComp f (g ≫ h)).hom ≫ F.map f ◁ (F.mapComp g h).hom = F.map₂ (α_ f g h).inv ≫
    (F.mapComp (f ≫ g) h).hom ≫ (F.mapComp f g).hom ▷ F.map h ≫
    (α_ (F.map f) (F.map g) (F.map h)).hom
-- Mathlib/RingTheory/FreeCommRing.lean
theorem isSupported_neg (hxs : IsSupported x s) : IsSupported (-x) s
-- Mathlib/Logic/Encodable/Basic.lean
theorem le_sequence (a : α) : f a ≤ f (hf.sequence f (encode a + 1))
-- Mathlib/Logic/Function/Basic.lean
theorem Injective.beq_eq {α β : Type*} [BEq α] [LawfulBEq α] [BEq β] [LawfulBEq β] {f : α → β}
    (I : Injective f) {a b : α} : (f a == f b) = (a == b)
-- Mathlib/Topology/Maps/Basic.lean
theorem closed_iff_image_closed (hf : ClosedEmbedding f) {s : Set X} :
    IsClosed s ↔ IsClosed (f '' s)
-- Mathlib/Probability/Kernel/Basic.lean
@[simp]
theorem integral_const {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {f : β → E} {μ : Measure β} {a : α} : ∫ x, f x ∂const α μ a = ∫ x, f x ∂μ
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
protected theorem IsCycle.extendDomain {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p) :
    IsCycle g → IsCycle (g.extendDomain f)
-- Mathlib/Data/Fin/Tuple/Basic.lean
theorem exists_fin_succ_pi {P : (∀ i, α i) → Prop} : (∃ x, P x) ↔ ∃ a v, P (Fin.cons a v)
-- Mathlib/Algebra/Order/AbsoluteValue.lean
/-- Bound `abv (a + b)` from below -/
protected theorem le_add (a b : R) : abv a - abv b ≤ abv (a + b)
-- Mathlib/Topology/ContinuousFunction/Basic.lean
@[simp]
theorem pi_eval (f : ∀ i, C(A, X i)) (a : A) : (pi f) a = fun i : I => (f i) a
-- Mathlib/GroupTheory/Nilpotent.lean
@[simp]
theorem lowerCentralSeries_nilpotencyClass :
    lowerCentralSeries G (Group.nilpotencyClass G) = ⊥
-- Mathlib/FieldTheory/Adjoin.lean
theorem exists_finset_of_mem_supr' {ι : Type*} {f : ι → IntermediateField F E} {x : E}
    (hx : x ∈ ⨆ i, f i) : ∃ s : Finset (Σ i, f i), x ∈ ⨆ i ∈ s, F⟮(i.2 : E)⟯
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem lt_add_one_iff_lt_or_eq : m < n + 1 ↔ m < n ∨ m = n
-- Mathlib/Algebra/Polynomial/GroupRingAction.lean
theorem smul_eq_map [MulSemiringAction M R] (m : M) :
    HSMul.hSMul m = map (MulSemiringAction.toRingHom M R m)
-- Mathlib/Algebra/Periodic.lean
/-- If a function is `antiperiodic` with antiperiod `c`, then it is also `Periodic` with period
  `2 * c`. -/
protected theorem Antiperiodic.periodic_two_mul [Semiring α] [InvolutiveNeg β]
    (h : Antiperiodic f c) : Periodic f (2 * c)
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp] theorem exists_prop : (∃ _h : a, b) ↔ a ∧ b
-- Mathlib/Order/Minimal.lean
theorem maximals_of_symm [IsSymm α r] : maximals r s = s
-- Mathlib/Order/Cover.lean
@[simp]
theorem ofDual_wcovBy_ofDual_iff {a b : αᵒᵈ} : ofDual a ⩿ ofDual b ↔ b ⩿ a
-- Mathlib/NumberTheory/MulChar/Basic.lean
/-- The sum over all values of a nontrivial multiplicative character on a finite ring is zero
(when the target is a domain). -/
theorem sum_eq_zero_of_ne_one [IsDomain R'] {χ : MulChar R R'} (hχ : χ ≠ 1) : ∑ a, χ a = 0
-- Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean
@[simp]
theorem liftAlternating_ιMulti :
    liftAlternating (R := R) (M := M) (N := ExteriorAlgebra R M) (ιMulti R) =
    (LinearMap.id : ExteriorAlgebra R M →ₗ[R] ExteriorAlgebra R M)
-- Mathlib/Analysis/Calculus/FDeriv/Linear.lean
@[fun_prop]
protected theorem ContinuousLinearMap.hasFDerivWithinAt : HasFDerivWithinAt e e s x
-- Mathlib/Algebra/GradedMonoid.lean
@[simp]
theorem List.dProd_nil (fι : α → ι) (fA : ∀ a, A (fι a)) :
    (List.nil : List α).dProd fι fA = GradedMonoid.GOne.one
-- Mathlib/Algebra/Order/Monoid/Unbundled/MinMax.lean
@[to_additive]
theorem max_mul_mul_left (a b c : α) : max (a * b) (a * c) = a * max b c
-- Mathlib/Order/Bounds/Basic.lean
theorem isGLB_univ [OrderBot α] : IsGLB (univ : Set α) ⊥
-- Mathlib/Data/Nat/Set.lean
theorem range_casesOn {α : Type*} (x : α) (f : ℕ → α) :
    (Set.range fun n => Nat.casesOn n x f : Set α) = {x} ∪ Set.range f
-- Mathlib/Data/Multiset/Basic.lean
theorem map_eq_map {f : α → β} (hf : Function.Injective f) {s t : Multiset α} :
    s.map f = t.map f ↔ s = t
-- Mathlib/Combinatorics/Enumerative/Catalan.lean
theorem catalan_two : catalan 2 = 2
-- Mathlib/Topology/Algebra/Algebra.lean
@[simp, norm_cast]
theorem coe_snd : ↑(snd R A B) = AlgHom.snd R A B
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem withBot_comp (f : LatticeHom β γ) (g : LatticeHom α β) :
    (f.comp g).withBot = f.withBot.comp g.withBot