ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
lemma δ_ofHom_comp {n : ℤ} (f : F ⟶ G) (z : Cochain G K n) (m : ℤ) :
    δ n m ((Cochain.ofHom f).comp z (zero_add n)) =
      (Cochain.ofHom f).comp (δ n m z) (zero_add m)
-- Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean
@[reassoc (attr := simp)] lemma φ₁_L₂_f : S.φ₁ ≫ S.L₂.f = S.φ₂
-- Mathlib/Control/Basic.lean
@[functor_norm]
theorem map_seq (f : β → γ) (x : F (α → β)) (y : F α) :
    f <$> (x <*> y) = (f ∘ ·) <$> x <*> y
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem contMDiffWithinAt_snd {s : Set (M × N)} {p : M × N} :
    ContMDiffWithinAt (I.prod J) J n Prod.snd s p
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
lemma isUpperSet_orderDual [Preorder α] [TopologicalSpace α] :
    Topology.IsUpperSet αᵒᵈ ↔ Topology.IsLowerSet α
-- Mathlib/Topology/ContinuousFunction/Basic.lean
/-- `Function.const α b` as a bundled continuous function of `b`. -/
@[simps (config := .asFn)]
def constPi : C(β, α → β)
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem intCast_imI (z : ℤ) : (z : ℍ[R]).imI = 0
-- Mathlib/Order/Category/BddLat.lean
theorem bddLat_dual_comp_forget_to_lat :
    BddLat.dual ⋙ forget₂ BddLat Lat = forget₂ BddLat Lat ⋙ Lat.dual
-- Mathlib/Geometry/Euclidean/MongePoint.lean
/-- `mongePointVSubFaceCentroidWeightsWithCircumcenter` is the
result of subtracting `centroidWeightsWithCircumcenter` from
`mongePointWeightsWithCircumcenter`. -/
theorem mongePointVSubFaceCentroidWeightsWithCircumcenter_eq_sub {n : ℕ} {i₁ i₂ : Fin (n + 3)}
    (h : i₁ ≠ i₂) :
    mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ =
      mongePointWeightsWithCircumcenter n - centroidWeightsWithCircumcenter {i₁, i₂}ᶜ
-- Mathlib/Data/Int/ModEq.lean
theorem modEq_zero_iff_dvd : a ≡ 0 [ZMOD n] ↔ n ∣ a
-- Mathlib/Data/Set/Function.lean
@[simp]
theorem restrict_eq_restrict_iff : restrict s f₁ = restrict s f₂ ↔ EqOn f₁ f₂ s
-- Mathlib/Data/Set/Finite.lean
theorem exists_max_image [LinearOrder β] (s : Set α) (f : α → β) (h1 : s.Finite) :
    s.Nonempty → ∃ a ∈ s, ∀ b ∈ s, f b ≤ f a
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
theorem finrank_euclideanSpace_fin {n : ℕ} :
    FiniteDimensional.finrank 𝕜 (EuclideanSpace 𝕜 (Fin n)) = n
-- Mathlib/Geometry/Euclidean/Sphere/Basic.lean
theorem dist_of_mem_subset_sphere {p : P} {ps : Set P} {s : Sphere P} (hp : p ∈ ps)
    (hps : ps ⊆ (s : Set P)) : dist p s.center = s.radius
-- Mathlib/NumberTheory/FLT/Four.lean
theorem comm {a b c : ℤ} : Fermat42 a b c ↔ Fermat42 b a c
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
@[simp]
theorem det_diagonal {d : n → R} : det (diagonal d) = ∏ i, d i
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem of_d_eq_zero' : (⟨0, 0, 0, 0⟩ : Cubic R).toPoly = 0
-- Mathlib/Analysis/Calculus/BumpFunction/Normed.lean
theorem normed_le_div_measure_closedBall_rOut [IsAddHaarMeasure μ] (K : ℝ) (h : f.rOut ≤ K * f.rIn)
    (x : E) :
    f.normed μ x ≤ K ^ finrank ℝ E / (μ (closedBall c f.rOut)).toReal
-- Mathlib/Data/SetLike/Basic.lean
protected theorem «exists» {q : p → Prop} : (∃ x, q x) ↔ ∃ (x : B) (h : x ∈ p), q ⟨x, ‹_›⟩
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp, norm_cast]
theorem coe_zsmul [∀ i, AddGroup (β i)] (b : ℤ) (v : Π₀ i, β i) : ⇑(b • v) = b • ⇑v
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem inv_coe_unit {n : ℕ} (u : (ZMod n)ˣ) : (u : ZMod n)⁻¹ = (u⁻¹ : (ZMod n)ˣ)
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[simp]
theorem colimit.post_post {E : Type u''} [Category.{v''} E] (H : D ⥤ E)
    -- H G (colimit F) ⟶ H (colimit (F ⋙ G)) ⟶ colimit ((F ⋙ G) ⋙ H) equals
    -- H G (colimit F) ⟶ colimit (F ⋙ (G ⋙ H))
    [h : HasColimit ((F ⋙ G) ⋙ H)] : haveI : HasColimit (F ⋙ G ⋙ H) := h
    colimit.post (F ⋙ G) H ≫ H.map (colimit.post F G) = colimit.post F (G ⋙ H)
-- Mathlib/FieldTheory/Minpoly/MinpolyDiv.lean
lemma minpolyDiv_spec :
    minpolyDiv R x * (X - C x) = (minpoly R x).map (algebraMap R S)
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
protected theorem gc : GaloisConnection (adjoin R : Set A → NonUnitalSubalgebra R A) (↑)
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem one_lt_rpow {x z : ℝ} (hx : 1 < x) (hz : 0 < z) : 1 < x ^ z
-- Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean
/-- `x ^ k = o(exp(b * x))` as `x → ∞` for any integer `k` and positive `b`. -/
theorem isLittleO_zpow_exp_pos_mul_atTop (k : ℤ) {b : ℝ} (hb : 0 < b) :
    (fun x : ℝ => x ^ k) =o[atTop] fun x => exp (b * x)
-- Mathlib/Algebra/Module/LocalizedModuleIntegers.lean
@[simp]
theorem map_integerMultiple {ι : Type*} (s : Finset ι) (g : ι → M') (i : s) :
    f (integerMultiple S f s g i) = commonDenom S f s g • g i
-- Mathlib/Data/List/Range.lean
theorem pairwise_le_range (n : ℕ) : Pairwise (· ≤ ·) (range n)
-- Mathlib/Data/List/Basic.lean
theorem reverse_bijective : Bijective (@reverse α)
-- Mathlib/ModelTheory/LanguageMap.lean
theorem sumInl_injective : (LHom.sumInl : L →ᴸ L.sum L').Injective
-- Mathlib/MeasureTheory/Group/Measure.lean
/-- If a left-invariant measure gives finite mass to a set with nonempty interior, then
it gives finite mass to any compact set. -/
@[to_additive
"If a left-invariant measure gives finite mass to a set with nonempty interior, then it gives finite
mass to any compact set."]
theorem measure_lt_top_of_isCompact_of_isMulLeftInvariant' {U : Set G}
    (hU : (interior U).Nonempty) (h : μ U ≠ ∞) {K : Set G} (hK : IsCompact K) : μ K < ∞
-- Mathlib/RepresentationTheory/Action/Monoidal.lean
/-- Given `X : Action (Type u) (Mon.of G)` for `G` a group, then `G × X` (with `G` acting as left
multiplication on the first factor and by `X.ρ` on the second) is isomorphic as a `G`-set to
`G × X` (with `G` acting as left multiplication on the first factor and trivially on the second).
The isomorphism is given by `(g, x) ↦ (g, g⁻¹ • x)`. -/
@[simps]
noncomputable def leftRegularTensorIso (G : Type u) [Group G] (X : Action (Type u) (MonCat.of G)) :
    leftRegular G ⊗ X ≅ leftRegular G ⊗ Action.mk X.V 1
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
theorem IsPushout.of_map [ReflectsColimit (span f g) F] (e : f ≫ h = g ≫ i)
    (H : IsPushout (F.map f) (F.map g) (F.map h) (F.map i)) : IsPushout f g h i
-- Mathlib/NumberTheory/Divisors.lean
theorem dvd_of_mem_divisors {m : ℕ} (h : n ∈ divisors m) : n ∣ m
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem bmex_monotone {o o' : Ordinal.{u}}
    {f : ∀ a < o, Ordinal.{max u v}} {g : ∀ a < o', Ordinal.{max u v}}
    (h : brange o f ⊆ brange o' g) : bmex.{_, v} o f ≤ bmex.{_, v} o' g
-- Mathlib/CategoryTheory/Simple.lean
/-- If `X` has subobject lattice `{⊥, ⊤}`, then `X` is simple. -/
theorem simple_of_isSimpleOrder_subobject (X : C) [IsSimpleOrder (Subobject X)] : Simple X
-- Mathlib/Data/Set/Basic.lean
/-- See also `Subtype.prop` -/
theorem Subtype.mem {α : Type*} {s : Set α} (p : s) : (p : α) ∈ s
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
theorem aeval_eq_sum_range [Algebra R S] {p : R[X]} (x : S) :
    aeval x p = ∑ i ∈ Finset.range (p.natDegree + 1), p.coeff i • x ^ i
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_symmetric : M ⊨ r.symmetric ↔ Symmetric fun x y : M => RelMap r ![x, y]
-- Mathlib/Order/RelClasses.lean
@[refl, simp]
lemma subset_refl [IsRefl α (· ⊆ ·)] (a : α) : a ⊆ a
-- Mathlib/Algebra/QuadraticDiscriminant.lean
/-- Root of a quadratic when its discriminant equals zero -/
theorem quadratic_eq_zero_iff_of_discrim_eq_zero (ha : a ≠ 0) (h : discrim a b c = 0) (x : K) :
    a * x * x + b * x + c = 0 ↔ x = -b / (2 * a)
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem norm_integral_le_integral_norm (f : α → G) : ‖∫ a, f a ∂μ‖ ≤ ∫ a, ‖f a‖ ∂μ
-- Mathlib/Order/Monotone/Monovary.lean
protected theorem Subsingleton.antivaryOn [Subsingleton ι] (f : ι → α) (g : ι → β) (s : Set ι) :
    AntivaryOn f g s
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem dual_comp (g : LatticeHom β γ) (f : LatticeHom α β) :
    LatticeHom.dual (g.comp f) = (LatticeHom.dual g).comp (LatticeHom.dual f)
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem zeroLocus_iSup_homogeneousIdeal {γ : Sort*} (I : γ → HomogeneousIdeal 𝒜) :
    zeroLocus _ ((⨆ i, I i : HomogeneousIdeal 𝒜) : Set A) = ⋂ i, zeroLocus 𝒜 (I i)
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
theorem starClosure_le {S₁ : NonUnitalSubalgebra R A} {S₂ : NonUnitalStarSubalgebra R A}
    (h : S₁ ≤ S₂.toNonUnitalSubalgebra) : S₁.starClosure ≤ S₂
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem isRegular_succ {c : Cardinal.{u}} (h : ℵ₀ ≤ c) : IsRegular (succ c)
-- Mathlib/Algebra/Order/Monovary.lean
lemma Antivary.pow_right₀ (hg : 0 ≤ g) (hfg : Antivary f g) (n : ℕ) : Antivary f (g ^ n)
-- Mathlib/Topology/Algebra/Module/CharacterSpace.lean
theorem apply_mem_spectrum [Nontrivial 𝕜] (φ : characterSpace 𝕜 A) (a : A) : φ a ∈ spectrum 𝕜 a
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem one_im : (1 : ℤ√d).im = 0
-- Mathlib/AlgebraicGeometry/Morphisms/OpenImmersion.lean
theorem isOpenImmersion_iff_stalk {f : X ⟶ Y} : IsOpenImmersion f ↔
    OpenEmbedding f.1.base ∧ ∀ x, IsIso (f.stalkMap x)
-- Mathlib/NumberTheory/DiophantineApproximation.lean
/-- *Dirichlet's approximation theorem:*
For any real number `ξ` and positive natural `n`, there is a natural number `k`,
with `0 < k ≤ n` such that `|k*ξ - round(k*ξ)| ≤ 1/(n+1)`.
-/
theorem exists_nat_abs_mul_sub_round_le (ξ : ℝ) {n : ℕ} (n_pos : 0 < n) :
    ∃ k : ℕ, 0 < k ∧ k ≤ n ∧ |↑k * ξ - round (↑k * ξ)| ≤ 1 / (n + 1)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
theorem mul_div_le (m n : Nat) : n * (m / n) ≤ m
-- Mathlib/Order/Partition/Finpartition.lean
theorem card_parts_le_card : P.parts.card ≤ s.card
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousOn.prod_map {f : α → γ} {g : β → δ} {s : Set α} {t : Set β}
    (hf : ContinuousOn f s) (hg : ContinuousOn g t) : ContinuousOn (Prod.map f g) (s ×ˢ t)
-- Mathlib/Probability/Kernel/Disintegration/Integral.lean
lemma lintegral_condKernel_mem {s : Set (β × Ω)} (hs : MeasurableSet s) :
    ∫⁻ x, ρ.condKernel x {y | (x, y) ∈ s} ∂ρ.fst = ρ s
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[ext]
theorem ext {f g : A →⋆ₙₐ[R] B} (h : ∀ x, f x = g x) : f = g
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[to_additive Ici_add_Ici_subset]
theorem Ici_mul_Ici_subset' (a b : α) : Ici a * Ici b ⊆ Ici (a * b)
-- Mathlib/Data/Finmap.lean
@[simp]
theorem mem_insert {a a' : α} {b' : β a'} {s : Finmap β} : a ∈ insert a' b' s ↔ a = a' ∨ a ∈ s
-- Mathlib/Order/CompleteLattice.lean
@[simp]
theorem iInf_Prop_eq {p : ι → Prop} : ⨅ i, p i = ∀ i, p i
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
@[simp]
lemma cyclesMap'_id (h : S.LeftHomologyData) :
    cyclesMap' (𝟙 S) h h = 𝟙 _
-- Mathlib/Computability/TuringMachine.lean
@[trans]
theorem BlankExtends.trans {Γ} [Inhabited Γ] {l₁ l₂ l₃ : List Γ} :
    BlankExtends l₁ l₂ → BlankExtends l₂ l₃ → BlankExtends l₁ l₃
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
@[simp]
theorem leadingCoeff_map [Semiring S] [Nontrivial S] (f : R →+* S) :
    leadingCoeff (p.map f) = f (leadingCoeff p)
-- Mathlib/Data/Sum/Basic.lean
theorem inr_injective : Function.Injective (inr : β → α ⊕ β)
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem mem_toNonUnitalSubalgebra {p : Submodule R A} {h_mul} {x} :
    x ∈ p.toNonUnitalSubalgebra h_mul ↔ x ∈ p
-- Mathlib/GroupTheory/GroupAction/Period.lean
@[to_additive]
theorem period_eq_one_iff {m : M} {a : α} : period m a = 1 ↔ m • a = a
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem getElem_fin_eq_data_get (a : Array α) (i : Fin _) : a[i] = a.data.get i
-- Mathlib/Control/Functor.lean
protected theorem comp_map (g' : α → β) (h : β → γ) :
    ∀ x : Comp F G α, Comp.map (h ∘ g') x = Comp.map h (Comp.map g' x)
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[simp]
theorem prodMonoidal_leftUnitor_inv_fst (X : C₁ × C₂) :
    ((λ_ X).inv : X ⟶ 𝟙_ _ ⊗ X).1 = (λ_ X.1).inv
-- Mathlib/Algebra/Ring/Equiv.lean
/-- A ring isomorphism preserves multiplication. -/
protected theorem map_mul (e : R ≃+* S) (x y : R) : e (x * y) = e x * e y
-- Mathlib/LinearAlgebra/Matrix/Block.lean
@[simp]
protected theorem BlockTriangular.submatrix {f : n → m} (h : M.BlockTriangular b) :
    (M.submatrix f f).BlockTriangular (b ∘ f)
-- Mathlib/Data/List/Basic.lean
@[simp] theorem self_eq_append_right {x y : List α} : x = x ++ y ↔ y = []
-- Mathlib/Order/Height.lean
theorem chainHeight_insert_of_forall_gt (a : α) (hx : ∀ b ∈ s, a < b) :
    (insert a s).chainHeight = s.chainHeight + 1
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
lemma map_apply (ν : ProbabilityMeasure Ω) {f : Ω → Ω'} (f_aemble : AEMeasurable f ν)
    {A : Set Ω'} (A_mble : MeasurableSet A) :
    (ν.map f_aemble) A = ν (f ⁻¹' A)
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
theorem isAffineOpen_top (X : Scheme) [IsAffine X] : IsAffineOpen (⊤ : X.Opens)
-- Mathlib/Data/Finset/Lattice.lean
theorem iInf_singleton (a : α) (s : α → β) : ⨅ x ∈ ({a} : Finset α), s x = s a
-- Mathlib/RingTheory/Kaehler/Basic.lean
theorem KaehlerDifferential.D_tensorProductTo (x : KaehlerDifferential.ideal R S) :
    (KaehlerDifferential.D R S).tensorProductTo x =
      (KaehlerDifferential.ideal R S).toCotangent x
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem HasLineDerivAt.tendsto_slope_zero_right [PartialOrder 𝕜] (h : HasLineDerivAt 𝕜 f f' x v) :
    Tendsto (fun (t : 𝕜) ↦ t⁻¹ • (f (x + t • v) - f x)) (𝓝[>] 0) (𝓝 f')
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem add_mul (n m k : Nat) : (n + m) * k = n * k + m * k
-- Mathlib/ModelTheory/LanguageMap.lean
theorem constantsOnMap_isExpansionOn {f : α → β} {fα : α → M} {fβ : β → M} (h : fβ ∘ f = fα) :
    @LHom.IsExpansionOn _ _ (LHom.constantsOnMap f) M (constantsOn.structure fα)
      (constantsOn.structure fβ)
-- Mathlib/CategoryTheory/IsomorphismClasses.lean
theorem Groupoid.isIsomorphic_iff_nonempty_hom {C : Type u} [Groupoid.{v} C] {X Y : C} :
    IsIsomorphic X Y ↔ Nonempty (X ⟶ Y)
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
nonrec theorem HasDerivAtFilter.const_smul (c : R) (hf : HasDerivAtFilter f f' x L) :
    HasDerivAtFilter (fun y => c • f y) (c • f') x L
-- Mathlib/Data/Sum/Interval.lean
lemma inl_mem_sumLexLift {c₁ : γ₁} :
    inl c₁ ∈ sumLexLift f₁ f₂ g₁ g₂ a b ↔
      (∃ a₁ b₁, a = inl a₁ ∧ b = inl b₁ ∧ c₁ ∈ f₁ a₁ b₁) ∨
        ∃ a₁ b₂, a = inl a₁ ∧ b = inr b₂ ∧ c₁ ∈ g₁ a₁ b₂
-- Mathlib/Order/UpperLower/Hom.lean
@[simp]
theorem coe_iicInfHom : (iicInfHom : α → LowerSet α) = Iic
-- Mathlib/Algebra/Field/Subfield.lean
/-- Two subfields are equal if they have the same elements. -/
@[ext]
theorem ext {S T : Subfield K} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T
-- Mathlib/Topology/Maps/Basic.lean
theorem IsClosedMap.lift'_closure_map_eq
    (f_closed : IsClosedMap f) (f_cont : Continuous f) (F : Filter X) :
    (map f F).lift' closure = map f (F.lift' closure)
-- Mathlib/NumberTheory/LegendreSymbol/GaussEisensteinLemmas.lean
theorem gauss_lemma_aux (p : ℕ) [hp : Fact p.Prime] {a : ℤ}
    (hap : (a : ZMod p) ≠ 0) : (↑a ^ (p / 2) : ZMod p) =
    ((-1) ^ ((Ico 1 (p / 2).succ).filter fun x : ℕ => p / 2 < (a * x : ZMod p).val).card :)
-- Mathlib/Data/Finset/Lattice.lean
theorem sup_eq_sSup_image [CompleteLattice β] (s : Finset α) (f : α → β) :
    s.sup f = sSup (f '' s)
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
theorem fderiv_mul (hc : DifferentiableAt 𝕜 c x) (hd : DifferentiableAt 𝕜 d x) :
    fderiv 𝕜 (fun y => c y * d y) x = c x • fderiv 𝕜 d x + d x • fderiv 𝕜 c x
-- Mathlib/Data/Complex/Exponential.lean
theorem cosh_sq' : cosh x ^ 2 = 1 + sinh x ^ 2
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[ext]
lemma hom_ext {C D : HomologicalComplex V c} (f g : C ⟶ D)
    (h : ∀ i, f.f i = g.f i) : f = g
-- .lake/packages/lean4/src/lean/Init/Omega/LinearCombo.lean
@[simp] theorem eval_nil : (lc : LinearCombo).eval .nil = lc.const
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
theorem isCobounded_ge_nhds (a : α) : (𝓝 a).IsCobounded (· ≥ ·)
-- Mathlib/Topology/Algebra/Field.lean
theorem Subfield.topologicalClosure_minimal (s : Subfield α) {t : Subfield α} (h : s ≤ t)
    (ht : IsClosed (t : Set α)) : s.topologicalClosure ≤ t
-- Mathlib/Order/Filter/Pi.lean
theorem NeBot.coprodᵢ [∀ i, Nonempty (α i)] {i : ι} (h : NeBot (f i)) : NeBot (Filter.coprodᵢ f)
-- Mathlib/Order/Interval/Multiset.lean
@[simp]
theorem Ioo_eq_zero_of_le (h : b ≤ a) : Ioo a b = 0
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem nhds_eq_uniformity' {x : α} : 𝓝 x = (𝓤 α).lift' fun s => { y | (y, x) ∈ s }
-- Mathlib/Analysis/Calculus/LineDeriv/Measurable.lean
theorem aemeasurable_lineDeriv_uncurry [MeasurableSpace F] [BorelSpace F]
    (hf : Continuous f) (μ : Measure (E × E)) :
    AEMeasurable (fun (p : E × E) ↦ lineDeriv 𝕜 f p.1 p.2) μ
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- Given two points in an affine subspace, the angles between those two points at two other
points on the same side of that subspace have the same sign. -/
theorem _root_.AffineSubspace.SSameSide.oangle_sign_eq {s : AffineSubspace ℝ P} {p₁ p₂ p₃ p₄ : P}
    (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s) (hp₃p₄ : s.SSameSide p₃ p₄) :
    (∡ p₁ p₄ p₂).sign = (∡ p₁ p₃ p₂).sign
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem getElem_of_mem : ∀ {a} {l : List α}, a ∈ l → ∃ (n : Nat) (h : n < l.length), l[n]'h = a
-- Mathlib/Algebra/Lie/Weights/Basic.lean
/-- This is the Fitting decomposition of the Lie module `M`. -/
lemma isCompl_weightSpace_zero_posFittingComp :
    IsCompl (weightSpace M 0) (posFittingComp R L M)
-- Mathlib/RingTheory/Regular/RegularSequence.lean
lemma _root_.LinearEquiv.isWeaklyRegular_congr' (e : M ≃ₛₗ[σ] M₂) (rs : List R) :
    IsWeaklyRegular M rs ↔ IsWeaklyRegular M₂ (rs.map σ)
-- Mathlib/Algebra/IsPrimePow.lean
theorem IsPrimePow.one_lt {n : ℕ} (h : IsPrimePow n) : 1 < n
-- Mathlib/Algebra/Lie/TraceForm.lean
@[simp]
lemma traceForm_lieSubalgebra_mk_right (L' : LieSubalgebra R L) {x : L'} {y : L} (hy : y ∈ L') :
    traceForm R L' M x ⟨y, hy⟩ = traceForm R L M x y
-- Mathlib/Probability/Independence/ZeroOne.lean
theorem indep_iSup_limsup (h_le : ∀ n, s n ≤ m0) (h_indep : iIndep s μ) (hf : ∀ t, p t → tᶜ ∈ f)
    (hns : Directed (· ≤ ·) ns) (hnsp : ∀ a, p (ns a)) (hns_univ : ∀ n, ∃ a, n ∈ ns a) :
    Indep (⨆ n, s n) (limsup s f) μ
-- Mathlib/Topology/Order.lean
theorem le_of_nhds_le_nhds (h : ∀ x, @nhds α t₁ x ≤ @nhds α t₂ x) : t₁ ≤ t₂
-- Mathlib/Data/Set/Function.lean
theorem LeftInverse.rightInvOn_range {g : β → α} (h : LeftInverse f g) :
    RightInvOn f g (range g)
-- Mathlib/NumberTheory/EllipticDivisibilitySequence.lean
lemma preNormEDS'_odd (m : ℕ) : preNormEDS' b c d (2 * (m + 2) + 1) =
    preNormEDS' b c d (m + 4) * preNormEDS' b c d (m + 2) ^ 3 * (if Even m then b else 1) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) ^ 3 * (if Even m then 1 else b)
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem mul_add_left_right : IsRelPrime x (x * z + y)
-- Mathlib/Algebra/Order/Interval/Basic.lean
theorem length_sub_le : (s - t).length ≤ s.length + t.length
-- Mathlib/Analysis/Convex/Intrinsic.lean
@[simp]
theorem intrinsicClosure_nonempty : (intrinsicClosure 𝕜 s).Nonempty ↔ s.Nonempty
-- Mathlib/RingTheory/Localization/Integer.lean
theorem isInteger_mul {a b : S} (ha : IsInteger R a) (hb : IsInteger R b) : IsInteger R (a * b)
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem baseChange_zero : baseChange A (0 : M →ₗ[R] N) = 0
-- Mathlib/GroupTheory/Perm/Support.lean
theorem support_zpow_le (σ : Perm α) (n : ℤ) : (σ ^ n).support ≤ σ.support
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
theorem arccos_cos {x : ℝ} (hx₁ : 0 ≤ x) (hx₂ : x ≤ π) : arccos (cos x) = x
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[simp]
theorem mapPair_left : (mapPair f g).app ⟨left⟩ = f
-- Mathlib/Algebra/Lie/Solvable.lean
theorem derivedSeries_of_derivedLength_succ (I : LieIdeal R L) (k : ℕ) :
    derivedLengthOfIdeal R L I = k + 1 ↔
      IsLieAbelian (derivedSeriesOfIdeal R L k I) ∧ derivedSeriesOfIdeal R L k I ≠ ⊥
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Basic.lean
/-- Every bitvector of length 0 is equal to `nil`, i.e., there is only one empty bitvector -/
theorem eq_nil (x : BitVec 0) : x = nil
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem toLp_norm_le [NontriviallyNormedField 𝕜] [NormedSpace 𝕜 E] :
    ‖(toLp p μ 𝕜 : (α →ᵇ E) →L[𝕜] Lp E p μ)‖ ≤ measureUnivNNReal μ ^ p.toReal⁻¹
-- Mathlib/Data/Set/Image.lean
theorem preimage_inter_range {f : α → β} {s : Set β} : f ⁻¹' (s ∩ range f) = f ⁻¹' s
-- Mathlib/Algebra/Lie/Weights/Killing.lean
lemma IsNonZero.neg (h : α.IsNonZero) : (-α).IsNonZero
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
protected theorem le_trans : ∀ {x y z : Bool}, x ≤ y → y ≤ z → x ≤ z
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[simp]
theorem range_subtype (s : NonUnitalSubring R) : (NonUnitalSubringClass.subtype s).range = s
-- Mathlib/Data/Set/Basic.lean
theorem nonempty_of_not_subset (h : ¬s ⊆ t) : (s \ t).Nonempty
-- Mathlib/MeasureTheory/Integral/DivergenceTheorem.lean
/-- **Fundamental theorem of calculus, part 2**. This version assumes that `f` is continuous on the
interval and is differentiable off a countable set `s`.

See also

* `intervalIntegral.integral_eq_sub_of_hasDeriv_right_of_le` for a version that only assumes right
differentiability of `f`;

* `MeasureTheory.integral_eq_of_hasDerivWithinAt_off_countable` for a version that works both
  for `a ≤ b` and `b ≤ a` at the expense of using unordered intervals instead of `Set.Icc`. -/
theorem integral_eq_of_hasDerivWithinAt_off_countable_of_le (f f' : ℝ → E) {a b : ℝ}
    (hle : a ≤ b) {s : Set ℝ} (hs : s.Countable) (Hc : ContinuousOn f (Icc a b))
    (Hd : ∀ x ∈ Ioo a b \ s, HasDerivAt f (f' x) x) (Hi : IntervalIntegrable f' volume a b) :
    ∫ x in a..b, f' x = f b - f a
-- Mathlib/Data/Sum/Order.lean
theorem toLex_mono : Monotone (@toLex (α ⊕ β))
-- Mathlib/Analysis/Convex/Intrinsic.lean
private theorem aux {α β : Type*} [TopologicalSpace α] [TopologicalSpace β] (φ : α ≃ₜ β)
    (s : Set β) : (interior s).Nonempty ↔ (interior (φ ⁻¹' s)).Nonempty
-- Mathlib/GroupTheory/Perm/Basic.lean
/-- See `Equiv.Perm.inv_subtypePerm`-/
theorem subtypePerm_inv (f : Perm α) (hf) :
    f⁻¹.subtypePerm hf = (f.subtypePerm <| inv_aux.2 hf : Perm { x // p x })⁻¹
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem eval_basis_not_at_node (hi : i ∈ s) (hxi : x ≠ v i) :
    eval x (Lagrange.basis s v i) = eval x (nodal s v) * (nodalWeight s v i * (x - v i)⁻¹)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Basic.lean
@[simp] theorem append_eq (x : BitVec w) (y : BitVec v)   : BitVec.append x y = x ++ y
-- Mathlib/MeasureTheory/Integral/DominatedConvergence.lean
theorem _root_.Antitone.tendsto_setIntegral (hsm : ∀ i, MeasurableSet (s i)) (h_anti : Antitone s)
    (hfi : IntegrableOn f (s 0) μ) :
    Tendsto (fun i => ∫ a in s i, f a ∂μ) atTop (𝓝 (∫ a in ⋂ n, s n, f a ∂μ))
-- Mathlib/Data/Matrix/Kronecker.lean
theorem kroneckerMap_reindex (f : α → β → γ) (el : l ≃ l') (em : m ≃ m') (en : n ≃ n') (ep : p ≃ p')
    (M : Matrix l m α) (N : Matrix n p β) :
    kroneckerMap f (reindex el em M) (reindex en ep N) =
      reindex (el.prodCongr en) (em.prodCongr ep) (kroneckerMap f M N)
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem subset_comp_self {s : Set (α × α)} (h : idRel ⊆ s) : s ⊆ s ○ s
-- Mathlib/Order/Circular.lean
/-- The order of the `↔` has been chosen so that `rw [btw_cyclic]` cycles to the right while
`rw [← btw_cyclic]` cycles to the left (thus following the prepended arrow). -/
theorem btw_cyclic {a b c : α} : btw a b c ↔ btw c a b
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive (attr := simp)]
theorem edist_mul_left [Mul M] [PseudoEMetricSpace M] [IsometricSMul M M] (a b c : M) :
    edist (a * b) (a * c) = edist b c
-- Mathlib/Data/PNat/Find.lean
@[simp]
theorem lt_find_iff (n : ℕ+) : n < PNat.find h ↔ ∀ m ≤ n, ¬p m
-- Mathlib/RingTheory/Polynomial/SeparableDegree.lean
theorem HasSeparableContraction.dvd_degree' : ∃ m : ℕ, hf.degree * q ^ m = f.natDegree
-- Mathlib/Algebra/Homology/ShortComplex/ModuleCat.lean
@[reassoc (attr := simp, elementwise)]
lemma π_moduleCatCyclesIso_hom :
    S.homologyπ ≫ S.moduleCatHomologyIso.hom =
      S.moduleCatCyclesIso.hom ≫ S.moduleCatHomologyπ