ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem map_le_sum {ι : Type*} {s : Finset ι} {f : ι → R} {g : Γ₀} (hf : ∀ i ∈ s, g ≤ v (f i)) :
    g ≤ v (∑ i ∈ s, f i)
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem sumCoords_self_apply : b.sumCoords (b i) = 1
-- Mathlib/Algebra/Ring/NegOnePow.lean
lemma negOnePow_odd (n : ℤ) (hn : Odd n) : n.negOnePow = -1
-- Mathlib/Data/Nat/GCD/Basic.lean
theorem gcd_mul_gcd_eq_iff_dvd_mul_of_coprime (hcop : Coprime n m) :
    gcd x n * gcd x m = x ↔ x ∣ n * m
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[reassoc] -- Porting note: both versions proven by simp
theorem biproduct.ι_π_self (f : J → C) [HasBiproduct f] (j : J) :
    biproduct.ι f j ≫ biproduct.π f j = 𝟙 _
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem iUnion_Ioc_add_zsmul : ⋃ n : ℤ, Ioc (a + n • p) (a + (n + 1) • p) = univ
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_neg_Ici : -Ici a = Iic (-a)
-- Mathlib/Data/Set/Finite.lean
theorem Finite.surjOn_iff_bijOn_of_mapsTo (hs : s.Finite) (hm : MapsTo f s s) :
    SurjOn f s s ↔ BijOn f s s
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfcHom_predicate (f : C(spectrum R a, R)) :
    p (cfcHom ha f)
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
lemma adjunction_unit_map_basicOpen (X : Scheme.{u}) (r : Γ(X, ⊤)) :
    (ΓSpec.adjunction.unit.app X ⁻¹ᵁ (PrimeSpectrum.basicOpen r)) = X.basicOpen r
-- Mathlib/Tactic/ComputeDegree.lean
theorem coeff_add_of_eq {n : ℕ} {a b : R} {f g : R[X]}
    (h_add_left : f.coeff n = a) (h_add_right : g.coeff n = b) :
    (f + g).coeff n = a + b
-- Mathlib/Data/Sum/Basic.lean
theorem eq_right_iff_getRight_eq {b : β} : x = inr b ↔ ∃ h, x.getRight h = b
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
theorem ne_none_iff_exists : o ≠ none ↔ ∃ x, some x = o
-- Mathlib/Analysis/Convex/Integral.lean
/-- **Jensen's inequality**: if a function `g : E → ℝ` is concave and continuous on a convex closed
set `s`, `μ` is a finite non-zero measure on `α`, and `f : α → E` is a function sending
`μ`-a.e. points of a set `t` to `s`, then the average value of `g ∘ f` over `t` is less than or
equal to the value of `g` at the average value of `f` over `t` provided that both `f` and `g ∘ f`
are integrable. -/
theorem ConcaveOn.set_average_mem_hypograph (hg : ConcaveOn ℝ s g) (hgc : ContinuousOn g s)
    (hsc : IsClosed s) (h0 : μ t ≠ 0) (ht : μ t ≠ ∞) (hfs : ∀ᵐ x ∂μ.restrict t, f x ∈ s)
    (hfi : IntegrableOn f t μ) (hgi : IntegrableOn (g ∘ f) t μ) :
    (⨍ x in t, f x ∂μ, ⨍ x in t, g (f x) ∂μ) ∈ {p : E × ℝ | p.1 ∈ s ∧ p.2 ≤ g p.1}
-- Mathlib/CategoryTheory/Extensive.lean
theorem FinitaryExtensive.isPullback_initial_to_binaryCofan [FinitaryExtensive C]
    {c : BinaryCofan X Y} (hc : IsColimit c) :
    IsPullback (initial.to _) (initial.to _) c.inl c.inr
-- Mathlib/Data/Fintype/Card.lean
@[simp] lemma Fintype.card_additive (α : Type*) [Fintype α] : card (Additive α) = card α
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
theorem aeval_eq_sum_range' [Algebra R S] {p : R[X]} {n : ℕ} (hn : p.natDegree < n) (x : S) :
    aeval x p = ∑ i ∈ Finset.range n, p.coeff i • x ^ i
-- Mathlib/RingTheory/PowerSeries/Basic.lean
theorem eval₂_C_X_eq_coe : φ.eval₂ (PowerSeries.C R) PowerSeries.X = ↑φ
-- Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean
/-- A `parallelepiped` is the convex hull of its vertices -/
theorem parallelepiped_eq_convexHull (v : ι → E) :
    parallelepiped v = convexHull ℝ (∑ i, {(0 : E), v i})
-- Mathlib/Order/Basic.lean
theorem not_le_of_lt [Preorder α] {a b : α} (h : a < b) : ¬b ≤ a
-- Mathlib/RingTheory/Idempotents.lean
lemma CompleteOrthogonalIdempotents.prod_one_sub (he : CompleteOrthogonalIdempotents e) :
    ∏ i, (1 - e i) = 0
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
theorem ContinuousOn.arsinh (h : ContinuousOn f s) : ContinuousOn (fun x => arsinh (f x)) s
-- Mathlib/RingTheory/ClassGroup.lean
@[simp]
theorem FractionalIdeal.coe_mk0 [IsDedekindDomain R] (I : (Ideal R)⁰) :
    (FractionalIdeal.mk0 K I : FractionalIdeal R⁰ K) = I
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem nonempty_Iic : (Iic a).Nonempty
-- Mathlib/Data/Set/Finite.lean
theorem Finite.preimage_embedding {s : Set β} (f : α ↪ β) (h : s.Finite) : (f ⁻¹' s).Finite
-- Mathlib/Algebra/Algebra/NonUnitalHom.lean
@[simp]
theorem toMulHom_eq_coe (f : A →ₛₙₐ[φ] B) : f.toMulHom = ↑f
-- Mathlib/Algebra/Algebra/Operations.lean
lemma mul_mem_smul_iff {S} [CommRing S] [Algebra R S] {x : S} {p : Submodule R S} {y : S}
    (hx : x ∈ nonZeroDivisors S) :
    x * y ∈ x • p ↔ y ∈ p
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem disjoint_of_disjoint_append_right_left (d : Disjoint l (l₁ ++ l₂)) : Disjoint l l₁
-- Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
lemma locallyRingedSpaceAdjunction_homEquiv_apply'
    {X : LocallyRingedSpace} {R : Type u} [CommRing R]
    (f : CommRingCat.of R ⟶ Γ.obj <| op X) :
    locallyRingedSpaceAdjunction.homEquiv X (op <| CommRingCat.of R) (op f) =
      identityToΓSpec.app X ≫ Spec.locallyRingedSpaceMap f
-- Mathlib/Data/Multiset/Basic.lean
theorem of_mem_filter {a : α} {s} (h : a ∈ filter p s) : p a
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
lemma biprod_isZero_iff (A B : C) [HasBinaryBiproduct A B] :
    IsZero (biprod A B) ↔ IsZero A ∧ IsZero B
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem Continuous.integrableOn_Icc [Preorder X] [CompactIccSpace X] [T2Space X]
    (hf : Continuous f) : IntegrableOn f (Icc a b) μ
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigOWith_abs_abs :
    (IsBigOWith c l (fun x => |u x|) fun x => |v x|) ↔ IsBigOWith c l u v
-- Mathlib/Data/Set/Image.lean
theorem range_inl : range (@Sum.inl α β) = {x | Sum.isLeft x}
-- Mathlib/Computability/TuringMachine.lean
theorem stmts₁_self {q : Stmt₂} : q ∈ stmts₁ q
-- Mathlib/Order/Fin/Tuple.lean
@[simp] lemma antitone_vecCons : Antitone (vecCons a f) ↔ f 0 ≤ a ∧ Antitone f
-- Mathlib/NumberTheory/Ostrowski.lean
/-- Values of a multiplicative norm of the rationals coincide on ℕ if and only if they coincide
on `ℤ`. -/
lemma eq_on_nat_iff_eq_on_Int : (∀ n : ℕ , f n = g n) ↔ (∀ n : ℤ , f n = g n)
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
/-- Given a graph embedding, map paths to paths. -/
@[simps!]
protected def mapEmbedding (f : G ↪g G') {u v : V} (p : G.Path u v) : G'.Path (f u) (f v)
-- Mathlib/NumberTheory/Padics/PadicVal.lean
lemma lt_add_of_lt {q r₁ r₂ : ℚ} (hqr : r₁ + r₂ ≠ 0)
    (hval₁ : padicValRat p q < padicValRat p r₁) (hval₂ : padicValRat p q < padicValRat p r₂) :
    padicValRat p q < padicValRat p (r₁ + r₂)
-- Mathlib/Geometry/Manifold/IntegralCurve.lean
lemma IsIntegralCurve.comp_add (hγ : IsIntegralCurve γ v) (dt : ℝ) :
    IsIntegralCurve (γ ∘ (· + dt)) v
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
/-- The function `oddKernel a` has exponential decay at `+∞`, for any `a`. -/
lemma isBigO_atTop_oddKernel (a : UnitAddCircle) :
    ∃ p, 0 < p ∧ IsBigO atTop (oddKernel a) (fun x ↦ Real.exp (-p * x))
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
@[nolint unusedHavesSuffices] -- false positive from unfolding String.takeWhileAux
theorem takeWhileAux_of_valid (p : Char → Bool) : ∀ l m r,
    Substring.takeWhileAux ⟨l ++ m ++ r⟩ ⟨utf8Len l + utf8Len m⟩ p ⟨utf8Len l⟩ =
      ⟨utf8Len l + utf8Len (m.takeWhile p)⟩
-- Mathlib/Order/Filter/Basic.lean
theorem tendsto_id {x : Filter α} : Tendsto id x x
-- Mathlib/Topology/Algebra/Order/Field.lean
@[simp] lemma inv_nhdsWithin_Ioi_zero : (𝓝[>] (0 : 𝕜))⁻¹ = atTop
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
@[reassoc]
theorem rightUnitor_inv_naturality {f g : a ⟶ b} (η : f ⟶ g) :
    η ≫ (ρ_ g).inv = (ρ_ f).inv ≫ η ▷ 𝟙 b
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion₂_inter (s : ∀ i, κ i → Set α) (t : Set α) :
    (⋃ (i) (j), s i j) ∩ t = ⋃ (i) (j), s i j ∩ t
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
protected theorem Set.EquicontinuousAt.continuousAt_of_mem {H : Set <| X → α} {x₀ : X}
    (h : H.EquicontinuousAt x₀) {f : X → α} (hf : f ∈ H) : ContinuousAt f x₀
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem lt_iff_le_and_ne {m n : Nat} : m < n ↔ m ≤ n ∧ m ≠ n
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
@[simp]
lemma map_id : W.map (RingHom.id R) = W
-- Mathlib/Order/WithBot.lean
theorem lt_toDual_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
    a < WithTop.toDual b ↔ b < WithBot.ofDual a
-- Mathlib/Algebra/Order/Group/Bounds.lean
theorem IsLUB.exists_between_sub_self' (h : IsLUB s a) (h₂ : a ∉ s) (hε : 0 < ε) :
    ∃ b ∈ s, a - ε < b ∧ b < a
-- Mathlib/Data/Rat/Cast/Lemmas.lean
theorem Nonneg.coe_ofScientific {K} [LinearOrderedField K] (m : ℕ) (s : Bool) (e : ℕ) :
    (ofScientific m s e : {x : K // 0 ≤ x}).val = ofScientific m s e
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `f` tends to infinity along a nontrivial filter,
`fun x ↦ f x * r` tends to negative infinity if and only if `r < 0. `-/
theorem tendsto_mul_const_atBot_iff_neg [NeBot l] (h : Tendsto f l atTop) :
    Tendsto (fun x => f x * r) l atBot ↔ r < 0
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem Continuous.integral_pos_of_hasCompactSupport_nonneg_nonzero [IsFiniteMeasureOnCompacts μ]
    {f : X → ℝ} {x : X} (f_cont : Continuous f) (f_comp : HasCompactSupport f) (f_nonneg : 0 ≤ f)
    (f_x : f x ≠ 0) : 0 < ∫ x, f x ∂μ
-- Mathlib/CategoryTheory/EssentialImage.lean
lemma essSurj_of_comp_fully_faithful (F : C ⥤ D) (G : D ⥤ E) [(F ⋙ G).EssSurj]
    [G.Faithful] [G.Full] : F.EssSurj
-- Mathlib/MeasureTheory/Constructions/Cylinders.lean
theorem cylinder_eq_cylinder_union [DecidableEq ι] (I : Finset ι) (S : Set (∀ i : I, α i))
    (J : Finset ι) :
    cylinder I S =
      cylinder (I ∪ J) ((fun f ↦ fun j : I ↦ f ⟨j, Finset.mem_union_left J j.prop⟩) ⁻¹' S)
-- Mathlib/Data/ENNReal/Inv.lean
@[simp]
theorem one_sub_inv_two : (1 : ℝ≥0∞) - 2⁻¹ = 2⁻¹
-- Mathlib/Combinatorics/SimpleGraph/DegreeSum.lean
theorem dart_card_eq_sum_degrees : Fintype.card G.Dart = ∑ v, G.degree v
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
@[simp]
theorem eval₂_intCastRingHom_X {R : Type*} [Ring R] (p : ℤ[X]) (f : ℤ[X] →+* R) :
    eval₂ (Int.castRingHom R) (f X) p = f p
-- Mathlib/Tactic/NormNum/NatFib.lean
theorem isNat_fib : {x nx z : ℕ} → IsNat x nx → Nat.fib nx = z → IsNat (Nat.fib x) z
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
theorem det_apply' (M : Matrix n n R) : M.det = ∑ σ : Perm n, ε σ * ∏ i, M (σ i) i
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
protected theorem IsTrail.dropUntil {u v w : V} {p : G.Walk v w} (hc : p.IsTrail)
    (h : u ∈ p.support) : (p.dropUntil u h).IsTrail
-- Mathlib/Logic/Equiv/Basic.lean
theorem sumCongr_symm (e : Equiv.Perm α) (f : Equiv.Perm β) :
    (sumCongr e f).symm = sumCongr e.symm f.symm
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- If the angle between three points is `-π / 2`, the last two points are not equal. -/
theorem right_ne_of_oangle_eq_neg_pi_div_two {p₁ p₂ p₃ : P} (h : ∡ p₁ p₂ p₃ = (-π / 2 : ℝ)) :
    p₃ ≠ p₂
-- Mathlib/Probability/Martingale/Convergence.lean
theorem Submartingale.upcrossings_ae_lt_top [IsFiniteMeasure μ] (hf : Submartingale f ℱ μ)
    (hbdd : ∀ n, eLpNorm (f n) 1 μ ≤ R) : ∀ᵐ ω ∂μ, ∀ a b : ℚ, a < b → upcrossings a b f ω < ∞
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- If `S` is dense and `x - y ∈ Kᗮ`, then `x = y`. -/
theorem eq_of_sub_mem_orthogonal (hK : Dense (K : Set E)) (h : x - y ∈ Kᗮ) : x = y
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
lemma aleph0_le_rank {ι : Type w} [Infinite ι] {v : ι → M}
    (hv : LinearIndependent R v) : ℵ₀ ≤ Module.rank R M
-- Mathlib/Deprecated/Subgroup.lean
theorem conjugatesOfSet_subset_normalClosure : conjugatesOfSet s ⊆ normalClosure s
-- Mathlib/Data/List/Nodup.lean
theorem Nodup.not_mem_erase [DecidableEq α] (h : Nodup l) : a ∉ l.erase a
-- Mathlib/Data/Vector/Basic.lean
/-- Providing an empty vector to `scanl` gives the starting value `b : β`. -/
@[simp]
theorem scanl_nil : scanl f b nil = b ::ᵥ nil
-- Mathlib/Data/Setoid/Partition.lean
@[simp]
theorem index_some (i : ι) : hs.index (hs.some i) = i
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem UniformSpace.replaceTopology_eq {α : Type*} [i : TopologicalSpace α] (u : UniformSpace α)
    (h : i = u.toTopologicalSpace) : u.replaceTopology h = u
-- Mathlib/Topology/MetricSpace/Isometry.lean
@[ext]
theorem ext ⦃h₁ h₂ : α ≃ᵢ β⦄ (H : ∀ x, h₁ x = h₂ x) : h₁ = h₂
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem eq_X_add_C_of_degree_eq_one (h : degree p = 1) :
    p = C p.leadingCoeff * X + C (p.coeff 0)
-- Mathlib/Analysis/Calculus/Deriv/Star.lean
protected nonrec theorem HasStrictDerivAt.star (h : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => star (f x)) (star f') x
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- The triangle (polygon) inequality for sequences of points; `Finset.range` version. -/
theorem edist_le_range_sum_edist (f : ℕ → α) (n : ℕ) :
    edist (f 0) (f n) ≤ ∑ i ∈ Finset.range n, edist (f i) (f (i + 1))
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem fract_sub_ofNat (a : α) (n : ℕ) [n.AtLeastTwo] :
    fract (a - (no_index (OfNat.ofNat n))) = fract a
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem insert_val (a : α) (s : Finset α) : (insert a s).1 = ndinsert a s.1
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem units_smul_resolvent_self {r : Rˣ} {a : A} :
    r • resolvent a (r : R) = resolvent (r⁻¹ • a) (1 : R)
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[simp]
theorem sum.of {x : α} : sum (of x) = x
-- Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean
theorem superpolynomialDecay_iff_norm_tendsto_zero :
    SuperpolynomialDecay l k f ↔ ∀ n : ℕ, Tendsto (fun a : α => ‖k a ^ n * f a‖) l (𝓝 0)
-- Mathlib/RingTheory/Kaehler/Basic.lean
/-- The kernel of `S ⊗[R] S →ₐ[R] S` is generated by `1 ⊗ s - s ⊗ 1` as a `S`-module. -/
theorem KaehlerDifferential.submodule_span_range_eq_ideal :
    Submodule.span S (Set.range fun s : S => (1 : S) ⊗ₜ[R] s - s ⊗ₜ[R] (1 : S)) =
      (KaehlerDifferential.ideal R S).restrictScalars S
-- Mathlib/Data/Set/Card.lean
theorem encard_insert_le (s : Set α) (x : α) : (insert x s).encard ≤ s.encard + 1
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem card_mul (a b) : card (a * b) = card a * card b
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp] theorem mk_den_one {r : Int} :
    ⟨r, 1, Nat.one_ne_zero, (Nat.coprime_one_right _)⟩ = (r : Rat)
-- Mathlib/Algebra/Algebra/Operations.lean
/-- A dependent version of `mul_induction_on`. -/
@[elab_as_elim]
protected theorem mul_induction_on' {C : ∀ r, r ∈ M * N → Prop}
    (mem_mul_mem : ∀ m (hm : m ∈ M) n (hn : n ∈ N), C (m * n) (mul_mem_mul hm hn))
    (add : ∀ x hx y hy, C x hx → C y hy → C (x + y) (add_mem hx hy)) {r : A} (hr : r ∈ M * N) :
    C r hr
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_eq_norm_mul_iff_div {x y : E} (h₀ : x ≠ 0) :
    ⟪x, y⟫ = (‖x‖ : 𝕜) * ‖y‖ ↔ (‖y‖ / ‖x‖ : 𝕜) • x = y
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem comap_coe_nhds (x : X) : comap ((↑) : X → OnePoint X) (𝓝 x) = 𝓝 x
-- Mathlib/RingTheory/Trace/Basic.lean
/-- Given `pb : PowerBasis K S`, then the trace of `pb.gen` is
`((minpoly K pb.gen).aroots F).sum`. -/
theorem PowerBasis.trace_gen_eq_sum_roots [Nontrivial S] (pb : PowerBasis K S)
    (hf : (minpoly K pb.gen).Splits (algebraMap K F)) :
    algebraMap K F (trace K S pb.gen) = ((minpoly K pb.gen).aroots F).sum
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem iteratedFDerivWithin_zero_eq : iteratedFDerivWithin 𝕜 0 f s = iteratedFDeriv 𝕜 0 f
-- Mathlib/CategoryTheory/Localization/SmallHom.lean
lemma equiv_equiv_symm (L : C ⥤ D) [L.IsLocalization W]
    (L' : C ⥤ D') [L'.IsLocalization W] (G : D ⥤ D')
    (e : L ⋙ G ≅ L') {X Y : C} [HasSmallLocalizedHom.{w} W X Y]
    (f : L.obj X ⟶ L.obj Y) :
    equiv W L' ((equiv W L).symm f) =
      e.inv.app X ≫ G.map f ≫ e.hom.app Y
-- Mathlib/Algebra/Order/ToIntervalMod.lean
/-- If `a` and `b` fall within the same cycle WRT `c`, then they are congruent modulo `p`. -/
@[simp]
theorem toIcoMod_inj {c : α} : toIcoMod hp c a = toIcoMod hp c b ↔ a ≡ b [PMOD p]
-- Mathlib/MeasureTheory/Measure/Restrict.lean
@[simp]
theorem restrict_univ : μ.restrict univ = μ
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem inter_def [BEq α] (l₁ l₂ : List α)  : l₁ ∩ l₂ = filter (elem · l₂) l₁
-- Mathlib/Algebra/GroupWithZero/Units/Equiv.lean
/-- Right multiplication by a nonzero element in a `GroupWithZero` is a permutation of the
underlying type. -/
@[simps! (config := .asFn)]
protected def mulRight₀ (a : G) (ha : a ≠ 0) : Perm G
-- Mathlib/Topology/MetricSpace/ThickenedIndicator.lean
theorem thickenedIndicator_one_of_mem_closure {δ : ℝ} (δ_pos : 0 < δ) (E : Set α) {x : α}
    (x_mem : x ∈ closure E) : thickenedIndicator δ_pos E x = 1
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
theorem KernelFork.app_one (s : KernelFork f) : s.π.app one = 0
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
theorem inf'_const (a : α) : (s.inf' H fun _ => a) = a
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc, simp]
theorem whiskerRight_tensor {X X' : C} (f : X ⟶ X') (Y Z : C) :
    f ▷ (Y ⊗ Z) = (α_ X Y Z).inv ≫ f ▷ Y ▷ Z ≫ (α_ X' Y Z).hom
-- Mathlib/RingTheory/DedekindDomain/SelmerGroup.lean
theorem fromUnit_ker [hn : Fact <| 0 < n] :
    (@fromUnit R _ _ K _ _ _ n).ker = (powMonoidHom n : Rˣ →* Rˣ).range
-- Mathlib/Data/Matroid/Map.lean
lemma map_dep_iff {hf} {D : Set β} :
    (M.map f hf).Dep D ↔ ∃ D₀, M.Dep D₀ ∧ D = f '' D₀
-- Mathlib/Algebra/Star/SelfAdjoint.lean
@[aesop 90% apply]
theorem add {x y : R} (hx : IsSelfAdjoint x) (hy : IsSelfAdjoint y) : IsSelfAdjoint (x + y)
-- Mathlib/Data/Finset/Lattice.lean
theorem sup_induction {p : α → Prop} (hb : p ⊥) (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊔ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.sup f)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp]
theorem filterMap_map (f : α → β) (g : β → Option γ) (l : List α) :
    filterMap g (map f l) = filterMap (g ∘ f) l
-- Mathlib/Data/Finset/Lattice.lean
/-- To rewrite from right to left, use `Finset.sup'_comp_eq_image`. -/
@[simp]
theorem sup'_image [DecidableEq β] {s : Finset γ} {f : γ → β} (hs : (s.image f).Nonempty)
    (g : β → α) :
    (s.image f).sup' hs g = s.sup' hs.of_image (g ∘ f)
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem mk_out (c : Cardinal) : #c.out = c
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem algebraicIndependent_empty [Nontrivial A] :
    AlgebraicIndependent K ((↑) : (∅ : Set A) → A)
-- Mathlib/Order/Bounds/Basic.lean
theorem Set.subsingleton_of_isLUB_le_isGLB (Ha : IsGLB s a) (Hb : IsLUB s b) (hab : b ≤ a) :
    s.Subsingleton
-- Mathlib/LinearAlgebra/Basis/VectorSpace.lean
@[simp]
theorem coe_extend (hs : LinearIndependent K ((↑) : s → V)) : ⇑(Basis.extend hs) = ((↑) : _ → _)
-- Mathlib/Combinatorics/Colex.lean
/-- The colexigraphic order is insensitive to removing the same elements from both sets. -/
lemma toColex_sdiff_lt_toColex_sdiff (hus : u ⊆ s) (hut : u ⊆ t) :
    toColex (s \ u) < toColex (t \ u) ↔ toColex s < toColex t
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem C_1 : C 1 = (1 : MvPolynomial σ R)
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
@[simp]
theorem Biprod.inr_ofComponents :
    biprod.inr ≫ Biprod.ofComponents f₁₁ f₁₂ f₂₁ f₂₂ = f₂₁ ≫ biprod.inl + f₂₂ ≫ biprod.inr
-- Mathlib/GroupTheory/Perm/List.lean
@[deprecated formPerm_apply_get_zero (since := "2024-05-30")]
theorem formPerm_apply_nthLe_zero (l : List α) (h : Nodup l) (hl : 1 < l.length) :
    formPerm l (l.nthLe 0 (by omega)) = l.nthLe 1 hl
-- Mathlib/Algebra/Star/Basic.lean
@[simp]
theorem commute_star_star {x y : R} : Commute (star x) (star y) ↔ Commute x y
-- Mathlib/RingTheory/Kaehler/Basic.lean
theorem KaehlerDifferential.D_apply (s : S) :
    KaehlerDifferential.D R S s =
      (KaehlerDifferential.ideal R S).toCotangent
        ⟨1 ⊗ₜ s - s ⊗ₜ 1, KaehlerDifferential.one_smul_sub_smul_one_mem_ideal R s⟩
-- Mathlib/Analysis/Normed/Operator/Compact.lean
theorem isCompactOperator_zero {M₁ M₂ : Type*} [Zero M₁] [TopologicalSpace M₁]
    [TopologicalSpace M₂] [Zero M₂] : IsCompactOperator (0 : M₁ → M₂)
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
theorem cocycle_snd_fst_fst (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.snd _ _ ≫ pullback.fst _ _ ≫
      pullback.fst _ _ = pullback.snd _ _ ≫ pullback.fst _ _ ≫ pullback.fst _ _
-- Mathlib/MeasureTheory/Function/UnifTight.lean
/-- This lemma is less general than `MeasureTheory.unifTight_finite` which applies to
all sequences indexed by a finite type. -/
private theorem unifTight_fin (hp_top : p ≠ ∞) {n : ℕ} {f : Fin n → α → β}
    (hf : ∀ i, Memℒp (f i) p μ) : UnifTight f p μ
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
@[simp, norm_cast]
theorem coe_monomial (n : σ →₀ ℕ) (a : R) :
    (monomial n a : MvPowerSeries σ R) = MvPowerSeries.monomial R n a
-- Mathlib/Order/SuccPred/Limit.lean
theorem not_isPredLimit_pred_of_not_isMin (ha : ¬IsMin a) : ¬IsPredLimit (pred a)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
/-- A subgroup is closed under division. -/
@[to_additive "An `AddSubgroup` is closed under subtraction."]
protected theorem div_mem {x y : G} (hx : x ∈ H) (hy : y ∈ H) : x / y ∈ H
-- Mathlib/Order/UpperLower/Basic.lean
@[norm_cast] lemma coe_ssubset_coe : (s : Set α) ⊂ t ↔ s < t
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
@[simp] lemma map_smul {f : Ω → Ω'} (c : ℝ≥0) (ν : FiniteMeasure Ω) :
    (c • ν).map f = c • (ν.map f)
-- Mathlib/Probability/Independence/Basic.lean
theorem IndepSets.inter {s₁ s' : Set (Set Ω)} (s₂ : Set (Set Ω)) (h₁ : IndepSets s₁ s' μ) :
    IndepSets (s₁ ∩ s₂) s' μ
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[simp]
theorem coe_comp (f : β →*₀o γ) (g : α →*₀o β) : (f.comp g : α → γ) = f ∘ g
-- Mathlib/Data/Set/Card.lean
theorem infinite_iff_infinite_of_encard_eq_encard (h : s.encard = t.encard) :
    s.Infinite ↔ t.Infinite
-- Mathlib/Topology/Order/Basic.lean
theorem pi_Ioi_mem_nhds (ha : ∀ i, a i < x i) : Ioi a ∈ 𝓝 x
-- Mathlib/RingTheory/Polynomial/ScaleRoots.lean
lemma isCoprime_scaleRoots (p q : R[X]) (r : R) (hr : IsUnit r) (h : IsCoprime p q) :
    IsCoprime (p.scaleRoots r) (q.scaleRoots r)
-- Mathlib/Data/Finmap.lean
@[simp]
theorem liftOn_toFinmap {γ} (s : AList β) (f : AList β → γ) (H) : liftOn ⟦s⟧ f H = f s
-- Mathlib/Analysis/Convex/Strong.lean
lemma UniformConcaveOn.add (hf : UniformConcaveOn s φ f) (hg : UniformConcaveOn s ψ g) :
    UniformConcaveOn s (φ + ψ) (f + g)
-- Mathlib/Computability/Primrec.lean
theorem dom_fintype [Finite α] (f : α → σ) : Primrec f
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
/-- If we know `f = 0`,
it requires a little work to conclude `image.ι f = 0`,
because `f = g` only implies `image f ≅ image g`.
-/
@[simp]
theorem image.ι_zero' [HasEqualizers C] {X Y : C} {f : X ⟶ Y} (h : f = 0) [HasImage f] :
    image.ι f = 0
-- Mathlib/Analysis/RCLike/Lemmas.lean
lemma aeval_conj (p : ℝ[X]) (z : K) : aeval (conj z) p = conj (aeval z p)
-- Mathlib/Topology/Order/ScottTopology.lean
@[simp, nolint simpNF]
lemma ofScott_inj {a b : WithScott α} : ofScott a = ofScott b ↔ a = b
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive (attr := simp)]
theorem coe_subtype : (SubmonoidClass.subtype S' : S' → M) = Subtype.val
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
/-- The extension of `f` to `yoneda.obj X` is unique. -/
theorem IsSheafFor.unique_extend {P : Cᵒᵖ ⥤ Type v₁} (h : IsSheafFor P S) {f : S.functor ⟶ P}
    (t : yoneda.obj X ⟶ P) (ht : S.functorInclusion ≫ t = f) : t = h.extend f
-- Mathlib/Data/Matroid/IndepAxioms.lean
/-- Construct an `Matroid` from an independence predicate that agrees with that of some matroid `M`.
  This is computable even if `M` is only known existentially, or when `M` exists for different
  reasons in different cases. This can also be used to change the independence predicate to a
  more useful definitional form. -/
@[simps! E] protected def ofExistsMatroid (E : Set α) (Indep : Set α → Prop)
    (hM : ∃ (M : Matroid α), E = M.E ∧ ∀ I, M.Indep I ↔ Indep I) : Matroid α
-- Mathlib/Order/CompleteLattice.lean
/-- The symmetric case of `iSup_and`, useful for rewriting into a supremum over a conjunction -/
theorem iSup_and' {p q : Prop} {s : p → q → α} :
    ⨆ (h₁ : p) (h₂ : q), s h₁ h₂ = ⨆ h : p ∧ q, s h.1 h.2