ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Triangulated/Basic.lean
@[simp, reassoc]
lemma comp_hom₃ {X Y Z : Triangle C} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).hom₃ = f.hom₃ ≫ g.hom₃
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem zero_imJ : (0 : ℍ[R,c₁,c₂]).imJ = 0
-- Mathlib/Data/List/Sigma.lean
theorem NodupKeys.kerase (a : α) : NodupKeys l → (kerase a l).NodupKeys
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
lemma hurwitzZetaOdd_neg (a : UnitAddCircle) (s : ℂ) :
    hurwitzZetaOdd (-a) s = -hurwitzZetaOdd a s
-- Mathlib/Topology/Homotopy/Basic.lean
@[simp]
theorem apply_zero (F : Homotopy f₀ f₁) (x : X) : F (0, x) = f₀ x
-- Mathlib/Data/Set/Prod.lean
theorem prod_range_range_eq {m₁ : α → γ} {m₂ : β → δ} :
    range m₁ ×ˢ range m₂ = range fun p : α × β => (m₁ p.1, m₂ p.2)
-- Mathlib/Analysis/PSeries.lean
theorem sum_schlomilch_le' (hf : ∀ ⦃m n⦄, 1 < m → m ≤ n → f n ≤ f m) (h_pos : ∀ n, 0 < u n)
    (hu : Monotone u) (n : ℕ) :
    (∑ k ∈ range n, (u (k + 1) - u k) • f (u (k + 1))) ≤ ∑ k ∈ Ico (u 0 + 1) (u n + 1), f k
-- Mathlib/Analysis/Convex/Segment.lean
theorem mem_segment_iff_sameRay : x ∈ [y -[𝕜] z] ↔ SameRay 𝕜 (x - y) (z - x)
-- Mathlib/Topology/Bornology/BoundedOperation.lean
lemma isBounded_mul [Bornology R] [Mul R] [BoundedMul R] {s t : Set R}
    (hs : Bornology.IsBounded s) (ht : Bornology.IsBounded t) :
    Bornology.IsBounded (s * t)
-- Mathlib/Data/List/Basic.lean
theorem filterMap_eq_bind_toList (f : α → Option β) (l : List α) :
    l.filterMap f = l.bind fun a ↦ (f a).toList
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem Matrix.toLinAlgEquiv'_one : Matrix.toLinAlgEquiv' (1 : Matrix n n R) = LinearMap.id
-- Mathlib/Algebra/Polynomial/Eval.lean
/-- `eval₂AddMonoidHom (f : R →+* S) (x : S)` is the `AddMonoidHom` from
`R[X]` to `S` obtained by evaluating the pushforward of `p` along `f` at `x`. -/
@[simps]
def eval₂AddMonoidHom : R[X] →+ S
-- Mathlib/CategoryTheory/LiftingProperties/Adjunction.lean
/-- A square has a lifting if and only if its (right) adjoint square has a lifting. -/
theorem right_adjoint_hasLift_iff : HasLift (sq.right_adjoint adj) ↔ HasLift sq
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem val_neg' {n : ZMod 0} : (-n).val = n.val
-- Mathlib/Geometry/Euclidean/PerpBisector.lean
@[simp] theorem right_mem_perpBisector : p₂ ∈ perpBisector p₁ p₂ ↔ p₁ = p₂
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma SMulPosMono.lift [SMulPosMono α γ]
    (hf : ∀ {b₁ b₂}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂)
    (smul : ∀ (a : α) b, f (a • b) = a • f b)
    (zero : f 0 = 0) : SMulPosMono α β
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem le_mul_right {a b : Cardinal} (h : b ≠ 0) : a ≤ a * b
-- Mathlib/Data/Int/Defs.lean
lemma natCast_succ (n : ℕ) : (Nat.succ n : ℤ) = Int.succ n
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem mul_sub (a b c : Int) : a * (b - c) = a * b - a * c
-- Mathlib/MeasureTheory/Measure/Sub.lean
@[simp]
theorem sub_top : μ - ⊤ = 0
-- .lake/packages/lean4/src/lean/Init/Classical.lean
theorem not_exists_not {p : α → Prop} : (¬∃ x, ¬p x) ↔ ∀ x, p x
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem mem_factors'_iff_dvd {a p : α} (ha0 : a ≠ 0) (hp : Irreducible p) :
    Subtype.mk (Associates.mk p) (irreducible_mk.2 hp) ∈ factors' a ↔ p ∣ a
-- Mathlib/RingTheory/Congruence/Basic.lean
@[simp]
theorem toCon_coe_eq_coe : (c.toCon : R → R → Prop) = c
-- Mathlib/Data/Finsupp/Basic.lean
theorem mapRange.zeroHom_comp (f : ZeroHom N P) (f₂ : ZeroHom M N) :
    (mapRange.zeroHom (f.comp f₂) : ZeroHom (α →₀ _) _) =
      (mapRange.zeroHom f).comp (mapRange.zeroHom f₂)
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem toQuadraticMap_list_sum (B : List (BilinMap R M N)) :
    B.sum.toQuadraticMap = (B.map toQuadraticMap).sum
-- Mathlib/Algebra/Polynomial/Degree/Lemmas.lean
theorem degree_mul_C (a0 : a ≠ 0) : (p * C a).degree = p.degree
-- Mathlib/Algebra/Algebra/Defs.lean
@[norm_cast]
theorem coe_prod {ι : Type*} {s : Finset ι} (a : ι → R) :
    (↑(∏ i ∈ s, a i : R) : A) = ∏ i ∈ s, (↑(a i) : A)
-- Mathlib/MeasureTheory/Measure/OpenPos.lean
theorem _root_.IsOpen.measure_zero_iff_eq_empty (hU : IsOpen U) :
    μ U = 0 ↔ U = ∅
-- Mathlib/Topology/Order/DenselyOrdered.lean
/-- The closure of the interval `[a, b)` is the closed interval `[a, b]`. -/
@[simp]
theorem closure_Ico {a b : α} (hab : a ≠ b) : closure (Ico a b) = Icc a b
-- Mathlib/Computability/TuringMachine.lean
@[simp, nolint simpNF]
theorem Tape.write_move_right_n {Γ} [Inhabited Γ] (f : Γ → Γ) (L R : ListBlank Γ) (n : ℕ) :
    ((Tape.move Dir.right)^[n] (Tape.mk' L R)).write (f (R.nth n)) =
      (Tape.move Dir.right)^[n] (Tape.mk' L (R.modifyNth f n))
-- Mathlib/FieldTheory/Minpoly/Basic.lean
/-- Given any `f : B →ₐ[A] B'` and any `x : L`, the minimal polynomial of `x` vanishes at `f x`. -/
@[simp]
theorem aeval_algHom (f : B →ₐ[A] B') (x : B) : (Polynomial.aeval (f x)) (minpoly A x) = 0
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem Decidable.not_iff [Decidable b] : ¬(a ↔ b) ↔ (¬a ↔ b)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem minimum?_eq_some_iff [Min α] [LE α] [anti : Antisymm ((· : α) ≤ ·)]
    (le_refl : ∀ a : α, a ≤ a)
    (min_eq_or : ∀ a b : α, min a b = a ∨ min a b = b)
    (le_min_iff : ∀ a b c : α, a ≤ min b c ↔ a ≤ b ∧ a ≤ c) {xs : List α} :
    xs.minimum? = some a ↔ a ∈ xs ∧ ∀ b, b ∈ xs → a ≤ b
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem UniqueMDiffOn.inter (hs : UniqueMDiffOn I s) (ht : IsOpen t) : UniqueMDiffOn I (s ∩ t)
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem IsCoprime.pow (H : IsCoprime x y) : IsCoprime (x ^ m) (y ^ n)
-- Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean
theorem strongEpi_of_epi [StrongEpiCategory C] (f : P ⟶ Q) [Epi f] : StrongEpi f
-- Mathlib/AlgebraicTopology/DoldKan/Projections.lean
theorem map_Q {D : Type*} [Category D] [Preadditive D] (G : C ⥤ D) [G.Additive]
    (X : SimplicialObject C) (q n : ℕ) :
    G.map ((Q q : K[X] ⟶ _).f n) = (Q q : K[((whiskering C D).obj G).obj X] ⟶ _).f n
-- Mathlib/NumberTheory/Zsqrtd/ToReal.lean
/-- The image of `Zsqrtd` in `ℝ`, using `Real.sqrt` which takes the positive root of `d`.

If the negative root is desired, use `toReal h (star a)`. -/
@[simps!]
noncomputable def toReal {d : ℤ} (h : 0 ≤ d) : ℤ√d →+* ℝ
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp, norm_cast]
theorem coe_smul (n : M) (f : CentroidHom α) : ⇑(n • f) = n • ⇑f
-- .lake/packages/lean4/src/lean/Init/ByCases.lean
/-- A function applied to a `dite` is a `dite` of that function applied to each of the branches. -/
theorem apply_dite (f : α → β) (P : Prop) [Decidable P] (x : P → α) (y : ¬P → α) :
    f (dite P x y) = dite P (fun h => f (x h)) (fun h => f (y h))
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
/-- Continuity from below: the measure of the union of a sequence of
(not necessarily measurable) sets is the supremum of the measures of the partial unions. -/
theorem measure_iUnion_eq_iSup' {α ι : Type*} [MeasurableSpace α] {μ : Measure α}
    [Countable ι] [Preorder ι] [IsDirected ι (· ≤ ·)]
    {f : ι → Set α} : μ (⋃ i, f i) = ⨆ i, μ (Accumulate f i)
-- Mathlib/Logic/Equiv/Set.lean
theorem eq_image_iff_symm_image_eq {α β} (e : α ≃ β) (s : Set α) (t : Set β) :
    t = e '' s ↔ e.symm '' t = s
-- Mathlib/Algebra/ModEq.lean
theorem modEq_rfl : a ≡ a [PMOD p]
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
theorem HasFDerivAtFilter.const_sub (hf : HasFDerivAtFilter f f' x L) (c : F) :
    HasFDerivAtFilter (fun x => c - f x) (-f') x L
-- Mathlib/LinearAlgebra/LinearPMap.lean
@[simp]
theorem zero_domain : (0 : E →ₗ.[R] F).domain = ⊤
-- Mathlib/Data/DFinsupp/WellFounded.lean
theorem Lex.acc (hbot : ∀ ⦃i a⦄, ¬s i a 0) (hs : ∀ i, WellFounded (s i))
    [DecidableEq ι] [∀ (i) (x : α i), Decidable (x ≠ 0)] (x : Π₀ i, α i)
    (h : ∀ i ∈ x.support, Acc (rᶜ ⊓ (· ≠ ·)) i) : Acc (DFinsupp.Lex r s) x
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
@[simp]
theorem dist_equiv_symm_single_same (i : ι) (b₁ b₂ : β i) :
    dist
        ((WithLp.equiv p (∀ i, β i)).symm (Pi.single i b₁))
        ((WithLp.equiv p (∀ i, β i)).symm (Pi.single i b₂)) =
      dist b₁ b₂
-- Mathlib/Data/Real/Hyperreal.lean
theorem infinite_iff_abs_lt_abs {x : ℝ*} : Infinite x ↔ ∀ r : ℝ, (|r| : ℝ*) < |x|
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
@[simp]
theorem natCast_apply [NatCast β] (n : ℕ) (x : α) : (n : α →ᵇ β) x = n
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
theorem ContMDiff.inv₀ (hf : ContMDiff I' I n f) (h0 : ∀ x, f x ≠ 0) :
    ContMDiff I' I n (fun x ↦ (f x)⁻¹)
-- Mathlib/Data/Set/Card.lean
@[simp] theorem ncard_subtype (P : α → Prop) (s : Set α) :
    { x : Subtype P | (x : α) ∈ s }.ncard = (s ∩ setOf P).ncard
-- Mathlib/Order/Filter/CountableSeparatingOn.lean
theorem exists_nonempty_countable_separating (α : Type*) {p : Set α → Prop} {s₀} (hp : p s₀)
    (t : Set α) [HasCountableSeparatingOn α p t] :
    ∃ S : Set (Set α), S.Nonempty ∧ S.Countable ∧ (∀ s ∈ S, p s) ∧
      ∀ x ∈ t, ∀ y ∈ t, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y
-- Mathlib/Order/MinMax.lean
theorem min_lt_max : min a b < max a b ↔ a ≠ b
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem sum_elim_dotProduct_sum_elim : Sum.elim u x ⬝ᵥ Sum.elim v y = u ⬝ᵥ v + x ⬝ᵥ y
-- Mathlib/Algebra/Module/Submodule/Range.lean
@[simp]
theorem map_subtype_embedding_eq (p' : Submodule R p) :
    MapSubtype.orderEmbedding p p' = map p.subtype p'
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[ext]
theorem hom_ext [Ring R] {d : ℤ} (f g : ℤ√d →+* R) (h : f sqrtd = g sqrtd) : f = g
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem norm_map (x : E) : ‖e x‖ = ‖x‖
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem and_and_left  : a ∧ (b ∧ c) ↔ (a ∧ b) ∧ a ∧ c
-- Mathlib/Topology/Bases.lean
@[simp]
theorem isSeparable_iUnion {ι : Sort*} [Countable ι] {s : ι → Set α} :
    IsSeparable (⋃ i, s i) ↔ ∀ i, IsSeparable (s i)
-- Mathlib/CategoryTheory/GradedObject/Single.lean
@[reassoc (attr := simp)]
lemma single_map_singleObjApplyIso_hom (j : J) {X Y : C} (f : X ⟶ Y) :
    (single j).map f j ≫ (singleObjApplyIso j Y).hom = (singleObjApplyIso j X).hom ≫ f
-- Mathlib/GroupTheory/HNNExtension.lean
@[simp]
theorem lift_t (f : G →* H) (x : H) (hx : ∀ a : A, x * f ↑a = f (φ a : G) * x) :
    lift f x hx t = x
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem getMsb_zeroExtend' (ge : m ≥ n) (x : BitVec n) (i : Nat) :
    getMsb (zeroExtend' ge x) i = (decide (i ≥ m - n) && getMsb x (i - (m - n)))
-- Mathlib/Analysis/Convex/Function.lean
theorem StrictConcaveOn.comp (hg : StrictConcaveOn 𝕜 (f '' s) g) (hf : StrictConcaveOn 𝕜 s f)
    (hg' : StrictMonoOn g (f '' s)) (hf' : s.InjOn f) : StrictConcaveOn 𝕜 s (g ∘ f)
-- Mathlib/Algebra/Associated/Basic.lean
theorem eq_of_prime_pow_eq (hp₁ : Prime p₁) (hp₂ : Prime p₂) (hk₁ : 0 < k₁)
    (h : p₁ ^ k₁ = p₂ ^ k₂) : p₁ = p₂
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem op_smul_finset_subset_mul : a ∈ t → op a • s ⊆ s * t
-- Mathlib/Geometry/Manifold/ContMDiff/Basic.lean
theorem smooth_id : Smooth I I (id : M → M)
-- Mathlib/Algebra/Module/LinearMap/Rat.lean
@[simp]
theorem AddMonoidHom.coe_toRatLinearMap [AddCommGroup M] [Module ℚ M] [AddCommGroup M₂]
    [Module ℚ M₂] (f : M →+ M₂) : ⇑f.toRatLinearMap = f
-- Mathlib/Tactic/Positivity/Basic.lean
private theorem pow_zero_pos [OrderedSemiring α] [Nontrivial α] (a : α) : 0 < a ^ 0
-- Mathlib/Algebra/Lie/Basic.lean
theorem nsmul_apply (n : ℕ) (f : M →ₗ⁅R,L⁆ N) (m : M) : (n • f) m = n • f m
-- Mathlib/Probability/Martingale/BorelCantelli.lean
/-- **Lévy's generalization of the Borel-Cantelli lemma**: given a sequence of sets `s` and a
filtration `ℱ` such that for all `n`, `s n` is `ℱ n`-measurable, `limsup s atTop` is almost
everywhere equal to the set for which `∑ k, ℙ(s (k + 1) | ℱ k) = ∞`. -/
theorem ae_mem_limsup_atTop_iff (μ : Measure Ω) [IsFiniteMeasure μ] {s : ℕ → Set Ω}
    (hs : ∀ n, MeasurableSet[ℱ n] (s n)) : ∀ᵐ ω ∂μ, ω ∈ limsup s atTop ↔
    Tendsto (fun n => ∑ k ∈ Finset.range n,
      (μ[(s (k + 1)).indicator (1 : Ω → ℝ)|ℱ k]) ω) atTop atTop
-- Mathlib/GroupTheory/ClassEquation.lean
/-- Conjugacy classes form a partition of G, stated in terms of cardinality. -/
theorem Group.sum_card_conj_classes_eq_card [Finite G] :
    ∑ᶠ x : ConjClasses G, x.carrier.ncard = Nat.card G
-- Mathlib/Order/Partition/Finpartition.lean
theorem biUnion_parts : P.parts.biUnion id = s
-- .lake/packages/batteries/Batteries/Data/UInt.lean
@[simp] theorem UInt32.val_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt32).val = OfNat.ofNat n
-- Mathlib/Data/Finset/Lattice.lean
theorem inf_attach (s : Finset β) (f : β → α) : (s.attach.inf fun x => f x) = s.inf f
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem expSeries_sum_eq (x : 𝔸) : (expSeries 𝕂 𝔸).sum x = ∑' n : ℕ, (n !⁻¹ : 𝕂) • x ^ n
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem proj_apply (i : ι) (f : ∀ i, P i) : @proj k _ ι V P _ _ _ i f = f i
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
private lemma expDegree_rec (m : ℕ) :
    (expDegree (2 * (m + 3)) = 2 * expDegree (m + 2) + expDegree (m + 3) + expDegree (m + 5) ∧
    expDegree (2 * (m + 3)) = expDegree (m + 1) + expDegree (m + 3) + 2 * expDegree (m + 4)) ∧
    (expDegree (2 * (m + 2) + 1) =
      expDegree (m + 4) + 3 * expDegree (m + 2) + (if Even m then 2 * 3 else 0) ∧
    expDegree (2 * (m + 2) + 1) =
      expDegree (m + 1) + 3 * expDegree (m + 3) + (if Even m then 0 else 2 * 3))
-- Mathlib/Topology/Semicontinuous.lean
theorem IsClosed.lowerSemicontinuousOn_indicator (hs : IsClosed s) (hy : y ≤ 0) :
    LowerSemicontinuousOn (indicator s fun _x => y) t
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
lemma isClosedMap_div_right (a : G) : IsClosedMap (· / a)
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem contDiffAt_zero : ContDiffAt 𝕜 0 f x ↔ ∃ u ∈ 𝓝 x, ContinuousOn f u
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
/-- Transposing a matrix preserves the determinant. -/
@[simp]
theorem det_transpose (M : Matrix n n R) : Mᵀ.det = M.det
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem comap_map_eq_self_of_injective
    {f : R →+* S} (hf : Function.Injective f) (s : Subsemiring R) : (s.map f).comap f = s
-- Mathlib/MeasureTheory/Constructions/EventuallyMeasurable.lean
theorem eventuallyMeasurableSet_of_mem_filter (hs : s ∈ l) : EventuallyMeasurableSet m l s
-- Mathlib/Data/Int/ModEq.lean
/-- To cancel a common factor `c` from a `ModEq` we must divide the modulus `m` by `gcd m c`. -/
theorem cancel_right_div_gcd (hm : 0 < m) (h : a * c ≡ b * c [ZMOD m]) :
    a ≡ b [ZMOD m / gcd m c]
-- Mathlib/Topology/PartitionOfUnity.lean
theorem toPartitionOfUnity_apply (i : ι) (x : X) :
    f.toPartitionOfUnity i x = f i x * ∏ᶠ (j) (_ : WellOrderingRel j i), (1 - f j x)
-- Mathlib/Data/Multiset/Basic.lean
theorem add_inter_distrib (s t u : Multiset α) : s + t ∩ u = (s + t) ∩ (s + u)
-- Mathlib/Order/Disjoint.lean
theorem codisjoint_left_comm : Codisjoint a (b ⊔ c) ↔ Codisjoint b (a ⊔ c)
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem enum_cons (s : Seq α) (x : α) :
    enum (cons x s) = cons (0, x) (map (Prod.map Nat.succ id) (enum s))
-- Mathlib/Algebra/Field/Basic.lean
@[field_simps]
theorem add_div' (a b c : α) (hc : c ≠ 0) : b + a / c = (b * c + a) / c
-- Mathlib/RingTheory/Polynomial/Content.lean
theorem content_eq_gcd_leadingCoeff_content_eraseLead (p : R[X]) :
    p.content = GCDMonoid.gcd p.leadingCoeff (eraseLead p).content
-- Mathlib/CategoryTheory/Idempotents/FunctorExtension.lean
/-- The natural isomorphism expressing that functors `Karoubi C ⥤ Karoubi D` obtained
using `functorExtension₁` actually extends the original functors `C ⥤ Karoubi D`. -/
@[simps!]
def functorExtension₁CompWhiskeringLeftToKaroubiIso :
    functorExtension₁ C D ⋙ (whiskeringLeft C (Karoubi C) (Karoubi D)).obj (toKaroubi C) ≅ 𝟭 _
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp]
theorem mul_symm (e : Perm α) : e * e.symm = 1
-- Mathlib/MeasureTheory/Measure/OpenPos.lean
theorem _root_.IsClosed.ae_eq_univ_iff_eq (hF : IsClosed F) :
    F =ᵐ[μ] univ ↔ F = univ
-- Mathlib/RingTheory/Valuation/Basic.lean
@[simp]
theorem map_neg (x : R) : v (-x) = v x
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem Iio_ae_eq_Iic' (ha : μ {a} = 0) : Iio a =ᵐ[μ] Iic a
-- Mathlib/Algebra/Associated/Basic.lean
@[simp]
theorem associated_zero_iff_eq_zero [MonoidWithZero α] (a : α) : a ~ᵤ 0 ↔ a = 0
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
/-- The conditional cdf is a strongly measurable function of `a : α` for all `x : ℝ`. -/
theorem stronglyMeasurable_condCDF (ρ : Measure (α × ℝ)) (x : ℝ) :
    StronglyMeasurable fun a ↦ condCDF ρ a x
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive prodMap_def]
theorem prodMap_def : prodMap f g = (f.comp (fst M N)).prod (g.comp (snd M N))
-- Mathlib/LinearAlgebra/Matrix/SchurComplement.lean
/-- A special case of the **Matrix determinant lemma** for when `A = I`. -/
theorem det_one_add_col_mul_row {ι : Type*} [Unique ι] (u v : m → α) :
    det (1 + col ι u * row ι v) = 1 + v ⬝ᵥ u
-- Mathlib/Data/Finmap.lean
@[elab_as_elim]
theorem induction_on {C : Finmap β → Prop} (s : Finmap β) (H : ∀ a : AList β, C ⟦a⟧) : C s
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem perm_append_right_iff {l₁ l₂ : List α} (l) : l₁ ++ l ~ l₂ ++ l ↔ l₁ ~ l₂
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma lt_inv_smul_iff_of_pos [PosSMulStrictMono α β] [PosSMulReflectLT α β] (ha : 0 < a) :
    b₁ < a⁻¹ • b₂ ↔ a • b₁ < b₂
-- Mathlib/Algebra/BigOperators/Ring/List.lean
@[simp] lemma sum_zipWith_distrib_left [Semiring R] (f : ι → κ → R) (a : R) :
    ∀ (l₁ : List ι) (l₂ : List κ),
      (zipWith (fun i j ↦ a * f i j) l₁ l₂).sum = a * (zipWith f l₁ l₂).sum
-- .lake/packages/lean4/src/lean/Init/Data/Option/Instances.lean
theorem some_inj {a b : α} : some a = some b ↔ a = b
-- Mathlib/RingTheory/PowerSeries/Basic.lean
theorem X_pow_eq (n : ℕ) : (X : R⟦X⟧) ^ n = monomial R n 1
-- Mathlib/RingTheory/SimpleModule.lean
theorem isSimpleModule_iff_isCoatom : IsSimpleModule R (M ⧸ m) ↔ IsCoatom m
-- Mathlib/CategoryTheory/FiberedCategory/Cartesian.lean
@[reassoc (attr := simp)]
lemma fac : IsCartesian.map p f φ φ' ≫ φ = φ'
-- Mathlib/GroupTheory/Perm/Basic.lean
theorem zpow_apply_comm {α : Type*} (σ : Perm α) (m n : ℤ) {x : α} :
    (σ ^ m) ((σ ^ n) x) = (σ ^ n) ((σ ^ m) x)
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem DifferentiableOn.smul (hc : DifferentiableOn 𝕜 c s) (hf : DifferentiableOn 𝕜 f s) :
    DifferentiableOn 𝕜 (fun y => c y • f y) s
-- Mathlib/Probability/Martingale/Centering.lean
theorem adapted_predictablePart : Adapted ℱ fun n => predictablePart f ℱ μ (n + 1)
-- Mathlib/CategoryTheory/Functor/FullyFaithful.lean
@[simp]
theorem preimage_comp (f : F.obj X ⟶ F.obj Y) (g : F.obj Y ⟶ F.obj Z) :
    F.preimage (f ≫ g) = F.preimage f ≫ F.preimage g
-- Mathlib/Data/Matroid/Basic.lean
theorem Base.finiteRk_of_finite (hB : M.Base B) (hfin : B.Finite) : FiniteRk M
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive (attr := gcongr) add_le_add]
theorem mul_le_mul' [CovariantClass α α (· * ·) (· ≤ ·)] [CovariantClass α α (swap (· * ·)) (· ≤ ·)]
    {a b c d : α} (h₁ : a ≤ b) (h₂ : c ≤ d) :
    a * c ≤ b * d
-- Mathlib/Data/Matroid/Map.lean
lemma comap_map {f : α → β} (hf : f.Injective) : (M.map f hf.injOn).comap f = M
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem hasFiniteIntegral_norm_iff (f : α → β) :
    HasFiniteIntegral (fun a => ‖f a‖) μ ↔ HasFiniteIntegral f μ
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma inv_smul_lt_iff_of_pos [PosSMulStrictMono α β] [PosSMulReflectLT α β] (ha : 0 < a) :
    a⁻¹ • b₁ < b₂ ↔ b₁ < a • b₂
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem erase_of_not_mem [LawfulBEq α] {a : α} : ∀ {l : List α}, a ∉ l → l.erase a = l
-- Mathlib/Topology/Sheaves/PresheafOfFunctions.lean
@[simp]
theorem presheafToType_map {T : Type v} {U V : (Opens X)ᵒᵖ} {i : U ⟶ V} {f} :
    (presheafToType X T).map i f = f ∘ i.unop
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
@[simp]
theorem Homeomorph.toMeasurableEquiv_symm_coe (h : γ ≃ₜ γ₂) :
    (h.toMeasurableEquiv.symm : γ₂ → γ) = h.symm
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem symm_symm (e : α ≃ β) : e.symm.symm = e
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem support_map : (p.map f).support = p.support.map f
-- Mathlib/Topology/Order/OrderClosed.lean
@[simp]
theorem continuousWithinAt_Ico_iff_Iio (h : a < b) :
    ContinuousWithinAt f (Ico a b) b ↔ ContinuousWithinAt f (Iio b) b
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
@[simp]
theorem mem_ofSubring (R : Subring K) (hR : ∀ x : K, x ∈ R ∨ x⁻¹ ∈ R) (x : K) :
    x ∈ ofSubring R hR ↔ x ∈ R
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem nthRoots_eq {n : ℕ} {ζ : R} (hζ : IsPrimitiveRoot ζ n)
    {α a : R} (e : α ^ n = a) :
    nthRoots n a = (Multiset.range n).map (ζ ^ · * α)
-- .lake/packages/lean4/src/lean/Init/Omega/Int.lean
theorem ofNat_shiftRight_eq_div_pow {x y : Nat} : (x >>> y : Int) = (x : Int) / (2 ^ y : Nat)
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem surjOn_logb : SurjOn (logb b) (Ioi 0) univ
-- Mathlib/Algebra/Order/Floor/Div.lean
@[simp]
lemma ceilDiv_le_iff_le_smul (ha : 0 < a) : b ⌈/⌉ a ≤ c ↔ b ≤ a • c
-- Mathlib/Topology/Order/Lattice.lean
lemma ContinuousWithinAt.finset_sup
    (hs : ∀ i ∈ s, ContinuousWithinAt (f i) t x) : ContinuousWithinAt (s.sup f) t x
-- Mathlib/Data/SetLike/Basic.lean
/-- Note: implementers of `SetLike` must copy this lemma in order to tag it with `@[ext]`. -/
theorem ext (h : ∀ x, x ∈ p ↔ x ∈ q) : p = q
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem _root_.IsCoprime.add_eq (h : IsCoprime I J) : I + J = 1
-- Mathlib/Order/Heyting/Hom.lean
@[simp]
theorem toFun_eq_coe_aux {f : HeytingHom α β} : (↑f.toLatticeHom) = ⇑f
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem integral_Iic_add_Ioi (h_left : IntegrableOn f (Iic b) μ)
    (h_right : IntegrableOn f (Ioi b) μ) :
    (∫ x in Iic b, f x ∂μ) + (∫ x in Ioi b, f x ∂μ) = ∫ (x : ℝ), f x ∂μ
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem continuousOn_smul [LocallyCompactSpace X] [T2Space X] {𝕜 : Type*} [NormedField 𝕜]
    [SecondCountableTopologyEither X 𝕜] [NormedSpace 𝕜 E] {f : X → E} {g : X → 𝕜} {s : Set X}
    (hs : IsOpen s) (hf : LocallyIntegrableOn f s μ) (hg : ContinuousOn g s) :
    LocallyIntegrableOn (fun x => g x • f x) s μ
-- Mathlib/Algebra/Lie/Weights/Basic.lean
lemma map_posFittingComp_eq (e : M ≃ₗ⁅R,L⁆ M₂) :
    (posFittingComp R L M).map e = posFittingComp R L M₂
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
@[simp]
theorem fractRestrict_apply (x : E) : (fractRestrict b x : E) = fract b x
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp]
theorem prev_nat_succ (i : ℕ) : (ComplexShape.up ℕ).prev (i + 1) = i
-- Mathlib/MeasureTheory/Function/LocallyIntegrable.lean
theorem IntegrableOn.mul_continuousOn_of_subset (hg : IntegrableOn g A μ) (hg' : ContinuousOn g' K)
    (hA : MeasurableSet A) (hK : IsCompact K) (hAK : A ⊆ K) :
    IntegrableOn (fun x => g x * g' x) A μ
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[simp]
lemma DifferentiableAt.sub_iff_right (hg : DifferentiableAt 𝕜 f x) :
    DifferentiableAt 𝕜 (fun y => f y - g y) x ↔ DifferentiableAt 𝕜 g x
-- Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean
theorem finrank_zero_iff_forall_zero [FiniteDimensional K V] : finrank K V = 0 ↔ ∀ x : V, x = 0
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
@[simp] theorem getLeft?_swap (x : α ⊕ β) : x.swap.getLeft? = x.getRight?
-- Mathlib/Algebra/Module/Injective.lean
theorem chain_linearPMap_of_chain_extensionOf {c : Set (ExtensionOf i f)}
    (hchain : IsChain (· ≤ ·) c) :
    IsChain (· ≤ ·) <| (fun x : ExtensionOf i f => x.toLinearPMap) '' c
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
theorem equicontinuousWithinAt_iInf_dom {t : κ → TopologicalSpace X'} {F : ι → X' → α}
    {S : Set X'} {x₀ : X'} {k : κ} (hk : EquicontinuousWithinAt (tX := t k) F S x₀) :
    EquicontinuousWithinAt (tX := ⨅ k, t k) F S x₀
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
@[reassoc (attr := simp)]
theorem map_lift_piComparison [HasProduct f] [HasProduct fun b => G.obj (f b)] (P : C)
    (g : ∀ j, P ⟶ f j) : G.map (Pi.lift g) ≫ piComparison G f = Pi.lift fun j => G.map (g j)