ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/Matrix/SchurComplement.lean
/-- The **Matrix determinant lemma**

TODO: show the more general version without `hA : IsUnit A.det` as
`(A + col u * row v).det = A.det + v ⬝ᵥ (adjugate A) *ᵥ u`.
-/
theorem det_add_col_mul_row {ι : Type*} [Unique ι]
    {A : Matrix m m α} (hA : IsUnit A.det) (u v : m → α) :
    (A + col ι u * row ι v).det = A.det * (1 + row ι v * A⁻¹ * col ι u).det
-- Mathlib/Topology/Basic.lean
/-- A predicate is true in a neighborhood of `x` iff it is true for all the points in an open set
containing `x`. -/
theorem eventually_nhds_iff {p : X → Prop} :
    (∀ᶠ y in 𝓝 x, p y) ↔ ∃ t : Set X, (∀ y ∈ t, p y) ∧ IsOpen t ∧ x ∈ t
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem filter_map (f : β → α) (l : List β) : filter p (map f l) = map f (filter (p ∘ f) l)
-- Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean
theorem compl_neighborFinset_sdiff_inter_eq {v w : V} :
    (G.neighborFinset v)ᶜ \ {v} ∩ ((G.neighborFinset w)ᶜ \ {w}) =
      ((G.neighborFinset v)ᶜ ∩ (G.neighborFinset w)ᶜ) \ ({w} ∪ {v})
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp] theorem lTensor_trans_rTensor (f : M ≃ₗ[R] P) (g : N ≃ₗ[R] Q) :
    g.lTensor M ≪≫ₗ f.rTensor Q = TensorProduct.congr f g
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
@[simp]
theorem mk_len (n : SimplexCategory) : ([n.len] : SimplexCategory) = n
-- Mathlib/Tactic/Ring/Basic.lean
theorem pow_atom (a : R) (b) : a ^ b = a ^ b * (nat_lit 1).rawCast + 0
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_add {f g : α → G} (hf : Integrable f μ) (hg : Integrable g μ) :
    ∫ a, f a + g a ∂μ = ∫ a, f a ∂μ + ∫ a, g a ∂μ
-- Mathlib/Algebra/Lie/Nilpotent.lean
lemma map_lowerCentralSeries_eq {f : M →ₗ⁅R,L⁆ M₂} (hf : Function.Surjective f) :
    (lowerCentralSeries R L M k).map f = lowerCentralSeries R L M₂ k
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The minimal distances to a set and its closure coincide. -/
theorem infDist_closure : infDist x (closure s) = infDist x s
-- Mathlib/Algebra/BigOperators/GroupWithZero/Finset.lean
lemma support_prod_subset (s : Finset ι) (f : ι → κ → M₀) :
    support (fun x ↦ ∏ i ∈ s, f i x) ⊆ ⋂ i ∈ s, support (f i)
-- Mathlib/CategoryTheory/Localization/SmallHom.lean
@[simp]
lemma equiv_mk (L : C ⥤ D) [L.IsLocalization W] {X Y : C}
    [HasSmallLocalizedHom.{w} W X Y] (f : X ⟶ Y) :
    equiv.{w} W L (mk W f) = L.map f
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem zeroLocus_inf (I J : Ideal A) :
    zeroLocus 𝒜 ((I ⊓ J : Ideal A) : Set A) = zeroLocus 𝒜 I ∪ zeroLocus 𝒜 J
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma preΨ'_two : W.preΨ' 2 = 1
-- Mathlib/Data/Fintype/Card.lean
theorem exists_pair_of_one_lt_card (h : 1 < card α) : ∃ a b : α, a ≠ b
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp, norm_cast] theorem intCast_add (a b : Int) :
    ((a + b : Int) : Rat) = (a : Rat) + (b : Rat)
-- Mathlib/SetTheory/Cardinal/Continuum.lean
@[simp]
theorem nat_mul_continuum {n : ℕ} (hn : n ≠ 0) : ↑n * 𝔠 = 𝔠
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem length_reverse (s : Cycle α) : s.reverse.length = s.length
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem coe_toFinset (s : Set α) [Fintype s] : (↑s.toFinset : Set α) = s
-- Mathlib/RingTheory/Polynomial/Basic.lean
/-- The push-forward of an ideal `I` of `R` to `R[X]` via inclusion
 is exactly the set of polynomials whose coefficients are in `I` -/
theorem mem_map_C_iff {I : Ideal R} {f : R[X]} :
    f ∈ (Ideal.map (C : R →+* R[X]) I : Ideal R[X]) ↔ ∀ n : ℕ, f.coeff n ∈ I
-- Mathlib/RingTheory/Coalgebra/Hom.lean
theorem copy_eq (f : A →ₗc[R] B) (f' : A → B) (h : f' = ⇑f) : f.copy f' h = f
-- Mathlib/RingTheory/Nilpotent/Basic.lean
theorem add_pow_add_eq_zero_of_pow_eq_zero (h_comm : Commute x y) {m n : ℕ}
    (hx : x ^ m = 0) (hy : y ^ n = 0) :
    (x + y) ^ (m + n - 1) = 0
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
theorem symm_bijective :
    Function.Bijective (MeasurableEquiv.symm : (α ≃ᵐ β) → β ≃ᵐ α)
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNorm_map_measure (hg : AEStronglyMeasurable g (Measure.map f μ))
    (hf : AEMeasurable f μ) : eLpNorm g p (Measure.map f μ) = eLpNorm (g ∘ f) p μ
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem le_translationNumber_of_add_nat_le {x : ℝ} {m : ℕ} (h : x + m ≤ f x) : ↑m ≤ τ f
-- Mathlib/Topology/Compactness/LocallyCompact.lean
/-- If `f : X → Y` is a continuous map in a locally compact pair of topological spaces,
`K : set X` is a compact set, and `U` is an open neighbourhood of `f '' K`,
then there exists a compact neighbourhood `L` of `K` such that `f` maps `L` to `U`.

This is a generalization of `exists_mem_nhds_isCompact_mapsTo`. -/
lemma exists_mem_nhdsSet_isCompact_mapsTo [LocallyCompactPair X Y] {f : X → Y} {K : Set X}
    {U : Set Y} (hf : Continuous f) (hK : IsCompact K) (hU : IsOpen U) (hKU : MapsTo f K U) :
    ∃ L ∈ 𝓝ˢ K, IsCompact L ∧ MapsTo f L U
-- Mathlib/Data/Fin/Basic.lean
@[simp] lemma range_succ (n : ℕ) : Set.range (Fin.succ : Fin n → Fin (n + 1)) = {0}ᶜ
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
@[simp] theorem isNone_some : isNone (some a) = false
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
theorem eq_withDensity_rnDeriv₀ {s : Measure α} {f : α → ℝ≥0∞}
    (hf : AEMeasurable f ν) (hs : s ⟂ₘ ν) (hadd : μ = s + ν.withDensity f) :
    ν.withDensity f = ν.withDensity (μ.rnDeriv ν)
-- Mathlib/Geometry/Euclidean/PerpBisector.lean
theorem Isometry.preimage_perpBisector {f : P → P'} (h : Isometry f) (p₁ p₂ : P) :
    f ⁻¹' (perpBisector (f p₁) (f p₂)) = perpBisector p₁ p₂
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[reassoc (attr := simp)]
lemma rightHomologyIso_inv_comp_rightHomologyι :
    h.rightHomologyIso.inv ≫ S.rightHomologyι = h.ι ≫ h.opcyclesIso.inv
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem le_sup_sdiff_sup_sdiff : a ≤ b ⊔ (a \ c ⊔ c \ b)
-- Mathlib/Analysis/Calculus/FDeriv/Analytic.lean
lemma cPolyomialOn : CPolynomialOn 𝕜 f ⊤
-- Mathlib/Topology/MetricSpace/Polish.lean
theorem IsClopenable.iUnion [t : TopologicalSpace α] [PolishSpace α] {s : ℕ → Set α}
    (hs : ∀ n, IsClopenable (s n)) : IsClopenable (⋃ n, s n)
-- Mathlib/NumberTheory/Cyclotomic/PrimitiveRoots.lean
theorem aeval_zeta [IsDomain B] [NeZero ((n : ℕ) : B)] :
    aeval (zeta n A B) (cyclotomic n A) = 0
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
@[simp]
protected theorem single_smul (p) (i : α) (a : E i) (c : 𝕜) :
    lp.single p i (c • a) = c • lp.single p i a
-- Mathlib/Data/Set/Basic.lean
theorem subset_of_mem_powerset {x s : Set α} (h : x ∈ 𝒫 s) : x ⊆ s
-- Mathlib/Order/SuccPred/Basic.lean
theorem succ_le_iff_eq_top : succ a ≤ a ↔ a = ⊤
-- Mathlib/Algebra/Regular/SMul.lean
/-- The element `0` is `M`-regular if and only if `M` is trivial. -/
theorem zero_iff_subsingleton : IsSMulRegular M (0 : R) ↔ Subsingleton M
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem MDifferentiable.neg (hf : MDifferentiable I 𝓘(𝕜, E') f) : MDifferentiable I 𝓘(𝕜, E') (-f)
-- Mathlib/Algebra/GradedMonoid.lean
/-- A version of `GradedMonoid.GOne` for internally graded objects. -/
class SetLike.GradedOne {S : Type*} [SetLike S R] [One R] [Zero ι] (A : ι → S) : Prop where
  /-- One has grade zero -/
  one_mem : (1 : R) ∈ A 0
-- Mathlib/Algebra/Category/ModuleCat/Sheaf/Free.lean
lemma freeHomEquiv_symm_comp {M N : SheafOfModules.{u} R} {I : Type u} (s : I → M.sections)
    (p : M ⟶ N) :
    M.freeHomEquiv.symm s ≫ p = N.freeHomEquiv.symm (fun i ↦ sectionsMap p (s i))
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem getMsb_shiftLeft (x : BitVec w) (i) :
    (x <<< i).getMsb k = x.getMsb (k + i)
-- Mathlib/Order/Compare.lean
@[simp]
theorem ofDual_compares_ofDual [LT α] {a b : αᵒᵈ} {o : Ordering} :
    Compares o (ofDual a) (ofDual b) ↔ Compares o b a
-- Mathlib/Analysis/Normed/Operator/WeakOperatorTopology.lean
@[simp] lemma neg_apply {f : E →WOT[𝕜] F} (x : E) : (-f) x = -(f x)
-- Mathlib/Topology/DiscreteQuotient.lean
@[simp]
theorem map_comp_proj (cond : LEComap f A B) : map f cond ∘ A.proj = B.proj ∘ f
-- Mathlib/RingTheory/PolynomialAlgebra.lean
theorem invFun_monomial (n : ℕ) (a : A) :
    invFun R A (monomial n a) = (a ⊗ₜ[R] 1) * 1 ⊗ₜ[R] X ^ n
-- Mathlib/Data/Nat/Pairing.lean
@[simp]
theorem unpair_pair (a b : ℕ) : unpair (pair a b) = (a, b)
-- Mathlib/Algebra/Quaternion.lean
nonrec theorem star_eq_two_re_sub : star a = ↑(2 * a.re) - a
-- Mathlib/Data/List/Sublists.lean
theorem range_bind_sublistsLen_perm (l : List α) :
    ((List.range (l.length + 1)).bind fun n => sublistsLen n l) ~ sublists' l
-- Mathlib/Analysis/NormedSpace/MatrixExponential.lean
theorem IsHermitian.exp [StarRing 𝔸] [ContinuousStar 𝔸] {A : Matrix m m 𝔸} (h : A.IsHermitian) :
    (exp 𝕂 A).IsHermitian
-- Mathlib/Algebra/MonoidAlgebra/Support.lean
/-- An element of `k[G]` is in the submodule generated by its support. -/
theorem mem_span_support [AddZeroClass G] (f : k[G]) :
    f ∈ Submodule.span k (of k G '' (f.support : Set G))
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
@[to_additive (attr := norm_cast) (reorder := 7 8)]
theorem coe_zpow [Group β] [TopologicalGroup β] (f : C(α, β)) (z : ℤ) : ⇑(f ^ z) = (⇑f) ^ z
-- Mathlib/Data/Rat/Cast/Defs.lean
@[norm_cast]
lemma cast_inv_of_ne_zero (hq : (q.num : α) ≠ 0) : (q⁻¹ : ℚ≥0) = (q⁻¹ : α)
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
theorem orderOf_eq_prime (hg : x ^ p = 1) (hg1 : x ≠ 1) : orderOf x = p
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem restrict_range (f : G →* N) : (f.restrict K).range = K.map f
-- Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean
/-- Convergence in the metric on `C₀(α, β)` is uniform convergence. -/
theorem tendsto_iff_tendstoUniformly {ι : Type*} {F : ι → C₀(α, β)} {f : C₀(α, β)} {l : Filter ι} :
    Tendsto F l (𝓝 f) ↔ TendstoUniformly (fun i => F i) f l
-- Mathlib/Data/Part.lean
@[simp]
theorem some_dom (a : α) : (some a).Dom
-- Mathlib/Order/CompleteLattice.lean
/-- A version of `iInf_option` useful for rewriting right-to-left. -/
theorem iInf_option_elim (a : α) (f : β → α) : ⨅ o : Option β, o.elim a f = a ⊓ ⨅ b, f b
-- Mathlib/SetTheory/Cardinal/ENat.lean
lemma toENatAux_nat (n : ℕ) : toENatAux n = n
-- Mathlib/Algebra/Polynomial/Expand.lean
@[simp]
theorem coeff_expand_mul {p : ℕ} (hp : 0 < p) (f : R[X]) (n : ℕ) :
    (expand R p f).coeff (n * p) = f.coeff n
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
@[simp] theorem drop_replicate (a : α) : ∀ n m : Nat, drop n (replicate m a) = replicate (m - n) a
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem IsRegular.pos {c : Cardinal} (H : c.IsRegular) : 0 < c
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem mul_inv_eq_one : a * b⁻¹ = 1 ↔ a = b
-- Mathlib/Data/Fin/Tuple/Basic.lean
@[simp]
theorem snoc_cast_add {α : Fin (n + m + 1) → Type*} (f : ∀ i : Fin (n + m), α (castSucc i))
    (a : α (last (n + m))) (i : Fin n) : (snoc f a) (castAdd (m + 1) i) = f (castAdd m i)
-- Mathlib/Data/Matroid/Restrict.lean
@[simp] protected theorem Matroidᵣ.le_iff {M M' : Matroidᵣ α} :
    M ≤ M' ↔ (M : Matroid α) ≤r (M' : Matroid α)
-- Mathlib/Analysis/RCLike/Basic.lean
@[rclike_simps]
theorem im_ofReal_mul (r : ℝ) (z : K) : im (↑r * z) = r * im z
-- Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean
theorem colimit_topology (F : J ⥤ TopCat.{max v u}) :
    (colimit F).str = ⨆ j, (F.obj j).str.coinduced (colimit.ι F j)
-- Mathlib/Order/Minimal.lean
theorem map_mem_maximals_iff (ha : a ∈ x) : f a ∈ maximals s (f '' x) ↔ a ∈ maximals r x
-- Mathlib/FieldTheory/ChevalleyWarning.lean
theorem MvPolynomial.sum_eval_eq_zero (f : MvPolynomial σ K)
    (h : f.totalDegree < (q - 1) * Fintype.card σ) : ∑ x, eval x f = 0
-- Mathlib/Topology/Connected/Basic.lean
theorem IsPreconnected.subset_right_of_subset_union (hu : IsOpen u) (hv : IsOpen v)
    (huv : Disjoint u v) (hsuv : s ⊆ u ∪ v) (hsv : (s ∩ v).Nonempty) (hs : IsPreconnected s) :
    s ⊆ v
-- Mathlib/Order/SuccPred/Limit.lean
theorem IsSuccLimit.succ_lt (hb : IsSuccLimit b) (ha : a < b) : succ a < b
-- Mathlib/Topology/Order/ScottTopology.lean
@[simp, nolint simpNF]
lemma toScott_inj {a b : α} : toScott a = toScott b ↔ a = b
-- Mathlib/Analysis/NormedSpace/HahnBanach/SeparatingDual.lean
/-- Given a finite-dimensional subspace `W` of a space `V` with separating dual, any
  linear functional on `W` extends to a continuous linear functional on `V`.
  This is stated more generally for an injective linear map from `W` to `V`. -/
theorem dualMap_surjective_iff {W} [AddCommGroup W] [Module R W] [FiniteDimensional R W]
    {f : W →ₗ[R] V} : Surjective (f.dualMap ∘ ContinuousLinearMap.toLinearMap) ↔ Injective f
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem star_smul [Monoid S] [DistribMulAction S R] (s : S) (a : ℍ[R]) :
    star (s • a) = s • star a
-- Mathlib/Data/Nat/Bitwise.lean
@[simp]
theorem xor_bit : ∀ a m b n, bit a m ^^^ bit b n = bit (bne a b) (m ^^^ n)
-- Mathlib/LinearAlgebra/Basis.lean
theorem reindexRange_repr_self (i : ι) :
    b.reindexRange.repr (b i) = Finsupp.single ⟨b i, mem_range_self i⟩ 1
-- Mathlib/Data/Real/Archimedean.lean
theorem sInf_def (S : Set ℝ) : sInf S = -sSup (-S)
-- Mathlib/Topology/Category/CompHausLike/Basic.lean
@[simp]
theorem coe_id (X : CompHausLike P) : (𝟙 ((forget (CompHausLike P)).obj X)) = id
-- Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean
@[ext]
theorem ext {f g : C₀(α, β)} (h : ∀ x, f x = g x) : f = g
-- Mathlib/Analysis/Convex/Cone/Basic.lean
@[simp]
theorem mem_comap {f : E →ₗ[𝕜] F} {S : ConvexCone 𝕜 F} {x : E} : x ∈ S.comap f ↔ f x ∈ S
-- Mathlib/RingTheory/LocalProperties.lean
/-- If `S` is an `R' = M⁻¹R` algebra, and `x ∈ adjoin R' s`,
then `t • x ∈ adjoin R s` for some `t : M`. -/
theorem multiple_mem_adjoin_of_mem_localization_adjoin [Algebra R' S] [Algebra R S]
    [IsScalarTower R R' S] [IsLocalization M R'] (s : Set S) (x : S)
    (hx : x ∈ Algebra.adjoin R' s) : ∃ t : M, t • x ∈ Algebra.adjoin R s
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
/-- this is slightly different from `StronglyMeasurable.piecewise`. It can be used to show
`StronglyMeasurable (ite (x=0) 0 1)` by
`exact StronglyMeasurable.ite (measurableSet_singleton 0) stronglyMeasurable_const
stronglyMeasurable_const`, but replacing `StronglyMeasurable.ite` by
`StronglyMeasurable.piecewise` in that example proof does not work. -/
protected theorem ite {_ : MeasurableSpace α} [TopologicalSpace β] {p : α → Prop}
    {_ : DecidablePred p} (hp : MeasurableSet { a : α | p a }) (hf : StronglyMeasurable f)
    (hg : StronglyMeasurable g) : StronglyMeasurable fun x => ite (p x) (f x) (g x)
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem ae_restrict_biUnion_iff (s : ι → Set α) {t : Set ι} (ht : t.Countable) (p : α → Prop) :
    (∀ᵐ x ∂μ.restrict (⋃ i ∈ t, s i), p x) ↔ ∀ i ∈ t, ∀ᵐ x ∂μ.restrict (s i), p x
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem mul_principal_add_is_principal_add (a : Ordinal.{u}) {b : Ordinal.{u}} (hb₁ : b ≠ 1)
    (hb : Principal (· + ·) b) : Principal (· + ·) (a * b)
-- Mathlib/Topology/TietzeExtension.lean
/-- Any retract of a `TietzeExtension` space is one itself. -/
theorem TietzeExtension.of_retract {Y : Type v} {Z : Type w} [TopologicalSpace Y]
    [TopologicalSpace Z] [TietzeExtension.{u, w} Z] (ι : C(Y, Z)) (r : C(Z, Y))
    (h : r.comp ι = .id Y) : TietzeExtension.{u, v} Y
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem head_cons : @head α (a::l) h = a
-- Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean
protected theorem dist_comm (z w : ℍ) : dist z w = dist w z
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem map_ciInf (e : α ≃o β) {f : ι → α} (hf : BddBelow (range f)) :
    e (⨅ i, f i) = ⨅ i, e (f i)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem tan_toReal (θ : Angle) : Real.tan θ.toReal = tan θ
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem union_ae_eq_left_iff_ae_subset : (s ∪ t : Set α) =ᵐ[μ] s ↔ t ≤ᵐ[μ] s
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
theorem Lex.mono_right (hs : ∀ a b, s₁ a b → s₂ a b) (h : Lex r s₁ x y) : Lex r s₂ x y
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem mem_rangeS_self (f : R →+* S) (x : R) : f x ∈ f.rangeS
-- Mathlib/Tactic/NormNum/LegendreSymbol.lean
theorem jacobiSymNat.qr₁'_mod (a b ab : ℕ) (r : ℤ) (ha : a % 2 = 1) (hb : b % 4 = 1)
    (hab : b % a = ab) (hr : jacobiSymNat ab a = r) : jacobiSymNat a b = r
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
theorem nndist_eq_of_L2 {β : ι → Type*} [∀ i, SeminormedAddCommGroup (β i)] (x y : PiLp 2 β) :
    nndist x y = NNReal.sqrt (∑ i, nndist (x i) (y i) ^ 2)
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem mod_eq_zero_of_dvd : ∀ {a b : Int}, a ∣ b → mod b a = 0
-- Mathlib/RingTheory/LaurentSeries.lean
@[simp, norm_cast]
theorem coe_neg : ((-f : RatFunc F) : LaurentSeries F) = -f
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
@[measurability]
protected theorem measurable (e : α ≃ᵐ β) : Measurable (e : α → β)
-- Mathlib/Data/ENNReal/Basic.lean
@[simp] theorem zero_lt_top : 0 < ∞
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- Viewing a module as an affine space modelled on itself, we can characterise affine independence
in terms of linear combinations. -/
theorem affineIndependent_iff {ι} {p : ι → V} :
    AffineIndependent k p ↔
      ∀ (s : Finset ι) (w : ι → k), s.sum w = 0 → ∑ e ∈ s, w e • p e = 0 → ∀ e ∈ s, w e = 0
-- Mathlib/Topology/Algebra/Order/UpperLower.lean
protected theorem IsOpen.upperClosure : IsOpen s → IsOpen (upperClosure s : Set α)
-- Mathlib/Algebra/AddConstMap/Basic.lean
theorem map_add_one [AddMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
    (f : F) (x : G) : f (x + 1) = f x + b
-- Mathlib/Algebra/Algebra/NonUnitalHom.lean
@[simp]
theorem coe_inr : (inr R A B : B → A × B) = Prod.mk 0
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
@[simp]
theorem isAdjointPair_toBilin [DecidableEq n] :
    BilinForm.IsAdjointPair (Matrix.toBilin b J) (Matrix.toBilin b J₃) (Matrix.toLin b b A)
        (Matrix.toLin b b A') ↔
      Matrix.IsAdjointPair J J₃ A A'
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem FactorSet.coe_add {a b : Multiset { a : Associates α // Irreducible a }} :
    (↑(a + b) : FactorSet α) = a + b
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem AlgebraicIndependent.isTranscendenceBasis_iff {ι : Type w} {R : Type u} [CommRing R]
    [Nontrivial R] {A : Type v} [CommRing A] [Algebra R A] {x : ι → A}
    (i : AlgebraicIndependent R x) :
    IsTranscendenceBasis R x ↔
      ∀ (κ : Type v) (w : κ → A) (_ : AlgebraicIndependent R w) (j : ι → κ) (_ : w ∘ j = x),
        Surjective j
-- Mathlib/Algebra/Lie/Subalgebra.lean
/-- If a predicate `p` is true on some set `s ⊆ L`, true for `0`, stable by scalar multiplication,
by addition and by Lie bracket, then the predicate is true on the Lie span of `s`. (Since `s` can be
empty, and the Lie span always contains `0`, the assumption that `p 0` holds cannot be removed.) -/
@[elab_as_elim]
theorem lieSpan_induction {p : L → Prop} {x : L} (h : x ∈ lieSpan R L s) (mem : ∀ x ∈ s, p x)
    (zero : p 0) (smul : ∀ (r : R), ∀ {x : L}, p x → p (r • x))
    (add : ∀ x y, p x → p y → p (x + y)) (lie : ∀ x y, p x → p y → p ⁅x, y⁆) : p x
-- Mathlib/CategoryTheory/Localization/Construction.lean
/-- A `MorphismProperty` in `W.Localization` is satisfied by all
morphisms in the localized category if it contains the image of the
morphisms in the original category, if is stable under composition
and if the property is stable by passing to inverses. -/
theorem morphismProperty_is_top' (P : MorphismProperty W.Localization)
    [P.IsStableUnderComposition] (hP₁ : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), P (W.Q.map f))
    (hP₂ : ∀ ⦃X Y : W.Localization⦄ (e : X ≅ Y) (_ : P e.hom), P e.inv) : P = ⊤
-- Mathlib/Order/Interval/Set/Basic.lean
theorem _root_.IsMax.Ioi_eq (h : IsMax a) : Ioi a = ∅
-- Mathlib/Data/Finsupp/AList.lean
@[simp]
theorem insert_lookupFinsupp [DecidableEq α] (l : AList fun _x : α => M) (a : α) (m : M) :
    (l.insert a m).lookupFinsupp = l.lookupFinsupp.update a m
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp]
theorem map_fract_sub_fract_eq (x : ℝ) : f (fract x) - fract x = f x - x
-- Mathlib/Data/List/ProdSigma.lean
@[simp]
theorem mem_sigma {l₁ : List α} {l₂ : ∀ a, List (σ a)} {a : α} {b : σ a} :
    Sigma.mk a b ∈ l₁.sigma l₂ ↔ a ∈ l₁ ∧ b ∈ l₂ a
-- Mathlib/Data/Setoid/Partition.lean
theorem equivQuotient_index : hs.equivQuotient ∘ hs.index = hs.proj
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem eval_intCast_map {R S : Type*} [Ring R] [Ring S] (f : R →+* S) (p : R[X]) (i : ℤ) :
    (p.map f).eval (i : S) = f (p.eval i)
-- Mathlib/Data/ENat/Basic.lean
theorem one_le_iff_pos : 1 ≤ n ↔ 0 < n
-- Mathlib/Data/Multiset/Fold.lean
theorem fold_distrib {f g : β → α} (u₁ u₂ : α) (s : Multiset β) :
    (s.map fun x => f x * g x).fold op (u₁ * u₂) = (s.map f).fold op u₁ * (s.map g).fold op u₂
-- Mathlib/Algebra/Homology/Homotopy.lean
@[simp 1100]
theorem dNext_comp_left (f : C ⟶ D) (g : ∀ i j, D.X i ⟶ E.X j) (i : ι) :
    (dNext i fun i j => f.f i ≫ g i j) = f.f i ≫ dNext i g
-- Mathlib/Data/Ordmap/Ordset.lean
nonrec theorem Valid.left {s l x r} (H : Valid (@node α s l x r)) : Valid l
-- Mathlib/Algebra/Category/AlgebraCat/Basic.lean
@[simp] theorem AlgHom.comp_id_algebraCat
    {R} [CommRing R] {G : AlgebraCat.{u} R} {H : Type u} [Ring H] [Algebra R H] (f : G →ₐ[R] H) :
    f.comp (𝟙 G) = f
-- Mathlib/Data/Nat/Defs.lean
lemma lt_of_div_lt_div (h : a / c < b / c) : a < b
-- Mathlib/SetTheory/Game/Domineering.lean
theorem mem_right {b : Board} (x : ℤ × ℤ) : x ∈ right b ↔ x ∈ b ∧ (x.1 - 1, x.2) ∈ b
-- Mathlib/Probability/Distributions/Uniform.lean
/-- Check that indeed any uniform random variable has the uniformPDF. -/
lemma uniformPDF_eq_pdf {s : Set E} (hs : MeasurableSet s) (hu : pdf.IsUniform X s ℙ μ) :
    (fun x ↦ uniformPDF s x μ) =ᵐ[μ] pdf X ℙ μ
-- Mathlib/Algebra/AddConstMap/Basic.lean
@[ext] protected theorem ext {f g : G →+c[a, b] H} (h : ∀ x, f x = g x) : f = g
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma RightHomologyData.exact_iff_mono_g' [S.HasHomology] (h : RightHomologyData S) :
    S.Exact ↔ Mono h.g'
-- Mathlib/Algebra/Lie/TraceForm.lean
@[simp] lemma traceForm_flip : LinearMap.flip (traceForm R L M) = traceForm R L M
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem toIsometryEquiv_symm : e.toIsometryEquiv.symm = e.symm.toIsometryEquiv
-- Mathlib/GroupTheory/Nilpotent.lean
theorem lowerCentralSeries.map {H : Type*} [Group H] (f : G →* H) (n : ℕ) :
    Subgroup.map f (lowerCentralSeries G n) ≤ lowerCentralSeries H n
-- Mathlib/Topology/MetricSpace/PiNat.lean
protected theorem completeSpace : CompleteSpace (∀ n, E n)
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
theorem and_iff_left_of_imp  (h : a → b) : (a ∧ b) ↔ a
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Eval.lean
theorem sub_one_lt_natAbs_cyclotomic_eval {n : ℕ} {q : ℕ} (hn' : 1 < n) (hq : q ≠ 1) :
    q - 1 < ((cyclotomic n ℤ).eval ↑q).natAbs
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem map_inf_comap_of_surjective (S T : Submonoid N) : (S.comap f ⊓ T.comap f).map f = S ⊓ T
-- Mathlib/Data/Multiset/Basic.lean
@[elab_as_elim]
protected theorem induction {p : Multiset α → Prop} (empty : p 0)
    (cons : ∀ (a : α) (s : Multiset α), p s → p (a ::ₘ s)) : ∀ s, p s
-- Mathlib/Order/Monotone/Basic.lean
protected theorem StrictMono.strictMonoOn (hf : StrictMono f) (s : Set α) : StrictMonoOn f s
-- Mathlib/CategoryTheory/Triangulated/TStructure/Basic.lean
lemma exists_triangle (A : C) (n₀ n₁ : ℤ) (h : n₀ + 1 = n₁) :
    ∃ (X Y : C) (_ : t.LE n₀ X) (_ : t.GE n₁ Y) (f : X ⟶ A) (g : A ⟶ Y)
      (h : Y ⟶ X⟦(1 : ℤ)⟧), Triangle.mk f g h ∈ distTriang C
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem star_coe : star (x : ℍ[R]) = x
-- Mathlib/Data/Fintype/Card.lean
theorem card_finset_fin_le {n : ℕ} (s : Finset (Fin n)) : s.card ≤ n
-- Mathlib/Topology/Order.lean
theorem induced_mono (h : t₁ ≤ t₂) : t₁.induced g ≤ t₂.induced g
-- Mathlib/Algebra/Ring/Equiv.lean
@[simp]
theorem symm_trans_self (e : R ≃+* S) : e.symm.trans e = RingEquiv.refl S