ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/Matrix/Transvection.lean
/-- A transvection matrix is obtained from the identity by adding `c` times the `j`-th row to
the `i`-th row. -/
theorem updateRow_eq_transvection [Finite n] (c : R) :
    updateRow (1 : Matrix n n R) i ((1 : Matrix n n R) i + c • (1 : Matrix n n R) j) =
      transvection i j c
-- Mathlib/Data/Set/Function.lean
theorem restrict_eq_iff {f : ∀ a, π a} {s : Set α} {g : ∀ a : s, π a} :
    restrict s f = g ↔ ∀ (a) (ha : a ∈ s), f a = g ⟨a, ha⟩
-- Mathlib/RingTheory/MvPolynomial/Symmetric.lean
@[simp]
theorem _root_.MvPolynomial.isSymmetric_rename {e : σ ≃ τ} :
    (MvPolynomial.rename e φ).IsSymmetric ↔ φ.IsSymmetric
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
@[ext] theorem ext : ∀ {o₁ o₂ : Option α}, (∀ a, a ∈ o₁ ↔ a ∈ o₂) → o₁ = o₂
-- Mathlib/Order/Defs.lean
theorem not_le_of_gt {a b : α} (h : a > b) : ¬a ≤ b
-- Mathlib/Dynamics/Ergodic/Ergodic.lean
theorem of_iterate (n : ℕ) (hf : PreErgodic f^[n] μ) : PreErgodic f μ
-- Mathlib/Topology/Instances/Matrix.lean
theorem continuous_matrix_diag : Continuous (Matrix.diag : Matrix n n R → n → R)
-- Mathlib/Order/Disjoint.lean
@[simp]
theorem codisjoint_ofDual_iff [SemilatticeSup α] [OrderTop α] {a b : αᵒᵈ} :
    Codisjoint (ofDual a) (ofDual b) ↔ Disjoint a b
-- Mathlib/CategoryTheory/Subobject/Basic.lean
protected theorem ind₂ {X : C} (p : Subobject X → Subobject X → Prop)
    (h : ∀ ⦃A B : C⦄ (f : A ⟶ X) (g : B ⟶ X) [Mono f] [Mono g],
      p (Subobject.mk f) (Subobject.mk g))
    (P Q : Subobject X) : p P Q
-- Mathlib/CategoryTheory/Equivalence.lean
@[simp]
theorem invFunIdAssoc_inv_app (e : C ≌ D) (F : D ⥤ E) (X : D) :
    (invFunIdAssoc e F).inv.app X = F.map (e.counitInv.app X)
-- .lake/packages/lean4/src/lean/Init/Core.lean
@[simp high] theorem imp_self : (a → a) ↔ True
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem smul_comp (c : S₃) (h : M₂ →SL[σ₂₃] M₃) (f : M →SL[σ₁₂] M₂) :
    (c • h).comp f = c • h.comp f
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
lemma appLE_eq_away_map {X Y : Scheme.{u}} (f : X ⟶ Y) {U : Y.Opens} (hU : IsAffineOpen U)
    {V : X.Opens} (hV : IsAffineOpen V) (e) (r : Γ(Y, U)) :
    letI := hU.isLocalization_basicOpen r
    letI := hV.isLocalization_basicOpen (f.appLE U V e r)
    f.appLE (Y.basicOpen r) (X.basicOpen (f.appLE U V e r)) (by simp [Scheme.Hom.appLE]) =
        IsLocalization.Away.map _ _ (f.appLE U V e) r
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
@[simp]
lemma ofHom_desc :
    Cochain.ofHom (desc φ α β eq) = descCochain φ α (Cochain.ofHom β) (neg_add_self 1)
-- Mathlib/Data/QPF/Univariate/Basic.lean
theorem liftp_iff' {α : Type u} (p : α → Prop) (x : F α) :
    Liftp p x ↔ ∃ u : q.P α, abs u = x ∧ ∀ i, p (u.snd i)
-- Mathlib/Order/Partition/Finpartition.lean
theorem card_mono {a : α} {P Q : Finpartition a} (h : P ≤ Q) : Q.parts.card ≤ P.parts.card
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp]
theorem zeta_pmul (f : ArithmeticFunction R) : (ζ : ArithmeticFunction R).pmul f = f
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
private lemma nonsingular_add_of_Z_ne_zero {P Q : Fin 3 → F} (hP : W.Nonsingular P)
    (hQ : W.Nonsingular Q) (hPz : P z ≠ 0) (hQz : Q z ≠ 0)
    (hxy : P x * Q z ^ 2 = Q x * P z ^ 2 → P y * Q z ^ 3 ≠ W.negY Q * P z ^ 3) : W.Nonsingular
      ![W.toAffine.addX (P x / P z ^ 2) (Q x / Q z ^ 2)
          (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3)),
        W.toAffine.addY (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3)
          (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3)), 1]
-- Mathlib/Data/Set/Basic.lean
theorem diff_union_of_subset {s t : Set α} (h : t ⊆ s) : s \ t ∪ t = s
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
/-- In an ordered commutative monoid, if each factor `f i` of one finite product is less than or
equal to the corresponding factor `g i` of another finite product, then `s.prod f ≤ s.prod g`.

This is a variant (beta-reduced) version of the standard lemma `Finset.prod_le_prod'`, convenient
for the `gcongr` tactic. -/
@[to_additive (attr := gcongr) GCongr.sum_le_sum]
theorem _root_.GCongr.prod_le_prod' (h : ∀ i ∈ s, f i ≤ g i) : s.prod f ≤ s.prod g
-- Mathlib/Algebra/Group/Aut.lean
@[simp]
theorem apply_inv_self (e : MulAut M) (m : M) : e (e⁻¹ m) = m
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive]
theorem NeBot.of_mul_right : (f * g).NeBot → g.NeBot
-- Mathlib/Data/Finset/Sups.lean
@[simp]
theorem disjSups_empty_left : ∅ ○ t = ∅
-- Mathlib/Analysis/Normed/Group/AddCircle.lean
theorem norm_coe_eq_abs_iff {x : ℝ} (hp : p ≠ 0) : ‖(x : AddCircle p)‖ = |x| ↔ |x| ≤ |p| / 2
-- Mathlib/NumberTheory/LSeries/Deriv.lean
private lemma LSeries.LSeriesSummable_logMul_and_hasDerivAt {f : ℕ → ℂ} {s : ℂ}
    (h : abscissaOfAbsConv f < s.re) :
    LSeriesSummable (logMul f) s ∧ HasDerivAt (LSeries f) (-LSeries (logMul f) s) s
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem cast_neg (h : m ∣ n) (a : ZMod n) : (cast (-a : ZMod n) : R) = -(cast a)
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
lemma map_map_assoc_symm (f : M →ₗ[R] Q) (g : N →ₗ[R] S) (h : P →ₗ[R] T) (x : M ⊗[R] (N ⊗[R] P)) :
    map (map f g) h ((TensorProduct.assoc R M N P).symm x) =
      (TensorProduct.assoc R Q S T).symm (map f (map g h) x)
-- Mathlib/Data/Complex/Abs.lean
@[simp]
theorem range_normSq : range normSq = Ici 0
-- Mathlib/Algebra/BigOperators/Ring.lean
lemma sum_prod_piFinset {κ : Type*} [Fintype ι] (s : Finset κ) (g : ι → κ → α) :
    ∑ f ∈ piFinset fun _ : ι ↦ s, ∏ i, g i (f i) = ∏ i, ∑ j ∈ s, g i j
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem tsub_tsub (b a c : α) : b - a - c = b - (a + c)
-- Mathlib/RingTheory/Ideal/Over.lean
theorem coeff_zero_mem_comap_of_root_mem_of_eval_mem {r : S} (hr : r ∈ I) {p : R[X]}
    (hp : p.eval₂ f r ∈ I) : p.coeff 0 ∈ I.comap f
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem pi_Ioo_ae_eq_pi_Ioc {s : Set ι} {f g : ∀ i, α i} :
    (pi s fun i => Ioo (f i) (g i)) =ᵐ[Measure.pi μ] pi s fun i => Ioc (f i) (g i)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ico_subset_Iio_self : Ico a b ⊆ Iio b
-- Mathlib/Tactic/Ring/Basic.lean
theorem inv_single {R} [DivisionRing R] {a b : R}
    (_ : (a : R)⁻¹ = b) : (a + 0)⁻¹ = b + 0
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
/-- If every element belongs to exactly `n` Finsets, then the sum of their sizes is `n` times how
many they are. -/
theorem sum_card [Fintype α] (h : ∀ a, (B.filter (a ∈ ·)).card = n) :
    ∑ s ∈ B, s.card = Fintype.card α * n
-- Mathlib/Combinatorics/SimpleGraph/DegreeSum.lean
theorem exists_ne_odd_degree_of_exists_odd_degree [Fintype V] [DecidableRel G.Adj] (v : V)
    (h : Odd (G.degree v)) : ∃ w : V, w ≠ v ∧ Odd (G.degree w)
-- Mathlib/GroupTheory/Perm/Sign.lean
theorem mem_finPairsLT {n : ℕ} {a : Σ_ : Fin n, Fin n} : a ∈ finPairsLT n ↔ a.2 < a.1
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem negSucc_emod (m : Nat) {b : Int} (bpos : 0 < b) : -[m+1] % b = b - 1 - m % b
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
/-- In the canonical isometric isomorphism between a Hilbert sum `E` of `G : ι → Type*` and
`lp G 2`, a finitely-supported vector in `lp G 2` is the image of the associated finite sum of
elements of `E`. -/
protected theorem IsHilbertSum.linearIsometryEquiv_symm_apply_dfinsupp_sum_single
    (hV : IsHilbertSum 𝕜 G V) (W₀ : Π₀ i : ι, G i) :
    hV.linearIsometryEquiv.symm (W₀.sum (lp.single 2)) = W₀.sum fun i => V i
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp, bv_toNat] theorem toInt_mul (x y : BitVec w) :
  (x * y).toInt = (x.toInt * y.toInt).bmod (2^w)
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
lemma exists_prime_iff :
    (∃ (p : α), Prime p) ↔ ∃ (x : α), x ≠ 0 ∧ ¬ IsUnit x
-- Mathlib/Algebra/Exact.lean
/-- Equivalent characterizations of split exact sequences. Also known as the **Splitting lemma**. -/
theorem Exact.split_tfae
    {R M N P} [Semiring R] [AddCommGroup M] [AddCommGroup N]
    [AddCommGroup P] [Module R M] [Module R N] [Module R P] {f : M →ₗ[R] N} {g : N →ₗ[R] P}
    (h : Function.Exact f g) (hf : Function.Injective f) (hg : Function.Surjective g) :
    List.TFAE [
      ∃ l, g ∘ₗ l = LinearMap.id,
      ∃ l, l ∘ₗ f = LinearMap.id,
      ∃ e : N ≃ₗ[R] M × P, f = e.symm ∘ₗ LinearMap.inl R M P ∧ g = LinearMap.snd R M P ∘ₗ e]
-- Mathlib/Topology/Order/Lattice.lean
lemma ContinuousWithinAt.finset_inf' (hne : s.Nonempty)
    (hs : ∀ i ∈ s, ContinuousWithinAt (f i) t x) : ContinuousWithinAt (s.inf' hne f) t x
-- Mathlib/RingTheory/WittVector/Defs.lean
@[simp]
theorem constantCoeff_wittAdd (n : ℕ) : constantCoeff (wittAdd p n) = 0
-- Mathlib/Algebra/Ring/Subring/Pointwise.lean
@[simp]
theorem smul_bot (a : M) : a • (⊥ : Subring R) = ⊥
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[fun_prop]
theorem hasFDerivWithinAt_pi''
    (hφ : ∀ i, HasFDerivWithinAt (fun x => Φ x i) ((proj i).comp Φ') s x) :
    HasFDerivWithinAt Φ Φ' s x
-- Mathlib/Logic/Embedding/Basic.lean
/-- The identity map as a `Function.Embedding`. -/
@[refl, simps (config := { simpRhs := true })]
protected def refl (α : Sort*) : α ↪ α
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
theorem normal_le_normalCore {H : Subgroup G} {N : Subgroup G} [hN : N.Normal] :
    N ≤ H.normalCore ↔ N ≤ H
-- Mathlib/Combinatorics/Colex.lean
lemma toColex_lt_toColex_iff_max'_mem :
    toColex s < toColex t ↔ ∃ hst : s ≠ t, (s ∆ t).max' (symmDiff_nonempty.2 hst) ∈ t
-- Mathlib/Analysis/Convex/Strict.lean
theorem StrictConvex.linear_image [Semiring 𝕝] [Module 𝕝 E] [Module 𝕝 F]
    [LinearMap.CompatibleSMul E F 𝕜 𝕝] (hs : StrictConvex 𝕜 s) (f : E →ₗ[𝕝] F) (hf : IsOpenMap f) :
    StrictConvex 𝕜 (f '' s)
-- Mathlib/Computability/Primrec.lean
/-- A `Primcodable` type is an `Encodable` type for which
  the encode/decode functions are primitive recursive. -/
class Primcodable (α : Type*) extends Encodable α where
  -- Porting note: was `prim [] `.
  -- This means that `prim` does not take the type explicitly in Lean 4
  prim : Nat.Primrec fun n => Encodable.encode (decode n)
-- Mathlib/GroupTheory/CoprodI.lean
/-- The empty reduced word. -/
@[simps]
def empty : Word M
-- Mathlib/CategoryTheory/Bicategory/Kan/HasKan.lean
theorem LeftLift.IsAbsKan.hasAbsLeftKanLift {t : LeftLift f g} (H : IsAbsKan t) :
    HasAbsLeftKanLift f g
-- Mathlib/Topology/Order/MonotoneConvergence.lean
theorem tendsto_iff_tendsto_subseq_of_antitone {ι₁ ι₂ α : Type*} [SemilatticeSup ι₁] [Preorder ι₂]
    [Nonempty ι₁] [TopologicalSpace α] [ConditionallyCompleteLinearOrder α] [OrderTopology α]
    [NoMinOrder α] {f : ι₂ → α} {φ : ι₁ → ι₂} {l : α} (hf : Antitone f)
    (hg : Tendsto φ atTop atTop) : Tendsto f atTop (𝓝 l) ↔ Tendsto (f ∘ φ) atTop (𝓝 l)
-- Mathlib/Topology/Order/OrderClosed.lean
@[simp]
theorem disjoint_nhds_atTop_iff : Disjoint (𝓝 a) atTop ↔ ¬IsTop a
-- Mathlib/CategoryTheory/Comma/Arrow.lean
/-- A helper construction: given a square between `i` and `f ≫ g`, produce a square between
`i` and `g`, whose top leg uses `f`:
A  → X
     ↓f
↓i   Y             --> A → Y
     ↓g                ↓i  ↓g
B  → Z                 B → Z
 -/
@[simps]
def squareToSnd {X Y Z : C} {i : Arrow C} {f : X ⟶ Y} {g : Y ⟶ Z} (sq : i ⟶ Arrow.mk (f ≫ g)) :
    i ⟶ Arrow.mk g
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp, norm_cast]
lemma toAlgHom_toRingHom : ((e : A₁ →ₐ[R] A₂) : A₁ →+* A₂) = e
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Iic_subset_Iio : Iic a ⊆ Iio b ↔ a < b
-- Mathlib/Data/Int/CardIntervalMod.lean
lemma Ico_filter_modEq_eq (v : ℤ) : (Ico a b).filter (· ≡ v [ZMOD r]) =
    ((Ico (a - v) (b - v)).filter (r ∣ ·)).map ⟨(· + v), add_left_injective v⟩
-- Mathlib/Data/Finset/Card.lean
theorem card_erase_le : (s.erase a).card ≤ s.card
-- Mathlib/Algebra/Lie/EngelSubalgebra.lean
lemma self_mem_engel (x : L) : x ∈ engel R x
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem coeff_update_same (p : R[X]) (n : ℕ) (a : R) : (p.update n a).coeff n = a
-- Mathlib/Data/Multiset/Basic.lean
theorem subset_cons (s : Multiset α) (a : α) : s ⊆ a ::ₘ s
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[reassoc (attr := simp)]
theorem dFrom_comp_xNextIsoSelf {i : ι} (h : ¬c.Rel i (c.next i)) :
    C.dFrom i ≫ (C.xNextIsoSelf h).hom = 0
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
theorem open_source' (he : e ∈ c.atlas) : IsOpen[c.toTopologicalSpace] e.source
-- Mathlib/CategoryTheory/Category/Basic.lean
theorem cancel_epi_id (f : X ⟶ Y) [Epi f] {h : Y ⟶ Y} : f ≫ h = f ↔ h = 𝟙 Y
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem mem_inter {a : α} {s₁ s₂ : Finset α} : a ∈ s₁ ∩ s₂ ↔ a ∈ s₁ ∧ a ∈ s₂
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem Ioc_bot_coe : Ioc (⊥ : WithBot α) b = (Iic b).map Embedding.some
-- Mathlib/Data/Set/Prod.lean
theorem update_preimage_univ_pi [DecidableEq ι] {f : ∀ i, α i} (hf : ∀ j ≠ i, f j ∈ t j) :
    update f i ⁻¹' pi univ t = t i
-- Mathlib/Data/Matrix/Composition.lean
/-- `Matrix.comp` as `LinearEquiv` -/
@[simps!]
def compLinearEquiv : Matrix I J (Matrix K L R) ≃ₗ[K] Matrix (I × K) (J × L) R
-- Mathlib/Combinatorics/Enumerative/Composition.lean
@[simp]
theorem coe_invEmbedding (j : Fin n) : (c.invEmbedding j : ℕ) = j - c.sizeUpTo (c.index j)
-- Mathlib/NumberTheory/NumberField/Basic.lean
@[simp] lemma neg_mk (x : K) (hx) : (-⟨x, hx⟩ : 𝓞 K) = ⟨-x, neg_mem hx⟩
-- Mathlib/Data/Finset/NoncommProd.lean
theorem noncommProd_erase_mul [DecidableEq α] (s : Multiset α) {a : α} (h : a ∈ s) (comm)
    (comm' := fun x hx y hy hxy ↦ comm (s.mem_of_mem_erase hx) (s.mem_of_mem_erase hy) hxy) :
    (s.erase a).noncommProd comm' * a = s.noncommProd comm
-- Mathlib/GroupTheory/Complement.lean
theorem IsComplement'.disjoint (h : IsComplement' H K) : Disjoint H K
-- Mathlib/Algebra/Lie/Rank.lean
lemma exists_isRegular_of_finrank_le_card (h : finrank R M ≤ #R) :
    ∃ x : L, IsRegular R M x
-- Mathlib/LinearAlgebra/QuotientPi.lean
@[simp]
theorem piQuotientLift_single [Fintype ι] [DecidableEq ι] (p : ∀ i, Submodule R (Ms i))
    (q : Submodule R N) (f : ∀ i, Ms i →ₗ[R] N) (hf : ∀ i, p i ≤ q.comap (f i)) (i)
    (x : Ms i ⧸ p i) : piQuotientLift p q f hf (Pi.single i x) = mapQ _ _ (f i) (hf i) x
-- Mathlib/NumberTheory/MulChar/Lemmas.lean
/-- The conjugate of a multiplicative character with values in `ℂ` is its inverse. -/
lemma star_eq_inv (χ : MulChar R ℂ) : star χ = χ⁻¹
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
lemma lipschitzOnWith_restrict {t : Set s} :
    LipschitzOnWith K (s.restrict f) t ↔ LipschitzOnWith K f (s ∩ Subtype.val '' t)
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem norm_setIntegral_le_of_norm_le_const_ae' {C : ℝ} (hs : μ s < ∞)
    (hC : ∀ᵐ x ∂μ, x ∈ s → ‖f x‖ ≤ C) (hfm : AEStronglyMeasurable f (μ.restrict s)) :
    ‖∫ x in s, f x ∂μ‖ ≤ C * (μ s).toReal
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem findIdx?_succ :
    (xs : List α).findIdx? p (i+1) = (xs.findIdx? p i).map fun i => i + 1
-- Mathlib/Algebra/QuaternionBasis.lean
theorem lift_add (x y : ℍ[R,c₁,c₂]) : q.lift (x + y) = q.lift x + q.lift y
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
/-- Power series expansion of the logarithm around `1`. -/
theorem hasSum_pow_div_log_of_abs_lt_one {x : ℝ} (h : |x| < 1) :
    HasSum (fun n : ℕ => x ^ (n + 1) / (n + 1)) (-log (1 - x))
-- Mathlib/Algebra/Homology/TotalComplexShift.lean
@[reassoc]
lemma D₁_totalShift₂XIso_hom (n₀ n₁ n₀' n₁' : ℤ) (h₀ : n₀ + y = n₀') (h₁ : n₁ + y = n₁') :
    ((shiftFunctor₂ C y).obj K).D₁ (up ℤ) n₀ n₁ ≫ (K.totalShift₂XIso y n₁ n₁' h₁).hom =
      y.negOnePow • ((K.totalShift₂XIso y n₀ n₀' h₀).hom ≫ K.D₁ (up ℤ) n₀' n₁')
-- Mathlib/Analysis/RCLike/Basic.lean
@[rclike_simps]
theorem conj_smul (r : ℝ) (z : K) : conj (r • z) = r • conj z
-- Mathlib/Algebra/Lie/Submodule.lean
theorem mk_eq_zero {x} (h : x ∈ N) : (⟨x, h⟩ : N) = 0 ↔ x = 0
-- Mathlib/Dynamics/Ergodic/MeasurePreserving.lean
protected theorem aemeasurable {f : α → β} (hf : MeasurePreserving f μa μb) : AEMeasurable f μa
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem Integrable.locallyIntegrable (hf : Integrable f μ) : LocallyIntegrable f μ
-- Mathlib/Data/Set/Subsingleton.lean
theorem Nontrivial.not_subset_singleton {x} (hs : s.Nontrivial) : ¬s ⊆ {x}
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem bot_apply [Bot β] (a : α) : (⊥ : SupHom α β) a = ⊥
-- Mathlib/Topology/Algebra/Valued/NormedValued.lean
theorem norm_eq_zero {x : L} (hx : norm x = 0) : x = 0
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- Auxiliary lemma in the proof of `integral_eq_sub_of_hasDeriv_right_of_le`. -/
theorem integral_le_sub_of_hasDeriv_right_of_le (hab : a ≤ b) (hcont : ContinuousOn g (Icc a b))
    (hderiv : ∀ x ∈ Ioo a b, HasDerivWithinAt g (g' x) (Ioi x) x) (φint : IntegrableOn φ (Icc a b))
    (hφg : ∀ x ∈ Ioo a b, φ x ≤ g' x) : (∫ y in a..b, φ y) ≤ g b - g a
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem rTensor_id : (id : N →ₗ[R] N).rTensor M = id
-- Mathlib/Logic/Unique.lean
theorem exists_iff {p : α → Prop} : Exists p ↔ p default
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem any_eq_not_all_not (l : List α) (p : α → Bool) : l.any p = !l.all (!p .)
-- Mathlib/CategoryTheory/Pi/Basic.lean
@[simp]
theorem comp_apply {X Y Z : ∀ i, C i} (f : X ⟶ Y) (g : Y ⟶ Z) (i) :
    (f ≫ g : ∀ i, X i ⟶ Z i) i = f i ≫ g i
-- Mathlib/CategoryTheory/Sites/DenseSubsite.lean
/-- The constructed `sheafHom α` is equal to `α` when restricted onto `C`. -/
theorem sheafHom_restrict_eq (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    whiskerLeft G.op (sheafHom α) = α
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem ofRelIsoLT_symm {α β} [PartialOrder α] [PartialOrder β]
    (e : ((· < ·) : α → α → Prop) ≃r ((· < ·) : β → β → Prop)) :
    (ofRelIsoLT e).symm = ofRelIsoLT e.symm
-- Mathlib/MeasureTheory/Measure/Content.lean
theorem innerContent_exists_compact {U : Opens G} (hU : μ.innerContent U ≠ ∞) {ε : ℝ≥0}
    (hε : ε ≠ 0) : ∃ K : Compacts G, (K : Set G) ⊆ U ∧ μ.innerContent U ≤ μ K + ε
-- Mathlib/Algebra/CharP/Two.lean
theorem list_sum_sq (l : List R) : l.sum ^ 2 = (l.map (· ^ 2)).sum
-- Mathlib/Algebra/Homology/HomotopyCategory.lean
/-- A natural transformation induces a natural transformation between
  the induced functors on the homotopy category. -/
@[simps]
def NatTrans.mapHomotopyCategory {F G : V ⥤ W} [F.Additive] [G.Additive] (α : F ⟶ G)
    (c : ComplexShape ι) : F.mapHomotopyCategory c ⟶ G.mapHomotopyCategory c
-- Mathlib/GroupTheory/GroupAction/Hom.lean
theorem comp_inverse' {f : X →ₑ[φ] Y} {g : Y → X}
    {k₁ : Function.LeftInverse φ' φ} {k₂ : Function.RightInverse φ' φ}
    {h₁ : Function.LeftInverse g f} {h₂ : Function.RightInverse g f} :
    (inverse' f g k₂ h₁ h₂).comp f (κ := CompTriple.comp_inv k₁)
      = MulActionHom.id M
-- Mathlib/Algebra/Regular/Basic.lean
/-- The element `0` is right-regular if and only if `R` is trivial. -/
theorem IsRightRegular.subsingleton (h : IsRightRegular (0 : R)) : Subsingleton R
-- Mathlib/Data/Set/Subsingleton.lean
theorem univ_eq_true_false : univ = ({True, False} : Set Prop)
-- Mathlib/Data/Set/Basic.lean
@[gcongr]
theorem inter_subset_inter_right {s t : Set α} (u : Set α) (H : s ⊆ t) : u ∩ s ⊆ u ∩ t
-- Mathlib/Data/Set/Lattice.lean
theorem iInter_eq_empty_iff {f : ι → Set α} : ⋂ i, f i = ∅ ↔ ∀ x, ∃ i, x ∉ f i
-- Mathlib/Order/Filter/Prod.lean
theorem tendsto_prod_iff {f : α × β → γ} {x : Filter α} {y : Filter β} {z : Filter γ} :
    Tendsto f (x ×ˢ y) z ↔ ∀ W ∈ z, ∃ U ∈ x, ∃ V ∈ y, ∀ x y, x ∈ U → y ∈ V → f (x, y) ∈ W
-- Mathlib/Analysis/Fourier/AddCircle.lean
@[simp]
theorem fourier_neg' {n : ℤ} {x : AddCircle T} : @toCircle T (-(n • x)) = conj (fourier n x)
-- Mathlib/Data/Set/Lattice.lean
theorem union_distrib_iInter_left (s : ι → Set α) (t : Set α) : (t ∪ ⋂ i, s i) = ⋂ i, t ∪ s i
-- Mathlib/Data/Finset/Basic.lean
theorem union_right_idem (s t : Finset α) : s ∪ t ∪ t = s ∪ t
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem linearIndependent_comp_of_eval
    (h₁ : ⊤ ≤ Submodule.span ℤ (Set.range (eval (π C (ord I · < o))))) :
    LinearIndependent ℤ (eval (C' C ho)) →
    LinearIndependent ℤ (ModuleCat.ofHom (Linear_CC' C hsC ho) ∘ SumEval C ho ∘ Sum.inr)
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- Reflection is involutive. -/
theorem reflection_involutive : Function.Involutive (reflection K)
-- Mathlib/Order/SupIndep.lean
theorem independent_iff_pairwiseDisjoint {f : ι → α} : Independent f ↔ Pairwise (Disjoint on f)
-- Mathlib/Order/Filter/Ker.lean
@[simp] lemma ker_principal (s : Set α) : ker (𝓟 s) = s
-- Mathlib/SetTheory/Game/PGame.lean
theorem LF.not_gt {x y : PGame} (h : x ⧏ y) : ¬y < x
-- Mathlib/Algebra/Order/Floor.lean
theorem sub_floor_div_mul_nonneg (a : k) (hb : 0 < b) : 0 ≤ a - ⌊a / b⌋ * b
-- Mathlib/Data/Set/Defs.lean
@[mfld_simps]
theorem mem_image_of_mem (f : α → β) {x : α} {a : Set α} (h : x ∈ a) : f x ∈ f '' a
-- Mathlib/Topology/StoneCech.lean
@[simp] theorem Ultrafilter.tendsto_pure_self (b : Ultrafilter α) : Tendsto pure b (𝓝 b)
-- Mathlib/Algebra/MvPolynomial/CommRing.lean
@[simp]
theorem coeff_neg (m : σ →₀ ℕ) (p : MvPolynomial σ R) : coeff m (-p) = -coeff m p
-- Mathlib/Algebra/MvPolynomial/Division.lean
@[simp]
theorem monomial_mul_modMonomial (s : σ →₀ ℕ) (x : MvPolynomial σ R) :
    monomial s 1 * x %ᵐᵒⁿᵒᵐⁱᵃˡ s = 0
-- Mathlib/Topology/Basic.lean
theorem Dense.nonempty_iff (hs : Dense s) : s.Nonempty ↔ Nonempty X
-- Mathlib/Analysis/NormedSpace/HomeomorphBall.lean
theorem continuousOn_univBall_symm (c : P) (r : ℝ) : ContinuousOn (univBall c r).symm (ball c r)
-- Mathlib/RingTheory/IntegralClosure/IsIntegral/Basic.lean
theorem isIntegral_zero : IsIntegral R (0 : B)
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma growsPolynomially_deriv_rpow_p_mul_one_sub_smoothingFn (p : ℝ) :
    GrowsPolynomially fun x => ‖deriv (fun z => z ^ p * (1 - ε z)) x‖
-- Mathlib/GroupTheory/GroupAction/Group.lean
/-- Right scalar multiplication as an order isomorphism. -/
@[simps] def Equiv.smulRight (ha : a ≠ 0) : β ≃ β
-- .lake/packages/lean4/src/lean/Init/Meta.lean
protected theorem beq_iff_eq {m n : Name} : m == n ↔ m = n
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
@[simp]
theorem AddValuation.map_one : addValuationDef (1 : ℚ_[p]) = 0
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem UniformSpace.mem_nhds_iff {x : α} {s : Set α} : s ∈ 𝓝 x ↔ ∃ V ∈ 𝓤 α, ball x V ⊆ s
-- Mathlib/RingTheory/AdjoinRoot.lean
theorem isIntegral_root (hf : f ≠ 0) : IsIntegral K (root f)
-- .lake/packages/lean4/src/lean/Init/Control/StateCps.lean
@[simp] theorem runK_get (s : σ) (k : σ → σ → m β) : (get : StateCpsT σ m σ).runK s k = k s s
-- Mathlib/Order/Filter/Extr.lean
theorem IsExtrOn.inter (hf : IsExtrOn f s a) (t) : IsExtrOn f (s ∩ t) a
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
@[nontriviality, simp]
theorem rank_subsingleton [Subsingleton R] : Module.rank R M = 1
-- Mathlib/Init/Data/List/Lemmas.lean
/-- Length of the list obtained by `mapAccumr`. -/
@[simp]
theorem length_mapAccumr :
    ∀ (f : α → σ → σ × β) (x : List α) (s : σ), length (mapAccumr f x s).2 = length x
-- Mathlib/Algebra/MvPolynomial/Equiv.lean
theorem finSuccEquiv_eq :
    (finSuccEquiv R n : MvPolynomial (Fin (n + 1)) R →+* Polynomial (MvPolynomial (Fin n) R)) =
      eval₂Hom (Polynomial.C.comp (C : R →+* MvPolynomial (Fin n) R)) fun i : Fin (n + 1) =>
        Fin.cases Polynomial.X (fun k => Polynomial.C (X k)) i
-- Mathlib/Data/Nat/Cast/Order/Basic.lean
@[simp, norm_cast]
theorem one_le_cast : 1 ≤ (n : α) ↔ 1 ≤ n
-- Mathlib/Data/Nat/Factorial/Basic.lean
@[mono, gcongr]
theorem factorial_le {m n} (h : m ≤ n) : m ! ≤ n !
-- Mathlib/Topology/Compactness/LocallyCompact.lean
protected theorem ClosedEmbedding.locallyCompactSpace [LocallyCompactSpace Y] {f : X → Y}
    (hf : ClosedEmbedding f) : LocallyCompactSpace X
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem le_iff_uniformContinuous_id {u v : UniformSpace α} :
    u ≤ v ↔ @UniformContinuous _ _ u v id
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
private lemma comp_map (C' : VariableChange R) : (C.comp C').map φ = (C.map φ).comp (C'.map φ)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mul_isLimit {a b : Ordinal} (a0 : 0 < a) : IsLimit b → IsLimit (a * b)
-- Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean
lemma hasRightExtension_iff_postcomp₁ :
    HasRightKanExtension L' F ↔ HasRightKanExtension L F