ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Sign.lean
@[simp]
theorem pos_eq_one : pos = 1
-- Mathlib/Data/Int/Defs.lean
protected lemma lt_or_le (a b : ℤ) : a < b ∨ b ≤ a
-- Mathlib/Order/Concept.lean
@[simp]
theorem bot_snd : (⊥ : Concept α β r).snd = univ
-- Mathlib/MeasureTheory/Measure/Haar/Disintegration.lean
/-- Given a surjective linear map `L`, it is equivalent to require a property almost everywhere
in the source or the target spaces of `L`, with respect to additive Haar measures there. -/
lemma ae_comp_linearMap_mem_iff (h : Function.Surjective L) {s : Set F} (hs : MeasurableSet s) :
    (∀ᵐ x ∂μ, L x ∈ s) ↔ ∀ᵐ y ∂ν, y ∈ s
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
theorem edgeSet_injective : Injective (edgeSet : SimpleGraph V → Set (Sym2 V))
-- Mathlib/MeasureTheory/Covering/Besicovitch.lean
/-- Consider, for each `x` in a set `s`, a radius `r x ∈ (0, 1]`. Then one can find finitely
many disjoint balls of the form `closedBall x (r x)` covering a proportion `1/(N+1)` of `s`, if
there are no satellite configurations with `N+1` points.
-/
theorem exist_finset_disjoint_balls_large_measure (μ : Measure α) [IsFiniteMeasure μ] {N : ℕ}
    {τ : ℝ} (hτ : 1 < τ) (hN : IsEmpty (SatelliteConfig α N τ)) (s : Set α) (r : α → ℝ)
    (rpos : ∀ x ∈ s, 0 < r x) (rle : ∀ x ∈ s, r x ≤ 1) :
    ∃ t : Finset α, ↑t ⊆ s ∧ μ (s \ ⋃ x ∈ t, closedBall x (r x)) ≤ N / (N + 1) * μ s ∧
      (t : Set α).PairwiseDisjoint fun x => closedBall x (r x)
-- Mathlib/Analysis/Calculus/TangentCone.lean
/-- Intersecting with a neighborhood of the point does not change the tangent cone. -/
theorem tangentCone_inter_nhds (ht : t ∈ 𝓝 x) : tangentConeAt 𝕜 (s ∩ t) x = tangentConeAt 𝕜 s x
-- Mathlib/CategoryTheory/Sites/Sieves.lean
theorem le_functorPushforward_pullback (R : Sieve X) :
    R ≤ (R.functorPushforward F).functorPullback F
-- Mathlib/CategoryTheory/Limits/ExactFunctor.lean
@[simp]
theorem RightExactFunctor.of_fst (F : C ⥤ D) [PreservesFiniteColimits F] :
    (RightExactFunctor.of F).obj = F
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
@[simp]
theorem dist_right_midpoint (p₁ p₂ : P) :
    dist p₂ (midpoint 𝕜 p₁ p₂) = ‖(2 : 𝕜)‖⁻¹ * dist p₁ p₂
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_finset_range : Tendsto Finset.range atTop atTop
-- Mathlib/Analysis/Analytic/Basic.lean
protected theorem HasFPowerSeriesAt.eventually (hf : HasFPowerSeriesAt f p x) :
    ∀ᶠ r : ℝ≥0∞ in 𝓝[>] 0, HasFPowerSeriesOnBall f p x r
-- Mathlib/Analysis/Calculus/BumpFunction/Normed.lean
theorem integral_pos : 0 < ∫ x, f x ∂μ
-- Mathlib/Computability/TuringMachine.lean
@[simp]
theorem Tape.mk'_right {Γ} [Inhabited Γ] (L R : ListBlank Γ) : (Tape.mk' L R).right = R.tail
-- Mathlib/Combinatorics/SimpleGraph/Metric.lean
theorem dist_self : dist G v v = 0
-- Mathlib/RingTheory/Ideal/Quotient.lean
@[simp]
theorem quotEquivOfEq_symm {R : Type*} [CommRing R] {I J : Ideal R} (h : I = J) :
    (Ideal.quotEquivOfEq h).symm = Ideal.quotEquivOfEq h.symm
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp] theorem coe_id_of {X : Type u} [CommSemiring X] :
    @DFunLike.coe no_index (CommSemiRingCat.of X ⟶ CommSemiRingCat.of X) X
      (fun _ ↦ X) _
      (𝟙 (of X)) =
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (RingHom.id X)
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem UniformContinuous₂.tendstoUniformly [UniformSpace α] [UniformSpace γ] {f : α → β → γ}
    (h : UniformContinuous₂ f) {x : α} : TendstoUniformly f (f x) (𝓝 x)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] theorem mul_ediv_cancel_left (b : Int) (H : a ≠ 0) : (a * b) / a = b
-- Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
theorem mdifferentiableOn_extChartAt :
    MDifferentiableOn I 𝓘(𝕜, E) (extChartAt I x) (chartAt H x).source
-- Mathlib/Order/Interval/Set/Image.lean
lemma StrictAnti.mapsTo_Iio (h : StrictAnti f) : MapsTo f (Iio b) (Ioi (f b))
-- Mathlib/Data/List/AList.lean
@[simp]
theorem keys_insert {a} {b : β a} (s : AList β) : (insert a b s).keys = a :: s.keys.erase a
-- Mathlib/Data/Set/Lattice.lean
lemma iInter_const (s : Set β) : ⋂ _ : ι, s = s
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[reassoc]
theorem coprod.inl_desc {W X Y : C} [HasBinaryCoproduct X Y] (f : X ⟶ W) (g : Y ⟶ W) :
    coprod.inl ≫ coprod.desc f g = f
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
lemma inf_eq_bot_of_bot_mem [OrderBot α] (h : ⊥ ∈ s) : sInf s = ⊥
-- Mathlib/Order/Defs.lean
theorem le_not_le_of_lt : ∀ {a b : α}, a < b → a ≤ b ∧ ¬b ≤ a
-- Mathlib/FieldTheory/Perfect.lean
@[simp]
theorem bijective_frobenius : Bijective (frobenius R p)
-- Mathlib/LinearAlgebra/Projectivization/Basic.lean
@[simp]
theorem mk''_submodule (v : ℙ K V) : mk'' v.submodule v.finrank_submodule = v
-- Mathlib/Order/SuccPred/Limit.lean
protected theorem _root_.IsMax.isPredLimit : IsMax a → IsPredLimit a
-- Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean
@[reassoc]
lemma mapComp_id_right_hom (f : a ⟶ b) : (F.mapComp f (𝟙 b)).hom =
    F.map₂ (ρ_ f).hom ≫ (ρ_ (F.map f)).inv ≫ F.map f ◁ (F.mapId b).inv
-- Mathlib/Algebra/AddConstMap/Basic.lean
@[scoped simp]
theorem map_nsmul_const [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
    (f : F) (n : ℕ) : f (n • a) = f 0 + n • b
-- Mathlib/Data/Finset/Lattice.lean
theorem exists_max_image (s : Finset β) (f : β → α) (h : s.Nonempty) :
    ∃ x ∈ s, ∀ x' ∈ s, f x' ≤ f x
-- Mathlib/Topology/Algebra/UniformGroup.lean
/-- A uniform additive group is an additive group in which addition
  and negation are uniformly continuous. -/
class UniformAddGroup (α : Type*) [UniformSpace α] [AddGroup α] : Prop where
  uniformContinuous_sub : UniformContinuous fun p : α × α => p.1 - p.2
-- Mathlib/Algebra/DirectSum/Internal.lean
theorem coe_of_mul_apply_of_le {i : ι} (r : A i) (r' : ⨁ i, A i) (n : ι) (h : i ≤ n) :
    ((of (fun i => A i) i r * r') n : R) = r * r' (n - i)
-- Mathlib/Data/Set/Card.lean
theorem Finite.exists_encard_eq_coe (h : s.Finite) : ∃ (n : ℕ), s.encard = n
-- Mathlib/Order/Hom/Lattice.lean
@[simp] theorem comp_id (f : BoundedLatticeHom α β) : f.comp (BoundedLatticeHom.id α) = f
-- Mathlib/Algebra/Homology/ShortComplex/Ab.lean
lemma ShortExact.ab_injective_f (hS : S.ShortExact) :
    Function.Injective S.f
-- Mathlib/LinearAlgebra/Trace.lean
theorem IsProj.trace {p : Submodule R M} {f : M →ₗ[R] M} (h : IsProj p f) [Module.Free R p]
    [Module.Finite R p] [Module.Free R (ker f)] [Module.Finite R (ker f)] :
    trace R M f = (finrank R p : R)
-- Mathlib/Data/List/Enum.lean
@[simp]
theorem enum_eq_nil {l : List α} : List.enum l = [] ↔ l = []
-- Mathlib/Lean/Thunk.lean
@[simp] theorem prod_get_fst {a : Thunk α} {b : Thunk β} : (prod a b).get.1 = a.get
-- Mathlib/Combinatorics/SimpleGraph/Turan.lean
lemma IsTuranMaximal.le_iff_eq (hG : G.IsTuranMaximal r) (hH : H.CliqueFree (r + 1)) :
    G ≤ H ↔ G = H
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[reassoc (attr := simp)]
theorem biprod.lift_snd {W X Y : C} [HasBinaryBiproduct X Y] (f : W ⟶ X) (g : W ⟶ Y) :
    biprod.lift f g ≫ biprod.snd = g
-- Mathlib/Combinatorics/SimpleGraph/Operations.lean
@[simp]
lemma sup_edge_self : G ⊔ edge s s = G
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem dvd_prime_pow {p : ℕ} (pp : Prime p) {m i : ℕ} : i ∣ p ^ m ↔ ∃ k ≤ m, i = p ^ k
-- Mathlib/Data/Set/Lattice.lean
theorem iInter_inter [Nonempty ι] (s : Set β) (t : ι → Set β) : (⋂ i, t i) ∩ s = ⋂ i, t i ∩ s
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
/--
Congruence in both function and argument. If `f₁ = f₂` and `a₁ = a₂` then
`f₁ a₁ = f₂ a₂`. This only works for nondependent functions; the theorem
statement is more complex in the dependent case.

For more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality)
-/
theorem congr {α : Sort u} {β : Sort v} {f₁ f₂ : α → β} {a₁ a₂ : α} (h₁ : Eq f₁ f₂) (h₂ : Eq a₁ a₂) : Eq (f₁ a₁) (f₂ a₂)
-- Mathlib/Tactic/CC/Lemmas.lean
theorem not_eq_of_eq_true {a : Prop} (h : a = True) : Not a = False
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
lemma DifferentiableAt.lineDeriv_eq_fderiv (hf : DifferentiableAt 𝕜 f x) :
    lineDeriv 𝕜 f x v = fderiv 𝕜 f x v
-- Mathlib/Topology/AlexandrovDiscrete.lean
lemma isClopen_iInter (hf : ∀ i, IsClopen (f i)) : IsClopen (⋂ i, f i)
-- Mathlib/Data/Finsupp/Defs.lean
theorem update_eq_single_add_erase (f : α →₀ M) (a : α) (b : M) :
    f.update a b = single a b + f.erase a
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem geom_series_mul_neg (x : R) (h : ‖x‖ < 1) : (∑' i : ℕ, x ^ i) * (1 - x) = 1
-- Mathlib/Logic/Equiv/Defs.lean
theorem apply_eq_iff_eq (f : α ≃ β) {x y : α} : f x = f y ↔ x = y
-- Mathlib/MeasureTheory/Measure/Trim.lean
theorem sigmaFinite_trim_bot_iff : SigmaFinite (μ.trim bot_le) ↔ IsFiniteMeasure μ
-- Mathlib/LinearAlgebra/AffineSpace/Basis.lean
@[simp]
theorem coord_apply_centroid [CharZero k] (b : AffineBasis ι k P) {s : Finset ι} {i : ι}
    (hi : i ∈ s) : b.coord i (s.centroid k b) = (s.card : k)⁻¹
-- Mathlib/Combinatorics/SimpleGraph/Matching.lean
lemma IsMatching.iSup {ι : Sort _} {f : ι → Subgraph G} (hM : (i : ι) → (f i).IsMatching)
    (hd : Pairwise fun i j ↦ Disjoint (f i).support (f j).support) :
    (⨆ i, f i).IsMatching
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_iff_comap_le {m₁ : MeasurableSpace α} {m₂ : MeasurableSpace β} {f : α → β} :
    Measurable f ↔ m₂.comap f ≤ m₁
-- Mathlib/Algebra/Quandle.lean
/-- Given a homomorphism from a rack to a group, it factors through the enveloping group.
-/
theorem toEnvelGroup.univ (R : Type*) [Rack R] (G : Type*) [Group G] (f : R →◃ Quandle.Conj G) :
    (Quandle.Conj.map (toEnvelGroup.map f)).comp (toEnvelGroup R) = f
-- Mathlib/Testing/SlimCheck/Functions.lean
theorem List.applyId_zip_eq [DecidableEq α] {xs ys : List α} (h₀ : List.Nodup xs)
    (h₁ : xs.length = ys.length) (x y : α) (i : ℕ) (h₂ : xs[i]? = some x) :
    List.applyId.{u} (xs.zip ys) x = y ↔ ys[i]? = some y
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The span of the empty set is `⊥`. -/
@[simp]
theorem span_empty : affineSpan k (∅ : Set P) = ⊥
-- Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean
@[simp]
theorem mul_adjMatrix_apply [NonAssocSemiring α] (M : Matrix V V α) (v w : V) :
    (M * G.adjMatrix α) v w = ∑ u ∈ G.neighborFinset w, M v u
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem codRestrict_apply' (p : L.Substructure N) (f : M ↪[L] N) {h} (x : M) :
    codRestrict p f h x = ⟨f x, h x⟩
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
lemma natDegree_le_pred (hf : p.natDegree ≤ n) (hn : p.coeff n = 0) : p.natDegree ≤ n - 1
-- Mathlib/Data/Set/Function.lean
theorem surjOn_image (f : α → β) (s : Set α) : SurjOn f s (f '' s)
-- Mathlib/Data/Finite/Card.lean
@[simp]
theorem card_option [Finite α] : Nat.card (Option α) = Nat.card α + 1
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem measure_union_add_inter₀ (s : Set α) (ht : NullMeasurableSet t μ) :
    μ (s ∪ t) + μ (s ∩ t) = μ s + μ t
-- Mathlib/Deprecated/Subring.lean
theorem isSubring_preimage {R : Type u} {S : Type v} [Ring R] [Ring S] (f : R →+* S) {s : Set S}
    (hs : IsSubring s) : IsSubring (f ⁻¹' s)
-- Mathlib/Data/Set/Pointwise/Interval.lean
theorem image_neg_Ioi : Neg.neg '' Ioi a = Iio (-a)
-- Mathlib/Tactic/CategoryTheory/Monoidal.lean
theorem evalWhiskerLeft_of_cons
    (α : g ⟶ h) (η : h ⟶ i) {ηs : i ⟶ j} {θ : f ⊗ i ⟶ f ⊗ j} (pf_θ : f ◁ ηs = θ) :
    f ◁ (α ≫ η ≫ ηs) = f ◁ α ≫ f ◁ η ≫ θ
-- Mathlib/Data/Ordmap/Ordset.lean
theorem rotateL_nil (l : Ordnode α) (x : α) : rotateL l x nil = node' l x nil
-- Mathlib/Algebra/Lie/Basic.lean
@[ext]
theorem ext {f g : M →ₗ⁅R,L⁆ N} (h : ∀ m, f m = g m) : f = g
-- Mathlib/MeasureTheory/Covering/DensityTheorem.lean
theorem tendsto_closedBall_filterAt {K : ℝ} {x : α} {ι : Type*} {l : Filter ι} (w : ι → α)
    (δ : ι → ℝ) (δlim : Tendsto δ l (𝓝[>] 0)) (xmem : ∀ᶠ j in l, x ∈ closedBall (w j) (K * δ j)) :
    Tendsto (fun j => closedBall (w j) (δ j)) l ((vitaliFamily μ K).filterAt x)
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_pi_iff {g : α → ∀ a, π a} : Measurable g ↔ ∀ a, Measurable fun x => g x a
-- Mathlib/CategoryTheory/Sites/Equivalence.lean
lemma W_inverseImage_whiskeringLeft :
    K.W.inverseImage ((whiskeringLeft Dᵒᵖ Cᵒᵖ A).obj G.op) = J.W
-- Mathlib/SetTheory/Cardinal/Continuum.lean
@[simp]
theorem continuum_add_ofNat {n : ℕ} [Nat.AtLeastTwo n] : 𝔠 + no_index (OfNat.ofNat n) = 𝔠
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem re_star : (star a).re = a.re
-- Mathlib/Data/Tree/Basic.lean
theorem numLeaves_eq_numNodes_succ (x : Tree α) : x.numLeaves = x.numNodes + 1
-- Mathlib/Algebra/Lie/TraceForm.lean
lemma traceForm_apply_apply (x y : L) :
    traceForm R L M x y = trace R _ (φ x ∘ₗ φ y)
-- Mathlib/ModelTheory/Semantics.lean
theorem Theory.realize_sentence_of_mem [M ⊨ T] {φ : L.Sentence} (h : φ ∈ T) : M ⊨ φ
-- Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
/-- There exists `π ∈ R` with `v`-adic valuation `Multiplicative.ofAdd (-1)`. -/
theorem intValuation_exists_uniformizer :
    ∃ π : R, v.intValuationDef π = Multiplicative.ofAdd (-1 : ℤ)
-- Mathlib/Algebra/Module/Torsion.lean
theorem supIndep_torsionBySet_ideal : S.SupIndep fun i => torsionBySet R M <| p i
-- Mathlib/Data/Finset/Lattice.lean
theorem inf_ite (p : β → Prop) [DecidablePred p] :
    (s.inf fun i ↦ ite (p i) (f i) (g i)) = (s.filter p).inf f ⊓ (s.filter fun i ↦ ¬ p i).inf g
-- Mathlib/Analysis/Calculus/ContDiff/Bounds.lean
/-- Bounding the norm of the iterated derivative of `B (f x) (g x)` within a set in terms of the
iterated derivatives of `f` and `g` when `B` is bilinear of norm at most `1`:
`‖D^n (x ↦ B (f x) (g x))‖ ≤ ∑_{k ≤ n} n.choose k ‖D^k f‖ ‖D^{n-k} g‖` -/
theorem ContinuousLinearMap.norm_iteratedFDerivWithin_le_of_bilinear_of_le_one
    (B : E →L[𝕜] F →L[𝕜] G) {f : D → E} {g : D → F} {N : ℕ∞} {s : Set D} {x : D}
    (hf : ContDiffOn 𝕜 N f s) (hg : ContDiffOn 𝕜 N g s) (hs : UniqueDiffOn 𝕜 s) (hx : x ∈ s) {n : ℕ}
    (hn : (n : ℕ∞) ≤ N) (hB : ‖B‖ ≤ 1) : ‖iteratedFDerivWithin 𝕜 n (fun y => B (f y) (g y)) s x‖ ≤
      ∑ i ∈ Finset.range (n + 1), (n.choose i : ℝ) * ‖iteratedFDerivWithin 𝕜 i f s x‖ *
        ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖
-- Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean
theorem integrable_exp_neg_mul_sq {b : ℝ} (hb : 0 < b) :
    Integrable fun x : ℝ => exp (-b * x ^ 2)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addMap_of_Z_eq_zero_right {P : PointClass F} {Q : Fin 3 → F} (hP : W.NonsingularLift P)
    (hQ : W.Nonsingular Q) (hQz : Q z = 0) : W.addMap P ⟦Q⟧ = P
-- Mathlib/Order/Filter/Bases.lean
protected theorem HasAntitoneBasis.comap {l : Filter α} {s : ι'' → Set α}
    (hf : HasAntitoneBasis l s) (m : β → α) : HasAntitoneBasis (comap m l) (m ⁻¹' s ·)
-- Mathlib/GroupTheory/PushoutI.lean
@[simp]
theorem prod_smul (g : PushoutI φ) (w : NormalWord d) :
    (g • w).prod = g * w.prod
-- Mathlib/Init/Algebra/Classes.lean
theorem incomp_trans [IsIncompTrans α r] {a b c : α} :
    ¬a ≺ b ∧ ¬b ≺ a → ¬b ≺ c ∧ ¬c ≺ b → ¬a ≺ c ∧ ¬c ≺ a
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem meas_preimage_singleton_ne_zero (h : f.FinMeasSupp μ) {y : β} (hy : y ≠ 0) :
    μ (f ⁻¹' {y}) < ∞
-- Mathlib/Analysis/Convex/Strict.lean
protected theorem StrictConvex.inter {t : Set E} (hs : StrictConvex 𝕜 s) (ht : StrictConvex 𝕜 t) :
    StrictConvex 𝕜 (s ∩ t)
-- Mathlib/Topology/Basic.lean
theorem ClusterPt.neBot {F : Filter X} (h : ClusterPt x F) : NeBot (𝓝 x ⊓ F)
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma nilRankAux_basis_indep [Nontrivial R] (b : Basis ι R L) (b' : Basis ι' R L) :
    nilRankAux φ b = (polyCharpoly φ b').natTrailingDegree
-- Mathlib/Order/GaloisConnection.lean
theorem u_iInf_l [CompleteLattice α] [CompleteLattice β] (gi : GaloisCoinsertion l u) {ι : Sort x}
    (f : ι → α) : u (⨅ i, l (f i)) = ⨅ i, f i
-- Mathlib/Algebra/Lie/Killing.lean
@[simp] lemma ker_killingForm_eq_bot :
    LinearMap.ker (killingForm R L) = ⊥
-- Mathlib/Algebra/Ring/Idempotents.lean
@[simp]
theorem coe_compl (p : { p : R // IsIdempotentElem p }) : ↑pᶜ = (1 : R) - ↑p
-- Mathlib/Data/Fin/Tuple/Basic.lean
theorem append_left_nil {α : Type*} (u : Fin m → α) (v : Fin n → α) (hu : m = 0) :
    append u v = v ∘ Fin.cast (by rw [hu, Nat.zero_add])
-- Mathlib/Data/Ordmap/Ordset.lean
theorem size_balanceL {l x r} (hl : Balanced l) (hr : Balanced r) (sl : Sized l) (sr : Sized r)
    (H : (∃ l', Raised l' (size l) ∧ BalancedSz l' (size r)) ∨
        ∃ r', Raised (size r) r' ∧ BalancedSz (size l) r') :
    size (@balanceL α l x r) = size l + size r + 1
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
theorem padicNormE_lim_le {f : CauSeq ℚ_[p] norm} {a : ℝ} (ha : 0 < a) (hf : ∀ i, ‖f i‖ ≤ a) :
    ‖f.lim‖ ≤ a
-- Mathlib/Geometry/Euclidean/Basic.lean
/-- Subtracting `p` from its `orthogonalProjectionFn` produces a
result in the orthogonal direction. This lemma is only intended for
use in setting up the bundled version and should not be used once that
is defined. -/
theorem orthogonalProjectionFn_vsub_mem_direction_orthogonal {s : AffineSubspace ℝ P} [Nonempty s]
    [HasOrthogonalProjection s.direction] (p : P) :
    orthogonalProjectionFn s p -ᵥ p ∈ s.directionᗮ
-- Mathlib/Data/Set/Accumulate.lean
@[gcongr]
theorem accumulate_subset_accumulate [Preorder α] {x y} (h : x ≤ y) :
    Accumulate s x ⊆ Accumulate s y
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma eval_polynomialX_of_Z_ne_zero {P : Fin 3 → F} (hPz : P z ≠ 0) :
    eval P W.polynomialX / P z ^ 4 =
      W.toAffine.polynomialX.evalEval (P x / P z ^ 2) (P y / P z ^ 3)
-- Mathlib/CategoryTheory/Preadditive/Yoneda/Injective.lean
theorem injective_iff_preservesEpimorphisms_preadditive_yoneda_obj' (J : C) :
    Injective J ↔ (preadditiveYonedaObj J).PreservesEpimorphisms
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
@[reassoc (attr := simp)]
lemma lift_f_fst_v (p q : ℤ) (hpq : p + 1 = q) :
    (lift φ α β eq).f p ≫ (fst φ).1.v p q hpq = α.1.v p q hpq
-- Mathlib/Data/List/MinMax.lean
theorem le_maximum_of_length_pos_of_mem (h : a ∈ l) (w : 0 < l.length) :
    a ≤ l.maximum_of_length_pos w
-- Mathlib/LinearAlgebra/LinearPMap.lean
theorem ext_iff {f g : E →ₗ.[R] F} :
    f = g ↔
      ∃ _domain_eq : f.domain = g.domain,
        ∀ ⦃x : f.domain⦄ ⦃y : g.domain⦄ (_h : (x : E) = y), f x = g y
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem proj_apply (i : ι) (b : ∀ i, φ i) : (proj i : (∀ i, φ i) →L[R] φ i) b = b i
-- Mathlib/Logic/Equiv/Basic.lean
theorem swapCore_swapCore (r a b : α) : swapCore a b (swapCore a b r) = r
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
@[simp] theorem rotateLeft_replicate (n) (a : α) : rotateLeft (replicate m a) n = replicate m a
-- Mathlib/Algebra/Order/Ring/Cast.lean
lemma cast_mono : Monotone (Int.cast : ℤ → R)
-- Mathlib/RingTheory/HahnSeries/Basic.lean
@[simp]
theorem order_zero : order (0 : HahnSeries Γ R) = 0
-- Mathlib/Algebra/Polynomial/Degree/Lemmas.lean
theorem natDegree_add_le_iff_left {n : ℕ} (p q : R[X]) (qn : q.natDegree ≤ n) :
    (p + q).natDegree ≤ n ↔ p.natDegree ≤ n
-- Mathlib/Order/WithBot.lean
theorem toDual_map (f : α → β) (a : WithTop α) :
    WithTop.toDual (map f a) = WithBot.map (toDual ∘ f ∘ ofDual) (WithTop.toDual a)
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[fun_prop]
theorem differentiable_apply (i : ι) :
    Differentiable (𝕜 := 𝕜) (fun f : ∀ i, F' i => f i)
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- Taking sub-families preserves equicontinuity. -/
theorem Equicontinuous.comp {F : ι → X → α} (h : Equicontinuous F) (u : κ → ι) :
    Equicontinuous (F ∘ u)
-- Mathlib/Data/Set/Image.lean
theorem Nonempty.preimage {s : Set β} (hs : s.Nonempty) {f : α → β} (hf : Surjective f) :
    (f ⁻¹' s).Nonempty
-- Mathlib/Order/SuccPred/Limit.lean
theorem not_isSuccLimit_iff' : ¬IsSuccLimit a ↔ a ∈ range (@succ α _ _)
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem edgeSet_inf {H₁ H₂ : Subgraph G} : (H₁ ⊓ H₂).edgeSet = H₁.edgeSet ∩ H₂.edgeSet
-- Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
theorem TopCat.Presheaf.isSheaf_of_openEmbedding (h : OpenEmbedding f) (hF : F.IsSheaf) :
    IsSheaf (h.isOpenMap.functor.op ⋙ F)
-- Mathlib/Topology/Order/DenselyOrdered.lean
@[simp]
theorem frontier_Iic' {a : α} (ha : (Ioi a).Nonempty) : frontier (Iic a) = {a}
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
theorem ext {i₁ i₂ : Pos} (h : i₁.byteIdx = i₂.byteIdx) : i₁ = i₂
-- Mathlib/Order/Interval/Set/Image.lean
lemma AntitoneOn.mapsTo_Ici (h : AntitoneOn f (Ici a)) : MapsTo f (Ici a) (Iic (f a))
-- Mathlib/NumberTheory/ZetaValues.lean
/-- Explicit formula for `L(χ, 3)`, where `χ` is the unique nontrivial Dirichlet character modulo 4.
-/
theorem hasSum_L_function_mod_four_eval_three :
    HasSum (fun n : ℕ => (1 : ℝ) / (n : ℝ) ^ 3 * Real.sin (π * n / 2)) (π ^ 3 / 32)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Adding the angles between two vectors in each order, with the second vector in each angle
negated, results in 0. -/
@[simp]
theorem oangle_add_oangle_rev_neg_right (x y : V) : o.oangle x (-y) + o.oangle y (-x) = 0
-- Mathlib/Algebra/Module/Zlattice/Covolume.lean
theorem covolume_ne_zero : covolume L μ ≠ 0
-- Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat/Monoidal.lean
theorem forget₂_map_associator_hom (X Y Z : QuadraticModuleCat.{u} R) :
    (forget₂ (QuadraticModuleCat R) (ModuleCat R)).map (α_ X Y Z).hom =
      (α_ X.toModuleCat Y.toModuleCat Z.toModuleCat).hom
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_sub_const_Iio : (fun x => x - a) ⁻¹' Iio b = Iio (b + a)
-- Mathlib/Analysis/Normed/Operator/Compact.lean
theorem isCompactOperator_iff_exists_mem_nhds_isCompact_closure_image [T2Space M₂] (f : M₁ → M₂) :
    IsCompactOperator f ↔ ∃ V ∈ (𝓝 0 : Filter M₁), IsCompact (closure <| f '' V)
-- Mathlib/Data/NNReal/Basic.lean
protected theorem «exists» {p : ℝ≥0 → Prop} :
    (∃ x : ℝ≥0, p x) ↔ ∃ (x : ℝ) (hx : 0 ≤ x), p ⟨x, hx⟩
-- Mathlib/RingTheory/Polynomial/GaussLemma.lean
theorem Monic.dvd_iff_fraction_map_dvd_fraction_map [IsIntegrallyClosed R] {p q : R[X]}
    (hp : p.Monic) (hq : q.Monic) : q.map (algebraMap R K) ∣ p.map (algebraMap R K) ↔ q ∣ p
-- Mathlib/Data/Real/EReal.lean
lemma div_le_div_right_of_nonpos {a a' b : EReal} (h : b ≤ 0) (h' : a ≤ a') :
    a' / b ≤ a / b
-- Mathlib/Topology/Order.lean
theorem nhds_inf {t₁ t₂ : TopologicalSpace α} {a : α} :
    @nhds α (t₁ ⊓ t₂) a = @nhds α t₁ a ⊓ @nhds α t₂ a
-- Mathlib/CategoryTheory/Adjunction/Basic.lean
/--
If the unit and counit for the adjunction corresponding to a right adjoint functor are (pointwise)
isomorphisms, then the functor is an equivalence of categories.
-/
lemma Functor.isEquivalence_of_isRightAdjoint (G : C ⥤ D) [IsRightAdjoint G]
    [∀ X, IsIso ((Adjunction.ofIsRightAdjoint G).unit.app X)]
    [∀ Y, IsIso ((Adjunction.ofIsRightAdjoint G).counit.app Y)] : G.IsEquivalence
-- Mathlib/Order/Filter/Lift.lean
theorem lift_neBot_iff (hm : Monotone g) : (NeBot (f.lift g)) ↔ ∀ s ∈ f, NeBot (g s)
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem and_congr (h₁ : a ↔ c) (h₂ : b ↔ d) : a ∧ b ↔ c ∧ d
-- Mathlib/Algebra/Module/Submodule/Map.lean
@[simp]
lemma comap_neg {f : M →ₗ[R] M₂} {p : Submodule R M₂} :
    p.comap (-f) = p.comap f
-- Mathlib/Algebra/Group/Fin/Tuple.lean
@[simp] lemma empty_add_empty (v w : Fin 0 → α) : v + w = ![]
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem induce_self_verts : G'.induce G'.verts = G'
-- Mathlib/Order/WithBot.lean
theorem unbot'_eq_iff {d y : α} {x : WithBot α} : unbot' d x = y ↔ x = y ∨ x = ⊥ ∧ y = d
-- Mathlib/NumberTheory/ModularForms/SlashInvariantForms.lean
@[simp]
theorem SlashInvariantForm.toFun_eq_coe {f : SlashInvariantForm Γ k} : f.toFun = (f : ℍ → ℂ)
-- Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean
lemma IsRatCondKernelCDFAux.mono (hf : IsRatCondKernelCDFAux f κ ν) (a : α) :
    ∀ᵐ c ∂(ν a), Monotone (f (a, c))
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_range_eq_of_injective {α : Type u} {β : Type v} {f : α → β} (hf : Injective f) :
    lift.{u} #(range f) = lift.{v} #α
-- Mathlib/RingTheory/Bialgebra/Equiv.lean
@[simp]
theorem coe_toEquiv_trans : (e₁₂ : A ≃ B).trans e₂₃ = (e₁₂.trans e₂₃ : A ≃ C)