ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Measure/Content.lean
theorem outerMeasure_preimage (f : G ≃ₜ G) (h : ∀ ⦃K : Compacts G⦄, μ (K.map f f.continuous) = μ K)
    (A : Set G) : μ.outerMeasure (f ⁻¹' A) = μ.outerMeasure A
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
protected theorem IsFiniteMeasureOnCompacts.smul [TopologicalSpace α] (μ : Measure α)
    [IsFiniteMeasureOnCompacts μ] {c : ℝ≥0∞} (hc : c ≠ ∞) : IsFiniteMeasureOnCompacts (c • μ)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem lt_lsub_iff {ι : Type u} {f : ι → Ordinal.{max u v}} {a} :
    a < lsub.{_, v} f ↔ ∃ i, a ≤ f i
-- Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean
theorem verticalIntegral_norm_le (hb : 0 < b.re) (c : ℝ) {T : ℝ} (hT : 0 ≤ T) :
    ‖verticalIntegral b c T‖ ≤
      (2 : ℝ) * |c| * exp (-(b.re * T ^ 2 - (2 : ℝ) * |b.im| * |c| * T - b.re * c ^ 2))
-- Mathlib/ModelTheory/FinitelyGenerated.lean
theorem cg_closure_singleton (x : M) : CG (closure L ({x} : Set M))
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- If the oriented angle between three points is `π / 2`, so is the unoriented angle
(reversed). -/
theorem angle_rev_eq_pi_div_two_of_oangle_eq_pi_div_two {p₁ p₂ p₃ : P} (h : ∡ p₁ p₂ p₃ = ↑(π / 2)) :
    ∠ p₃ p₂ p₁ = π / 2
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem totallyBounded_of_forall_symm {s : Set α}
    (h : ∀ V ∈ 𝓤 α, SymmetricRel V → ∃ t : Set α, Set.Finite t ∧ s ⊆ ⋃ y ∈ t, ball y V) :
    TotallyBounded s
-- Mathlib/Geometry/Manifold/IntegralCurve.lean
lemma IsIntegralCurveOn.continuousOn (hγ : IsIntegralCurveOn γ v s) :
    ContinuousOn γ s
-- Mathlib/GroupTheory/Coxeter/Basic.lean
theorem wordProd_cons (i : B) (ω : List B) : π (i :: ω) = s i * π ω
-- Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean
/-- The converse: if the additive character takes the value `1` only at `0`,
then it is primitive. -/
theorem zmod_char_primitive_of_eq_one_only_at_zero (n : ℕ) (ψ : AddChar (ZMod n) C)
    (hψ : ∀ a, ψ a = 1 → a = 0) : IsPrimitive ψ
-- Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean
/-- If an integrable function has zero integral on all compact sets in a sigma-compact space, then
it is zero almost everwhere. -/
lemma ae_eq_zero_of_forall_setIntegral_isCompact_eq_zero
    [SigmaCompactSpace β] [R1Space β] {μ : Measure β} {f : β → E} (hf : Integrable f μ)
    (h'f : ∀ (s : Set β), IsCompact s → ∫ x in s, f x ∂μ = 0) :
    f =ᵐ[μ] 0
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
/-- If a set is bounded below and above, and nonempty, its infimum is less than or equal to
its supremum. -/
theorem csInf_le_csSup (hb : BddBelow s) (ha : BddAbove s) (ne : s.Nonempty) : sInf s ≤ sSup s
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
protected theorem fin_support_approx : ∀ n, μ (support (hf.approx n)) < ∞
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem symmetric_symmetrizeRel (V : Set (α × α)) : SymmetricRel (symmetrizeRel V)
-- Mathlib/RingTheory/Filtration.lean
protected theorem antitone : Antitone F.N
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
theorem rank_quotient_le (p : Submodule R M) : Module.rank R (M ⧸ p) ≤ Module.rank R M
-- Mathlib/RingTheory/Ideal/Maps.lean
@[simp]
theorem comap_eq_top_iff {I : Ideal S} : I.comap f = ⊤ ↔ I = ⊤
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem any_eq (s : String) (p : Char → Bool) : any s p = s.1.any p
-- Mathlib/Tactic/Ring/Basic.lean
theorem natCast_mul {a₁ a₃ : ℕ} (a₂) (_ : ((a₁ : ℕ) : R) = b₁)
    (_ : ((a₃ : ℕ) : R) = b₃) : ((a₁ ^ a₂ * a₃ : ℕ) : R) = b₁ ^ a₂ * b₃
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem mul_limZero_right (f : CauSeq β abv) {g} (hg : LimZero g) : LimZero (f * g)
-- Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean
@[simp]
theorem whiskerLeft_apply (L : ModuleCat.{u} R) {M N : ModuleCat.{u} R} (f : M ⟶ N)
    (l : L) (m : M) :
    (L ◁ f) (l ⊗ₜ m) = l ⊗ₜ f m
-- Mathlib/Topology/MetricSpace/ThickenedIndicator.lean
theorem indicator_le_thickenedIndicatorAux (δ : ℝ) (E : Set α) :
    (E.indicator fun _ => (1 : ℝ≥0∞)) ≤ thickenedIndicatorAux δ E
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem isNoetherianRing : IsNoetherianRing A
-- Mathlib/Data/List/Basic.lean
theorem takeWhile_cons_of_pos {x : α} (h : p x) :
    List.takeWhile p (x :: l) = x :: takeWhile p l
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] theorem zero_emod (b : Int) : 0 % b = 0
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem pow_monotone (n : ℕ) : Monotone fun f : CircleDeg1Lift => f ^ n
-- Mathlib/CategoryTheory/Triangulated/HomologicalFunctor.lean
/-- A functor from a pretriangulated category to an abelian category is an homological functor
if it sends distinguished triangles to exact sequences. -/
class IsHomological extends F.PreservesZeroMorphisms : Prop where
  exact (T : Triangle C) (hT : T ∈ distTriang C) :
    ((shortComplexOfDistTriangle T hT).map F).Exact
-- Mathlib/CategoryTheory/Limits/Shapes/FiniteLimits.lean
/-- We can always derive `HasFiniteColimits C` by providing colimits at an
arbitrary universe. -/
theorem hasFiniteColimits_of_hasFiniteColimits_of_size
    (h : ∀ (J : Type w) {𝒥 : SmallCategory J} (_ : @FinCategory J 𝒥), HasColimitsOfShape J C) :
    HasFiniteColimits C
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem isMaximal_def {I : Ideal α} : I.IsMaximal ↔ IsCoatom I
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem nodup_reverse_iff {s : Cycle α} : s.reverse.Nodup ↔ s.Nodup
-- Mathlib/Data/Set/Subsingleton.lean
theorem subsingleton_of_subsingleton [Subsingleton α] {s : Set α} : Set.Subsingleton s
-- Mathlib/Topology/Compactness/Compact.lean
theorem IsCompact.finite (hs : IsCompact s) (hs' : DiscreteTopology s) : s.Finite
-- Mathlib/GroupTheory/Finiteness.lean
@[to_additive]
theorem Group.rank_spec [h : Group.FG G] :
    ∃ S : Finset G, S.card = Group.rank G ∧ Subgroup.closure (S : Set G) = ⊤
-- Mathlib/Data/Matroid/Basic.lean
theorem Base.insert_not_base {e : α} (hB : M.Base B) (heB : e ∉ B) : ¬ M.Base (insert e B)
-- Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean
@[simp]
theorem algebraMap_inj (x y : R) :
    algebraMap R (TensorAlgebra R M) x = algebraMap R (TensorAlgebra R M) y ↔ x = y
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
theorem mod_two_eq_zero_or_one (n : Nat) : n % 2 = 0 ∨ n % 2 = 1
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem eta (o : WellOrder) : mk o.α o.r o.wo = o
-- Mathlib/Topology/Algebra/UniformConvergence.lean
@[to_additive]
protected theorem UniformFun.hasBasis_nhds_one_of_basis {p : ι → Prop} {b : ι → Set G}
    (h : (𝓝 1 : Filter G).HasBasis p b) :
    (𝓝 1 : Filter (α →ᵤ G)).HasBasis p fun i => { f : α →ᵤ G | ∀ x, toFun f x ∈ b i }
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
theorem map_zero₂ (f : M →SL[ρ₁₂] F →SL[σ₁₂] G') (y : F) : f 0 y = 0
-- Mathlib/Init/Algebra/Classes.lean
theorem not_lt_of_lt {α : Sort u} {lt : α → α → Prop} [IsStrictOrder α lt] {a b} :
    lt a b → ¬lt b a
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
theorem singleton_mul_subgroup {H : Subgroup G} {h : G} (hh : h ∈ H) : {h} * (H : Set G) = H
-- Mathlib/Tactic/CancelDenoms/Core.lean
/-- Helper lemma to chain together a `simp` proof and the result of `mkProdPrf`. -/
theorem derive_trans {α} [Mul α] {a b c d : α} (h : a = b) (h' : c * b = d) : c * a = d
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive]
theorem mul_mem_mul : s ∈ f → t ∈ g → s * t ∈ f * g
-- Mathlib/CategoryTheory/NatIso.lean
@[reassoc (attr := simp)]
theorem hom_inv_id_app {F G : C ⥤ D} (α : F ≅ G) (X : C) :
    α.hom.app X ≫ α.inv.app X = 𝟙 (F.obj X)
-- Mathlib/Topology/ContinuousOn.lean
theorem mem_closure_pi {ι : Type*} {α : ι → Type*} [∀ i, TopologicalSpace (α i)] {I : Set ι}
    {s : ∀ i, Set (α i)} {x : ∀ i, α i} : x ∈ closure (pi I s) ↔ ∀ i ∈ I, x i ∈ closure (s i)
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma mor₂_eq_zero_of_mono₃ (h : Mono T.mor₃) : T.mor₂ = 0
-- Mathlib/Data/Int/GCD.lean
theorem ne_zero_of_gcd {x y : ℤ} (hc : gcd x y ≠ 0) : x ≠ 0 ∨ y ≠ 0
-- Mathlib/Geometry/Manifold/Sheaf/Smooth.lean
/-- The object of `smoothSheaf IM I M N` for the open set `U` in `M` is
`C^∞⟮IM, (unop U : Opens M); I, N⟯`, the `(IM, I)`-smooth functions from `U` to `N`.  This is not
just a "moral" equality but a literal and definitional equality! -/
lemma smoothSheaf.obj_eq (U : (Opens (TopCat.of M))ᵒᵖ) :
    (smoothSheaf IM I M N).presheaf.obj U = C^∞⟮IM, (unop U : Opens M); I, N⟯
-- Mathlib/Data/List/GetD.lean
theorem getD_eq_default {n : ℕ} (hn : l.length ≤ n) : l.getD n d = d
-- Mathlib/RingTheory/ZMod.lean
/-- The ring homomorphism `ℤ → ZMod n` has kernel generated by `n`. -/
theorem ZMod.ker_intCastRingHom (n : ℕ) :
    RingHom.ker (Int.castRingHom (ZMod n)) = Ideal.span ({(n : ℤ)} : Set ℤ)
-- Mathlib/Order/Hom/Basic.lean
/-- Lift an order homomorphism `f : α →o β` to an order homomorphism `WithTop α →o WithTop β`. -/
@[simps (config := .asFn)]
protected def withTopMap (f : α →o β) : WithTop α →o WithTop β
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
/-- Characterization of the value of `Nat.gcd`. -/
theorem gcd_eq_iff (a b : Nat) :
    gcd a b = g ↔ g ∣ a ∧ g ∣ b ∧ (∀ c, c ∣ a → c ∣ b → c ∣ g)
-- Mathlib/Analysis/ODE/PicardLindelof.lean
protected theorem lipschitzOnWith {t} (ht : t ∈ Icc v.tMin v.tMax) :
    LipschitzOnWith v.L (v t) (closedBall v.x₀ v.R)
-- Mathlib/RingTheory/Regular/RegularSequence.lean
lemma quot_ofList_smul_nontrivial {rs : List R} (h : IsRegular M rs)
    (N : Submodule R M) : Nontrivial (M ⧸ Ideal.ofList rs • N)
-- Mathlib/Order/Filter/Basic.lean
theorem comap_eq_of_inverse {f : Filter α} {g : Filter β} {φ : α → β} (ψ : β → α) (eq : ψ ∘ φ = id)
    (hφ : Tendsto φ f g) (hψ : Tendsto ψ g f) : comap φ g = f
-- Mathlib/Analysis/Convex/Between.lean
theorem Sbtw.ne_right {x y z : P} (h : Sbtw R x y z) : y ≠ z
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- Remap a simplex along an `Equiv` of index types. -/
@[simps]
def reindex {m n : ℕ} (s : Simplex k P m) (e : Fin (m + 1) ≃ Fin (n + 1)) : Simplex k P n
-- Mathlib/Analysis/Complex/ReImTopology.lean
@[simp]
theorem interior_setOf_im_le (a : ℝ) : interior { z : ℂ | z.im ≤ a } = { z | z.im < a }
-- Mathlib/Topology/Order/ScottTopology.lean
lemma isClosed_iff_isLowerSet_and_dirSupClosed : IsClosed s ↔ IsLowerSet s ∧ DirSupClosed s
-- Mathlib/Analysis/Seminorm.lean
@[simp]
theorem ball_bot {r : ℝ} (x : E) (hr : 0 < r) : ball (⊥ : Seminorm 𝕜 E) x r = Set.univ
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
/-- `LinearMap.toAddMonoidHom` promoted to an `AddMonoidHom`. -/
@[simps]
def toAddMonoidHom' : (M →ₛₗ[σ₁₂] M₂) →+ M →+ M₂
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
protected lemma comp_smul {n₁ n₂ n₁₂ : ℤ} (z₁ : Cochain F G n₁) (k : R) (z₂ : Cochain G K n₂)
    (h : n₁ + n₂ = n₁₂ ) : z₁.comp (k • z₂) h = k • (z₁.comp z₂ h)
-- Mathlib/RingTheory/Localization/Basic.lean
/-- Given `z : S`, `IsLocalization.sec M z` is defined to be a pair `(x, y) : R × M` such
that `z * f y = f x` (so this lemma is true by definition). -/
theorem sec_spec (z : S) :
    z * algebraMap R S (IsLocalization.sec M z).2 = algebraMap R S (IsLocalization.sec M z).1
-- Mathlib/Algebra/Lie/Rank.lean
lemma polyCharpoly_coeff_rank_ne_zero :
    (polyCharpoly φ b).coeff (rank R L M) ≠ 0
-- Mathlib/Order/Basic.lean
theorem Ne.le_iff_lt [PartialOrder α] {a b : α} (h : a ≠ b) : a ≤ b ↔ a < b
-- Mathlib/Analysis/NormedSpace/Connected.lean
/-- In a real vector space of dimension `> 1`, the complement of any countable set is path
connected. -/
theorem Set.Countable.isPathConnected_compl_of_one_lt_rank
    (h : 1 < Module.rank ℝ E) {s : Set E} (hs : s.Countable) :
    IsPathConnected sᶜ
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_to_countable' [MeasurableSpace α] [Countable α] [MeasurableSpace β] {f : β → α}
    (h : ∀ x, MeasurableSet (f ⁻¹' {x})) : Measurable f
-- Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
@[simp]
theorem interUnionPullbackCone_snd :
    (interUnionPullbackCone F U V).snd = F.1.map (homOfLE le_sup_right).op
-- Mathlib/Data/Finset/Card.lean
theorem card_eq_one : s.card = 1 ↔ ∃ a, s = {a}
-- Mathlib/Order/LiminfLimsup.lean
/-- In other words, `limsup cofinite s` is the set of elements lying inside the family `s`
infinitely often. -/
theorem cofinite.limsup_set_eq : limsup s cofinite = { x | { n | x ∈ s n }.Infinite }
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem IsCoprime.of_mul_add_left_left (h : IsCoprime (y * z + x) y) : IsCoprime x y
-- Mathlib/ModelTheory/Semantics.lean
theorem realize_con {A : Set M} {a : A} {v : α → M} : (L.con a).term.realize v = a
-- Mathlib/Probability/Kernel/Basic.lean
lemma sum_const [Countable ι] (μ : ι → Measure β) :
    Kernel.sum (fun n ↦ const α (μ n)) = const α (Measure.sum μ)
-- Mathlib/CategoryTheory/Limits/Shapes/NormalMono/Equalizers.lean
/-- If a zero morphism is a cokernel of `f`, then `f` is an epimorphism. -/
theorem epi_of_zero_cokernel {X Y : C} (f : X ⟶ Y) (Z : C)
    (l : IsColimit (CokernelCofork.ofπ (0 : Y ⟶ Z) (show f ≫ 0 = 0 by simp))) : Epi f
-- Mathlib/Data/Finset/Lattice.lean
theorem ofDual_min' {s : Finset αᵒᵈ} (hs : s.Nonempty) :
    ofDual (min' s hs) = max' (s.image ofDual) (hs.image _)
-- Mathlib/Data/ENNReal/Inv.lean
@[simp]
theorem orderIsoUnitIntervalBirational_apply_coe (x : ℝ≥0∞) :
    (orderIsoUnitIntervalBirational x : ℝ) = (x⁻¹ + 1)⁻¹.toReal
-- Mathlib/Data/Part.lean
theorem mem_toOption {o : Part α} [Decidable o.Dom] {a : α} : a ∈ toOption o ↔ a ∈ o
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem testBit_toNat (x : BitVec w) : x.toNat.testBit i = x.getLsb i
-- Mathlib/Probability/Process/Stopping.lean
theorem stoppedProcess_eq' (n : ℕ) : stoppedProcess u τ n = Set.indicator {a | n + 1 ≤ τ a} (u n) +
    ∑ i ∈ Finset.range (n + 1), Set.indicator {a | τ a = i} (u i)
-- Mathlib/Analysis/Matrix.lean
private theorem norm_unitOf (a : α) : ‖unitOf a‖₊ = 1
-- Mathlib/Algebra/MvPolynomial/Rename.lean
theorem eval₂_cast_comp (f : σ → τ) (c : ℤ →+* R) (g : τ → R) (p : MvPolynomial σ ℤ) :
    eval₂ c (g ∘ f) p = eval₂ c g (rename f p)
-- Mathlib/Computability/Reduce.lean
@[simp]
theorem manyOneReducible_toNat {p : Set α} : p ≤₀ toNat p
-- Mathlib/Data/Int/Defs.lean
protected lemma lt_or_lt_of_ne : a ≠ b → a < b ∨ b < a
-- Mathlib/Topology/MetricSpace/Isometry.lean
/-- The injection from a subtype is an isometry -/
theorem _root_.isometry_subtype_coe {s : Set α} : Isometry ((↑) : s → α)
-- Mathlib/Analysis/InnerProductSpace/OfNorm.lean
private theorem add_left_aux6 (x y z : E) :
    ‖(I : 𝕜) • (x + y) - z‖ * ‖(I : 𝕜) • (x + y) - z‖ =
    (‖(I : 𝕜) • (2 • x + y)‖ * ‖(I : 𝕜) • (2 • x + y)‖ +
    ‖(I : 𝕜) • y - 2 • z‖ * ‖(I : 𝕜) • y - 2 • z‖) / 2 -
    ‖(I : 𝕜) • x + z‖ * ‖(I : 𝕜) • x + z‖
-- Mathlib/Topology/Algebra/Module/StrongTopology.lean
theorem t2Space [TopologicalSpace F] [TopologicalAddGroup F] [T2Space F]
    (𝔖 : Set (Set E)) (h𝔖 : ⋃₀ 𝔖 = Set.univ) : T2Space (UniformConvergenceCLM σ F 𝔖)
-- Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat/Monoidal.lean
/-- Auxiliary definition used to build `QuadraticModuleCat.instMonoidalCategory`. -/
@[simps! form]
noncomputable abbrev tensorObj (X Y : QuadraticModuleCat.{u} R) : QuadraticModuleCat.{u} R
-- Mathlib/Analysis/Normed/Field/Basic.lean
theorem Finset.norm_prod_le' {α : Type*} [NormedCommRing α] (s : Finset ι) (hs : s.Nonempty)
    (f : ι → α) : ‖∏ i ∈ s, f i‖ ≤ ∏ i ∈ s, ‖f i‖
-- Mathlib/Order/RelClasses.lean
theorem trans_trichotomous_left [IsTrans α r] [IsTrichotomous α r] {a b c : α} :
    ¬r b a → r b c → r a c
-- Mathlib/Data/List/Permutation.lean
theorem length_foldr_permutationsAux2 (t : α) (ts : List α) (r L : List (List α)) :
    length (foldr (fun y r => (permutationsAux2 t ts r y id).2) r L) =
      Nat.sum (map length L) + length r
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive]
theorem smul_mem_smul_set : b ∈ s → a • b ∈ a • s
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem ord_cof_le (o : Ordinal.{u}) : o.cof.ord ≤ o
-- Mathlib/Algebra/BigOperators/Intervals.lean
@[to_additive]
theorem prod_range_succ_div_top : (∏ i ∈ range (n + 1), f i) / f n = ∏ i ∈ range n, f i
-- Mathlib/Algebra/ModEq.lean
@[simp]
theorem modEq_zero : a ≡ b [PMOD 0] ↔ a = b
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
theorem restrict_biInf {ι} {I : Set ι} (hI : I.Nonempty) (s : Set α) (m : ι → OuterMeasure α) :
    restrict s (⨅ i ∈ I, m i) = ⨅ i ∈ I, restrict s (m i)
-- Mathlib/Order/SuccPred/CompleteLinearOrder.lean
lemma IsGLB.exists_of_nonempty_of_not_isPredLimit
    (hf : IsGLB (Set.range f) x) (hx : ¬ IsPredLimit x) :
    ∃ i, f i = x
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean
@[simp]
lemma toNNReal_one : (1 : C(X, ℝ)).toNNReal = 1
-- Mathlib/CategoryTheory/Galois/Decomposition.lean
@[simp]
private lemma mkSelfProdFib_map_π (t : F.obj X) : F.map (Pi.π _ t) (mkSelfProdFib F X) = t
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem hasDerivAt_iff_isLittleO_nhds_zero :
    HasDerivAt f f' x ↔ (fun h => f (x + h) - f x - h • f') =o[𝓝 0] fun h => h
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
theorem aemeasurable_indicator_iff {s} (hs : MeasurableSet s) :
    AEMeasurable (indicator s f) μ ↔ AEMeasurable f (μ.restrict s)
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem irreducible_pow_sup_of_ge (hI : I ≠ ⊥) (hJ : Irreducible J) (n : ℕ)
    (hn : multiplicity J I ≤ n) :
    J ^ n ⊔ I = J ^ (multiplicity J I).get (PartENat.dom_of_le_natCast hn)
-- Mathlib/Algebra/CharP/LocalRing.lean
/-- In a local ring the characteristics is either zero or a prime power. -/
theorem charP_zero_or_prime_power (R : Type*) [CommRing R] [LocalRing R] (q : ℕ)
    [char_R_q : CharP R q] : q = 0 ∨ IsPrimePow q
-- Mathlib/Data/Matrix/Basic.lean
@[norm_cast]
theorem diagonal_intCast [Zero α] [IntCast α] (m : ℤ) : diagonal (fun _ : n => (m : α)) = m
-- Mathlib/Data/Matrix/Invertible.lean
@[simp] lemma isUnit_conjTranspose : IsUnit Aᴴ ↔ IsUnit A
-- Mathlib/Data/Real/EReal.lean
@[simp]
lemma image_coe_Ico (x y : ℝ) : Real.toEReal '' Ico x y = Ico ↑x ↑y
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[to_additive (attr := simp)]
lemma smul_coe_set [Group G] [SetLike S G] [SubgroupClass S G] {s : S} {a : G} (ha : a ∈ s) :
    a • (s : Set G) = s
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem surjective_unitGroupToResidueFieldUnits :
    Function.Surjective A.unitGroupToResidueFieldUnits
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
theorem AddMonoidHom.toNatLinearMap_injective [AddCommMonoid M] [AddCommMonoid M₂] :
    Function.Injective (@AddMonoidHom.toNatLinearMap M M₂ _ _)
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
@[simp]
theorem abs_arg_le_pi_div_two_iff {z : ℂ} : |arg z| ≤ π / 2 ↔ 0 ≤ re z
-- Mathlib/RingTheory/Generators.lean
lemma Cotangent.val_smul''' {R₀} [CommRing R₀] [Algebra R₀ S] (r : R₀) (x : P.Cotangent) :
    (r • x).val = P.σ (algebraMap R₀ S r) • x.val
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- Each function of a family equicontinuous at `x₀` is continuous at `x₀`. -/
theorem EquicontinuousAt.continuousAt {F : ι → X → α} {x₀ : X} (h : EquicontinuousAt F x₀) (i : ι) :
    ContinuousAt (F i) x₀
-- Mathlib/LinearAlgebra/Semisimple.lean
@[simp]
lemma isSemisimple_zero [IsSemisimpleModule R M] : IsSemisimple (0 : Module.End R M)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[measurability]
theorem SimpleFunc.aestronglyMeasurable {_ : MeasurableSpace α} {μ : Measure α} [TopologicalSpace β]
    (f : α →ₛ β) : AEStronglyMeasurable f μ
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma le_of_smul_le_smul_left [PosSMulReflectLE α β] (h : a • b₁ ≤ a • b₂) (ha : 0 < a) : b₁ ≤ b₂
-- Mathlib/Algebra/Lie/Nilpotent.lean
@[simp]
theorem lcs_zero (N : LieSubmodule R L M) : N.lcs 0 = N
-- Mathlib/Algebra/Lie/Weights/Basic.lean
@[simp] lemma posFittingCompOf_le_lowerCentralSeries (x : L) (k : ℕ) :
    posFittingCompOf R M x ≤ lowerCentralSeries R L M k
-- Mathlib/Algebra/Ring/Ext.lean
theorem ext_iff {inst₁ inst₂ : NonUnitalRing R} :
    inst₁ = inst₂ ↔
      (local_hAdd[R, inst₁] = local_hAdd[R, inst₂]) ∧
      (local_hMul[R, inst₁] = local_hMul[R, inst₂])
-- Mathlib/Data/Finmap.lean
@[simp]
theorem lookup_insert {a} {b : β a} (s : Finmap β) : lookup a (insert a b s) = some b
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem reindex_symm (eₘ : m ≃ l) (eₙ : n ≃ o) :
    (reindex eₘ eₙ).symm = (reindex eₘ.symm eₙ.symm : Matrix l o α ≃ _)
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem coe_nil : ↑([] : List α) = @nil α
-- Mathlib/Data/Matrix/DMatrix.lean
@[simp]
theorem add_apply [∀ i j, Add (α i j)] (M N : DMatrix m n α) (i j) : (M + N) i j = M i j + N i j
-- Mathlib/CategoryTheory/Functor/Derived/RightDerived.lean
@[reassoc (attr := simp)]
lemma rightDerived_fac_app (G : D ⥤ H) (β : F ⟶ L ⋙ G) (X : C) :
    α.app X ≫ (RF.rightDerivedDesc α W G β).app (L.obj X) = β.app X
-- Mathlib/Order/Lattice.lean
theorem of_map_sup [SemilatticeSup α] [SemilatticeSup β] {f : α → β}
    (h : ∀ x y, f (x ⊔ y) = f x ⊔ f y) : Monotone f
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addXYZ_of_Z_ne_zero {P Q : Fin 3 → F} (hP : W.Equation P) (hQ : W.Equation Q) (hPz : P z ≠ 0)
    (hQz : Q z ≠ 0) (hx : P x * Q z ^ 2 ≠ Q x * P z ^ 2) :
    W.addXYZ P Q = addZ P Q •
      ![W.toAffine.addX (P x / P z ^ 2) (Q x / Q z ^ 2)
          (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3)),
        W.toAffine.addY (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3)
          (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3)),
        1]
-- Mathlib/CategoryTheory/EqToHom.lean
theorem precomp_map_heq (H : E ⥤ C) (hmap : ∀ {X Y} (f : X ⟶ Y), HEq (F.map f) (G.map f)) {X Y : E}
    (f : X ⟶ Y) : HEq ((H ⋙ F).map f) ((H ⋙ G).map f)
-- Mathlib/CategoryTheory/CommSq.lean
/-- The proposition that a square
```
  W ---f---> X
  |          |
  g          h
  |          |
  v          v
  Y ---i---> Z

```
is a commuting square.
-/
structure CommSq {W X Y Z : C} (f : W ⟶ X) (g : W ⟶ Y) (h : X ⟶ Z) (i : Y ⟶ Z) : Prop where
  /-- The square commutes. -/
  w : f ≫ h = g ≫ i
-- Mathlib/Geometry/RingedSpace/SheafedSpace.lean
@[simp]
theorem id_base (X : SheafedSpace C) : (𝟙 X : X ⟶ X).base = 𝟙 (X : TopCat)
-- Mathlib/Order/Fin/Tuple.lean
lemma insertNth_mem_Icc {i : Fin (n + 1)} {x : α i} {p : ∀ j, α (i.succAbove j)}
    {q₁ q₂ : ∀ j, α j} :
    i.insertNth x p ∈ Icc q₁ q₂ ↔
      x ∈ Icc (q₁ i) (q₂ i) ∧ p ∈ Icc (fun j ↦ q₁ (i.succAbove j)) fun j ↦ q₂ (i.succAbove j)
-- Mathlib/Topology/MetricSpace/Thickening.lean
@[simp]
theorem cthickening_singleton {α : Type*} [PseudoMetricSpace α] (x : α) {δ : ℝ} (hδ : 0 ≤ δ) :
    cthickening δ ({x} : Set α) = closedBall x δ
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLog.lean
@[simp] lemma log_lt_log_iff {x y : ℝ≥0∞} : log x < log y ↔ x < y
-- Mathlib/Tactic/NormNum/Eq.lean
theorem isNat_eq_false [AddMonoidWithOne α] [CharZero α] : {a b : α} → {a' b' : ℕ} →
    IsNat a a' → IsNat b b' → Nat.beq a' b' = false → ¬a = b
-- Mathlib/Order/CountableDenseLinearOrder.lean
/-- For each `a`, we can find a `b` in the codomain, such that `a`'s relation to
the domain of `f` is `b`'s relation to the image of `f`.

Thus, if `a` is not already in `f`, then we can extend `f` by sending `a` to `b`.
-/
theorem exists_across [DenselyOrdered β] [NoMinOrder β] [NoMaxOrder β] [Nonempty β]
    (f : PartialIso α β) (a : α) :
    ∃ b : β, ∀ p ∈ f.val, cmp (Prod.fst p) a = cmp (Prod.snd p) b
-- Mathlib/Analysis/Convex/Hull.lean
@[mono, gcongr]
theorem convexHull_mono (hst : s ⊆ t) : convexHull 𝕜 s ⊆ convexHull 𝕜 t