ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Module/Equiv/Defs.lean
/-- `SemilinearEquivClass F σ M M₂` asserts `F` is a type of bundled `σ`-semilinear equivs
`M → M₂`.

See also `LinearEquivClass F R M M₂` for the case where `σ` is the identity map on `R`.

A map `f` between an `R`-module and an `S`-module over a ring homomorphism `σ : R →+* S`
is semilinear if it satisfies the two properties `f (x + y) = f x + f y` and
`f (c • x) = (σ c) • f x`. -/
class SemilinearEquivClass (F : Type*) {R S : outParam Type*} [Semiring R] [Semiring S]
  (σ : outParam <| R →+* S) {σ' : outParam <| S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ]
  (M M₂ : outParam Type*) [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module S M₂]
  [EquivLike F M M₂]
  extends AddEquivClass F M M₂ : Prop where
  /-- Applying a semilinear equivalence `f` over `σ` to `r • x` equals `σ r • f x`. -/
  map_smulₛₗ : ∀ (f : F) (r : R) (x : M), f (r • x) = σ r • f x
-- .lake/packages/batteries/Batteries/Classes/Order.lean
/-- Local instance for `TransOrd lexOrd`. -/
theorem TransOrd.instLexOrd [Ord α] [Ord β]
    [TransOrd α] [TransOrd β] : @TransOrd (α × β) lexOrd
-- Mathlib/Analysis/Convex/Normed.lean
/-- The set of vectors in the same ray as `x` is connected. -/
theorem isConnected_setOf_sameRay (x : E) : IsConnected { y | SameRay ℝ x y }
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
@[simp] theorem cliqueFree_map_iff {f : α ↪ β} [Nonempty α] :
    (G.map f).CliqueFree n ↔ G.CliqueFree n
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem frequently_true_iff_neBot (f : Filter α) : (∃ᶠ _ in f, True) ↔ NeBot f
-- Mathlib/MeasureTheory/Integral/Layercake.lean
theorem meas_le_ae_eq_meas_lt {R : Type*} [LinearOrder R] [MeasurableSpace R]
    (ν : Measure R) [NoAtoms ν] (g : α → R) :
    (fun t => μ {a : α | t ≤ g a}) =ᵐ[ν] fun t => μ {a : α | t < g a}
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
@[simp]
theorem trans_refl (e : P₁ ≃ᵃL[k] P₂) : e.trans (refl k P₂) = e
-- Mathlib/Algebra/Polynomial/Induction.lean
@[elab_as_elim]
protected theorem induction_on {M : R[X] → Prop} (p : R[X]) (h_C : ∀ a, M (C a))
    (h_add : ∀ p q, M p → M q → M (p + q))
    (h_monomial : ∀ (n : ℕ) (a : R), M (C a * X ^ n) → M (C a * X ^ (n + 1))) : M p
-- Mathlib/Order/Filter/AtTopBot.lean
/-- The `atBot` filter for an open interval `Iic a` comes from the `atBot` filter in the ambient
order. -/
theorem atBot_Iic_eq [SemilatticeInf α] (a : α) : atBot = comap ((↑) : Iic a → α) atBot
-- Mathlib/Data/List/Cycle.lean
theorem next_mem (h : x ∈ l) : l.next x h ∈ l
-- Mathlib/Data/Multiset/Functor.lean
theorem id_traverse {α : Type*} (x : Multiset α) : traverse (pure : α → Id α) x = x
-- Mathlib/Topology/DiscreteQuotient.lean
@[simp]
theorem ofLE_proj (h : A ≤ B) (x : X) : ofLE h (A.proj x) = B.proj x
-- .lake/packages/lean4/src/lean/Init/Data/Char/Lemmas.lean
protected theorem le_total (a b : Char) : a ≤ b ∨ b ≤ a
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- Fundamental theorem of calculus-2: If `f : ℝ → E` is continuous on `[a, b]` and
  has a right derivative at `f' x` for all `x` in `[a, b)`, and `f'` is integrable on `[a, b]` then
  `∫ y in a..b, f' y` equals `f b - f a`. -/
theorem integral_eq_sub_of_hasDeriv_right (hcont : ContinuousOn f (uIcc a b))
    (hderiv : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt f (f' x) (Ioi x) x)
    (hint : IntervalIntegrable f' volume a b) : ∫ y in a..b, f' y = f b - f a
-- Mathlib/Order/Filter/Germ/Basic.lean
theorem le_def [LE β] : ((· ≤ ·) : Germ l β → Germ l β → Prop) = LiftRel (· ≤ ·)
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
theorem ofMul_toMul (x : Additive α) : ofMul (toMul x) = x
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem ContMDiffWithinAt.mono (hf : ContMDiffWithinAt I I' n f s x) (hts : t ⊆ s) :
    ContMDiffWithinAt I I' n f t x
-- Mathlib/Algebra/Group/Action/Defs.lean
@[to_additive]
lemma smul_one_smul {M} (N) [Monoid N] [SMul M N] [MulAction N α] [SMul M α]
    [IsScalarTower M N α] (x : M) (y : α) : (x • (1 : N)) • y = x • y
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
theorem map_mk_eq_bot_of_le {I J : Ideal R} (h : I ≤ J) : I.map (Quotient.mk J) = ⊥
-- Mathlib/Data/Real/Irrational.lean
theorem irrational_sqrt_of_multiplicity_odd (m : ℤ) (hm : 0 < m) (p : ℕ) [hp : Fact p.Prime]
    (Hpv :
      (multiplicity (p : ℤ) m).get (finite_int_iff.2 ⟨hp.1.ne_one, (ne_of_lt hm).symm⟩) % 2 = 1) :
    Irrational (√m)
-- Mathlib/Order/Defs.lean
theorem lt_iff_not_ge (x y : α) : x < y ↔ ¬x ≥ y
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[reassoc (attr := simp)]
theorem bicone_ι_π_ne {F : J → C} (B : Bicone F) {j j' : J} (h : j ≠ j') : B.ι j ≫ B.π j' = 0
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem inclusion_self {S : Subalgebra R A} : inclusion (le_refl S) = AlgHom.id R S
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem exists_dvd_of_not_prime2 {n : ℕ} (n2 : 2 ≤ n) (np : ¬Prime n) :
    ∃ m, m ∣ n ∧ 2 ≤ m ∧ m < n
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
protected theorem continuousAt {x} : ContinuousAt I x
-- Mathlib/LinearAlgebra/Prod.lean
@[simp] theorem fst_comp_inl : fst R M M₂ ∘ₗ inl R M M₂ = id
-- Mathlib/CategoryTheory/Bicategory/Kan/HasKan.lean
/-- We say that a 1-morphism `h` commutes with the left Kan lift `f₊ g` if the whiskered left lift
for `f₊ g` by `h` is a Kan lift of `h ≫ g` along `f`. -/
class LanLift.CommuteWith
    (f : b ⟶ a) (g : c ⟶ a) [HasLeftKanLift f g] {x : B} (h : x ⟶ c) : Prop where
  commute : Nonempty <| IsKan <| (lanLiftLeftLift f g).whisker h
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem norm_indicatorConstLp_top (hμs_ne_zero : μ s ≠ 0) :
    ‖indicatorConstLp ∞ hs hμs c‖ = ‖c‖
-- .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean
theorem coprime_comm : Coprime n m ↔ Coprime m n
-- Mathlib/Data/Matroid/Constructions.lean
theorem restrict_eq_freeOn_iff : M ↾ I = freeOn I ↔ M.Indep I
-- Mathlib/Data/Nat/Nth.lean
@[simp] theorem nth_false (n : ℕ) : nth (fun _ ↦ False) n = 0
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
/-- An elliptic curve over a commutative ring. Note that this definition is only mathematically
accurate for certain rings whose Picard group has trivial 12-torsion, such as a field or a PID. -/
@[ext]
structure EllipticCurve (R : Type u) [CommRing R] extends WeierstrassCurve R where
  /-- The discriminant `Δ'` of an elliptic curve over `R`, which is given as a unit in `R`. -/
  Δ' : Rˣ
  /-- The discriminant of `E` is equal to the discriminant of `E` as a Weierstrass curve. -/
  coe_Δ' : Δ' = toWeierstrassCurve.Δ
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToSimpleFunc_mono_left {m : MeasurableSpace α} (T T' : Set α → F →L[ℝ] G'')
    (hTT' : ∀ s x, T s x ≤ T' s x) (f : α →ₛ F) : setToSimpleFunc T f ≤ setToSimpleFunc T' f
-- Mathlib/LinearAlgebra/Matrix/ZPow.lean
@[simp, norm_cast]
theorem coe_units_zpow (u : Mˣ) : ∀ n : ℤ, ((u ^ n : Mˣ) : M) = (u : M) ^ n
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp, norm_cast]
theorem coe_snd [Module R₁ M₂] : ↑(snd R₁ M₁ M₂) = LinearMap.snd R₁ M₁ M₂
-- Mathlib/Algebra/Module/LinearMap/End.lean
theorem smulRight_apply (f : M₁ →ₗ[R] S) (x : M) (c : M₁) : smulRight f x c = f c • x
-- Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
theorem iff_of_isAffine [IsAffine Y] : P f ↔ Q f
-- Mathlib/Topology/Sets/Opens.lean
theorem comap_injective [T0Space β] : Injective (comap : C(α, β) → FrameHom (Opens β) (Opens α))
-- Mathlib/RingTheory/Polynomial/Basic.lean
lemma aeval_natDegree_le {R : Type*} [CommSemiring R] {m n : ℕ}
    (F : MvPolynomial σ R) (hF : F.totalDegree ≤ m)
    (f : σ → Polynomial R) (hf : ∀ i, (f i).natDegree ≤ n) :
    (MvPolynomial.aeval f F).natDegree ≤ m * n
-- Mathlib/Computability/Partrec.lean
protected theorem some : Partrec some
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma isPrimitive_one_level_one : IsPrimitive (1 : DirichletCharacter R 1)
-- Mathlib/MeasureTheory/Integral/Periodic.lean
/-- The integral of an almost-everywhere strongly measurable function over `UnitAddCircle` is
equal to the integral over an interval (t, t + 1] in `ℝ` of its lift to `ℝ`. -/
protected theorem intervalIntegral_preimage (t : ℝ) (f : UnitAddCircle → E) :
    ∫ a in t..t + 1, f a = ∫ b : UnitAddCircle, f b
-- Mathlib/Topology/GDelta.lean
theorem IsGδ.iInter_of_isOpen [Countable ι'] {f : ι' → Set X} (hf : ∀ i, IsOpen (f i)) :
    IsGδ (⋂ i, f i)
-- Mathlib/Order/SymmDiff.lean
theorem disjoint_symmDiff_inf : Disjoint (a ∆ b) (a ⊓ b)
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
theorem Ideal.homogeneousHull.gc : GaloisConnection (Ideal.homogeneousHull 𝒜) toIdeal
-- Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean
/-- If `f : R → ℝ` is a nonnegative, multiplicatively bounded function, then
  `seminormFromBounded' f` is nonnegative. -/
theorem seminormFromBounded_nonneg (f_nonneg : 0 ≤ f)
    (f_mul : ∀ x y : R, f (x * y) ≤ c * f x * f y)  :
    0 ≤ seminormFromBounded' f
-- Mathlib/Data/Set/Image.lean
@[simp]
theorem Nonempty.subset_preimage_const {s : Set α} (hs : Set.Nonempty s) (t : Set β) (a : β) :
    s ⊆ (fun _ => a) ⁻¹' t ↔ a ∈ t
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
theorem mono_of_kernel_iso_zero {X Y : C} {f : X ⟶ Y} [HasLimit (parallelPair f 0)]
    (w : kernel f ≅ 0) : Mono f
-- Mathlib/Algebra/Algebra/Operations.lean
protected theorem map_mul {A'} [Semiring A'] [Algebra R A'] (f : A →ₐ[R] A') :
    map f.toLinearMap (M * N) = map f.toLinearMap M * map f.toLinearMap N
-- Mathlib/Data/Matrix/Hadamard.lean
theorem dotProduct_vecMul_hadamard [DecidableEq m] [DecidableEq n] (v : m → α) (w : n → α) :
    dotProduct (v ᵥ* (A ⊙ B)) w = trace (diagonal v * A * (B * diagonal w)ᵀ)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_smul_real_right (x y : E) (r : ℝ) : ⟪x, (r : 𝕜) • y⟫ = r • ⟪x, y⟫
-- Mathlib/Analysis/Convex/Between.lean
theorem Wbtw.left_mem_image_Ici_of_right_ne {x y z : P} (h : Wbtw R x y z) (hne : z ≠ y) :
    x ∈ lineMap z y '' Set.Ici (1 : R)
-- Mathlib/CategoryTheory/Whiskering.lean
@[simp, reassoc]
theorem whiskerRight_comp {G H K : C ⥤ D} (α : G ⟶ H) (β : H ⟶ K) (F : D ⥤ E) :
    whiskerRight (α ≫ β) F = whiskerRight α F ≫ whiskerRight β F
-- Mathlib/Logic/Equiv/TransferInstance.lean
theorem algEquiv_symm_apply (e : α ≃ β) [Semiring β] [Algebra R β] (b : β) : by
    letI := Equiv.semiring e
    letI := Equiv.algebra R e
    exact (algEquiv R e).symm b = e.symm b
-- Mathlib/Data/Nat/Prime/Defs.lean
theorem Prime.pos {p : ℕ} (pp : Prime p) : 0 < p
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_unique [Unique α] (f : α → E) : ∫ x, f x ∂μ = (μ univ).toReal • f default
-- .lake/packages/lean4/src/lean/Init/Classical.lean
@[simp] theorem imp_and_neg_imp_iff (p q : Prop) : (p → q) ∧ (¬p → q) ↔ q
-- Mathlib/SetTheory/Game/PGame.lean
theorem ofLists_moveRight {L R : List PGame} (i : Fin R.length) :
    (ofLists L R).moveRight (toOfListsRightMoves i) = R.get i
-- Mathlib/Computability/Partrec.lean
theorem map {f : α →. β} {g : α → β → σ} (hf : Partrec f) (hg : Computable₂ g) :
    Partrec fun a => (f a).map (g a)
-- Mathlib/Data/Int/Cast/Lemmas.lean
/-- If two `MonoidHom`s agree on `-1` and the naturals then they are equal. -/
@[ext]
theorem ext_int {f g : ℤ →* M} (h_neg_one : f (-1) = g (-1))
    (h_nat : f.comp Int.ofNatHom.toMonoidHom = g.comp Int.ofNatHom.toMonoidHom) : f = g
-- Mathlib/Analysis/SpecialFunctions/Stirling.lean
/-- We have the bound `log (stirlingSeq n) - log (stirlingSeq (n+1))` ≤ 1/(4 n^2)
-/
theorem log_stirlingSeq_sub_log_stirlingSeq_succ (n : ℕ) :
    log (stirlingSeq (n + 1)) - log (stirlingSeq (n + 2)) ≤ 1 / (4 * (↑(n + 1) : ℝ) ^ 2)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
@[simp] theorem and_one_is_mod (x : Nat) : x &&& 1 = x % 2
-- Mathlib/Analysis/Calculus/Dslope.lean
theorem continuousOn_dslope (h : s ∈ 𝓝 a) :
    ContinuousOn (dslope f a) s ↔ ContinuousOn f s ∧ DifferentiableAt 𝕜 f a
-- Mathlib/Combinatorics/Schnirelmann.lean
lemma schnirelmannDensity_nonneg : 0 ≤ schnirelmannDensity A
-- Mathlib/LinearAlgebra/TensorProduct/Submodule.lean
theorem mulMap_comm : mulMap N M = (mulMap M N).comp (TensorProduct.comm R N M).toLinearMap
-- Mathlib/NumberTheory/Cyclotomic/Basic.lean
/-- A reformulation of `IsCyclotomicExtension` in the case `S` is a singleton. -/
theorem iff_singleton :
    IsCyclotomicExtension {n} A B ↔
      (∃ r : B, IsPrimitiveRoot r n) ∧ ∀ x, x ∈ adjoin A {b : B | b ^ (n : ℕ) = 1}
-- Mathlib/RingTheory/Perfection.lean
/-- For a perfect ring, it itself is the perfection. -/
theorem id [PerfectRing R p] : PerfectionMap p (RingHom.id R)
-- Mathlib/RingTheory/Multiplicity.lean
theorem finite_iff_dom [DecidableRel ((· ∣ ·) : α → α → Prop)] {a b : α} :
    Finite a b ↔ (multiplicity a b).Dom
-- Mathlib/RingTheory/LocalProperties.lean
theorem RingHom.ofLocalizationSpan_iff_finite :
    RingHom.OfLocalizationSpan @P ↔ RingHom.OfLocalizationFiniteSpan @P
-- Mathlib/Algebra/Order/Sub/Defs.lean
protected theorem lt_tsub_of_add_lt_right (hc : AddLECancellable c) (h : a + c < b) : a < b - c
-- Mathlib/Algebra/Module/LocalizedModule.lean
/--
If `g` is a linear map `M → M''` such that all scalar multiplication by `s : S` is invertible, then
`lift g m s = s⁻¹ • g m`.
-/
theorem lift_mk
    (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit (algebraMap R (Module.End R M'') x)) (m : M) (s : S) :
    LocalizedModule.lift S g h (LocalizedModule.mk m s) = (h s).unit⁻¹.val (g m)
-- Mathlib/Data/Vector/Basic.lean
@[simp]
theorem head_ofFn {n : ℕ} (f : Fin n.succ → α) : head (ofFn f) = f 0
-- Mathlib/Data/DFinsupp/Multiset.lean
@[simp]
theorem toDFinsupp_inter (s t : Multiset α) : toDFinsupp (s ∩ t) = toDFinsupp s ⊓ toDFinsupp t
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasStrictFDerivAt.rpow (hf : HasStrictFDerivAt f f' x) (hg : HasStrictFDerivAt g g' x)
    (h : 0 < f x) : HasStrictFDerivAt (fun x => f x ^ g x)
      ((g x * f x ^ (g x - 1)) • f' + (f x ^ g x * Real.log (f x)) • g') x
-- Mathlib/Analysis/Calculus/FDeriv/Bilinear.lean
@[fun_prop]
theorem IsBoundedBilinearMap.differentiableAt (h : IsBoundedBilinearMap 𝕜 b) (p : E × F) :
    DifferentiableAt 𝕜 b p
-- Mathlib/CategoryTheory/Sites/Coherent/LocallySurjective.lean
lemma coherentTopology.presheafIsLocallySurjective_iff {F G : Cᵒᵖ ⥤ D} (f : F ⟶ G)
    [Preregular C] [FinitaryPreExtensive C] [PreservesFiniteProducts F] [PreservesFiniteProducts G]
      [PreservesFiniteProducts (forget D)] :
        Presheaf.IsLocallySurjective (coherentTopology C) f ↔
          Presheaf.IsLocallySurjective (regularTopology C) f
-- Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
@[simp]
theorem coe_toEquiv (e : P₁ ≃ᵃL[k] P₂) : ⇑e.toEquiv = e
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
/-- For vectors `a x y : E`, the identity `⟪a, x⟫ * ω a y - ω a x * ⟪a, y⟫ = ‖a‖ ^ 2 * ω x y`. -/
theorem inner_mul_areaForm_sub (a x y : E) : ⟪a, x⟫ * ω a y - ω a x * ⟪a, y⟫ = ‖a‖ ^ 2 * ω x y
-- Mathlib/Order/Filter/CardinalInter.lean
lemma cardinalInter_ofCardinalGenerate (hc : 2 < c) :
    CardinalInterFilter (cardinalGenerate g hc) c
-- Mathlib/Topology/PartialHomeomorph.lean
theorem preimage_closure (s : Set Y) : e.source ∩ e ⁻¹' closure s = e.source ∩ closure (e ⁻¹' s)
-- Mathlib/LinearAlgebra/TensorProduct/Tower.lean
@[simp]
lemma baseChange_bot : (⊥ : Submodule R M).baseChange A = ⊥
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem fdiv_neg' : ∀ {a b : Int}, a < 0 → 0 < b → a.fdiv b < 0
-- Mathlib/Order/InitialSeg.lean
@[simp]
theorem antisymm_toFun [IsWellOrder β s] (f : r ≼i s) (g : s ≼i r) : (antisymm f g : α → β) = f
-- Mathlib/Algebra/Polynomial/UnitTrinomial.lean
theorem trinomial_monic (hkm : k < m) (hmn : m < n) : (trinomial k m n u v 1).Monic
-- Mathlib/Data/Nat/Cast/Order/Ring.lean
@[simp, norm_cast]
theorem cast_max {α} [LinearOrderedSemiring α] {a b : ℕ} : ((max a b : ℕ) : α) = max (a : α) b
-- Mathlib/Order/Fin/Basic.lean
/--  `Fin.predAbove p` as an `OrderHom`. -/
@[simps!] def predAboveOrderHom (p : Fin n) : Fin (n + 1) →o Fin n
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma b_relation : 4 * W.b₈ = W.b₂ * W.b₆ - W.b₄ ^ 2
-- Mathlib/MeasureTheory/Measure/Stieltjes.lean
theorem measure_Ici {l : ℝ} (hf : Tendsto f atTop (𝓝 l)) (x : ℝ) :
    f.measure (Ici x) = ofReal (l - leftLim f x)
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem snd_comp_prod [Module R₁ M₂] [Module R₁ M₃] (f : M₁ →L[R₁] M₂) (g : M₁ →L[R₁] M₃) :
    (snd R₁ M₂ M₃).comp (f.prod g) = g
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem IsPrime.radical_le_iff (hJ : IsPrime J) : I.radical ≤ J ↔ I ≤ J
-- Mathlib/Topology/Instances/ENNReal.lean
/-- Comparison test of convergence of `ℝ≥0`-valued series. -/
theorem exists_le_hasSum_of_le {f g : β → ℝ≥0} {r : ℝ≥0} (hgf : ∀ b, g b ≤ f b) (hfr : HasSum f r) :
    ∃ p ≤ r, HasSum g p
-- Mathlib/Data/Nat/Fib/Zeckendorf.lean
@[simp] lemma greatestFib_pos : 0 < greatestFib n ↔ 0 < n
-- Mathlib/Logic/Relation.lean
theorem TransGen.lift {p : β → β → Prop} {a b : α} (f : α → β) (h : ∀ a b, r a b → p (f a) (f b))
    (hab : TransGen r a b) : TransGen p (f a) (f b)
-- Mathlib/Analysis/Complex/Basic.lean
lemma isOpen_slitPlane : IsOpen slitPlane
-- Mathlib/Combinatorics/Configuration.lean
theorem HasLines.exists_bijective_of_card_eq [HasLines P L] [Fintype P] [Fintype L]
    (h : Fintype.card P = Fintype.card L) :
    ∃ f : L → P, Function.Bijective f ∧ ∀ l, pointCount P l = lineCount L (f l)
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp]
theorem coe_subtype : ⇑s.subtype = ((↑) : s → R)
-- Mathlib/Data/Set/Subset.lean
@[simp]
lemma image_val_union_self_right_eq : A ∪ ↑D = A
-- Mathlib/Topology/Order/Bounded.lean
@[deprecated isBoundedUnder_of (since := "2024-06-07")]
lemma Filter.isBounded_ge_map_of_bounded_range {ι : Type*} (F : Filter ι) {f : ι → ℝ}
    (h : Bornology.IsBounded (Set.range f)) :
    (F.map f).IsBounded (· ≥ ·)
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
/-- Formula for `cosZeta` as a Dirichlet series in the convergence range, with sum over `ℤ`. -/
lemma hasSum_int_cosZeta (a : ℝ) {s : ℂ} (hs : 1 < re s) :
    HasSum (fun n : ℤ ↦ cexp (2 * π * I * a * n) / ↑|n| ^ s / 2) (cosZeta a s)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem IsNormal.bsup {f : Ordinal.{max u v} → Ordinal.{max u w}} (H : IsNormal f)
    {o : Ordinal.{u}} :
    ∀ (g : ∀ a < o, Ordinal), o ≠ 0 → f (bsup.{_, v} o g) = bsup.{_, w} o fun a h => f (g a h)
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
theorem im_smul_eq_div_normSq (g : GL(2, ℝ)⁺) (z : ℍ) :
    (g • z).im = det ↑ₘg * z.im / Complex.normSq (denom g z)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem monomial_single_add : monomial (Finsupp.single n e + s) a = X n ^ e * monomial s a
-- Mathlib/Analysis/Seminorm.lean
@[simp]
theorem coe_bot : ⇑(⊥ : Seminorm 𝕜 E) = 0
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem modifyNth_eq_take_drop (f : α → α) :
    ∀ n l, modifyNth f n l = take n l ++ modifyHead f (drop n l)
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_plift_up (f : PLift ι → α) : ⨅ i, f (PLift.up i) = ⨅ i, f i
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem incl_coe : (N.incl : N →ₗ[R] M) = (N : Submodule R M).subtype
-- Mathlib/Analysis/Complex/Basic.lean
theorem hasSum_im {f : α → ℂ} {x : ℂ} (h : HasSum f x) : HasSum (fun x => (f x).im) x.im
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
theorem isUnit_iff_isUnit_val (f : HomogeneousLocalization.AtPrime 𝒜 𝔭) :
    IsUnit f.val ↔ IsUnit f
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
@[simp, norm_cast]
theorem coe_mul (z1 z2 : ℤ_[p]) : ((z1 * z2 : ℤ_[p]) : ℚ_[p]) = z1 * z2
-- Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean
/-- Use the above equivalence to prove we have a limit. -/
theorem has_over_limit_discrete_of_widePullback_limit {B : C} (F : Discrete J ⥤ Over B)
    [HasLimit (widePullbackDiagramOfDiagramOver B F)] : HasLimit F
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem negPart_map_norm (f : α →ₛ ℝ) : (negPart f).map norm = negPart f
-- Mathlib/Order/SuccPred/Limit.lean
theorem not_isSuccLimit_of_noMax [NoMinOrder α] [NoMaxOrder α] : ¬IsSuccLimit a
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean
theorem contDiffAt_arcsin {x : ℝ} (h₁ : x ≠ -1) (h₂ : x ≠ 1) {n : ℕ∞} : ContDiffAt ℝ n arcsin x
-- Mathlib/Data/Set/Lattice.lean
@[simp]
theorem sInter_range (f : ι → Set β) : ⋂₀ range f = ⋂ x, f x
-- Mathlib/Algebra/Order/Monoid/Unbundled/Defs.lean
theorem covariantClass_le_of_lt [PartialOrder N] [CovariantClass M N μ (· < ·)] :
    CovariantClass M N μ (· ≤ ·)
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem HasFDerivWithinAt.continuousMultilinear_apply_const (hc : HasFDerivWithinAt c c' s x)
    (u : ∀ i, M i) :
    HasFDerivWithinAt (fun y ↦ (c y) u) (c'.flipMultilinear u) s x
-- Mathlib/Analysis/Normed/Operator/Compact.lean
theorem IsCompactOperator.image_subset_compact_of_isVonNBounded {f : M₁ →ₛₗ[σ₁₂] M₂}
    (hf : IsCompactOperator f) {S : Set M₁} (hS : IsVonNBounded 𝕜₁ S) :
    ∃ K : Set M₂, IsCompact K ∧ f '' S ⊆ K
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
theorem toMul_ofMul (x : α) : toMul (ofMul x) = x
-- Mathlib/RingTheory/RingHom/Integral.lean
theorem isIntegral_respectsIso : RespectsIso fun f => f.IsIntegral
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem smul_coeff_order_add_order {Γ} [LinearOrderedCancelAddCommMonoid Γ] [Zero R]
    [SMulWithZero R V] (x : HahnSeries Γ R) (y : HahnModule Γ R V) :
    ((of R).symm (x • y)).coeff (x.order + ((of R).symm y).order) =
    x.leadingCoeff • ((of R).symm y).leadingCoeff
-- Mathlib/Analysis/Fourier/AddCircle.lean
/-- Under the isometric isomorphism `fourierBasis` from `Lp ℂ 2 haarAddCircle` to `ℓ²(ℤ, ℂ)`, the
`i`-th coefficient is `fourierCoeff f i`, i.e., the integral over `AddCircle T` of
`fun t => fourier (-i) t * f t` with respect to the Haar measure of total mass 1. -/
theorem fourierBasis_repr (f : Lp ℂ 2 <| @haarAddCircle T hT) (i : ℤ) :
    fourierBasis.repr f i = fourierCoeff f i
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem forall_prop_of_false {p : Prop} {q : p → Prop} (hn : ¬p) : (∀ h' : p, q h') ↔ True
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- `F⟮x⟯ / F` is a purely inseparable extension if and only if the mininal polynomial of `x`
has separable degree one. -/
theorem isPurelyInseparable_adjoin_simple_iff_natSepDegree_eq_one {x : E} :
    IsPurelyInseparable F F⟮x⟯ ↔ (minpoly F x).natSepDegree = 1
-- Mathlib/Data/Finsupp/Lex.lean
theorem lex_lt_of_lt [PartialOrder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
    Pi.Lex r (· < ·) x y
-- Mathlib/Topology/Irreducible.lean
/-- A set is preirreducible if and only if
for every cover by two closed sets, it is contained in one of the two covering sets. -/
theorem isPreirreducible_iff_closed_union_closed :
    IsPreirreducible s ↔
      ∀ z₁ z₂ : Set X, IsClosed z₁ → IsClosed z₂ → s ⊆ z₁ ∪ z₂ → s ⊆ z₁ ∨ s ⊆ z₂
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean
theorem condexp_condexp_of_le {m₁ m₂ m0 : MeasurableSpace α} {μ : Measure α} (hm₁₂ : m₁ ≤ m₂)
    (hm₂ : m₂ ≤ m0) [SigmaFinite (μ.trim hm₂)] : μ[μ[f|m₂]|m₁] =ᵐ[μ] μ[f|m₁]
-- Mathlib/Analysis/RCLike/Basic.lean
theorem re_eq_norm_of_mul_conj (x : K) : re (x * conj x) = ‖x * conj x‖
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem UpperSet.iInf_Ici (s : Set α) : ⨅ a ∈ s, UpperSet.Ici a = upperClosure s
-- Mathlib/Data/Nat/Choose/Sum.lean
theorem sum_range_choose_halfway (m : Nat) : (∑ i ∈ range (m + 1), choose (2 * m + 1) i) = 4 ^ m
-- Mathlib/Algebra/Group/Fin/Tuple.lean
@[simp] lemma head_neg (a : Fin n.succ → α) : vecHead (-a) = -vecHead a
-- Mathlib/Topology/Instances/ENNReal.lean
lemma continuousOn_toReal : ContinuousOn ENNReal.toReal { a | a ≠ ∞ }
-- Mathlib/LinearAlgebra/QuadraticForm/Prod.lean
@[simp]
lemma Isometry.snd_comp_inr (Q₂ : QuadraticMap R M₂ P) :
    (snd M₁ Q₂).comp (inr (0 : QuadraticMap R M₁ P) Q₂) = .id _
-- Mathlib/Data/Nat/Choose/Sum.lean
theorem sum_antidiagonal_choose_add (d n : ℕ) :
    (Finset.sum (antidiagonal n) fun ij => (d + ij.2).choose d) =
    (d + n).choose d + (d + n).choose (succ d)
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem lowerClosure_sUnion (S : Set (Set α)) : lowerClosure (⋃₀ S) = ⨆ s ∈ S, lowerClosure s