ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/WittVector/WittPolynomial.lean
theorem wittPolynomial_vars_subset (n : ℕ) : (wittPolynomial p R n).vars ⊆ range (n + 1)
-- Mathlib/CategoryTheory/Sites/CoversTop.lean
lemma sections_ext (F : Sheaf J (Type _)) {x y : F.1.sections}
    (h : ∀ (i : I), x.1 (Opposite.op (Y i)) = y.1 (Opposite.op (Y i))) :
    x = y
-- Mathlib/Topology/Clopen.lean
theorem isClopen_range_inr : IsClopen (range (Sum.inr : Y → X ⊕ Y))
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem comap_comap {T : Type*} [Semiring T] {I : Ideal T} (f : R →+* S) (g : S →+* T) :
    (I.comap g).comap f = I.comap (g.comp f)
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean
/-- The sine of the angle between two vectors is 0 if and only if the angle is 0 or π. -/
theorem sin_eq_zero_iff_angle_eq_zero_or_angle_eq_pi :
    sin (angle x y) = 0 ↔ angle x y = 0 ∨ angle x y = π
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_eq_zero_iff_degree_le_zero : p.natDegree = 0 ↔ p.degree ≤ 0
-- Mathlib/ModelTheory/DirectLimit.lean
@[elab_as_elim]
protected theorem inductionOn {C : DirectLimit G f → Prop} (z : DirectLimit G f)
    (ih : ∀ i x, C (of L ι G f i x)) : C z
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
/-- If `f` is continuous multilinear, then `f (Σ_{j₁ ∈ A₁} g₁ j₁, ..., Σ_{jₙ ∈ Aₙ} gₙ jₙ)` is the
sum of `f (g₁ (r 1), ..., gₙ (r n))` where `r` ranges over all functions with `r 1 ∈ A₁`, ...,
`r n ∈ Aₙ`. This follows from multilinearity by expanding successively with respect to each
coordinate. -/
theorem map_sum_finset [DecidableEq ι] :
    (f fun i => ∑ j ∈ A i, g i j) = ∑ r ∈ piFinset A, f fun i => g i (r i)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[simp]
protected theorem add_right_inj (i j k : Int) : (i + k = j + k) ↔ i = j
-- Mathlib/RingTheory/PowerSeries/Inverse.lean
@[simp]
theorem Inv_divided_by_X_pow_order_rightInv {f : k⟦X⟧} (hf : f ≠ 0) :
    divided_by_X_pow_order hf * Inv_divided_by_X_pow_order hf = 1
-- Mathlib/GroupTheory/Finiteness.lean
theorem AddMonoid.fg_iff_mul_fg : AddMonoid.FG N ↔ Monoid.FG (Multiplicative N)
-- Mathlib/Topology/Instances/TrivSqZeroExt.lean
theorem embedding_inl [Zero M] : Embedding (inl : R → tsze R M)
-- Mathlib/Data/Stream/Init.lean
@[simp]
theorem get_tails : ∀ (n : ℕ) (s : Stream' α), get (tails s) n = drop n (tail s)
-- Mathlib/Data/Finset/Sort.lean
/-- Any increasing map `f` from `Fin k` to a finset of cardinality `k` has to coincide with
the increasing bijection `orderEmbOfFin s h`. -/
theorem orderEmbOfFin_unique {s : Finset α} {k : ℕ} (h : s.card = k) {f : Fin k → α}
    (hfs : ∀ x, f x ∈ s) (hmono : StrictMono f) : f = s.orderEmbOfFin h
-- Mathlib/Data/Sign.lean
theorem range_eq {α} (f : SignType → α) : Set.range f = {f zero, f neg, f pos}
-- Mathlib/LinearAlgebra/Ray.lean
theorem sameRay_neg_smul_right_iff_of_ne {v : M} {r : R} (hv : v ≠ 0) (hr : r ≠ 0) :
    SameRay R (-v) (r • v) ↔ r < 0
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
@[simp]
theorem setToFun_zero (hT : DominatedFinMeasAdditive μ T C) : setToFun μ T hT (0 : α → E) = 0
-- Mathlib/Topology/Instances/NNReal.lean
/-- An antitone sequence `f : ℕ → ℝ≥0` has a finite limit. -/
theorem tendsto_of_antitone {f : ℕ → ℝ≥0} (h_ant : Antitone f) :
    ∃ r : ℝ≥0, Tendsto f atTop (𝓝 r)
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem ContDiffWithinAt.rpow (hf : ContDiffWithinAt ℝ n f s x) (hg : ContDiffWithinAt ℝ n g s x)
    (h : f x ≠ 0) : ContDiffWithinAt ℝ n (fun x => f x ^ g x) s x
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem domDomCongr_eq_zero_iff (σ : ι ≃ ι') (f : M [⋀^ι]→ₗ[R] N) :
    f.domDomCongr σ = 0 ↔ f = 0
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem productMap_apply_tmul (a : A) (b : B) : productMap f g (a ⊗ₜ b) = f a * g b
-- Mathlib/Algebra/Order/AbsoluteValue.lean
protected theorem ne_zero {x : R} (hx : x ≠ 0) : abv x ≠ 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem continuousOn_tan_Ioo : ContinuousOn tan (Ioo (-(π / 2)) (π / 2))
-- Mathlib/Data/List/EditDistance/Bounds.lean
theorem suffixLevenshtein_minimum_le_levenshtein_cons (xs : List α) (y ys) :
    (suffixLevenshtein C xs ys).1.minimum ≤ levenshtein C xs (y :: ys)
-- Mathlib/Data/Fintype/CardEmbedding.lean
theorem card_embedding_eq_of_unique {α β : Type*} [Unique α] [Fintype β] [Fintype (α ↪ β)] :
    ‖α ↪ β‖ = ‖β‖
-- Mathlib/Order/LiminfLimsup.lean
theorem IsBounded.isBoundedUnder {q : β → β → Prop} {u : α → β}
    (hu : ∀ a₀ a₁, r a₀ a₁ → q (u a₀) (u a₁)) : f.IsBounded r → f.IsBoundedUnder q u
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
theorem not_isUniform_zero : ¬G.IsUniform (0 : 𝕜) s t
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem bounded_singleton {r : α → α → Prop} [IsWellOrder α r] (hr : (type r).IsLimit) (x) :
    Bounded r {x}
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem mk (h : ∀ ⦃s : Set α⦄, MeasurableSet s → ν s = 0 → μ s = 0) : μ ≪ ν
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
@[reassoc (attr := simp)]
theorem Pi.reindex_hom_π (b : β) : (Pi.reindex ε f).hom ≫ Pi.π f (ε b) = Pi.π (f ∘ ε) b
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_const_mul_Iio (a : α) {c : α} (h : 0 < c) : (c * ·) ⁻¹' Iio a = Iio (a / c)
-- Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean
@[simp]
lemma prodEquiv_apply_fst (x : (forget C).obj (X₁ ⨯ X₂)) :
    (prodEquiv X₁ X₂ x).fst = (Limits.prod.fst : X₁ ⨯ X₂ ⟶ X₁) x
-- Mathlib/Order/Irreducible.lean
theorem IsMin.not_supIrred (ha : IsMin a) : ¬SupIrred a
-- Mathlib/Data/List/Enum.lean
@[simp]
theorem enumFrom_map_snd : ∀ (n) (l : List α), map Prod.snd (enumFrom n l) = l
-- Mathlib/Data/Fin/VecNotation.lean
theorem vecAlt0_vecAppend (v : Fin n → α) :
    vecAlt0 rfl (vecAppend rfl v v) = v ∘ (fun n ↦ n + n)
-- Mathlib/Data/ENNReal/Basic.lean
@[simp] theorem two_ne_top : (2 : ℝ≥0∞) ≠ ∞
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem trans_apply (e : α ≃o β) (e' : β ≃o γ) (x : α) : e.trans e' x = e' (e x)
-- Mathlib/Geometry/Euclidean/Inversion/Basic.lean
theorem inversion_eq_lineMap (c : P) (R : ℝ) (x : P) :
    inversion c R x = lineMap c x ((R / dist x c) ^ 2)
-- Mathlib/Algebra/Polynomial/Inductions.lean
@[simp]
theorem X_mul_divX_add (p : R[X]) : X * divX p + C (p.coeff 0) = p
-- Mathlib/RingTheory/LaurentSeries.lean
theorem intValuation_eq_of_coe (P : K[X]) :
    (Polynomial.idealX K).intValuation P = (idealX K).intValuation (P : K⟦X⟧)
-- .lake/packages/lean4/src/lean/Init/Omega/Int.lean
theorem ofNat_sub_dichotomy {a b : Nat} :
    b ≤ a ∧ ((a - b : Nat) : Int) = a - b ∨ a < b ∧ ((a - b : Nat) : Int) = 0
-- Mathlib/Algebra/Lie/Solvable.lean
@[simp]
theorem derivedSeriesOfIdeal_succ (k : ℕ) :
    derivedSeriesOfIdeal R L (k + 1) I =
      ⁅derivedSeriesOfIdeal R L k I, derivedSeriesOfIdeal R L k I⁆
-- Mathlib/Data/Real/ConjExponents.lean
protected lemma inv_ne_zero : p⁻¹ ≠ 0
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma one_add_smoothingFn_le_two {x : ℝ} (hx : exp 1 ≤ x) : 1 + ε x ≤ 2
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem eq_empty_or_nonempty (u : ZFSet) : u = ∅ ∨ u.Nonempty
-- Mathlib/Algebra/ContinuedFractions/ConvergentsEquiv.lean
/-- The auxiliary function `convs'Aux` returns the same value for a sequence and the
corresponding squashed sequence at the squashed position. -/
theorem succ_succ_nth_conv'Aux_eq_succ_nth_conv'Aux_squashSeq :
    convs'Aux s (n + 2) = convs'Aux (squashSeq s n) (n + 1)
-- Mathlib/Algebra/Order/Floor/Div.lean
lemma ceilDiv_le_iff_le_mul (ha : 0 < a) : b ⌈/⌉ a ≤ c ↔ b ≤ a * c
-- Mathlib/Data/List/Basic.lean
theorem dropSlice_eq (xs : List α) (n m : ℕ) : dropSlice n m xs = xs.take n ++ xs.drop (n + m)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Simproc.lean
theorem beqFalseOfEqFalse {a b : Nat} (p : (a = b) = False) : (a == b) = false
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- A family `𝓕 : ι → X → α` is equicontinuous at `x₀` within `S` iff the function
`swap 𝓕 : X → ι → α` is continuous at `x₀` within `S`
*when `ι → α` is equipped with the topology of uniform convergence*. This is very useful for
developping the equicontinuity API, but it should not be used directly for other purposes. -/
theorem equicontinuousWithinAt_iff_continuousWithinAt {F : ι → X → α} {S : Set X} {x₀ : X} :
    EquicontinuousWithinAt F S x₀ ↔
    ContinuousWithinAt (ofFun ∘ Function.swap F : X → ι →ᵤ α) S x₀
-- Mathlib/RingTheory/PrimeSpectrum.lean
theorem subset_zeroLocus_vanishingIdeal (t : Set (PrimeSpectrum R)) :
    t ⊆ zeroLocus (vanishingIdeal t)
-- Mathlib/Data/Matrix/Block.lean
theorem blockDiagonal'_submatrix_eq_blockDiagonal (M : o → Matrix m n α) :
    (blockDiagonal' M).submatrix (Prod.toSigma ∘ Prod.swap) (Prod.toSigma ∘ Prod.swap) =
      blockDiagonal M
-- Mathlib/Algebra/Star/StarAlgHom.lean
/-- The second projection of a product is a ⋆-algebra homomorphism. -/
@[simps!]
def snd : A × B →⋆ₐ[R] B
-- Mathlib/Data/Sym/Card.lean
theorem card_subtype_diag [Fintype α] : card { a : Sym2 α // a.IsDiag } = card α
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isLittleO_iff_nat_mul_le' : f' =o[l] g ↔ ∀ n : ℕ, ∀ᶠ x in l, ↑n * ‖f' x‖ ≤ ‖g x‖
-- Mathlib/Data/Finsupp/Multiset.lean
theorem toMultiset_apply (f : α →₀ ℕ) : toMultiset f = f.sum fun a n => n • {a}
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem getLsb_zeroExtend (m : Nat) (x : BitVec n) (i : Nat) :
    getLsb (zeroExtend m x) i = (decide (i < m) && getLsb x i)
-- Mathlib/CategoryTheory/Localization/Bousfield.lean
lemma W_of_isIso {X Y : C} (f : X ⟶ Y) [IsIso f] : W P f
-- Mathlib/Probability/Kernel/Disintegration/Density.lean
/-- Auxiliary lemma for `setIntegral_density`. -/
lemma setIntegral_density_of_measurableSet (hκν : fst κ ≤ ν)
    [IsFiniteKernel ν] (n : ℕ) (a : α) {s : Set β} (hs : MeasurableSet s) {A : Set γ}
    (hA : MeasurableSet[countableFiltration γ n] A) :
    ∫ x in A, density κ ν a x s ∂(ν a) = (κ a (A ×ˢ s)).toReal
-- Mathlib/RingTheory/Support.lean
lemma Module.support_subset_of_injective (hf : Function.Injective f) :
    Module.support R M ⊆ Module.support R N
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem toBlocks_fromBlocks₂₁ (A : Matrix n l α) (B : Matrix n m α) (C : Matrix o l α)
    (D : Matrix o m α) : (fromBlocks A B C D).toBlocks₂₁ = C
-- Mathlib/Algebra/Order/Sub/Defs.lean
/-- See `add_tsub_add_eq_tsub_left` for the equality. -/
theorem add_tsub_add_le_tsub_left : a + b - (a + c) ≤ b - c
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
/-- For two points on the same vertical line, the distance is equal to the distance between the
logarithms of their imaginary parts. -/
nonrec theorem dist_of_re_eq (h : z.re = w.re) : dist z w = dist (log z.im) (log w.im)
-- Mathlib/Computability/Primrec.lean
theorem pow : Nat.Primrec (unpaired (· ^ ·))
-- Mathlib/Combinatorics/SetFamily/Shatter.lean
@[simp] lemma shatters_univ [Fintype α] : 𝒜.Shatters univ ↔ 𝒜 = univ
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
@[aesop safe apply]
lemma differentiableAt_one_sub_smoothingFn {x : ℝ} (hx : 1 < x) :
    DifferentiableAt ℝ (fun z => 1 - ε z) x
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp low]
theorem if_true_left [h : Decidable p] :
    ite p True q ↔ ¬p → q
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem sub_apply {x : α} : (f - g) x = f x - g x
-- Mathlib/RingTheory/Coalgebra/Basic.lean
@[simp]
theorem coassoc_apply (a : A) :
    TensorProduct.assoc R A A A (comul.rTensor A (comul a)) = comul.lTensor A (comul a)
-- Mathlib/Order/Filter/Basic.lean
theorem sup_bind {f g : Filter α} {h : α → Filter β} : bind (f ⊔ g) h = bind f h ⊔ bind g h
-- Mathlib/MeasureTheory/Measure/Regular.lean
/-- Given `r` larger than the measure of a set `A`, there exists an open superset of `A` with
measure less than `r`. -/
theorem _root_.Set.exists_isOpen_lt_of_lt [OuterRegular μ] (A : Set α) (r : ℝ≥0∞) (hr : μ A < r) :
    ∃ U, U ⊇ A ∧ IsOpen U ∧ μ U < r
-- Mathlib/GroupTheory/Complement.lean
theorem rightCosetEquivalence_equiv_snd (g : G) :
    RightCosetEquivalence H g ((hHT.equiv g).snd : G)
-- Mathlib/Algebra/GroupWithZero/Defs.lean
theorem zero_ne_mul_self : 0 ≠ a * a ↔ a ≠ 0
-- Mathlib/CategoryTheory/Subobject/Basic.lean
/-- To show that two subobjects are equal, it suffices to exhibit an isomorphism commuting with
    the arrows. -/
theorem mk_eq_of_comm {B A : C} {X : Subobject B} (f : A ⟶ B) [Mono f] (i : A ≅ (X : C))
    (w : i.hom ≫ X.arrow = f) : mk f = X
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
/-- This left homology map data expresses compatibilities of the left homology data
constructed by `LeftHomologyData.ofEpiOfIsIsoOfMono` -/
@[simps]
def ofEpiOfIsIsoOfMono (φ : S₁ ⟶ S₂) (h : LeftHomologyData S₁)
    [Epi φ.τ₁] [IsIso φ.τ₂] [Mono φ.τ₃] :
    LeftHomologyMapData φ h (LeftHomologyData.ofEpiOfIsIsoOfMono φ h)
-- Mathlib/Computability/Partrec.lean
theorem vector_length {n} : Computable (@Vector.length α n)
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- Given a point in the affine span from which all the points are
equidistant, that distance is the circumradius. -/
theorem eq_circumradius_of_dist_eq {n : ℕ} (s : Simplex ℝ P n) {p : P}
    (hp : p ∈ affineSpan ℝ (Set.range s.points)) {r : ℝ} (hr : ∀ i, dist (s.points i) p = r) :
    r = s.circumradius
-- Mathlib/Data/List/Sym.lean
theorem sym_sublist_sym_cons {a : α} : xs.sym n <+ (a :: xs).sym n
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp]
lemma RingEquiv_coe_eq {X Y : Type _} [Semiring X] [Semiring Y] (e : X ≃+* Y) :
    (@DFunLike.coe (SemiRingCat.of X ⟶ SemiRingCat.of Y) _ (fun _ => (forget SemiRingCat).obj _)
      ConcreteCategory.instFunLike (e : X →+* Y) : X → Y) = ↑e
-- Mathlib/Analysis/Oscillation.lean
theorem oscillation_eq_zero [TopologicalSpace E] {f : E → F} {x : E} (hf : ContinuousAt f x) :
    oscillation f x = 0
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem sub_eq_of_add_eq {a b c : Ordinal} (h : a + b = c) : c - a = b
-- Mathlib/RingTheory/Polynomial/IntegralNormalization.lean
theorem integralNormalization_coeff {f : R[X]} {i : ℕ} :
    (integralNormalization f).coeff i =
      if f.degree = i then 1 else coeff f i * f.leadingCoeff ^ (f.natDegree - 1 - i)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
@[simp] theorem mod_zero (a : Nat) : a % 0 = a
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem indicatorConstLp_coeFn : ⇑(indicatorConstLp p hs hμs c) =ᵐ[μ] s.indicator fun _ => c
-- Mathlib/Algebra/Ring/Subsemiring/Pointwise.lean
theorem mem_smul_pointwise_iff_exists (m : M) (r : R) (S : Subsemiring R) :
    r ∈ m • S ↔ ∃ s : R, s ∈ S ∧ m • s = r
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
@[simp]
theorem sameCycle_subtypePerm {h} {x y : { x // p x }} :
    (f.subtypePerm h).SameCycle x y ↔ f.SameCycle x y
-- Mathlib/Analysis/NormedSpace/MStructure.lean
@[simp]
theorem coe_zero : ↑(0 : { P : M // IsLprojection X P }) = (0 : M)
-- Mathlib/RingTheory/Localization/FractionRing.lean
@[simp]
theorem mk'_eq_div {r} (s : nonZeroDivisors A) : mk' K r s = algebraMap A K r / algebraMap A K s
-- Mathlib/Algebra/Order/Antidiag/Pi.lean
lemma map_nsmul_piAntidiag_univ [Fintype ι] (m : ℕ) {n : ℕ} (hn : n ≠ 0) :
    (piAntidiag (univ : Finset ι) m).map
        ⟨(n • ·), fun f g h ↦ funext fun i ↦ mul_right_injective₀ hn (congr_fun h i)⟩ =
      (piAntidiag univ (n * m)).filter fun f : ι → ℕ ↦ ∀ i, n ∣ f i
-- Mathlib/Order/Sublattice.lean
lemma le_comap_iSup (f : LatticeHom α β) (L : ι → Sublattice β) :
    ⨆ i, (L i).comap f ≤ (⨆ i, L i).comap f
-- Mathlib/Order/Heyting/Basic.lean
/-- `p → p → q ↔ p → q` -/
theorem le_himp_iff_left : a ≤ a ⇨ b ↔ a ≤ b
-- Mathlib/RingTheory/Filtration.lean
@[simp]
theorem sup_N : (F ⊔ F').N = F.N ⊔ F'.N
-- Mathlib/GroupTheory/MonoidLocalization/Order.lean
@[to_additive]
theorem mk_le_mk : mk a₁ a₂ ≤ mk b₁ b₂ ↔ ↑b₂ * a₁ ≤ a₂ * b₁
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
theorem denseRange_coeSimpleFuncNonnegToLpNonneg [hp : Fact (1 ≤ p)] (hp_ne_top : p ≠ ∞) :
    DenseRange (coeSimpleFuncNonnegToLpNonneg p μ G)
-- Mathlib/Order/Filter/Basic.lean
theorem not_tendsto_iff_exists_frequently_nmem {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
    ¬Tendsto f l₁ l₂ ↔ ∃ s ∈ l₂, ∃ᶠ x in l₁, f x ∉ s
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem continuousAt_extChartAt_symm'' {x : M} {y : E} (h : y ∈ (extChartAt I x).target) :
    ContinuousAt (extChartAt I x).symm y
-- Mathlib/Algebra/Algebra/Spectrum.lean
/-- The resolvent is a unit when the argument is in the resolvent set. -/
theorem isUnit_resolvent {r : R} {a : A} : r ∈ resolventSet R a ↔ IsUnit (resolvent a r)
-- Mathlib/Combinatorics/SetFamily/Compression/Down.lean
@[simp]
theorem nonMemberSubfamily_nonMemberSubfamily :
    (𝒜.nonMemberSubfamily a).nonMemberSubfamily a = 𝒜.nonMemberSubfamily a
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
lemma inl_eq_inr_iff [Mono f] (x₁ : X₁) (x₂ : X₂) :
    (inl f g x₁ = inr f g x₂) ↔
      ∃ (s : S), f s = x₁ ∧ g s = x₂
-- Mathlib/Order/Zorn.lean
theorem zorn_superset (S : Set (Set α))
    (h : ∀ c ⊆ S, IsChain (· ⊆ ·) c → ∃ lb ∈ S, ∀ s ∈ c, lb ⊆ s) :
    ∃ m ∈ S, ∀ a ∈ S, a ⊆ m → a = m
-- Mathlib/FieldTheory/Minpoly/IsIntegrallyClosed.lean
@[simp]
theorem _root_.PowerBasis.ofGenMemAdjoin'_dim (B : PowerBasis R S) (hint : IsIntegral R x)
    (hx : B.gen ∈ adjoin R ({x} : Set S)) :
    (B.ofGenMemAdjoin' hint hx).dim = (minpoly R x).natDegree
-- Mathlib/Tactic/CC/Lemmas.lean
theorem eq_false_of_not_eq_true {a : Prop} (h : Not a = True) : a = False
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma exact_iff_epi [HasZeroObject C] (hg : S.g = 0) :
    S.Exact ↔ Epi S.f
-- Mathlib/Topology/Order/LocalExtr.lean
theorem IsLocalMaxOn.inter (hf : IsLocalMaxOn f s a) (t) : IsLocalMaxOn f (s ∩ t) a
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem uniformContinuous_coe : @UniformContinuous (α →ᵇ β) (α → β) _ _ (⇑)
-- .lake/packages/batteries/Batteries/Logic.lean
theorem eqRec_heq_self {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
    (x : motive a (rfl : a = a)) {a' : α} (e : a = a') :
    HEq (@Eq.rec α a motive x a' e) x
-- Mathlib/MeasureTheory/Measure/GiryMonad.lean
theorem measurable_measure {μ : α → Measure β} :
    Measurable μ ↔ ∀ (s : Set β), MeasurableSet s → Measurable fun b => μ b s
-- Mathlib/Analysis/Convex/Gauge.lean
theorem gauge_lt_one_subset_self (hs : Convex ℝ s) (h₀ : (0 : E) ∈ s) (absorbs : Absorbent ℝ s) :
    { x | gauge s x < 1 } ⊆ s
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem LinearEquiv.finsuppUnique_symm_apply [Unique α] (m : M) :
    (LinearEquiv.finsuppUnique R M α).symm m = Finsupp.single default m
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
theorem AddSubmonoid.toSubmonoid'_closure (S : Set (Additive M)) :
    AddSubmonoid.toSubmonoid' (AddSubmonoid.closure S)
      = Submonoid.closure (Multiplicative.ofAdd ⁻¹' S)
-- Mathlib/Data/Nat/Factors.lean
theorem primeFactorsList_chain' (n) : List.Chain' (· ≤ ·) (primeFactorsList n)
-- Mathlib/Data/Finsupp/Basic.lean
theorem mapDomain_support [DecidableEq β] {f : α → β} {s : α →₀ M} :
    (s.mapDomain f).support ⊆ s.support.image f
-- Mathlib/NumberTheory/LegendreSymbol/Basic.lean
/-- The Legendre symbol is multiplicative in `a` for `p` fixed. -/
protected theorem mul (a b : ℤ) : legendreSym p (a * b) = legendreSym p a * legendreSym p b
-- Mathlib/MeasureTheory/Integral/Average.lean
/-- **First moment method**. A measurable function is greater than its integral on a set f
positive measure. -/
theorem measure_lintegral_le_pos (hint : ∫⁻ a, f a ∂μ ≠ ∞) : 0 < μ {x | ∫⁻ a, f a ∂μ ≤ f x}
-- Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean
lemma adjoin_id_eq_span_one_add (s : Set 𝕜) :
    ((StarAlgebra.adjoin 𝕜 {(restrict s (.id 𝕜) : C(s, 𝕜))}) : Set C(s, 𝕜)) =
      (span 𝕜 {(1 : C(s, 𝕜))} : Set C(s, 𝕜)) + (adjoin 𝕜 {(restrict s (.id 𝕜) : C(s, 𝕜))})
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem modByMonicHom_root (h : IsAdjoinRootMonic S f) (hdeg : 1 < natDegree f) :
    h.modByMonicHom h.root = X
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem IsIntegral.tower_bot_of_field {R A B : Type*} [CommRing R] [Field A]
    [CommRing B] [Nontrivial B] [Algebra R A] [Algebra A B] [Algebra R B] [IsScalarTower R A B]
    {x : A} (h : IsIntegral R (algebraMap A B x)) : IsIntegral R x
-- Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean
/-- If `L` is a finite separable extension of `K = Frac(A)`, where `A` is a Dedekind domain,
the integral closure `C` of `A` in `L` is a Dedekind domain.

This cannot be an instance since `A`, `K` or `L` can't be inferred. See also the instance
`integralClosure.isDedekindDomain_fractionRing` where `K := FractionRing A`
and `C := integralClosure A L`. -/
theorem IsIntegralClosure.isDedekindDomain [IsDedekindDomain A] : IsDedekindDomain C
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- Let `f` be a function continuous on a convex (or, equivalently, connected) subset `D`
of the real line. If `f` is differentiable on the interior of `D` and `f'` is strictly positive,
then `f` is a strictly monotone function on `D`. -/
lemma strictMonoOn_of_hasDerivWithinAt_pos {D : Set ℝ} (hD : Convex ℝ D) {f f' : ℝ → ℝ}
    (hf : ContinuousOn f D) (hf' : ∀ x ∈ interior D, HasDerivWithinAt f (f' x) (interior D) x)
    (hf'₀ : ∀ x ∈ interior D, 0 < f' x) : StrictMonoOn f D
-- Mathlib/Analysis/Convex/Side.lean
theorem sOppSide_lineMap_right {s : AffineSubspace R P} {x y : P} (hx : x ∈ s) (hy : y ∉ s) {t : R}
    (ht : t < 0) : s.SOppSide y (lineMap x y t)
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma _root_.Antitone.image_uIcc_subset (hf : Antitone f) : f '' uIcc a b ⊆ uIcc (f a) (f b)
-- Mathlib/FieldTheory/IntermediateField.lean
/-- An intermediate field is closed under scalar multiplication. -/
theorem smul_mem {y : L} : y ∈ S → ∀ {x : K}, x • y ∈ S
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem arrowCongr_symm (e₁ : A₁ ≃ₐ[R] A₁') (e₂ : A₂ ≃ₐ[R] A₂') :
    (arrowCongr e₁ e₂).symm = arrowCongr e₁.symm e₂.symm
-- Mathlib/Data/PFunctor/Multivariate/W.lean
theorem wDest'_wMk' {α : TypeVec n} (x : P (α.append1 (P.W α))) : P.wDest' (P.wMk' x) = x
-- Mathlib/Data/List/Basic.lean
theorem foldl_eq_foldr (hcomm : Commutative f) (hassoc : Associative f) :
    ∀ a l, foldl f a l = foldr f a l
-- Mathlib/Data/Matroid/Restrict.lean
theorem restrict_restrict_eq {R₁ R₂ : Set α} (M : Matroid α) (hR : R₂ ⊆ R₁) :
    (M ↾ R₁) ↾ R₂ = M ↾ R₂
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem restrict_apply {i : Set α} (hi : MeasurableSet i) {j : Set α} (hj : MeasurableSet j) :
    v.restrict i j = v (j ∩ i)
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp low] theorem true_eq (b : Bool) : (true = b) = (b = true)
-- Mathlib/Topology/Order/LocalExtr.lean
nonrec theorem IsLocalMin.neg (hf : IsLocalMin f a) : IsLocalMax (fun x => -f x) a
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem trans_toLinearMap (f : A₁ ≃ₐ[R] A₂) (g : A₂ ≃ₐ[R] A₃) :
    (f.trans g).toLinearMap = g.toLinearMap.comp f.toLinearMap
-- Mathlib/RingTheory/Valuation/Basic.lean
@[simp]
theorem mem_supp_iff (x : R) : x ∈ supp v ↔ v x = (⊤ : Γ₀)
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
theorem aeval_zero : aeval x (0 : R[X]) = 0
-- Mathlib/Analysis/NormedSpace/HahnBanach/Separation.lean
/-- See also `NormedSpace.eq_iff_forall_dual_eq`. -/
theorem geometric_hahn_banach_point_point [T1Space E] (hxy : x ≠ y) :
    ∃ f : E →L[ℝ] ℝ, f x < f y
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
theorem coe_extChartAt_transDiffeomorph (x : M) :
    ⇑(extChartAt (I.transDiffeomorph e) x) = e ∘ extChartAt I x
-- .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean
theorem Heap.WF.singleton : (Heap.singleton a).WF le 0
-- Mathlib/Analysis/MeanInequalitiesPow.lean
/-- Weighted generalized mean inequality, version for sums over finite sets, with `ℝ≥0∞`-valued
functions and real exponents. -/
theorem rpow_arith_mean_le_arith_mean_rpow (w z : ι → ℝ≥0∞) (hw' : ∑ i ∈ s, w i = 1) {p : ℝ}
    (hp : 1 ≤ p) : (∑ i ∈ s, w i * z i) ^ p ≤ ∑ i ∈ s, w i * z i ^ p
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem _root_.Set.Finite.nullMeasurableSet_biUnion {f : ι → Set α} {s : Set ι} (hs : s.Finite)
    (h : ∀ b ∈ s, NullMeasurableSet (f b) μ) : NullMeasurableSet (⋃ b ∈ s, f b) μ