ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Set/Image.lean
theorem range_comp_subset_range (f : α → β) (g : β → γ) : range (g ∘ f) ⊆ range g
-- Mathlib/Topology/Order/OrderClosed.lean
@[simp]
theorem nhdsWithin_Ioc_eq_nhdsWithin_Iic (h : a < b) : 𝓝[Ioc a b] b = 𝓝[≤] b
-- Mathlib/Order/Interval/Multiset.lean
@[simp] lemma mem_Ioc : x ∈ Ioc a b ↔ a < x ∧ x ≤ b
-- Mathlib/Logic/Function/Defs.lean
theorem leftInverse_of_surjective_of_rightInverse {f : α → β} {g : β → α} (surjf : Surjective f)
    (rfg : RightInverse f g) : LeftInverse f g
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1_mono {T : Set α → G' →L[ℝ] G''} {C : ℝ} (hT : DominatedFinMeasAdditive μ T C)
    (hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) {f g : α →₁[μ] G'}
    (hfg : f ≤ g) : setToL1 hT f ≤ setToL1 hT g
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
theorem toIdeal_iInf₂ {κ : Sort*} {κ' : κ → Sort*} (s : ∀ i, κ' i → HomogeneousIdeal 𝒜) :
    (⨅ (i) (j), s i j).toIdeal = ⨅ (i) (j), (s i j).toIdeal
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem mem_toSubalgebra {p : Submodule R A} {h_one h_mul} {x} :
    x ∈ p.toSubalgebra h_one h_mul ↔ x ∈ p
-- Mathlib/Data/ULift.lean
@[simp] lemma map_surjective : Surjective (PLift.map f) ↔ Surjective f
-- Mathlib/Analysis/Normed/Group/HomCompletion.lean
/-- The map from a normed group to its completion, as a normed group hom. -/
@[simps] -- Porting note: added `@[simps]`
def NormedAddCommGroup.toCompl : NormedAddGroupHom G (Completion G)
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem iSup_lt_of_isRegular {ι} {f : ι → Cardinal} {c} (hc : IsRegular c) (hι : #ι < c) :
    (∀ i, f i < c) → iSup f < c
-- Mathlib/Data/Int/ModEq.lean
theorem mod_coprime {a b : ℕ} (hab : Nat.Coprime a b) : ∃ y : ℤ, a * y ≡ 1 [ZMOD b]
-- Mathlib/NumberTheory/LucasLehmer.lean
/-- `q` is the minimum factor of `mersenne p`, so `M p = 0` in `X q`. -/
theorem mersenne_coe_X (p : ℕ) : (mersenne p : X (q p)) = 0
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem coeIdeal_inj' (h : S ≤ nonZeroDivisors R) {I J : Ideal R} :
    (I : FractionalIdeal S P) = J ↔ I = J
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
@[to_additive contMDiffWithinAt_of_not_mem]
theorem contMDiffWithinAt_of_not_mem_mulTSupport {f : M → M'} [One M'] {x : M}
    (hx : x ∉ mulTSupport f) (n : ℕ∞) (s : Set M) : ContMDiffWithinAt I I' n f s x
-- Mathlib/Algebra/Module/LinearMap/Prod.lean
theorem isLinearMap_add [AddCommMonoid M] [Module R M] :
    IsLinearMap R fun x : M × M => x.1 + x.2
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem contDiffOn_pi : ContDiffOn 𝕜 n Φ s ↔ ∀ i, ContDiffOn 𝕜 n (fun x => Φ x i) s
-- .lake/packages/lean4/src/lean/Init/Omega/Constraint.lean
theorem tidy_sat {s x v} (w : s.sat' x v) : (tidyConstraint s x).sat' (tidyCoeffs s x) v
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem Pairwise.insert_of_symmetric (hs : s.Pairwise r) (hr : Symmetric r)
    (h : ∀ b ∈ s, a ≠ b → r a b) : (insert a s).Pairwise r
-- Mathlib/Data/Setoid/Partition.lean
theorem disjoint : Pairwise fun i j => Disjoint (s i) (s j)
-- Mathlib/Data/List/Basic.lean
theorem append_right_injective (s : List α) : Injective fun t ↦ s ++ t
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean
@[simp]
theorem pullbackConeOfRightIso_π_app_left : (pullbackConeOfRightIso f g).π.app left = 𝟙 _
-- Mathlib/Data/Finset/Sort.lean
@[simp]
theorem sort_sorted (s : Finset α) : List.Sorted r (sort r s)
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem mono_measure (hf : IntervalIntegrable f ν a b) (h : μ ≤ ν) : IntervalIntegrable f μ a b
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem contDiffOn_prod {t : Finset ι} {f : ι → E → 𝔸'} (h : ∀ i ∈ t, ContDiffOn 𝕜 n (f i) s) :
    ContDiffOn 𝕜 n (fun y => ∏ i ∈ t, f i y) s
-- Mathlib/Data/Finset/Card.lean
@[simp]
theorem card_attach : s.attach.card = s.card
-- Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean
theorem le_rank_iff_exists_linearIndependent [Module.Free K V] {c : Cardinal} :
    c ≤ Module.rank K V ↔ ∃ s : Set V, #s = c ∧ LinearIndependent K ((↑) : s → V)
-- Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean
theorem Gamma_eq_integral {s : ℂ} (hs : 0 < s.re) : Gamma s = GammaIntegral s
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
@[simp]
lemma cfcₙ_zero : cfcₙ (0 : R → R) a = 0
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma IsMeasurableRatCDF.iInf_rat_gt_eq {f : α → ℚ → ℝ} (hf : IsMeasurableRatCDF f) (a : α)
    (q : ℚ) :
    ⨅ r : Ioi q, f a r = f a q
-- Mathlib/RingTheory/PrimeSpectrum.lean
@[simp]
theorem vanishingIdeal_singleton (x : PrimeSpectrum R) :
    vanishingIdeal ({x} : Set (PrimeSpectrum R)) = x.asIdeal
-- Mathlib/Order/SuccPred/Basic.lean
theorem le_succ : ∀ a : α, a ≤ succ a
-- Mathlib/Analysis/Seminorm.lean
@[simp]
theorem zero_apply (x : E) : (0 : Seminorm 𝕜 E) x = 0
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
lemma cyclesMap'_eq : cyclesMap' φ h₁.left h₂.left = γ.left.φK
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem preimage_sphere (x : E) (r : ℝ) : f ⁻¹' Metric.sphere (f x) r = Metric.sphere x r
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem enum_nil : ([] : List α).enum = []
-- Mathlib/Deprecated/Subgroup.lean
theorem Multiplicative.isNormalSubgroup_iff [AddGroup A] {s : Set A} :
    @IsNormalSubgroup (Multiplicative A) _ s ↔ IsNormalAddSubgroup s
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lcm.lean
@[simp] theorem lcm_self (m : Nat) : lcm m m = m
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[measurability, fun_prop]
theorem AEMeasurable.coe_nnreal_ennreal {f : α → ℝ≥0} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => (f x : ℝ≥0∞)) μ
-- Mathlib/Algebra/Homology/HomologySequence.lean
@[reassoc (attr := simp)]
lemma opcyclesToCycles_naturality :
    opcyclesMap φ i ≫ opcyclesToCycles L i j = opcyclesToCycles K i j ≫ cyclesMap φ j
-- Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Basic.lean
@[simp]
theorem BinaryFan.assoc_snd {X Y Z : C} {sXY : BinaryFan X Y} {sYZ : BinaryFan Y Z}
    (Q : IsLimit sYZ) (s : BinaryFan sXY.pt Z) :
    (BinaryFan.assoc Q s).snd = Q.lift (BinaryFan.mk (s.fst ≫ sXY.snd) s.snd)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- A combination of two points expressed with `lineMap` lies in their affine span. -/
theorem AffineMap.lineMap_mem_affineSpan_pair (r : k) (p₁ p₂ : P) :
    AffineMap.lineMap p₁ p₂ r ∈ line[k, p₁, p₂]
-- Mathlib/Algebra/Ring/BooleanRing.lean
@[simp]
theorem toBoolAlg_zero : toBoolAlg (0 : α) = ⊥
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Bitblast.lean
theorem ule_eq_not_ult (x y : BitVec w) : x.ule y = !y.ult x
-- Mathlib/Order/RelSeries.lean
theorem length_ne_zero_of_nontrivial (h : {x | x ∈ s}.Nontrivial) : s.length ≠ 0
-- Mathlib/RingTheory/Ideal/Basic.lean
protected theorem sub_mem : a ∈ I → b ∈ I → a - b ∈ I
-- Mathlib/Data/Matrix/Basic.lean
theorem vecMulVec_apply [Mul α] (w : m → α) (v : n → α) (i j) : vecMulVec w v i j = w i * v j
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem map_rel (φ : M →[L] N) {n : ℕ} (r : L.Relations n) (x : Fin n → M) :
    RelMap r x → RelMap r (φ ∘ x)
-- Mathlib/Algebra/Algebra/Defs.lean
/-- This is just a special case of the global `smul_mul_assoc` lemma that requires less typeclass
search (and was here first). -/
@[simp]
protected theorem smul_mul_assoc (r : R) (x y : A) : r • x * y = r • (x * y)
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma eventually_one_sub_smoothingFn_nonneg : ∀ᶠ (n : ℕ) in atTop, 0 ≤ 1 - ε n
-- Mathlib/Data/Fin/Basic.lean
theorem last_pos' [NeZero n] : 0 < last n
-- Mathlib/Topology/Sheaves/Skyscraper.lean
/-- The counit in `Presheaf.stalkFunctor ⊣ skyscraperPresheafFunctor`
-/
@[simps]
protected def counit :
    skyscraperPresheafFunctor p₀ ⋙ (Presheaf.stalkFunctor C p₀ : Presheaf C X ⥤ C) ⟶ 𝟭 C
-- Mathlib/Logic/Equiv/PartialEquiv.lean
protected theorem surjOn : SurjOn e e.source e.target
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma mul_eq_one_iff_eq_inv₀ (hb : b ≠ 0) : a * b = 1 ↔ a = b⁻¹
-- Mathlib/Order/Heyting/Basic.lean
/-- `(q → r) → (p → q) → q → r` -/
theorem himp_le_himp_himp_himp : b ⇨ c ≤ (a ⇨ b) ⇨ a ⇨ c
-- Mathlib/Data/Finset/Sups.lean
theorem disjSups_union_right : s ○ (t₁ ∪ t₂) = s ○ t₁ ∪ s ○ t₂
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem any_iff (s : String) (p : Char → Bool) : any s p ↔ ∃ c ∈ s.1, p c
-- Mathlib/Computability/Primrec.lean
theorem ulower_up : Primrec (ULower.up : ULower α → α)
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
/-- Binary **rearrangement inequality**. -/
lemma mul_add_mul_lt_mul_add_mul' [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (· + ·) (· < ·)] [ContravariantClass α α (· + ·) (· < ·)]
    (hba : b < a) (hdc : d < c) : a * d + b * c < a * c + b * d
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
@[simp]
theorem prod_zero (μ : Measure α) : μ.prod (0 : Measure β) = 0
-- Mathlib/Analysis/NormedSpace/QuaternionExponential.lean
/-- Note that this implies that exponentials of pure imaginary quaternions are unit quaternions
since in that case the RHS is `1` via `NormedSpace.exp_zero` and `norm_one`. -/
@[simp]
theorem norm_exp (q : ℍ[ℝ]) : ‖exp ℝ q‖ = ‖exp ℝ q.re‖
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
@[reassoc (attr := simp)]
lemma restrictStalkIso_inv_eq_germ :
    X.presheaf.germ ⟨f x, show f x ∈ h.isOpenMap.functor.obj V from ⟨x, hx, rfl⟩⟩ ≫
      (X.restrictStalkIso h x).inv = (X.restrict h).presheaf.germ ⟨x, hx⟩
-- Mathlib/Algebra/AddConstMap/Equiv.lean
/-- Projection from `G ≃+c[a, a] G` to permutations `G ≃ G`, as a monoid homomorphism. -/
@[simps! apply]
def toPerm : (G ≃+c[a, a] G) →* Equiv.Perm G
-- Mathlib/Data/Setoid/Partition.lean
theorem exists_mem (x : α) : ∃ i, x ∈ s i
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
theorem _root_.Matrix.separatingLeft_toLinearMap₂'_iff_separatingLeft_toLinearMap₂
    {M : Matrix ι ι R₁} (b : Basis ι R₁ M₁) :
    (Matrix.toLinearMap₂' R₁ M).SeparatingLeft (R := R₁) ↔
      (Matrix.toLinearMap₂ b b M).SeparatingLeft
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
@[simp] theorem liftOrGet_none_left {f} {b : Option α} : liftOrGet f none b = b
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem get_append_left {as bs : Array α} {h : i < (as ++ bs).size} (hlt : i < as.size) :
    (as ++ bs)[i] = as[i]
-- Mathlib/Tactic/Ring/RingNF.lean
theorem add_neg {R} [Ring R] (a b : R) : a + -b = a - b
-- Mathlib/RingTheory/Kaehler/Basic.lean
@[simp]
theorem KaehlerDifferential.mapBaseChange_tmul (x : B) (y : Ω[A⁄R]) :
    KaehlerDifferential.mapBaseChange R A B (x ⊗ₜ y) = x • KaehlerDifferential.map R R A B y
-- Mathlib/Algebra/Module/LocalizedModule.lean
theorem mk'_add (m₁ m₂ : M) (s : S) : mk' f (m₁ + m₂) s = mk' f m₁ s + mk' f m₂ s
-- Mathlib/Order/SupIndep.lean
theorem Independent.comp' {ι ι' : Sort*} {t : ι → α} {f : ι' → ι} (ht : Independent <| t ∘ f)
    (hf : Surjective f) : Independent t
-- Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
theorem coverDense_inducedFunctor {B : ι → Opens X} (h : Opens.IsBasis (Set.range B)) :
    (inducedFunctor B).IsCoverDense (Opens.grothendieckTopology X)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem sInf_eq_argmin_on (hs : s.Nonempty) : sInf s = argminOn id wellFounded_lt s hs
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_pow (f : R → R) (n : ℕ) (a : A)
    (hf : ContinuousOn f (spectrum R a) := by cfc_cont_tac) (ha : p a := by cfc_tac) :
    cfc (fun x ↦ (f x) ^ n) a = cfc f a ^ n
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem principal_nfp_blsub₂ (op : Ordinal → Ordinal → Ordinal) (o : Ordinal) :
    Principal op (nfp (fun o' => blsub₂.{u, u, u} o' o' (@fun a _ b _ => op a b)) o)
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
@[simp]
theorem Γ_map {X Y : LocallyRingedSpace.{u}ᵒᵖ} (f : X ⟶ Y) : Γ.map f = f.unop.1.c.app (op ⊤)
-- Mathlib/FieldTheory/Minpoly/MinpolyDiv.lean
lemma eval_minpolyDiv_of_aeval_eq_zero [IsDomain S] [DecidableEq S]
    {y} (hy : aeval y (minpoly R x) = 0) :
    (minpolyDiv R x).eval y = if x = y then aeval x (derivative <| minpoly R x) else 0
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
@[simp] lemma prob_compl_eq_zero_iff₀ (hs : NullMeasurableSet s μ) : μ sᶜ = 0 ↔ μ s = 1
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma exact_iff_kernel_ι_comp_cokernel_π_zero [S.HasHomology]
    [HasKernel S.g] [HasCokernel S.f] :
    S.Exact ↔ kernel.ι S.g ≫ cokernel.π S.f = 0
-- Mathlib/Algebra/Algebra/Pi.lean
@[simp]
theorem piCongrRight_refl {R ι : Type*} {A : ι → Type*} [CommSemiring R] [∀ i, Semiring (A i)]
    [∀ i, Algebra R (A i)] :
    (piCongrRight fun i => (AlgEquiv.refl : A i ≃ₐ[R] A i)) = AlgEquiv.refl
-- Mathlib/Analysis/Seminorm.lean
theorem coe_add (p q : Seminorm 𝕜 E) : ⇑(p + q) = p + q
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem _root_.Set.smul_mem_centralizer {s : Set A} (r : R) {a : A} (ha : a ∈ s.centralizer) :
    r • a ∈ s.centralizer
-- Mathlib/GroupTheory/Perm/Support.lean
theorem zpow_apply_mem_support {n : ℤ} {x : α} : (f ^ n) x ∈ f.support ↔ x ∈ f.support
-- Mathlib/Data/Multiset/Fintype.lean
@[simp] lemma map_toEnumFinset_fst (m : Multiset α) : m.toEnumFinset.val.map Prod.fst = m
-- Mathlib/Order/Lattice.lean
theorem inf_eq_minDefault [SemilatticeInf α] [DecidableRel ((· ≤ ·) : α → α → Prop)]
    [IsTotal α (· ≤ ·)] :
    (· ⊓ ·) = (minDefault : α → α → α)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem _root_.Embedding.aestronglyMeasurable_comp_iff [PseudoMetrizableSpace β]
    [PseudoMetrizableSpace γ] {g : β → γ} {f : α → β} (hg : Embedding g) :
    AEStronglyMeasurable (fun x => g (f x)) μ ↔ AEStronglyMeasurable f μ
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
@[simp] lemma truncatedInf_empty (a : α) : truncatedInf ∅ a = ⊥
-- Mathlib/Topology/Category/LightProfinite/AsLimit.lean
lemma proj_surjective (n : ℕ) : Function.Surjective (S.proj n)
-- Mathlib/Data/DFinsupp/Multiset.lean
@[simp]
theorem toMultiset_toDFinsupp (f : Π₀ _ : α, ℕ) :
    Multiset.toDFinsupp (DFinsupp.toMultiset f) = f
-- Mathlib/LinearAlgebra/Prod.lean
theorem inr_injective : Function.Injective (inr R M M₂)
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
theorem norm_le_convexBodySumFun (x : E K) : ‖x‖ ≤ convexBodySumFun x
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem map_X (h : IsAdjoinRoot S f) : h.map X = h.root
-- Mathlib/Data/Finset/Basic.lean
@[simp] lemma forall_mem_not_eq {s : Finset α} {a : α} : (∀ b ∈ s, ¬ a = b) ↔ a ∉ s
-- Mathlib/CategoryTheory/Opposites.lean
@[simp]
theorem unop_id_op {X : C} : (𝟙 (op X)).unop = 𝟙 X
-- Mathlib/GroupTheory/Nilpotent.lean
/-- If a finite group is the direct product of its Sylow groups, it is nilpotent -/
theorem isNilpotent_of_product_of_sylow_group
    (e : (∀ p : (Nat.card G).primeFactors, ∀ P : Sylow p G, (↑P : Subgroup G)) ≃* G) :
    IsNilpotent G
-- Mathlib/Order/CompleteLattice.lean
lemma sSup_eq_bot' {s : Set α} : sSup s = ⊥ ↔ s = ∅ ∨ s = {⊥}
-- Mathlib/CategoryTheory/Subterminal.lean
/-- If the unique morphism from `A` to the terminal object is a monomorphism, `A` is subterminal.
The converse of `IsSubterminal.mono_terminal_from`.
-/
theorem isSubterminal_of_mono_terminal_from [HasTerminal C] [Mono (terminal.from A)] :
    IsSubterminal A
-- Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean
@[simp]
theorem leftUnitor_hom_apply {M : ModuleCat.{u} R} (r : R) (m : M) :
    ((λ_ M).hom : 𝟙_ (ModuleCat R) ⊗ M ⟶ M) (r ⊗ₜ[R] m) = r • m
-- Mathlib/RingTheory/Finiteness.lean
/-- If a free module is finite, then any arbitrary basis is finite. -/
lemma Module.Finite.finite_basis {R M} [Ring R] [Nontrivial R] [AddCommGroup M] [Module R M]
    {ι} [Module.Finite R M] (b : Basis ι R M) :
    _root_.Finite ι
-- Mathlib/Analysis/Calculus/InverseFunctionTheorem/FDeriv.lean
theorem localInverse_unique (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) {g : F → E}
    (hg : ∀ᶠ x in 𝓝 a, g (f x) = x) : ∀ᶠ y in 𝓝 (f a), g y = localInverse f f' a hf y
-- Mathlib/Order/Filter/Ultrafilter.lean
theorem mem_or_compl_mem (f : Ultrafilter α) (s : Set α) : s ∈ f ∨ sᶜ ∈ f
-- Mathlib/Data/NNRat/Defs.lean
@[simp]
theorem coe_coeHom : ⇑coeHom = ((↑) : ℚ≥0 → ℚ)
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma SMulPosReflectLT.toSMulPosMono [SMulPosReflectLT α β] : SMulPosMono α β
-- Mathlib/Order/Ideal.lean
theorem _root_.IsCoatom.isMaximal (hI : IsCoatom I) : IsMaximal I
-- Mathlib/Order/Atoms.lean
theorem exists_le_covBy_of_lt [IsStronglyCoatomic α] (h : a < b) : ∃ x, a ≤ x ∧ x ⋖ b
-- Mathlib/Analysis/Convex/Gauge.lean
theorem interior_subset_gauge_lt_one (s : Set E) : interior s ⊆ { x | gauge s x < 1 }
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
protected theorem Nat.lt_of_le_of_lt {n m k : Nat} (h₁ : LE.le n m) (h₂ : LT.lt m k) : LT.lt n k
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
theorem map_units (f : LocalizationMap S N) (y : S) : IsUnit (f.toMap y)
-- Mathlib/Data/Nat/Defs.lean
lemma le_and_le_add_one_iff : n ≤ m ∧ m ≤ n + 1 ↔ m = n ∨ m = n + 1
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem lt_iff : μ < ν ↔ μ ≤ ν ∧ ∃ s, MeasurableSet s ∧ μ s < ν s
-- Mathlib/Analysis/Analytic/Constructions.lean
/-- Scalar multiplication is analytic (jointly in both variables). The statement is a little
pedantic to allow towers of field extensions.

TODO: can we replace `𝕜'` with a "normed module" in such a way that `analyticAt_mul` is a special
case of this? -/
lemma analyticAt_smul [NormedSpace 𝕝 E] [IsScalarTower 𝕜 𝕝 E] (z : 𝕝 × E) :
    AnalyticAt 𝕜 (fun x : 𝕝 × E ↦ x.1 • x.2) z
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean
@[simp]
theorem toSubgraph_rotate [DecidableEq V] (c : G.Walk v v) (h : u ∈ c.support) :
    (c.rotate h).toSubgraph = c.toSubgraph
-- Mathlib/Logic/Equiv/PartialEquiv.lean
/-- Two equivalent partial equivs have the same source. -/
theorem EqOnSource.source_eq {e e' : PartialEquiv α β} (h : e ≈ e') : e.source = e'.source
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
/-- An almost everywhere sequential limit of almost everywhere strongly measurable functions is
almost everywhere strongly measurable. -/
theorem _root_.aestronglyMeasurable_of_tendsto_ae {ι : Type*} [PseudoMetrizableSpace β]
    (u : Filter ι) [NeBot u] [IsCountablyGenerated u] {f : ι → α → β} {g : α → β}
    (hf : ∀ i, AEStronglyMeasurable (f i) μ) (lim : ∀ᵐ x ∂μ, Tendsto (fun n => f n x) u (𝓝 (g x))) :
    AEStronglyMeasurable g μ
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem castLE_of_eq {m n : Nat} (h : m = n) {h' : m ≤ n} : castLE h' = Fin.cast h
-- Mathlib/Probability/Process/Filtration.lean
@[norm_cast]
theorem coeFn_inf {f g : Filtration ι m} : ⇑(f ⊓ g) = ⇑f ⊓ ⇑g
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
/-- If `d₁ < d₂`, then for any set `s` we have either `μH[d₂] s = 0`, or `μH[d₁] s = ∞`. -/
theorem hausdorffMeasure_zero_or_top {d₁ d₂ : ℝ} (h : d₁ < d₂) (s : Set X) :
    μH[d₂] s = 0 ∨ μH[d₁] s = ∞
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_generateFrom [MeasurableSpace α] {s : Set (Set β)} {f : α → β}
    (h : ∀ t ∈ s, MeasurableSet (f ⁻¹' t)) : @Measurable _ _ _ (generateFrom s) f
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
lemma subsingleton (hx : 0 ∈ x) : Subsingleton (HomogeneousLocalization 𝒜 x)
-- Mathlib/Topology/Instances/Int.lean
theorem dist_eq (x y : ℤ) : dist x y = |(x : ℝ) - y|
-- Mathlib/MeasureTheory/Constructions/Pi.lean
@[simp]
theorem pi_pi (s : ∀ i, Set (α i)) : Measure.pi μ (pi univ s) = ∏ i, μ i (s i)
-- Mathlib/Data/Set/Semiring.lean
@[simp]
theorem _root_.Set.up_empty : Set.up (∅ : Set α) = 0
-- Mathlib/Topology/Inseparable.lean
/-- A set is stable under generalization iff it is an intersection of open sets. -/
lemma stableUnderGeneralization_iff_exists_sInter_eq {s : Set X} :
    StableUnderGeneralization s ↔ ∃ (S : Set (Set X)), (∀ s ∈ S, IsOpen s) ∧ ⋂₀ S = s
-- Mathlib/Analysis/Convex/Uniform.lean
theorem exists_forall_closed_ball_dist_add_le_two_sub (hε : 0 < ε) :
    ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ ≤ 1 → ∀ ⦃y⦄, ‖y‖ ≤ 1 → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 - δ
-- Mathlib/CategoryTheory/Preadditive/FunctorCategory.lean
@[simp]
theorem app_nsmul (X : C) (α : F ⟶ G) (n : ℕ) : (n • α).app X = n • α.app X
-- Mathlib/RingTheory/WittVector/Defs.lean
@[simp]
theorem constantCoeff_wittNeg (n : ℕ) : constantCoeff (wittNeg p n) = 0
-- Mathlib/AlgebraicTopology/TopologicalSimplex.lean
@[ext]
theorem toTopObj.ext {x : SimplexCategory} (f g : x.toTopObj) : (f : x → ℝ≥0) = g → f = g
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem total_unique [Unique α] (l : α →₀ R) (v) :
    Finsupp.total α M R v l = l default • v default
-- Mathlib/Topology/Connected/Basic.lean
theorem isPreconnected_iff_preconnectedSpace {s : Set α} : IsPreconnected s ↔ PreconnectedSpace s
-- Mathlib/RingTheory/Generators.lean
@[simp]
lemma Hom.comp_id (f : Hom P P') : f.comp (Hom.id P) = f
-- Mathlib/LinearAlgebra/DirectSum/Finsupp.lean
@[simp]
lemma finsuppLeft_apply_tmul_apply (p : ι →₀ M) (n : N) (i : ι) :
    finsuppLeft R M N ι (p ⊗ₜ[R] n) i = p i ⊗ₜ[R] n
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
@[simp]
theorem kahler_rightAngleRotation_left (x y : E) :
    o.kahler (J x) y = -Complex.I * o.kahler x y
-- Mathlib/Data/Multiset/Basic.lean
theorem cons_le_cons_iff (a : α) : a ::ₘ s ≤ a ::ₘ t ↔ s ≤ t
-- Mathlib/RingTheory/PowerSeries/Basic.lean
@[simp]
theorem coeff_X_pow_self (n : ℕ) : coeff R n ((X : R⟦X⟧) ^ n) = 1
-- Mathlib/RingTheory/Perfection.lean
theorem map_map {π : P →+* R} (m : PerfectionMap p π) {σ : Q →+* S} (n : PerfectionMap p σ)
    (φ : R →+* S) (x : P) : σ (map p m n φ x) = φ (π x)
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem sup_eq_union : ((· ⊔ ·) : Set α → Set α → Set α) = (· ∪ ·)
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
@[simp]
theorem ofPiFork_π_app_right (c : Fork I.fstPiMap I.sndPiMap) (a) :
    (ofPiFork I c).π.app (WalkingMulticospan.right a) = c.ι ≫ I.fstPiMap ≫ Pi.π _ _
-- Mathlib/Combinatorics/SimpleGraph/Metric.lean
lemma Reachable.of_dist_ne_zero (h : G.dist u v ≠ 0) : G.Reachable u v
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem ite_false (a b : α) : (if False then a else b) = b
-- Mathlib/Combinatorics/SetFamily/Intersecting.lean
theorem intersecting_iff_pairwise_not_disjoint :
    s.Intersecting ↔ (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
-- Mathlib/Order/Closure.lean
@[simp]
theorem closure_iSup₂_closure (f : ∀ i, κ i → α) :
    c (⨆ (i) (j), c (f i j)) = c (⨆ (i) (j), f i j)
-- Mathlib/Analysis/Normed/Group/ControlledClosure.lean
/-- Given `f : NormedAddGroupHom G H` for some complete `G` and a subgroup `K` of `H`, if every
element `x` of `K` has a preimage under `f` whose norm is at most `C*‖x‖` then the same holds for
elements of the (topological) closure of `K` with constant `C+ε` instead of `C`, for any
positive `ε`.
-/
theorem controlled_closure_of_complete {f : NormedAddGroupHom G H} {K : AddSubgroup H} {C ε : ℝ}
    (hC : 0 < C) (hε : 0 < ε) (hyp : f.SurjectiveOnWith K C) :
    f.SurjectiveOnWith K.topologicalClosure (C + ε)
-- Mathlib/RingTheory/WittVector/FrobeniusFractionField.lean
theorem solution_spec (a₁ a₂ : 𝕎 k) : solution p a₁ a₂ ^ (p - 1) = a₂.coeff 0 / a₁.coeff 0
-- Mathlib/Geometry/RingedSpace/PresheafedSpace/HasColimits.lean
@[simp]
theorem map_comp_c_app (F : J ⥤ PresheafedSpace.{_, _, v} C) {j₁ j₂ j₃}
    (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃) (U) :
    (F.map (f ≫ g)).c.app U =
      (F.map g).c.app U ≫
        ((pushforward C (F.map g).base).map (F.map f).c).app U ≫
          (pushforwardEq (congr_arg Hom.base (F.map_comp f g).symm) _).hom.app U
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem inv_lt_one_iff_of_pos (h₀ : 0 < a) : a⁻¹ < 1 ↔ 1 < a
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
theorem apply_mono (μ : FiniteMeasure Ω) {s₁ s₂ : Set Ω} (h : s₁ ⊆ s₂) : μ s₁ ≤ μ s₂
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.ex_mem (h : l.HasBasis p s) : ∃ i, p i