ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- Reindexing a simplex produces one with the same set of points. -/
@[simp]
theorem reindex_range_points {m n : ℕ} (s : Simplex k P m) (e : Fin (m + 1) ≃ Fin (n + 1)) :
    Set.range (s.reindex e).points = Set.range s.points
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive]
theorem mulIndicator_mul' (s : Set α) (f g : α → M) :
    mulIndicator s (f * g) = mulIndicator s f * mulIndicator s g
-- Mathlib/Topology/MetricSpace/Isometry.lean
/-- The composition of isometries is an isometry. -/
theorem comp {g : β → γ} {f : α → β} (hg : Isometry g) (hf : Isometry f) : Isometry (g ∘ f)
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem derivWithin_zero_of_nmem_closure (h : x ∉ closure s) : derivWithin f s x = 0
-- Mathlib/Order/UpperLower/Basic.lean
theorem isUpperSet_Ici : IsUpperSet (Ici a)
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
@[simp]
lemma toRows₁_apply (A : Matrix (m₁ ⊕ m₂) n R) (i : m₁) (j : n) :
    (toRows₁ A) i j = A (Sum.inl i) j
-- Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean
theorem Real.Angle.coe_expMapCircle (θ : Real.Angle) :
    (θ.expMapCircle : ℂ) = θ.cos + θ.sin * I
-- Mathlib/Algebra/Order/AbsoluteValue.lean
theorem abs_abv_sub_le_abv_sub (a b : R) : abs (abv a - abv b) ≤ abv (a - b)
-- Mathlib/Data/List/Indexes.lean
theorem mapIdxGo_length : ∀ (f : ℕ → α → β) (l : List α) (arr : Array β),
    length (mapIdx.go f l arr) = length l + arr.size
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma add_def (P Q : W.Point) : P.add Q = P + Q
-- Mathlib/Computability/Reduce.lean
theorem ManyOneEquiv.le_congr_left {α β γ} [Primcodable α] [Primcodable β] [Primcodable γ]
    {p : α → Prop} {q : β → Prop} {r : γ → Prop} (h : ManyOneEquiv p q) : p ≤₀ r ↔ q ≤₀ r
-- Mathlib/Data/Nat/Factorization/Defs.lean
theorem factorization_eq_zero_iff (n p : ℕ) :
    n.factorization p = 0 ↔ ¬p.Prime ∨ ¬p ∣ n ∨ n = 0
-- Mathlib/Algebra/Regular/SMul.lean
/-- The product of `M`-regular elements is `M`-regular. -/
theorem smul (ra : IsSMulRegular M a) (rs : IsSMulRegular M s) : IsSMulRegular M (a • s)
-- Mathlib/Algebra/Group/Submonoid/Pointwise.lean
@[simp]
theorem pointwise_smul_le_pointwise_smul_iff {a : α} {S T : Submonoid M} : a • S ≤ a • T ↔ S ≤ T
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
@[simp]
theorem basisFun_equivFun : (basisFun p 𝕜 ι).equivFun = WithLp.linearEquiv p 𝕜 (ι → 𝕜)
-- Mathlib/Topology/Order/IntermediateValue.lean
theorem Continuous.strictMono_of_inj_boundedOrder [BoundedOrder α] {f : α → δ}
    (hf_c : Continuous f) (hf : f ⊥ ≤ f ⊤) (hf_i : Injective f) : StrictMono f
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
/-- If `J(a | b)` is `-1`, then `a` is not a square modulo `b`. -/
theorem nonsquare_of_jacobiSym_eq_neg_one {a : ℤ} {b : ℕ} (h : J(a | b) = -1) :
    ¬IsSquare (a : ZMod b)
-- Mathlib/CategoryTheory/Sites/Grothendieck.lean
/-- Constructor for `Cover.Relation` which takes as an input
`r : I₁.Relation I₂` with `I₁ I₂ : S.Arrow`. -/
@[simps]
def Relation.mk' {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd) :
    S.Relation
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Integrable.mono' {f : α → β} {g : α → ℝ} (hg : Integrable g μ)
    (hf : AEStronglyMeasurable f μ) (h : ∀ᵐ a ∂μ, ‖f a‖ ≤ g a) : Integrable f μ
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
@[simp]
theorem coe_vadd : ↑(x +ᵥ z) = (x + z : ℂ)
-- Mathlib/Order/Closure.lean
/-- Define a closure operator from a predicate that's preserved under infima. -/
@[simps!]
def ofCompletePred (p : α → Prop) (hsinf : ∀ s, (∀ a ∈ s, p a) → p (sInf s)) : ClosureOperator α
-- Mathlib/Data/Set/Subsingleton.lean
theorem Subsingleton.induction_on {p : Set α → Prop} (hs : s.Subsingleton) (he : p ∅)
    (h₁ : ∀ x, p {x}) : p s
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem mk_equiv_le_embedding : #(α ≃ β') ≤ #(α ↪ β')
-- Mathlib/RingTheory/PowerSeries/Order.lean
/-- If the `n`th coefficient of a formal power series is nonzero,
then the order of the power series is less than or equal to `n`. -/
theorem order_le (n : ℕ) (h : coeff R n φ ≠ 0) : order φ ≤ n
-- Mathlib/Topology/Constructions.lean
theorem comap_sigmaMk_nhds (i : ι) (x : σ i) : comap (Sigma.mk i) (𝓝 ⟨i, x⟩) = 𝓝 x
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem enum_type {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s]
    (f : s ≺i r) {h : type s < type r} : enum r (type s) h = f.top
-- Mathlib/FieldTheory/RatFunc/Basic.lean
/-- Addition of rational functions. -/
protected irreducible_def add : RatFunc K → RatFunc K → RatFunc K
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
theorem res_mk_eq_mk_pullback {Y X : C} {P : Cᵒᵖ ⥤ D} {S : J.Cover X} (x : Meq P S) (f : Y ⟶ X) :
    (J.plusObj P).map f.op (mk x) = mk (x.pullback f)
-- Mathlib/Algebra/Polynomial/Eval.lean
protected theorem map_eq_zero_iff (hf : Function.Injective f) : p.map f = 0 ↔ p = 0
-- Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean
/-- **Ruzsa's triangle inequality**. Division version. -/
@[to_additive "**Ruzsa's triangle inequality**. Subtraction version."]
theorem ruzsa_triangle_inequality_div_div_div (A B C : Finset α) :
    (A / C).card * B.card ≤ (A / B).card * (B / C).card
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
@[simp]
theorem toList_one : toList (1 : Perm α) x = []
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem range_comp (f : A →ₐ[R] B) (g : B →ₐ[R] C) : (g.comp f).range = f.range.map g
-- Mathlib/SetTheory/Surreal/Basic.lean
theorem zero_toGame : toGame 0 = 0
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem StrictMono.const_mul [PosMulStrictMono α]
    (hf : StrictMono f) (ha : 0 < a) : StrictMono fun x => a * f x
-- Mathlib/Data/List/Perm.lean
theorem Perm.fold_op_eq {l₁ l₂ : List α} {a : α} (h : l₁ ~ l₂) : (l₁ <*> a) = l₂ <*> a
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem zipWith_single_single (f : M → N → P) (hf : f 0 0 = 0) (a : α) (m : M) (n : N) :
    zipWith f hf (single a m) (single a n) = single a (f m n)
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem star_moveLeft (x) : star.moveLeft x = 0
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive]
theorem mem_smul_set : x ∈ a • t ↔ ∃ y, y ∈ t ∧ a • y = x
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
protected theorem sup_eq_right {a b : CauSeq α abs} (h : a ≤ b) : a ⊔ b ≈ b
-- Mathlib/Order/Monotone/Basic.lean
theorem monotone_lam {f : α → β → γ} (hf : ∀ b, Monotone fun a ↦ f a b) : Monotone f
-- Mathlib/CategoryTheory/Sites/PreservesLocallyBijective.lean
lemma isLocallySurjective_whisker [H.IsCocontinuous J K] [IsLocallySurjective K f] :
    IsLocallySurjective J (whiskerLeft H.op f)
-- Mathlib/Topology/Algebra/PontryaginDual.lean
@[simp]
theorem map_one : map (one A B) = one (PontryaginDual B) (PontryaginDual A)
-- Mathlib/Order/Bounded.lean
theorem unbounded_le_inter_le [LinearOrder α] (a : α) :
    Unbounded (· ≤ ·) (s ∩ { b | a ≤ b }) ↔ Unbounded (· ≤ ·) s
-- Mathlib/Data/Real/Archimedean.lean
@[simp]
theorem sSup_empty : sSup (∅ : Set ℝ) = 0
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive (attr := simp)]
theorem mulIndicator_univ (f : α → M) : mulIndicator (univ : Set α) f = f
-- Mathlib/RingTheory/Finiteness.lean
theorem fg_of_fg_map_injective (f : M →ₗ[R] P) (hf : Function.Injective f) {N : Submodule R M}
    (hfn : (N.map f).FG) : N.FG
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem eq_one_of_mul_le_one_left (ha : 1 ≤ a) (hb : 1 ≤ b) (hab : a * b ≤ 1) : a = 1
-- Mathlib/Order/Lattice.lean
@[simp]
theorem toDual_sup [Sup α] (a b : α) : toDual (a ⊔ b) = toDual a ⊓ toDual b
-- Mathlib/MeasureTheory/Integral/Asymptotics.lean
/-- Variant of `MeasureTheory.Integrable.mono` taking `f =O[⊤] (g)` instead of `‖f(x)‖ ≤ ‖g(x)‖` -/
theorem _root_.Asymptotics.IsBigO.integrable (hfm : AEStronglyMeasurable f μ)
    (hf : f =O[⊤] g) (hg : Integrable g μ) : Integrable f μ
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive le_add_of_nonneg_left]
theorem le_mul_of_one_le_left' [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b : α} (h : 1 ≤ b) :
    a ≤ b * a
-- Mathlib/Algebra/Group/Center.lean
@[to_additive (attr := simp) zero_mem_addCenter]
theorem one_mem_center : (1 : M) ∈ Set.center M
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- If a sequence of functions is uniformly Cauchy on a set, then the values at each point form
a Cauchy sequence.  See `UniformCauchSeqOn.cauchy_map` for the non-`atTop` case. -/
theorem UniformCauchySeqOn.cauchySeq [Nonempty ι] [SemilatticeSup ι]
    (hf : UniformCauchySeqOn F atTop s) (hx : x ∈ s) :
    CauchySeq fun i ↦ F i x
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem toFin_ofNat (x : Nat) : toFin (BitVec.ofNat w x) = Fin.ofNat' x (Nat.two_pow_pos w)
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
theorem smul_sup (a : α) (S T : Subgroup G) : a • (S ⊔ T) = a • S ⊔ a • T
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem IsPrefix.length_le (h : l₁ <+: l₂) : l₁.length ≤ l₂.length
-- Mathlib/Algebra/Divisibility/Basic.lean
theorem dvd_mul [DecompositionMonoid α] {k m n : α} :
    k ∣ m * n ↔ ∃ d₁ d₂, d₁ ∣ m ∧ d₂ ∣ n ∧ k = d₁ * d₂
-- Mathlib/Tactic/NormNum/NatFib.lean
theorem isFibAux_two_mul_done {n a b n' a' : ℕ} (H : IsFibAux n a b)
    (hn : 2 * n = n') (h : a * (2 * b - a) = a') : fib n' = a'
-- Mathlib/CategoryTheory/Limits/Shapes/Reflexive.lean
/-- The pair `f g : A ⟶ B` is reflexive if there is a morphism `B ⟶ A` which is a section for both.
-/
class IsReflexivePair (f g : A ⟶ B) : Prop where
  common_section' : ∃ s : B ⟶ A, s ≫ f = 𝟙 B ∧ s ≫ g = 𝟙 B
-- Mathlib/RingTheory/PowerSeries/Trunc.lean
theorem trunc_coe_eq_self {n} {f : R[X]} (hn : natDegree f < n) : trunc n (f : R⟦X⟧) = f
-- Mathlib/Algebra/GroupWithZero/Basic.lean
@[simp] lemma pow_eq_zero_iff (hn : n ≠ 0) : a ^ n = 0 ↔ a = 0
-- Mathlib/Logic/Nonempty.lean
@[simp]
theorem nonempty_subtype {α} {p : α → Prop} : Nonempty (Subtype p) ↔ ∃ a : α, p a
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem singletonSubgraph_le_iff (v : V) (H : G.Subgraph) :
    G.singletonSubgraph v ≤ H ↔ v ∈ H.verts
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem neg_add_cancel_right (a b : Int) : a + -b + b = a
-- Mathlib/Topology/Compactness/Lindelof.lean
/-- A set `s` is Lindelöf if and only if
for every open cover of `s`, there exists a countable subcover. -/
theorem isLindelof_iff_countable_subcover :
    IsLindelof s ↔ ∀ {ι : Type u} (U : ι → Set X),
      (∀ i, IsOpen (U i)) → (s ⊆ ⋃ i, U i) → ∃ t : Set ι, t.Countable ∧ s ⊆ ⋃ i ∈ t, U i
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp] lemma isRegular_X : IsRegular (X n : MvPolynomial σ R)
-- Mathlib/Order/CompleteLattice.lean
theorem iSup₂_le_iSup (κ : ι → Sort*) (f : ι → α) : ⨆ (i) (_ : κ i), f i ≤ ⨆ i, f i
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem curryFinFinset_symm_apply {k l n : ℕ} {s : Finset (Fin n)} (hk : s.card = k)
    (hl : sᶜ.card = l)
    (f : MultilinearMap R (fun _ : Fin k => M') (MultilinearMap R (fun _ : Fin l => M') M₂))
    (m : Fin n → M') :
    (curryFinFinset R M₂ M' hk hl).symm f m =
      f (fun i => m <| finSumEquivOfFinset hk hl (Sum.inl i)) fun i =>
        m <| finSumEquivOfFinset hk hl (Sum.inr i)
-- Mathlib/RingTheory/DedekindDomain/Different.lean
@[simp]
lemma dual_dual :
    dual A K (dual A K I) = I
-- Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean
private theorem candidates_refl (fA : f ∈ candidates X Y) : f (x, x) = 0
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
theorem SmoothAt.inv₀ (hf : SmoothAt I' I f a) (ha : f a ≠ 0) :
    SmoothAt I' I (fun x => (f x)⁻¹) a
-- Mathlib/Data/Set/Image.lean
theorem image_diff {f : α → β} (hf : Injective f) (s t : Set α) : f '' (s \ t) = f '' s \ f '' t
-- Mathlib/Data/Part.lean
theorem toOption_eq_none_iff {a : Part α} [Decidable a.Dom] : a.toOption = Option.none ↔ ¬a.Dom
-- Mathlib/GroupTheory/GroupAction/Support.lean
@[to_additive]
theorem Supports.smul (g : H) (h : Supports G s b) : Supports G (g • s) (g • b)
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean
theorem hasZeroObject_unop [HasZeroObject Cᵒᵖ] : HasZeroObject C
-- Mathlib/Data/ENNReal/Real.lean
theorem ofReal_add {p q : ℝ} (hp : 0 ≤ p) (hq : 0 ≤ q) :
    ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q
-- Mathlib/ModelTheory/ElementaryMaps.lean
/-- Bundles an embedding satisfying the Tarski-Vaught test as an elementary embedding. -/
@[simps]
def toElementaryEmbedding (f : M ↪[L] N)
    (htv :
      ∀ (n : ℕ) (φ : L.BoundedFormula Empty (n + 1)) (x : Fin n → M) (a : N),
        φ.Realize default (Fin.snoc (f ∘ x) a : _ → N) →
          ∃ b : M, φ.Realize default (Fin.snoc (f ∘ x) (f b) : _ → N)) :
    M ↪ₑ[L] N
-- Mathlib/NumberTheory/FLT/Three.lean
private lemma u₄_eq_one_or_neg_one : S.u₄ = 1 ∨ S.u₄ = -1
-- Mathlib/CategoryTheory/Triangulated/Basic.lean
@[simp]
lemma id_hom₂ (A : Triangle C) : TriangleMorphism.hom₂ (𝟙 A) = 𝟙 _
-- Mathlib/FieldTheory/Perfect.lean
@[simp]
theorem frobeniusEquiv_symm_apply_frobenius (x : R) :
    (frobeniusEquiv R p).symm (frobenius R p x) = x
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
theorem mem_Spec_essImage (X : Scheme) : X ∈ Scheme.Spec.essImage ↔ IsAffine X
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem eLpNormEssSup_indicator_eq_eLpNormEssSup_restrict {f : α → F} (hs : MeasurableSet s) :
    eLpNormEssSup (s.indicator f) μ = eLpNormEssSup f (μ.restrict s)
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Perm.union_left (l : List α) {t₁ t₂ : List α} (h : t₁ ~ t₂) : l ∪ t₁ ~ l ∪ t₂
-- Mathlib/MeasureTheory/Measure/EverywherePos.lean
/-- In a space with an inner regular measure, the everywhere positive subset of a measurable set
is itself everywhere positive. This is not obvious as `μ.everywherePosSubset s` is defined as
the points whose neighborhoods intersect `s` along positive measure subsets, but this does not
say they also intersect `μ.everywherePosSubset s` along positive measure subsets. -/
lemma isEverywherePos_everywherePosSubset
    [OpensMeasurableSpace α] [InnerRegular μ] (hs : MeasurableSet s) :
    μ.IsEverywherePos (μ.everywherePosSubset s)
-- Mathlib/Algebra/Polynomial/Laurent.lean
theorem algebraMap_X_pow (n : ℕ) : algebraMap R[X] R[T;T⁻¹] (X ^ n) = T n
-- Mathlib/Algebra/Group/Even.lean
@[to_additive] lemma IsSquare.zpow (n : ℤ) : IsSquare a → IsSquare (a ^ n)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem norm_indicatorConstLp_le :
    ‖indicatorConstLp p hs hμs c‖ ≤ ‖c‖ * (μ s).toReal ^ (1 / p.toReal)
-- Mathlib/Geometry/Manifold/LocalInvariantProperties.lean
theorem liftPropOn_of_liftProp (mono : ∀ ⦃s x t⦄ ⦃f : H → H'⦄, t ⊆ s → P f s x → P f t x)
    (h : LiftProp P g) : LiftPropOn P g s
-- Mathlib/Logic/Function/Conjugate.lean
/-- If `f` and `f'` commute with `g`, then `f ∘ f'` commutes with `g` as well. -/
nonrec theorem comp_left (h : Commute f g) (h' : Commute f' g) : Commute (f ∘ f') g
-- Mathlib/CategoryTheory/Closed/Cartesian.lean
theorem uncurry_injective : Function.Injective (uncurry : (Y ⟶ A ⟹ X) → (A ⨯ Y ⟶ X))
-- Mathlib/Algebra/Order/Field/Power.lean
theorem zpow_le_one_of_nonpos (ha : 1 ≤ a) (hn : n ≤ 0) : a ^ n ≤ 1
-- Mathlib/LinearAlgebra/AffineSpace/Basis.lean
@[simp]
theorem linear_eq_sumCoords (i : ι) : (b.coord i).linear = -(b.basisOf i).sumCoords
-- Mathlib/LinearAlgebra/Prod.lean
@[simp]
theorem fst_apply (x : M × M₂) : fst R M M₂ x = x.1
-- Mathlib/CategoryTheory/MorphismProperty/Factorization.lean
/-- The functorial factorization axiom for two classes of morphisms `W₁` and `W₂` in a
category `C`. It asserts that any morphism can be factored in a functorial manner
as a morphism in `W₁` followed by a morphism in `W₂`. -/
class HasFunctorialFactorization : Prop where
  nonempty_functorialFactorizationData : Nonempty (FunctorialFactorizationData W₁ W₂)
-- Mathlib/RingTheory/Kaehler/Polynomial.lean
@[simp]
lemma KaehlerDifferential.polynomialEquiv_D (P) :
    polynomialEquiv R (D R R[X] P) = derivative P
-- Mathlib/CategoryTheory/Monad/Coequalizer.lean
/-- The cofork map in the coequalizer diagram we will construct. -/
@[simps]
def FreeCoequalizer.π : (Monad.free T).obj X.A ⟶ X
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
@[simp]
theorem neg_right_iff {N : Type*} [AddCommGroup N] [TopologicalSpace N] [TopologicalAddGroup N]
    {v : VectorMeasure α M} {w : VectorMeasure α N} : v ⟂ᵥ -w ↔ v ⟂ᵥ w
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem sameCycle_comm : SameCycle f x y ↔ SameCycle f y x
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem C_mul_eq_smul {r : R} {x : HahnSeries Γ R} : C r * x = r • x
-- Mathlib/Order/Basic.lean
theorem lt_of_strongLT [Nonempty ι] (h : a ≺ b) : a < b
-- Mathlib/Topology/Sequences.lean
theorem subset_seqClosure {s : Set X} : s ⊆ seqClosure s
-- Mathlib/Algebra/ContinuedFractions/Computation/Approximations.lean
/--
Shows that the partial numerators `aᵢ` of the continued fraction are equal to one and the partial
denominators `bᵢ` correspond to integers.
-/
theorem of_partNum_eq_one_and_exists_int_partDen_eq {gp : GenContFract.Pair K}
    (nth_s_eq : (of v).s.get? n = some gp) : gp.a = 1 ∧ ∃ z : ℤ, gp.b = (z : K)
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
theorem det_eq_elem_of_card_eq_one {A : Matrix n n R} (h : Fintype.card n = 1) (k : n) :
    det A = A k k
-- Mathlib/Data/List/Sigma.lean
@[simp]
theorem nodupKeys_cons {s : Sigma β} {l : List (Sigma β)} :
    NodupKeys (s :: l) ↔ s.1 ∉ l.keys ∧ NodupKeys l
-- Mathlib/Algebra/Exact.lean
lemma Exact.inr_fst : Function.Exact (LinearMap.inr R M N) (LinearMap.fst R M N)
-- Mathlib/Analysis/Convolution.lean
/-- Approximate `(f ⋆ g) x₀` if the support of the `f` is bounded within a ball, and `g` is near
`g x₀` on a ball with the same radius around `x₀`. See `dist_convolution_le` for a special case.

We can simplify the second argument of `dist` further if we add some extra type-classes on `E`
and `𝕜` or if `L` is scalar multiplication. -/
theorem dist_convolution_le' {x₀ : G} {R ε : ℝ} {z₀ : E'} (hε : 0 ≤ ε) (hif : Integrable f μ)
    (hf : support f ⊆ ball (0 : G) R) (hmg : AEStronglyMeasurable g μ)
    (hg : ∀ x ∈ ball x₀ R, dist (g x) z₀ ≤ ε) :
    dist ((f ⋆[L, μ] g : G → F) x₀) (∫ t, L (f t) z₀ ∂μ) ≤ (‖L‖ * ∫ x, ‖f x‖ ∂μ) * ε
-- Mathlib/Analysis/Normed/Field/Basic.lean
/-- A normed field is a field with a norm satisfying ‖x y‖ = ‖x‖ ‖y‖. -/
class NormedField (α : Type*) extends Norm α, Field α, MetricSpace α where
  /-- The distance is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = norm (x - y)
  /-- The norm is multiplicative. -/
  norm_mul' : ∀ a b, norm (a * b) = norm a * norm b
-- Mathlib/Data/Multiset/Fintype.lean
theorem Multiset.coe_mk {x : α} {i : Fin (m.count x)} : ↑(m.mkToType x i) = x
-- Mathlib/CategoryTheory/Abelian/Exact.lean
theorem exact_iff_epi_imageToKernel : S.Exact ↔ Epi (imageToKernel S.f S.g S.zero)
-- Mathlib/Algebra/Lie/Subalgebra.lean
@[simp]
theorem range_coe : (f.range : Set L₂) = Set.range f
-- Mathlib/Topology/ContinuousFunction/Sigma.lean
/-- Every continuous map from a connected topological space to the disjoint union of a family of
topological spaces is a composition of the embedding `ContinuousMap.sigmMk i : C(Y i, Σ i, Y i)` for
some `i` and a continuous map `g : C(X, Y i)`. See also `Continuous.exists_lift_sigma` for a version
with unbundled functions and `ContinuousMap.sigmaCodHomeomorph` for a homeomorphism defined using
this fact. -/
theorem exists_lift_sigma (f : C(X, Σ i, Y i)) : ∃ i g, f = (sigmaMk i).comp g
-- Mathlib/Data/Finset/Lattice.lean
theorem exists_mem_eq_inf [OrderTop α] (s : Finset ι) (h : s.Nonempty) (f : ι → α) :
    ∃ i, i ∈ s ∧ s.inf f = f i
-- Mathlib/Topology/Constructions.lean
theorem continuous_ofDual : Continuous (ofDual : Xᵒᵈ → X)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- If the oriented angle between three points is `-π / 2`, the unoriented angle is `π / 2`. -/
theorem angle_eq_pi_div_two_of_oangle_eq_neg_pi_div_two {p₁ p₂ p₃ : P}
    (h : ∡ p₁ p₂ p₃ = ↑(-π / 2)) : ∠ p₁ p₂ p₃ = π / 2
-- Mathlib/CategoryTheory/Sites/Types.lean
@[simp]
theorem yoneda'_comp : yoneda'.{u} ⋙ sheafOfTypesToPresheaf _ = yoneda
-- Mathlib/Order/Filter/AtTopBot.lean
theorem eventually_atBot_prod_self' [SemilatticeInf α] [Nonempty α] {p : α × α → Prop} :
    (∀ᶠ x in atBot, p x) ↔ ∃ a, ∀ k ≤ a, ∀ l ≤ a, p (k, l)
-- Mathlib/NumberTheory/RamificationInertia.lean
theorem Factors.inertiaDeg_ne_zero [IsNoetherian R S] [p.IsMaximal]
    (P : (factors (map (algebraMap R S) p)).toFinset) : inertiaDeg (algebraMap R S) p P ≠ 0
-- Mathlib/Order/Chain.lean
private theorem chainClosure_succ_total_aux (hc₁ : ChainClosure r c₁)
    (h : ∀ ⦃c₃⦄, ChainClosure r c₃ → c₃ ⊆ c₂ → c₂ = c₃ ∨ SuccChain r c₃ ⊆ c₂) :
    SuccChain r c₂ ⊆ c₁ ∨ c₁ ⊆ c₂
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
lemma singularPart_restrict (μ ν : Measure α) [HaveLebesgueDecomposition μ ν]
    {s : Set α} (hs : MeasurableSet s) :
    (μ.restrict s).singularPart ν = (μ.singularPart ν).restrict s
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem add_one_inj : a + 1 = b + 1 ↔ a = b
-- Mathlib/Init/Logic.lean
theorem exists_unique_of_exists_of_unique {α : Sort u} {p : α → Prop}
    (hex : ∃ x, p x) (hunique : ∀ y₁ y₂, p y₁ → p y₂ → y₁ = y₂) : ∃! x, p x
-- Mathlib/Data/ENNReal/Real.lean
theorem ofReal_lt_iff_lt_toReal {a : ℝ} {b : ℝ≥0∞} (ha : 0 ≤ a) (hb : b ≠ ∞) :
    ENNReal.ofReal a < b ↔ a < ENNReal.toReal b
-- Mathlib/Algebra/Group/Subsemigroup/Basic.lean
@[to_additive]
theorem mem_iSup {ι : Sort*} (p : ι → Subsemigroup M) {m : M} :
    (m ∈ ⨆ i, p i) ↔ ∀ N, (∀ i, p i ≤ N) → m ∈ N
-- Mathlib/Data/Int/GCD.lean
theorem gcd_mul_right (i j k : ℤ) : gcd (i * j) (k * j) = gcd i k * natAbs j
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
/-- If one controls the norm of every `A x`, then one controls the norm of `A`. -/
theorem opNorm_le_bound (f : E →SL[σ₁₂] F) {M : ℝ} (hMp : 0 ≤ M) (hM : ∀ x, ‖f x‖ ≤ M * ‖x‖) :
    ‖f‖ ≤ M
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
@[simp]
theorem familyOfElements_ofArrows_mk (i : I) :
    hx.familyOfElements _ (ofArrows.mk i) = x i
-- Mathlib/Algebra/Order/AddTorsor.lean
@[to_additive]
theorem IsOrderedSMul.smul_le_smul [Preorder G] [Preorder P] [SMul G P] [IsOrderedSMul G P]
    {a b : G} {c d : P} (hab : a ≤ b) (hcd : c ≤ d) : a • c ≤ b • d
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive (attr := simp) one_zsmul]
lemma zpow_one (a : G) : a ^ (1 : ℤ) = a
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
@[simp]
theorem _root_.ContinuousLinearEquiv.compContinuousMultilinearMapL_apply (g : G ≃L[𝕜] G')
    (f : ContinuousMultilinearMap 𝕜 E G) :
    g.compContinuousMultilinearMapL E f = (g : G →L[𝕜] G').compContinuousMultilinearMap f
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
theorem IsBoundedBilinearMap.map_sub_right (h : IsBoundedBilinearMap 𝕜 f) {x : E} {y z : F} :
    f (x, y - z) = f (x, y) - f (x, z)
-- Mathlib/LinearAlgebra/Projection.lean
theorem ker_id_sub_eq_of_proj {f : E →ₗ[R] p} (hf : ∀ x : p, f x = x) :
    ker (id - p.subtype.comp f) = p
-- Mathlib/Data/Ordmap/Ordset.lean
theorem valid'_singleton {x : α} {o₁ o₂} (h₁ : Bounded nil o₁ x) (h₂ : Bounded nil x o₂) :
    Valid' o₁ (singleton x : Ordnode α) o₂
-- Mathlib/Data/Int/ModEq.lean
theorem modEq_sub_fac {a b n : ℤ} (c : ℤ) (ha : a ≡ b [ZMOD n]) : a - n * c ≡ b [ZMOD n]
-- Mathlib/Data/Fintype/Fin.lean
@[simp]
theorem Ioi_zero_eq_map : Ioi (0 : Fin n.succ) = univ.map (Fin.succEmb _)
-- Mathlib/Algebra/Quaternion.lean
@[ext]
theorem ext : a.re = b.re → a.imI = b.imI → a.imJ = b.imJ → a.imK = b.imK → a = b
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
theorem sheafify_hom_ext {P Q : Cᵒᵖ ⥤ D} (η γ : J.sheafify P ⟶ Q) (hQ : Presheaf.IsSheaf J Q)
    (h : J.toSheafify P ≫ η = J.toSheafify P ≫ γ) : η = γ
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive existing, simp] lemma sum_inv_index [InvolutiveInv ι] (s : Finset ι) (f : ι → α) :
    ∑ i ∈ s⁻¹, f i = ∑ i ∈ s, f i⁻¹
-- Mathlib/CategoryTheory/Monoidal/Preadditive.lean
@[ext]
theorem rightDistributor_ext₂_left {J : Type} [Fintype J]
    {f : J → C} {X Y Z : C} {g h : ((⨁ f) ⊗ X) ⊗ Y ⟶ Z}
    (w : ∀ j, ((biproduct.ι f j ▷ X) ▷ Y) ≫ g = ((biproduct.ι f j ▷ X) ▷ Y) ≫ h) :
    g = h
-- Mathlib/Algebra/Lie/Basic.lean
theorem neg_apply (f : M →ₗ⁅R,L⁆ N) (m : M) : (-f) m = -f m