ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Constructions/Polish/Basic.lean
/-- In a Polish space, a set is clopenable if and only if it is Borel-measurable. -/
theorem isClopenable_iff_measurableSet
    [tγ : TopologicalSpace γ] [PolishSpace γ] [MeasurableSpace γ] [BorelSpace γ] :
    IsClopenable s ↔ MeasurableSet s
-- Mathlib/GroupTheory/SpecificGroups/Alternating.lean
/-- The normal closure of the 5-cycle `finRotate 5` within $A_5$ is the whole group. This will be
  used to show that the normal closure of any 5-cycle within $A_5$ is the whole group. -/
theorem normalClosure_finRotate_five : normalClosure ({⟨finRotate 5,
    finRotate_bit1_mem_alternatingGroup (n := 2)⟩} : Set (alternatingGroup (Fin 5))) = ⊤
-- Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean
theorem SuperpolynomialDecay.mul_polynomial [ContinuousAdd β] [ContinuousMul β]
    (hf : SuperpolynomialDecay l k f) (p : β[X]) :
    SuperpolynomialDecay l k fun x => f x * (p.eval <| k x)
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem coeff_C [DecidableEq σ] (n : σ →₀ ℕ) (a : R) :
    coeff R n (C σ R a) = if n = 0 then a else 0
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem curryLeft_compLinearMap {n : ℕ} (g : M₂'' →ₗ[R'] M'')
    (f : M'' [⋀^Fin n.succ]→ₗ[R'] N'') (m : M₂'') :
    (f.compLinearMap g).curryLeft m = (f.curryLeft (g m)).compLinearMap g
-- Mathlib/RingTheory/Kaehler/Polynomial.lean
@[simp]
lemma KaehlerDifferential.polynomialEquiv_symm (P) :
    (polynomialEquiv R).symm P = P • D R R[X] X
-- Mathlib/CategoryTheory/NatIso.lean
/-- Constructor for a functor that is isomorphic to a given functor `F : C ⥤ D`,
while being definitionally equal on objects to a given map `obj : C → D`
such that for all `X : C`, we have an isomorphism `F.obj X ≅ obj X`. -/
@[simps obj]
def copyObj : C ⥤ D
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
protected theorem lipschitz : LipschitzWith 1 f
-- Mathlib/Data/Matroid/Dual.lean
theorem Coindep.exists_subset_compl_base (h : M.Coindep X) : ∃ B, M.Base B ∧ X ⊆ M.E \ B
-- Mathlib/Algebra/Order/Monoid/Submonoid.lean
/-- The submonoid of elements greater than `1`. -/
@[to_additive (attr := simps) nonneg "The submonoid of nonnegative elements."]
def oneLE : Submonoid M
-- Mathlib/Topology/Connected/PathConnected.lean
/-- Path composition commutes with products -/
theorem trans_prod_eq_prod_trans (γ₁ : Path a₁ a₂) (δ₁ : Path a₂ a₃) (γ₂ : Path b₁ b₂)
    (δ₂ : Path b₂ b₃) : (γ₁.prod γ₂).trans (δ₁.prod δ₂) = (γ₁.trans δ₁).prod (γ₂.trans δ₂)
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
theorem sum_nonneg (x : M) : 0 ≤ ∑ᶠ i, f i x
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive]
theorem lipschitzOnWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
    LipschitzOnWith C f s ↔ ∀ ⦃x⦄, x ∈ s → ∀ ⦃y⦄, y ∈ s → ‖f x / f y‖ ≤ C * ‖x / y‖
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem _root_.Finset.coe_infsep [DecidableEq α] (s : Finset α) : (s : Set α).infsep =
    if hs : s.offDiag.Nonempty then s.offDiag.inf' hs (uncurry dist) else 0
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Icc_ssubset_Icc_left (hI : a₂ ≤ b₂) (ha : a₂ < a₁) (hb : b₁ ≤ b₂) : Icc a₁ b₁ ⊂ Icc a₂ b₂
-- Mathlib/Topology/Order/LeftRightNhds.lean
theorem mem_nhdsWithin_Ici_iff_exists_mem_Ioc_Ico_subset {a u' : α} {s : Set α} (hu' : a < u') :
    s ∈ 𝓝[≥] a ↔ ∃ u ∈ Ioc a u', Ico a u ⊆ s
-- Mathlib/GroupTheory/Perm/Option.lean
@[simp]
theorem Equiv.optionCongr_sign {α : Type*} [DecidableEq α] [Fintype α] (e : Perm α) :
    Perm.sign e.optionCongr = Perm.sign e
-- Mathlib/GroupTheory/QuotientGroup.lean
@[to_additive (attr := simp)]
theorem lift_mk {φ : G →* M} (HN : N ≤ φ.ker) (g : G) : lift N φ HN (g : Q) = φ g
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
/-- An antitone function between (conditionally) complete linear ordered spaces sends a
`Filter.limsSup` to the `Filter.liminf` of the image if the function is continuous at the `limsSup`
(and the filter is bounded from above and frequently bounded from below). -/
theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
    (f_decr : Antitone f) (f_cont : ContinuousAt f F.limsSup)
    (bdd_above : F.IsBounded (· ≤ ·) := by isBoundedDefault)
    (cobdd : F.IsCobounded (· ≤ ·) := by isBoundedDefault) :
    f F.limsSup = F.liminf f
-- Mathlib/FieldTheory/Adjoin.lean
theorem induction_on_adjoin [FiniteDimensional F E] (P : IntermediateField F E → Prop)
    (base : P ⊥) (ih : ∀ (K : IntermediateField F E) (x : E), P K → P (K⟮x⟯.restrictScalars F))
    (K : IntermediateField F E) : P K
-- Mathlib/Geometry/Manifold/Algebra/Monoid.lean
@[to_additive]
theorem contMDiffWithinAt_finprod (lf : LocallyFinite fun i ↦ mulSupport <| f i) {x₀ : M}
    (h : ∀ i, ContMDiffWithinAt I' I n (f i) s x₀) :
    ContMDiffWithinAt I' I n (fun x ↦ ∏ᶠ i, f i x) s x₀
-- Mathlib/NumberTheory/VonMangoldt.lean
@[simp]
theorem vonMangoldt_apply_one : Λ 1 = 0
-- Mathlib/Probability/Distributions/Gaussian.lean
lemma integrable_gaussianPDFReal (μ : ℝ) (v : ℝ≥0) :
    Integrable (gaussianPDFReal μ v)
-- Mathlib/GroupTheory/GroupAction/Blocks.lean
/-- If `B` is a block containing `a`, then the stabilizer of `B` contains the stabilizer of `a` -/
theorem IsBlock.stabilizer_le {B : Set X} (hB : IsBlock G B) {a : X} (ha : a ∈ B) :
    stabilizer G a ≤ stabilizer G B
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
lemma primeSpectrumProd_symm_inr (x) :
    (primeSpectrumProd R S).symm (.inr x) = comap (RingHom.snd R S) x
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
protected theorem mul_comm (x y : BitVec w) : x * y = y * x
-- Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
@[simp]
theorem map_comp_ι (f : Q₁ →qᵢ Q₂) :
    (map f).toLinearMap ∘ₗ ι Q₁ = ι Q₂ ∘ₗ f.toLinearMap
-- Mathlib/Algebra/Polynomial/Inductions.lean
theorem divX_C_mul_X_pow : divX (C a * X ^ n) = if n = 0 then 0 else C a * X ^ (n - 1)
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- Two points are collinear. -/
theorem collinear_pair (p₁ p₂ : P) : Collinear k ({p₁, p₂} : Set P)
-- Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean
/-- (Impl) A preliminary definition to avoid timeouts. -/
@[simps]
def conesEquivFunctor (B : C) {J : Type w} (F : Discrete J ⥤ Over B) :
    Cone (widePullbackDiagramOfDiagramOver B F) ⥤ Cone F
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
theorem ascPochhammer_eval_succ (r n : ℕ) :
    (n : S) * (ascPochhammer S r).eval (n + 1 : S) =
    (n + r) * (ascPochhammer S r).eval (n : S)
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem untrop_mul [Add R] (x y : Tropical R) : untrop (x * y) = untrop x + untrop y
-- Mathlib/Order/Ideal.lean
theorem coe_subset_coe : (s : Set P) ⊆ t ↔ s ≤ t
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem compl_involutive : Function.Involutive (compl : α → α)
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem mem_closure {x : R} {s : Set R} : x ∈ closure s ↔ ∀ S : NonUnitalSubring R, s ⊆ S → x ∈ S
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem not_mem_nil (a : α) : ¬ a ∈ (nil : Sym α 0)
-- Mathlib/GroupTheory/SpecificGroups/Cyclic.lean
/-- A group of order `p ^ 2` is not cyclic if and only if its exponent is `p`. -/
@[to_additive]
lemma not_isCyclic_iff_exponent_eq_prime [Group α] {p : ℕ} (hp : p.Prime)
    (hα : Nat.card α = p ^ 2) : ¬ IsCyclic α ↔ Monoid.exponent α = p
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive]
theorem mem_div : s ∈ f / g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ / t₂ ⊆ s
-- Mathlib/Analysis/BoxIntegral/Partition/Filter.lean
theorem hasBasis_toFilterDistortion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) :
    (l.toFilterDistortion I c).HasBasis l.RCond fun r => { π | l.MemBaseSet I c r π }
-- Mathlib/Analysis/Normed/Order/UpperLower.lean
@[to_additive IsUpperSet.cthickening]
protected theorem IsUpperSet.cthickening' (hs : IsUpperSet s) (ε : ℝ) :
    IsUpperSet (cthickening ε s)
-- Mathlib/Analysis/Complex/Schwarz.lean
theorem affine_of_mapsTo_ball_of_exists_norm_dslope_eq_div' [CompleteSpace E]
    [StrictConvexSpace ℝ E] (hd : DifferentiableOn ℂ f (ball c R₁))
    (h_maps : Set.MapsTo f (ball c R₁) (ball (f c) R₂))
    (h_z₀ : ∃ z₀ ∈ ball c R₁, ‖dslope f c z₀‖ = R₂ / R₁) :
    ∃ C : E, ‖C‖ = R₂ / R₁ ∧ Set.EqOn f (fun z => f c + (z - c) • C) (ball c R₁)
-- Mathlib/LinearAlgebra/AffineSpace/Basis.lean
@[simp]
theorem coe_coord_of_subsingleton_eq_one [Subsingleton ι] (i : ι) : (b.coord i : P → k) = 1
-- Mathlib/AlgebraicTopology/DoldKan/Projections.lean
@[reassoc (attr := simp)]
theorem P_f_idem (q n : ℕ) : ((P q).f n : X _[n] ⟶ _) ≫ (P q).f n = (P q).f n
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
/-- `rpow` version of `List.prod_map_pow` for `Real`. -/
theorem _root_.Real.list_prod_map_rpow (l : List ℝ) (hl : ∀ x ∈ l, (0 : ℝ) ≤ x) (r : ℝ) :
    (l.map (· ^ r)).prod = l.prod ^ r
-- Mathlib/Data/Matrix/Basis.lean
@[simp]
theorem smul_stdBasisMatrix [SMulZeroClass R α] (r : R) (i : m) (j : n) (a : α) :
    r • stdBasisMatrix i j a = stdBasisMatrix i j (r • a)
-- Mathlib/Algebra/FreeMonoid/Basic.lean
@[to_additive]
theorem of_injective : Function.Injective (@of α)
-- Mathlib/Order/Filter/EventuallyConst.lean
@[to_additive]
theorem mulIndicator_const_iff_of_ne (hc : c ≠ 1) :
    EventuallyConst (s.mulIndicator fun _ ↦ c) l ↔ EventuallyConst s l
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
/-- A sequence of uniformly integrable functions which converges μ-a.e. converges in Lp. -/
theorem tendsto_Lp_finite_of_tendsto_ae [IsFiniteMeasure μ] (hp : 1 ≤ p) (hp' : p ≠ ∞)
    {f : ℕ → α → β} {g : α → β} (hf : ∀ n, AEStronglyMeasurable (f n) μ) (hg : Memℒp g p μ)
    (hui : UnifIntegrable f p μ) (hfg : ∀ᵐ x ∂μ, Tendsto (fun n => f n x) atTop (𝓝 (g x))) :
    Tendsto (fun n => eLpNorm (f n - g) p μ) atTop (𝓝 0)
-- Mathlib/Probability/Kernel/Composition.lean
@[simp]
lemma map_const (μ : Measure α) {f : α → β} (hf : Measurable f) :
    map (const γ μ) f hf = const γ (μ.map f)
-- Mathlib/Order/Fin/Basic.lean
lemma succAbove_lt_succAbove_iff : succAbove p i < succAbove p j ↔ i < j
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ico_union_right (hab : a ≤ b) : Ico a b ∪ {b} = Icc a b
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem composition_card (n : ℕ) : Fintype.card (Composition n) = 2 ^ (n - 1)
-- Mathlib/RingTheory/Valuation/Basic.lean
@[simp]
theorem comap_id : v.comap (RingHom.id R) = v
-- Mathlib/RingTheory/Congruence/Basic.lean
protected theorem mul {w x y z} : c w x → c y z → c (w * y) (x * z)
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem nhds_eq_inf_comap {z : Z} (hz : z ∈ e.source) :
    𝓝 z = comap proj (𝓝 (proj z)) ⊓ comap (Prod.snd ∘ e) (𝓝 (e z).2)
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
theorem isRefl : B.IsRefl
-- Mathlib/Data/Real/Sqrt.lean
theorem sqrt_le_iff : √x ≤ y ↔ 0 ≤ y ∧ x ≤ y ^ 2
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem em (p : Prop) [Decidable p] : p ∨ ¬p
-- Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean
lemma iff_appLE : P f ↔ ∀ (U : Y.affineOpens) (V : X.affineOpens) (e), Q (f.appLE U V e)
-- Mathlib/Analysis/Complex/CauchyIntegral.lean
/-- Suppose that a function `f : ℂ → E` is continuous on a closed rectangle with opposite corners at
`z w : ℂ`, is *real* differentiable on the corresponding open rectangle, and
$\frac{\partial f}{\partial \bar z}$ is integrable on this rectangle. Then the integral of `f` over
the boundary of the rectangle is equal to the integral of
$2i\frac{\partial f}{\partial \bar z}=i\frac{\partial f}{\partial x}-\frac{\partial f}{\partial y}$
over the rectangle. -/
theorem integral_boundary_rect_of_continuousOn_of_hasFDerivAt_real (f : ℂ → E) (f' : ℂ → ℂ →L[ℝ] E)
    (z w : ℂ) (Hc : ContinuousOn f ([[z.re, w.re]] ×ℂ [[z.im, w.im]]))
    (Hd : ∀ x ∈ Ioo (min z.re w.re) (max z.re w.re) ×ℂ Ioo (min z.im w.im) (max z.im w.im),
      HasFDerivAt f (f' x) x)
    (Hi : IntegrableOn (fun z => I • f' z 1 - f' z I) ([[z.re, w.re]] ×ℂ [[z.im, w.im]])) :
    (∫ x : ℝ in z.re..w.re, f (x + z.im * I)) - (∫ x : ℝ in z.re..w.re, f (x + w.im * I)) +
      I • (∫ y : ℝ in z.im..w.im, f (re w + y * I)) -
      I • (∫ y : ℝ in z.im..w.im, f (re z + y * I)) =
      ∫ x : ℝ in z.re..w.re, ∫ y : ℝ in z.im..w.im, I • f' (x + y * I) 1 - f' (x + y * I) I
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
theorem support_toSmoothPartitionOfUnity_subset (i : ι) :
    support (fs.toSmoothPartitionOfUnity i) ⊆ support (fs i)
-- Mathlib/SetTheory/Cardinal/ToNat.lean
/-- Two finite cardinals are equal
iff they are equal their `Cardinal.toNat` projections are equal. -/
theorem toNat_eq_iff_eq_of_lt_aleph0 (hc : c < ℵ₀) (hd : d < ℵ₀) :
    toNat c = toNat d ↔ c = d
-- Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean
theorem d_comp_ε : (groupCohomology.resolution k G).d 1 0 ≫ ε k G = 0
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
@[simp]
theorem distortion_disjUnion (h : Disjoint π₁.iUnion π₂.iUnion) :
    (π₁.disjUnion π₂ h).distortion = max π₁.distortion π₂.distortion
-- Mathlib/LinearAlgebra/Basis.lean
theorem repr_eq_iff' {b : Basis ι R M} {f : M ≃ₗ[R] ι →₀ R} :
    b.repr = f ↔ ∀ i, f (b i) = Finsupp.single i 1
-- Mathlib/Topology/Sets/Opens.lean
@[simp, norm_cast]
theorem coe_iSup {ι} (s : ι → Opens α) : ((⨆ i, s i : Opens α) : Set α) = ⋃ i, s i
-- Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
theorem mult_log_place_eq_zero {x : (𝓞 K)ˣ} {w : InfinitePlace K} :
    mult w * Real.log (w x) = 0 ↔ w x = 1
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive] lemma le_mabs_self (a : α) : a ≤ |a|ₘ
-- Mathlib/Algebra/Divisibility/Units.lean
theorem IsRelPrime.of_dvd_left (h : IsRelPrime y z) (dvd : x ∣ y) : IsRelPrime x z
-- Mathlib/Algebra/Lie/Weights/Basic.lean
lemma weightSpace_weightSpaceOf_map_incl (x : L) (χ : L → R) :
    (weightSpace (weightSpaceOf M (χ x) x) χ).map (weightSpaceOf M (χ x) x).incl =
    weightSpace M χ
-- Mathlib/Algebra/AddTorsor.lean
/-- Adding a group element then subtracting the original point
produces that group element. -/
@[simp]
theorem vadd_vsub (g : G) (p : P) : g +ᵥ p -ᵥ p = g
-- Mathlib/Data/Finset/NAry.lean
theorem image₂_union_right [DecidableEq β] : image₂ f s (t ∪ t') = image₂ f s t ∪ image₂ f s t'
-- Mathlib/Data/Fintype/Prod.lean
@[simp] lemma product_eq_univ [Nonempty α] [Nonempty β] : s ×ˢ t = univ ↔ s = univ ∧ t = univ
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
theorem log_pos_iff (hx : 0 < x) : 0 < log x ↔ 1 < x
-- Mathlib/Analysis/Calculus/LineDeriv/Measurable.lean
theorem measurable_lineDeriv [MeasurableSpace F] [BorelSpace F]
    (hf : Continuous f) : Measurable (fun x ↦ lineDeriv 𝕜 f x v)
-- Mathlib/Tactic/Sat/FromLRAT.lean
/-- The reification of a positive literal `¬⟦a⟧_v ≡ ¬a`. -/
theorem Literal.reify_pos {a : Prop} {n : ℕ} (h : v n ↔ a) : (Literal.pos n).reify v ¬a
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp]
protected theorem map_add {F} [Add β] [FunLike F α β] [AddHomClass F α β]
    (f : F) (a b : WithTop α) :
    (a + b).map f = a.map f + b.map f
-- Mathlib/Topology/Bases.lean
theorem _root_.QuotientMap.separableSpace [SeparableSpace α] [TopologicalSpace β] {f : α → β}
    (hf : QuotientMap f) : SeparableSpace β
-- Mathlib/Algebra/BigOperators/Fin.lean
theorem finPiFinEquiv_single {m : ℕ} {n : Fin m → ℕ} [∀ i, NeZero (n i)] (i : Fin m)
    (j : Fin (n i)) :
    (finPiFinEquiv (Pi.single i j : ∀ i : Fin m, Fin (n i)) : ℕ) =
      j * ∏ j, n (Fin.castLE i.is_lt.le j)
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
@[measurability]
theorem measurableSet_eq {a : α} : MeasurableSet { x | x = a }
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem strictAntiOn_cos : StrictAntiOn cos (Icc 0 π)
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem lineDeriv_smul {c : 𝕜} : lineDeriv 𝕜 f x (c • v) = c • lineDeriv 𝕜 f x v
-- Mathlib/Algebra/Lie/EngelSubalgebra.lean
/-- The Engel subalgebra `Engel R x` consists of
all `y : L` such that `(ad R L x)^n` kills `y` for some `n`.

Engel subalgebras are self-normalizing (`LieSubalgebra.normalizer_engel`),
and minimal ones are nilpotent, hence Cartan subalgebras. -/
@[simps!]
def engel (x : L) : LieSubalgebra R L
-- Mathlib/Algebra/AddTorsor.lean
theorem vadd_eq_vadd_iff_sub_eq_vsub {v₁ v₂ : G} {p₁ p₂ : P} :
    v₁ +ᵥ p₁ = v₂ +ᵥ p₂ ↔ v₂ - v₁ = p₁ -ᵥ p₂
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp, norm_cast)]
theorem coe_smul_finset (a : α) (s : Finset β) : ↑(a • s) = a • (↑s : Set β)
-- Mathlib/Data/Set/Basic.lean
theorem union_left (hs : Disjoint s u) (ht : Disjoint t u) : Disjoint (s ∪ t) u
-- Mathlib/Analysis/MellinTransform.lean
theorem MellinConvergent.comp_mul_left {f : ℝ → E} {s : ℂ} {a : ℝ} (ha : 0 < a) :
    MellinConvergent (fun t => f (a * t)) s ↔ MellinConvergent f s
-- Mathlib/Algebra/Polynomial/Derivation.lean
lemma mkDerivation_one_eq_derivative (f : R[X]) : mkDerivation R (1 : R[X]) f = derivative f
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- If the second of three points is weakly between the other two, and not equal to the first,
the angle at the first point is zero. -/
theorem _root_.Wbtw.angle₂₁₃_eq_zero_of_ne {p₁ p₂ p₃ : P} (h : Wbtw ℝ p₁ p₂ p₃) (hp₂p₁ : p₂ ≠ p₁) :
    ∠ p₂ p₁ p₃ = 0
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem image_mem_nhdsWithin {x : H} {s : Set H} (hs : s ∈ 𝓝 x) : I '' s ∈ 𝓝[range I] I x
-- Mathlib/Algebra/Homology/ComplexShapeSigns.lean
@[simp]
lemma ε_zero : c.ε 0 = 1
-- Mathlib/Data/Finite/Card.lean
theorem card_le_of_embedding [Finite β] (f : α ↪ β) : Nat.card α ≤ Nat.card β
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem comap_fst_neBot_iff {f : Filter α} :
    (f.comap (Prod.fst : α × β → α)).NeBot ↔ f.NeBot ∧ Nonempty β
-- Mathlib/Data/Rel.lean
theorem image_core_gc : GaloisConnection r.image r.core
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_comp' (g f : R → R) (a : A)
    (hg : ContinuousOn g (f '' σₙ R a) := by cfc_cont_tac) (hg0 : g 0 = 0 := by cfc_zero_tac)
    (hf : ContinuousOn f (σₙ R a) := by cfc_cont_tac) (hf0 : f 0 = 0 := by cfc_zero_tac)
    (ha : p a := by cfc_tac) :
    cfcₙ (g <| f ·) a = cfcₙ g (cfcₙ f a)
-- Mathlib/Tactic/NormNum/Result.lean
theorem IsRat.to_raw_eq {n : ℤ} {d : ℕ} [DivisionRing α] :
    ∀ {a}, IsRat (a : α) n d → a = Rat.rawCast n d
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
theorem isSkewAdjoint_iff_neg_self_adjoint (f : Module.End R M) :
    B.IsSkewAdjoint f ↔ IsAdjointPair (-B) B f f
-- Mathlib/Control/Fold.lean
theorem toList_spec (xs : t α) : toList xs = FreeMonoid.toList (foldMap FreeMonoid.of xs)
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
theorem IsCycle.existsUnique_cycle_subtype {f : Perm α} (hf : IsCycle f) :
    ∃! s : { s : Cycle α // s.Nodup }, (s : Cycle α).formPerm s.prop = f
-- Mathlib/SetTheory/Ordinal/Notation.lean
@[simp]
theorem repr_scale (x) [NF x] (o) [NF o] : repr (scale x o) = ω ^ repr x * repr o
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem toL1_add (f g : α → β) (hf : Integrable f μ) (hg : Integrable g μ) :
    toL1 (f + g) (hf.add hg) = toL1 f hf + toL1 g hg
-- Mathlib/Data/Finset/Basic.lean
theorem union_sdiff_of_subset (h : s ⊆ t) : s ∪ t \ s = t
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
theorem trailingDegree_one_le : (0 : ℕ∞) ≤ trailingDegree (1 : R[X])
-- Mathlib/Algebra/Exact.lean
lemma exact_of_comp_of_mem_range
    (h1 : g.comp f = 0) (h2 : ∀ x, g x = 0 → x ∈ range f) : Exact f g
-- Mathlib/Topology/Order/DenselyOrdered.lean
@[simp]
theorem Ico_mem_nhds_iff [NoMinOrder α] {a b x : α} : Ico a b ∈ 𝓝 x ↔ x ∈ Ioo a b
-- Mathlib/Order/LiminfLimsup.lean
theorem blimsup_congr {f : Filter β} {u v : β → α} {p : β → Prop} (h : ∀ᶠ a in f, p a → u a = v a) :
    blimsup u f p = blimsup v f p
-- Mathlib/Data/Set/Finite.lean
theorem Infinite.nontrivial {s : Set α} (hs : s.Infinite) : s.Nontrivial
-- Mathlib/Data/Set/Image.lean
theorem inter_preimage_subset (s : Set α) (t : Set β) (f : α → β) :
    s ∩ f ⁻¹' t ⊆ f ⁻¹' (f '' s ∩ t)
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_nat_gt_zero_eq (f : ℕ → α) : ⨅ i > 0, f i = ⨅ i, f (i + 1)
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
theorem measure_condCDF_Iic (ρ : Measure (α × ℝ)) (a : α) (x : ℝ) :
    (condCDF ρ a).measure (Iic x) = ENNReal.ofReal (condCDF ρ a x)
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem apply_coe_mem_map (f : F) (I : Ideal R) (x : I) : f x ∈ I.map f
-- Mathlib/LinearAlgebra/Matrix/Permutation.lean
/-- The determinant of a permutation matrix equals its sign. -/
@[simp]
theorem det_permutation [CommRing R] : det (σ.permMatrix R) = Perm.sign σ
-- Mathlib/CategoryTheory/Limits/FullSubcategory.lean
theorem hasColimit_of_closedUnderColimits (h : ClosedUnderColimitsOfShape J P)
    (F : J ⥤ FullSubcategory P) [HasColimit (F ⋙ fullSubcategoryInclusion P)] : HasColimit F
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
@[simp]
theorem LinearMap.toMatrix'_toLinearMapₛₗ₂' (M : Matrix n m N₂) :
    LinearMap.toMatrixₛₗ₂' R (Matrix.toLinearMapₛₗ₂' R σ₁ σ₂ M) = M
-- Mathlib/Data/Sigma/Lex.lean
theorem Lex.mono_right (hs : ∀ i a b, s₁ i a b → s₂ i a b) {a b : Σ i, α i} (h : Lex r s₁ a b) :
    Lex r s₂ a b
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem not_def {x : BitVec v} : ~~~x = allOnes v ^^^ x
-- Mathlib/GroupTheory/Nilpotent.lean
/-- The lower central series of a group is a descending central series. -/
theorem lowerCentralSeries_isDescendingCentralSeries :
    IsDescendingCentralSeries (lowerCentralSeries G)
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
theorem not_mem_none (a : α) : a ∉ (none : Option α)
-- Mathlib/Topology/LocallyConstant/Algebra.lean
theorem charFn_inj [Nontrivial Y] (hU : IsClopen U) (hV : IsClopen V)
    (h : charFn Y hU = charFn Y hV) : U = V
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem toTopologicalSpace_inf {u v : UniformSpace α} :
    (u ⊓ v).toTopologicalSpace = u.toTopologicalSpace ⊓ v.toTopologicalSpace
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
/-- An iterated coproduct is a coproduct over a sigma type. -/
@[simps]
def sigmaSigmaIso {ι : Type*} (f : ι → Type*) (g : (i : ι) → (f i) → C)
    [∀ i, HasCoproduct (g i)] [HasCoproduct fun i => ∐ g i] :
    (∐ fun i => ∐ g i) ≅ (∐ fun p : Σ i, f i => g p.1 p.2)
-- Mathlib/Lean/Thunk.lean
@[simp] theorem prod_get_snd {a : Thunk α} {b : Thunk β} : (prod a b).get.2 = b.get
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem abs_moebius_le_one {n : ℕ} : |μ n| ≤ 1
-- Mathlib/Order/Filter/Basic.lean
theorem Eventually.filter_mono {f₁ f₂ : Filter α} (h : f₁ ≤ f₂) {p : α → Prop}
    (hp : ∀ᶠ x in f₂, p x) : ∀ᶠ x in f₁, p x
-- Mathlib/Topology/UniformSpace/Cauchy.lean
lemma cauchy_prod_iff [UniformSpace β] {F : Filter (α × β)} :
    Cauchy F ↔ Cauchy (map Prod.fst F) ∧ Cauchy (map Prod.snd F)
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem hasFDerivWithinAt_inter (h : t ∈ 𝓝 x) :
    HasFDerivWithinAt f f' (s ∩ t) x ↔ HasFDerivWithinAt f f' s x
-- Mathlib/Topology/Connected/Basic.lean
theorem connectedComponent_disjoint {x y : α} (h : connectedComponent x ≠ connectedComponent y) :
    Disjoint (connectedComponent x) (connectedComponent y)
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Instances.lean
theorem seqRight_eq [Monad m] [LawfulMonad m] (x : StateT σ m α) (y : StateT σ m β) : x *> y = const α id <$> x <*> y
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem pow_subset_pow_of_one_mem (hs : (1 : α) ∈ s) : m ≤ n → s ^ m ⊆ s ^ n
-- Mathlib/CategoryTheory/Iso.lean
theorem IsIso.inv_eq_inv {f g : X ⟶ Y} [IsIso f] [IsIso g] : inv f = inv g ↔ f = g
-- Mathlib/CategoryTheory/GradedObject.lean
/-- The projection of a graded object to its `i`-th component. -/
@[simps]
def eval {β : Type w} (b : β) : GradedObject β C ⥤ C
-- Mathlib/SetTheory/Game/PGame.lean
/-- The definition of `0 ≤ x` on pre-games, in terms of `0 ≤` two moves later. -/
theorem zero_le {x : PGame} : 0 ≤ x ↔ ∀ j, ∃ i, 0 ≤ (x.moveRight j).moveLeft i
-- Mathlib/LinearAlgebra/QuadraticForm/Prod.lean
/-- An isometry between quadratic forms generated by `QuadraticMap.pi` can be constructed
from a pair of isometries between the left and right parts. -/
@[simps toLinearEquiv]
def IsometryEquiv.pi [Fintype ι]
    {Q : ∀ i, QuadraticMap R (Mᵢ i) P} {Q' : ∀ i, QuadraticMap R (Nᵢ i) P}
    (e : ∀ i, (Q i).IsometryEquiv (Q' i)) : (pi Q).IsometryEquiv (pi Q')