ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Semicontinuous.lean
theorem upperSemicontinuousAt_iff_limsup_le {f : α → γ} :
    UpperSemicontinuousAt f x ↔ limsup f (𝓝 x) ≤ f x
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
theorem normAtPlace_add_le (w : InfinitePlace K) (x y : E K) :
    normAtPlace w (x + y) ≤ normAtPlace w x + normAtPlace w y
-- Mathlib/RingTheory/OreLocalization/Ring.lean
@[simp]
lemma zsmul_eq_zsmul (n : ℤ) (x : X[S⁻¹]) :
    letI inst := OreLocalization.instModuleOfIsScalarTower (R₀ := ℤ) (R := R) (X := X) (S := S)
    HSMul.hSMul (self := @instHSMul _ _ inst.toSMul) n x = n • x
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem finsuppTotal_apply_eq_of_fintype [Fintype ι] (f : ι →₀ I) :
    finsuppTotal ι M I v f = ∑ i, (f i : R) • v i
-- Mathlib/Algebra/Polynomial/Degree/Lemmas.lean
theorem degree_sum_eq_of_disjoint (f : S → R[X]) (s : Finset S)
    (h : Set.Pairwise { i | i ∈ s ∧ f i ≠ 0 } (Ne on degree ∘ f)) :
    degree (s.sum f) = s.sup fun i => degree (f i)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma fin3_def_ext (X Y Z : R) : ![X, Y, Z] x = X ∧ ![X, Y, Z] y = Y ∧ ![X, Y, Z] z = Z
-- Mathlib/Combinatorics/HalesJewett.lean
theorem apply_none {α ι} (l : Line α ι) (x : α) (i : ι) (h : l.idxFun i = none) : l x i = x
-- Mathlib/Data/Finsupp/NeLocus.lean
theorem zipWith_neLocus_eq_right [DecidableEq M] [Zero M] [DecidableEq P] [Zero P] [Zero N]
    {F : M → N → P} (F0 : F 0 0 = 0) (f₁ f₂ : α →₀ M) (g : α →₀ N)
    (hF : ∀ g, Function.Injective fun f => F f g) :
    (zipWith F F0 f₁ g).neLocus (zipWith F F0 f₂ g) = f₁.neLocus f₂
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem edges_dropUntil_subset {u v w : V} (p : G.Walk v w) (h : u ∈ p.support) :
    (p.dropUntil u h).edges ⊆ p.edges
-- Mathlib/ModelTheory/Syntax.lean
@[simp]
theorem relabel_imp (g : α → β ⊕ (Fin n)) {k} (φ ψ : L.BoundedFormula α k) :
    (φ.imp ψ).relabel g = (φ.relabel g).imp (ψ.relabel g)
-- Mathlib/Algebra/Lie/Basic.lean
@[norm_cast, simp]
theorem coe_nsmul (n : ℕ) (f : M →ₗ⁅R,L⁆ N) : ⇑(n • f) = n • (⇑f)
-- Mathlib/LinearAlgebra/SymplecticGroup.lean
theorem J_det_mul_J_det : det (J l R) * det (J l R) = 1
-- Mathlib/Data/Real/EReal.lean
lemma mul_div_mul_cancel {a b c : EReal} (h₁ : c ≠ ⊥) (h₂ : c ≠ ⊤) (h₃ : c ≠ 0) :
    (a * c) / (b * c) = a / b
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem contDiffWithinAt_prod' {t : Finset ι} {f : ι → E → 𝔸'}
    (h : ∀ i ∈ t, ContDiffWithinAt 𝕜 n (f i) s x) : ContDiffWithinAt 𝕜 n (∏ i ∈ t, f i) s x
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem cast_bit1 [AddGroupWithOne α] : ∀ n : ZNum, (n.bit1 : α) = ((n : α) + n) + 1
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
@[simp]
theorem neg_left_iff {M : Type*} [AddCommGroup M] [TopologicalSpace M] [TopologicalAddGroup M]
    {v : VectorMeasure α M} {w : VectorMeasure α N} : -v ⟂ᵥ w ↔ v ⟂ᵥ w
-- Mathlib/GroupTheory/PGroup.lean
theorem to_sup_of_normal_left {H K : Subgroup G} (hH : IsPGroup p H) (hK : IsPGroup p K)
    [H.Normal] : IsPGroup p (H ⊔ K : Subgroup G)
-- Mathlib/Data/Finsupp/Pointwise.lean
@[simp]
theorem mul_apply {g₁ g₂ : α →₀ β} {a : α} : (g₁ * g₂) a = g₁ a * g₂ a
-- Mathlib/Data/Nat/Fib/Basic.lean
theorem le_fib_self {n : ℕ} (five_le_n : 5 ≤ n) : n ≤ fib n
-- Mathlib/RingTheory/HahnSeries/Basic.lean
theorem embDomain_notin_range {f : Γ ↪o Γ'} {x : HahnSeries Γ R} {b : Γ'} (hb : b ∉ Set.range f) :
    (embDomain f x).coeff b = 0
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
theorem drop_take : ∀ (m n : Nat) (l : List α), drop n (take m l) = take (m - n) (drop n l)
-- Mathlib/Analysis/InnerProductSpace/MeanErgodic.lean
/-- **Von Neumann Mean Ergodic Theorem** for an operator in a Hilbert space.
For a contracting continuous linear self-map `f : E →L[𝕜] E` of a Hilbert space, `‖f‖ ≤ 1`,
the Birkhoff averages
```
birkhoffAverage 𝕜 f id N x = (N : 𝕜)⁻¹ • ∑ n ∈ Finset.range N, f^[n] x
```
converge to the orthogonal projection of `x` to the subspace of fixed points of `f`. -/
theorem ContinuousLinearMap.tendsto_birkhoffAverage_orthogonalProjection (f : E →L[𝕜] E)
    (hf : ‖f‖ ≤ 1) (x : E) :
    Tendsto (birkhoffAverage 𝕜 f _root_.id · x) atTop
      (𝓝 <| orthogonalProjection (LinearMap.eqLocus f 1) x)
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem continuousWithinAt_inv {s : Set G} {x : G} : ContinuousWithinAt Inv.inv s x
-- Mathlib/CategoryTheory/Generator.lean
theorem inf_eq_of_isDetecting [HasPullbacks C] {𝒢 : Set C} (h𝒢 : IsDetecting 𝒢) {X : C}
    (P Q : Subobject X) (h : ∀ G ∈ 𝒢, ∀ {f : G ⟶ X}, P.Factors f → Q.Factors f) : P ⊓ Q = P
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem preimage_Ioo {a b : α} : ((↑) : ℤ → α) ⁻¹' Set.Ioo a b = Set.Ioo ⌊a⌋ ⌈b⌉
-- Mathlib/Analysis/PSeries.lean
/-- Test for convergence of the `p`-series: the real-valued series `∑' n : ℕ, 1 / n ^ p` converges
if and only if `1 < p`. -/
theorem summable_one_div_nat_rpow {p : ℝ} :
    Summable (fun n => 1 / (n : ℝ) ^ p : ℕ → ℝ) ↔ 1 < p
-- Mathlib/Data/Nat/PartENat.lean
theorem toWithTop_zero :
    have : Decidable (0 : PartENat).Dom := someDecidable 0
    toWithTop 0 = 0
-- Mathlib/Order/Filter/Pointwise.lean
@[simp]
theorem map₂_vsub : map₂ (· -ᵥ ·) f g = f -ᵥ g
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem bot_toSubmonoid : (⊥ : Subgroup G).toSubmonoid = ⊥
-- Mathlib/Topology/MetricSpace/Pseudo/Lemmas.lean
lemma Real.dist_right_le_of_mem_uIcc {x y z : ℝ} (h : y ∈ uIcc x z) : dist y z ≤ dist x z
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
theorem ne_zero_of_trailingDegree_lt {n : ℕ∞} (h : trailingDegree p < n) : p ≠ 0
-- Mathlib/Algebra/Category/AlgebraCat/Limits.lean
/-- The category of R-algebras has all limits. -/
lemma hasLimitsOfSize [UnivLE.{v, w}] : HasLimitsOfSize.{t, v} (AlgebraCat.{w} R)
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive (attr := simp)]
theorem MonoidHom.one_apply [MulOneClass M] [MulOneClass N] (x : M) : (1 : M →* N) x = 1
-- Mathlib/Data/Set/Accumulate.lean
theorem subset_accumulate [Preorder α] {x : α} : s x ⊆ Accumulate s x
-- Mathlib/Topology/Separation.lean
theorem disjoint_nhds_pure [T1Space X] {x y : X} (h : x ≠ y) : Disjoint (𝓝 x) (pure y)
-- Mathlib/Algebra/Order/Group/Abs.lean
@[to_additive]
theorem apply_abs_le_mul_of_one_le' {β : Type*} [MulOneClass β] [Preorder β]
    [CovariantClass β β (· * ·) (· ≤ ·)] [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {f : α → β}
    {a : α} (h₁ : 1 ≤ f a) (h₂ : 1 ≤ f (-a)) : f |a| ≤ f a * f (-a)
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem ne_zero_of_mem_of_unit {a : Aˣ} {r : R} (hr : r ∈ σ (a : A)) : r ≠ 0
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive]
theorem mem_fixedPoints' {a : α} : a ∈ fixedPoints M α ↔ ∀ a', a' ∈ orbit M a → a' = a
-- Mathlib/Order/Filter/Basic.lean
/-- A special case of `iInf_principal` that is safe to mark `simp`. -/
@[simp]
theorem iInf_principal' {ι : Type w} [Finite ι] (f : ι → Set α) : ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i)
-- Mathlib/NumberTheory/MulChar/Basic.lean
lemma ringHomComp_pow (χ : MulChar R R') (f : R' →+* R'') (n : ℕ) :
    χ.ringHomComp f ^ n = (χ ^ n).ringHomComp f
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
/-- A charted space has an atlas in a groupoid `G` if the change of coordinates belong to the
groupoid. -/
class HasGroupoid {H : Type*} [TopologicalSpace H] (M : Type*) [TopologicalSpace M]
    [ChartedSpace H M] (G : StructureGroupoid H) : Prop where
  compatible : ∀ {e e' : PartialHomeomorph M H}, e ∈ atlas H M → e' ∈ atlas H M → e.symm ≫ₕ e' ∈ G
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem one_div_pow_strictAnti (a1 : 1 < a) : StrictAnti fun n : ℕ => 1 / a ^ n
-- Mathlib/CategoryTheory/Subobject/Limits.lean
theorem imageSubobject_mono (f : X ⟶ Y) [Mono f] : imageSubobject f = Subobject.mk f
-- Mathlib/CategoryTheory/Comma/Basic.lean
/-- The functor `(F ⋙ L, R) ⥤ (L, R)` -/
@[simps]
def preRight (L : A ⥤ T) (F : C ⥤ B) (R : B ⥤ T) : Comma L (F ⋙ R) ⥤ Comma L R
-- Mathlib/Order/Grade.lean
@[simp]
theorem isMin_grade_iff : IsMin (grade 𝕆 a) ↔ IsMin a
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem tan_nat_mul_pi (n : ℕ) : tan (n * π) = 0
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive (attr := simp)]
theorem div_eq_self : a / b = a ↔ b = 1
-- Mathlib/Topology/Algebra/ConstMulAction.lean
@[to_additive]
theorem Filter.Tendsto.const_smul {f : β → α} {l : Filter β} {a : α} (hf : Tendsto f l (𝓝 a))
    (c : M) : Tendsto (fun x => c • f x) l (𝓝 (c • a))
-- Mathlib/Topology/MetricSpace/DilationEquiv.lean
@[simp]
theorem ratio_pow (e : X ≃ᵈ X) (n : ℕ) : ratio (e ^ n) = ratio e ^ n
-- Mathlib/Topology/Compactness/Compact.lean
theorem IsCompact.prod_nhdsSet_eq_biSup {K : Set Y} (hK : IsCompact K) (l : Filter X) :
    l ×ˢ (𝓝ˢ K) = ⨆ y ∈ K, l ×ˢ 𝓝 y
-- Mathlib/Algebra/Lie/Submodule.lean
theorem subset_lieSpan : s ⊆ lieSpan R L s
-- Mathlib/Tactic/CancelDenoms/Core.lean
theorem sub_subst {α} [Ring α] {n e1 e2 t1 t2 : α} (h1 : n * e1 = t1) (h2 : n * e2 = t2) :
    n * (e1 - e2) = t1 - t2
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem IsTrail.of_append_right {u v w : V} {p : G.Walk u v} {q : G.Walk v w}
    (h : (p.append q).IsTrail) : q.IsTrail
-- Mathlib/Algebra/Star/StarAlgHom.lean
theorem one_apply (a : A) : (1 : A →⋆ₙₐ[R] A) a = a
-- Mathlib/RingTheory/Coprime/Basic.lean
@[symm]
theorem IsCoprime.symm (H : IsCoprime x y) : IsCoprime y x
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_subtype'' {ι} (s : Set ι) (f : ι → α) : ⨅ i : s, f i = ⨅ (t : ι) (_ : t ∈ s), f t
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Perm.filterMap (f : α → Option β) {l₁ l₂ : List α} (p : l₁ ~ l₂) :
    filterMap f l₁ ~ filterMap f l₂
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem getLast_concat : getLast (concat l a) h = a
-- Mathlib/NumberTheory/Padics/RingHoms.lean
theorem zmod_congr_of_sub_mem_span_aux (n : ℕ) (x : ℤ_[p]) (a b : ℤ)
    (ha : x - a ∈ (Ideal.span {(p : ℤ_[p]) ^ n}))
    (hb : x - b ∈ (Ideal.span {(p : ℤ_[p]) ^ n})) : (a : ZMod (p ^ n)) = b
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[to_additive]
theorem toMonoidHom_injective : Injective (toMonoidHom : _ → α →* β)
-- Mathlib/Data/Finset/Basic.lean
@[gcongr]
theorem union_subset_union_right (h : t₁ ⊆ t₂) : s ∪ t₁ ⊆ s ∪ t₂
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem toSet_sdiff (x y : ZFSet.{u}) : (x \ y).toSet = x.toSet \ y.toSet
-- Mathlib/Algebra/Module/Torsion.lean
@[simp]
theorem torsion'_torsion'_eq_top : torsion' R (torsion' R M S) S = ⊤
-- Mathlib/Tactic/CategoryTheory/MonoidalComp.lean
@[simps]
instance tensor_right' (X Y : C) [MonoidalCoherence Y (𝟙_ C)] :
    MonoidalCoherence (X ⊗ Y) X
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem concat_ne_nil (a : α) (l : List α) : concat l a ≠ []
-- Mathlib/Data/Nat/PartENat.lean
theorem find_le (n : ℕ) (h : P n) : find P ≤ n
-- Mathlib/Topology/Category/CompHausLike/Limits.lean
lemma finiteCoproduct.ι_injective (a : α) : Function.Injective (finiteCoproduct.ι X a)
-- Mathlib/Algebra/Algebra/Subalgebra/MulOpposite.lean
@[simp]
theorem unop_toSubring (S : Subalgebra R Aᵐᵒᵖ) : S.unop.toSubring = S.toSubring.unop
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem foldr_append (f : α → β → β) (b) (l l' : List α) :
    (l ++ l').foldr f b = l.foldr f (l'.foldr f b)
-- Mathlib/RingTheory/Ideal/Prod.lean
theorem isPrime_of_isPrime_prod_top {I : Ideal R} (h : (Ideal.prod I (⊤ : Ideal S)).IsPrime) :
    I.IsPrime
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_eq_zero_of_ae {f : α → G} (hf : f =ᵐ[μ] 0) : ∫ a, f a ∂μ = 0
-- Mathlib/Topology/Order/Lattice.lean
lemma inf_nhds' [Inf L] [ContinuousInf L] (hf : Tendsto f l (𝓝 x)) (hg : Tendsto g l (𝓝 y)) :
    Tendsto (f ⊓ g) l (𝓝 (x ⊓ y))
-- Mathlib/Topology/ContinuousFunction/Units.lean
theorem isUnit_iff_forall_isUnit (f : C(X, R)) : IsUnit f ↔ ∀ x, IsUnit (f x)
-- Mathlib/AlgebraicGeometry/Morphisms/ClosedImmersion.lean
/-- If `f ≫ g` is a closed immersion, then `f` is a closed immersion. -/
theorem of_comp {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) [IsClosedImmersion g]
    [IsClosedImmersion (f ≫ g)] : IsClosedImmersion f
-- Mathlib/Algebra/Algebra/Operations.lean
theorem comap_op_mul (M N : Submodule R Aᵐᵒᵖ) :
    comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) (M * N) =
      comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) N *
        comap (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ) : A →ₗ[R] Aᵐᵒᵖ) M
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
@[ext]
theorem Hom.ext {a b : SimplexCategory} (f g : a ⟶ b) :
    f.toOrderHom = g.toOrderHom → f = g
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem map_sup (s t : NonUnitalSubsemiring R) (f : F) :
    (map f (s ⊔ t) : NonUnitalSubsemiring S) = map f s ⊔ map f t
-- Mathlib/CategoryTheory/EssentialImage.lean
/-- Being in the essential image is a "hygienic" property: it is preserved under isomorphism. -/
theorem essImage.ofIso {Y Y' : D} (h : Y ≅ Y') (hY : Y ∈ essImage F) : Y' ∈ essImage F
-- Mathlib/Data/Set/Lattice.lean
theorem biInter_empty (u : α → Set β) : ⋂ x ∈ (∅ : Set α), u x = univ
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem bot_subgroupOf : (⊥ : Subgroup G).subgroupOf H = ⊥
-- Mathlib/Tactic/Linarith/Lemmas.lean
@[nolint unusedArguments]
lemma zero_mul_eq {α} {R : α → α → Prop} [Semiring α] {a b : α} (h : a = 0) (_ : R b 0) :
    a * b = 0
-- Mathlib/Probability/Kernel/Invariance.lean
@[simp]
theorem bind_add (μ ν : Measure α) (κ : Kernel α β) : (μ + ν).bind κ = μ.bind κ + ν.bind κ
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem monomial_neg (n : ℕ) (a : R) : monomial n (-a) = -monomial n a
-- Mathlib/LinearAlgebra/AffineSpace/Pointwise.lean
theorem pointwise_vadd_direction (v : V) (s : AffineSubspace k P) :
    (v +ᵥ s).direction = s.direction
-- Mathlib/Algebra/Ring/BooleanRing.lean
@[simp]
theorem toBoolRing_inf (a b : α) : toBoolRing (a ⊓ b) = toBoolRing a * toBoolRing b
-- Mathlib/Data/Multiset/Powerset.lean
theorem powersetAux_perm_powersetAux' {l : List α} : powersetAux l ~ powersetAux' l
-- Mathlib/Topology/Instances/Int.lean
theorem dist_eq' (m n : ℤ) : dist m n = |m - n|
-- Mathlib/LinearAlgebra/Dual.lean
theorem toDual_ker : LinearMap.ker b.toDual = ⊥
-- Mathlib/Analysis/Normed/Module/FiniteDimension.lean
protected theorem LinearIndependent.eventually {ι} [Finite ι] {f : ι → E}
    (hf : LinearIndependent 𝕜 f) : ∀ᶠ g in 𝓝 f, LinearIndependent 𝕜 g
-- Mathlib/Logic/Equiv/Basic.lean
/-- Type product is associative up to an equivalence. -/
@[simps]
def prodAssoc (α β γ) : (α × β) × γ ≃ α × β × γ
-- Mathlib/Order/Interval/Set/Basic.lean
@[gcongr]
theorem Ioc_subset_Ioc (h₁ : a₂ ≤ a₁) (h₂ : b₁ ≤ b₂) : Ioc a₁ b₁ ⊆ Ioc a₂ b₂
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem map_rootOfSplits {f : K[X]} (hf : f.Splits i) (hfd) :
    f.eval₂ i (rootOfSplits i hf hfd) = 0
-- Mathlib/MeasureTheory/Integral/Average.lean
@[simp]
theorem average_neg (f : α → E) : ⨍ x, -f x ∂μ = -⨍ x, f x ∂μ
-- Mathlib/Data/Nat/Choose/Central.lean
theorem two_dvd_centralBinom_succ (n : ℕ) : 2 ∣ centralBinom (n + 1)
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
@[simp, norm_cast]
theorem coe_zero : ((0 : s) : R) = (0 : R)
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
/-- If `S / R` and `S' / R'` are algebras, `i : R ≃+* R'` and `j : S ≃+* S'` are
ring isomorphisms, such that `R → R' → S'` and `R → S → S'` commute,
then the rank of `S / R` is equal to the rank of `S' / R'`. -/
theorem lift_rank_eq_of_equiv_equiv (i : R ≃+* R') (j : S ≃+* S')
    (hc : (algebraMap R' S').comp i.toRingHom = j.toRingHom.comp (algebraMap R S)) :
    lift.{v'} (Module.rank R S) = lift.{v} (Module.rank R' S')
-- Mathlib/Data/Nat/Bitwise.lean
@[simp]
theorem testBit_ldiff : ∀ m n k, testBit (ldiff m n) k = (testBit m k && not (testBit n k))
-- Mathlib/Algebra/Polynomial/Lifts.lean
/-- The polynomial `X` lifts. -/
theorem X_mem_lifts (f : R →+* S) : (X : S[X]) ∈ lifts f
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
theorem resolvent_isBigO_inv (a : A) : resolvent a =O[cobounded 𝕜] Inv.inv
-- Mathlib/LinearAlgebra/AffineSpace/Matrix.lean
theorem isUnit_toMatrix : IsUnit (b.toMatrix b₂)
-- Mathlib/RingTheory/Coprime/Lemmas.lean
theorem pairwise_coprime_iff_coprime_prod [DecidableEq I] :
    Pairwise (IsCoprime on fun i : t ↦ s i) ↔ ∀ i ∈ t, IsCoprime (s i) (∏ j ∈ t \ {i}, s j)
-- Mathlib/CategoryTheory/Monoidal/Types/Basic.lean
@[simp] theorem associator_hom_apply_1 {X Y Z : Type u} {x} :
    (((α_ X Y Z).hom : (X ⊗ Y) ⊗ Z → X ⊗ Y ⊗ Z) x).1 = x.1.1
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean
lemma summable_f_int (k : ℕ) (a : ℝ) {t : ℝ} (ht : 0 < t) : Summable (f_int k a t)
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp, norm_cast]
theorem coe_sInf (S : Set (NonUnitalSubalgebra R A)) : (↑(sInf S) : Set A) = ⋂ s ∈ S, ↑s
-- Mathlib/Geometry/RingedSpace/PresheafedSpace/Gluing.lean
/-- `ιInvApp` is the inverse of `D.ι i` on `U`. -/
theorem π_ιInvApp_eq_id (i : D.J) (U : Opens (D.U i).carrier) :
    D.diagramOverOpenπ U i ≫ D.ιInvAppπEqMap U ≫ D.ιInvApp U = 𝟙 _
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem iterateFrobenius_add :
    iterateFrobenius R p (m + n) = (iterateFrobenius R p m).comp (iterateFrobenius R p n)
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem ContMDiffWithinAt.fst {f : N → M × M'} {s : Set N} {x : N}
    (hf : ContMDiffWithinAt J (I.prod I') n f s x) :
    ContMDiffWithinAt J I n (fun x => (f x).1) s x
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace/HasColimits.lean
theorem imageBasicOpen_image_open :
    IsOpen ((coequalizer.π f.1 g.1).base '' (imageBasicOpen f g U s).1)
-- Mathlib/Data/Finset/NAry.lean
/-- Symmetric statement to `Finset.image_image₂_distrib_left`. -/
theorem image₂_image_left_comm {f : α' → β → γ} {g : α → α'} {f' : α → β → δ} {g' : δ → γ}
    (h_left_comm : ∀ a b, f (g a) b = g' (f' a b)) :
    image₂ f (s.image g) t = (image₂ f' s t).image g'
-- Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
/-- `Complex.conj` is analogous to `CliffordAlgebra.involute`. -/
@[simp]
theorem ofComplex_conj (c : ℂ) : ofComplex (conj c) = involute (ofComplex c)
-- Mathlib/RingTheory/DedekindDomain/Factorization.lean
/-- val_v(0) = 0. -/
lemma count_zero : count K v (0 : FractionalIdeal R⁰ K) = 0
-- Mathlib/Data/Set/Pointwise/Finite.lean
@[to_additive]
theorem Infinite.of_smul_set : (a • s).Infinite → s.Infinite
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp] protected theorem mul_one (a : Rat) : a * 1 = a
-- Mathlib/Algebra/Polynomial/Coeff.lean
theorem mul_X_pow_eq_zero {p : R[X]} {n : ℕ} (H : p * X ^ n = 0) : p = 0
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive (attr := gcongr) sub_le_sub]
theorem div_le_div'' (hab : a ≤ b) (hcd : c ≤ d) : a / d ≤ b / c
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem hasBasis_cobounded_compl_closedBall (c : α) :
    (cobounded α).HasBasis (fun _ ↦ True) (fun r ↦ (closedBall c r)ᶜ)
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean
/-- The tangent of an angle in a right-angled triangle multiplied by the adjacent side equals
the opposite side. -/
theorem tan_angle_mul_dist_of_angle_eq_pi_div_two {p₁ p₂ p₃ : P} (h : ∠ p₁ p₂ p₃ = π / 2)
    (h0 : p₁ = p₂ ∨ p₃ ≠ p₂) : Real.tan (∠ p₂ p₃ p₁) * dist p₃ p₂ = dist p₁ p₂
-- Mathlib/Data/PNat/Xgcd.lean
theorem finish_v (hr : u.r = 0) : u.finish.v = u.v
-- Mathlib/Algebra/Algebra/Subalgebra/MulOpposite.lean
theorem unop_sup (S₁ S₂ : Subalgebra R Aᵐᵒᵖ) : (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop
-- Mathlib/Algebra/Order/Sub/Canonical.lean
protected theorem tsub_lt_self_iff (ha : AddLECancellable a) : a - b < a ↔ 0 < a ∧ 0 < b
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem lintegral_eq_of_subset (f : α →ₛ ℝ≥0∞) {s : Finset ℝ≥0∞}
    (hs : ∀ x, f x ≠ 0 → μ (f ⁻¹' {f x}) ≠ 0 → f x ∈ s) :
    f.lintegral μ = ∑ x ∈ s, x * μ (f ⁻¹' {x})
-- Mathlib/Probability/Independence/Kernel.lean
@[to_additive]
lemma iIndepFun.indepFun_div_right (hf_indep : iIndepFun (fun _ ↦ m) f κ μ)
    (hf_meas : ∀ i, Measurable (f i)) (i j k : ι) (hij : i ≠ j) (hik : i ≠ k) :
    IndepFun (f i) (f j / f k) κ μ
-- Mathlib/Order/RelIso/Basic.lean
@[simp]
protected theorem cast_refl {α : Type u} {r : α → α → Prop} (h₁ : α = α := rfl)
    (h₂ : HEq r r := HEq.rfl) : RelIso.cast h₁ h₂ = RelIso.refl r
-- Mathlib/Algebra/Module/LinearMap/Basic.lean
theorem  _root_.DomMulAct.coe_smul_linearMap (a : S'ᵈᵐᵃ) (f : M →ₛₗ[σ₁₂] M₂) :
    (a • f : M →ₛₗ[σ₁₂] M₂) = a • (f : M → M₂)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem sub_one_add_one {a : Nat} (h : a ≠ 0) : a - 1 + 1 = a
-- Mathlib/Data/Fin/Basic.lean
@[simp]
theorem coe_fin_one (a : Fin 1) : (a : ℕ) = 0
-- Mathlib/Topology/Algebra/Module/StrongTopology.lean
@[simp] lemma arrowCongr_apply (e₁ : E ≃L[𝕜] F) (e₂ : H ≃L[𝕜] G) (f : E →L[𝕜] H) (x : F) :
    e₁.arrowCongr e₂ f x = e₂ (f (e₁.symm x))
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem ae_zero {_m0 : MeasurableSpace α} : ae (0 : Measure α) = ⊥
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem continuousAt_sign {θ : Angle} (h0 : θ ≠ 0) (hpi : θ ≠ π) : ContinuousAt sign θ
-- Mathlib/Topology/UniformSpace/CompactConvergence.lean
/-- In a weakly locally compact space,
convergence in the compact-open topology is the same as locally uniform convergence.

The right-to-left implication holds in any topological space,
see `ContinuousMap.tendsto_of_tendstoLocallyUniformly`. -/
theorem tendsto_iff_tendstoLocallyUniformly [WeaklyLocallyCompactSpace α] :
    Tendsto F p (𝓝 f) ↔ TendstoLocallyUniformly (fun i a => F i a) f p
-- Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean
lemma mem_sInf {S : Set (TwoSidedIdeal R)} {x : R} :
    x ∈ sInf S ↔ ∀ I ∈ S, x ∈ I
-- Mathlib/Order/Interval/Set/Pi.lean
@[simp]
theorem pi_univ_Icc : (pi univ fun i ↦ Icc (x i) (y i)) = Icc x y
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
theorem mem_support_ofFinset_iff (a : α) : a ∈ (ofFinset f s h h').support ↔ a ∈ s ∧ f a ≠ 0
-- Mathlib/CategoryTheory/Sums/Basic.lean
@[simp]
theorem swap_obj_inr (X : D) : (swap C D).obj (inr X) = inl X
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
@[simp]
lemma toMvPolynomial_zero : (0 : Matrix m n R).toMvPolynomial = 0
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive (attr := simp 1100, nolint simpNF)]
theorem mem_map_iff_mem {f : F} (hf : Function.Injective f) {S : Submonoid M} {x : M} :
    f x ∈ S.map f ↔ x ∈ S
-- Mathlib/Algebra/BigOperators/Intervals.lean
@[to_additive]
lemma mul_prod_Ioc_eq_prod_Icc (h : a ≤ b) : f a * ∏ x ∈ Ioc a b, f x = ∏ x ∈ Icc a b, f x
-- Mathlib/Logic/Relation.lean
lemma reflGen_minimal {r' : α → α → Prop} (hr' : Reflexive r') (h : ∀ x y, r x y → r' x y) {x y : α}
    (hxy : ReflGen r x y) : r' x y
-- Mathlib/Order/Cover.lean
@[simp]
theorem toDual_covBy_toDual_iff : toDual b ⋖ toDual a ↔ a ⋖ b
-- Mathlib/Data/Set/Finite.lean
lemma Finite.of_surjOn {s : Set α} {t : Set β} (f : α → β) (hf : SurjOn f s t) (hs : s.Finite) :
    t.Finite
-- Mathlib/CategoryTheory/Subobject/FactorThru.lean
theorem factors_of_factors_right {X Y Z : C} {P : Subobject Z} (f : X ⟶ Y) {g : Y ⟶ Z}
    (h : P.Factors g) : P.Factors (f ≫ g)
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem eq_zero_of_mul_eq_zero_of_smul (P : R[X]) (h : ∀ r : R, r • P = 0 → r = 0) :
    ∀ (Q : R[X]), P * Q = 0 → Q = 0
-- Mathlib/Order/Filter/Ultrafilter.lean
@[simp]
nonrec theorem comap_id (f : Ultrafilter α) (h₀ : Injective (id : α → α) := injective_id)
    (h₁ : range id ∈ f := (by rw [range_id]; exact univ_mem)) :
    f.comap h₀ h₁ = f
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
nonrec theorem _root_.DenseRange.exists_dist_lt {β : Type*} {f : β → α} (hf : DenseRange f) (x : α)
    {ε : ℝ} (hε : 0 < ε) : ∃ y, dist x (f y) < ε
-- Mathlib/LinearAlgebra/FreeAlgebra.lean
theorem rank_eq [CommRing R] [Nontrivial R] :
    Module.rank R (FreeAlgebra R X) = Cardinal.lift.{u} (Cardinal.mk (List X))
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem liftOfRightInverse_comp (hf : Function.RightInverse f_inv f)
    (g : { g : A →+* C // RingHom.ker f ≤ RingHom.ker g }) :
    (f.liftOfRightInverse f_inv hf g).comp f = g
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
lemma mem_ae_iff_prob_eq_one (hs : MeasurableSet s) : s ∈ ae μ ↔ μ s = 1
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem mul_iInter_subset (s : Set α) (t : ι → Set α) : (s * ⋂ i, t i) ⊆ ⋂ i, s * t i