ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/UnitaryGroup.lean
theorem mem_specialUnitaryGroup_iff :
    A ∈ specialUnitaryGroup n α ↔ A ∈ unitaryGroup n α ∧ A.det = 1
-- Mathlib/Data/Nat/Defs.lean
lemma leRecOn_self {C : ℕ → Sort*} {n} {next : ∀ {k}, C k → C (k + 1)} (x : C n) :
    (leRecOn n.le_refl next x : C n) = x
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
/-- We can turn any limit cone over a pair into a bicone. -/
@[simps]
def BinaryBicone.ofLimitCone {X Y : C} {t : Cone (pair X Y)} (ht : IsLimit t) :
    BinaryBicone X Y
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma isUnramified_iff_mult_le :
    IsUnramified k w ↔ mult w ≤ mult (w.comap (algebraMap k K))
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem exists_lt_add_of_not_principal_add {a} (ha : ¬Principal (· + ·) a) :
    ∃ b c, b < a ∧ c < a ∧ b + c = a
-- Mathlib/FieldTheory/Galois.lean
theorem integral [IsGalois F E] (x : E) : IsIntegral F x
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp]
theorem Icc_diff_Ioc_self (h : a ≤ b) : Icc a b \ Ioc a b = {a}
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
theorem isReal_iff {w : InfinitePlace K} :
    IsReal w ↔ ComplexEmbedding.IsReal (embedding w)
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Expand `⟪x - y, x - y⟫_ℝ` -/
theorem real_inner_sub_sub_self (x y : F) :
    ⟪x - y, x - y⟫_ℝ = ⟪x, x⟫_ℝ - 2 * ⟪x, y⟫_ℝ + ⟪y, y⟫_ℝ
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
theorem eq_σ_comp_of_not_injective' {n : ℕ} {Δ' : SimplexCategory} (θ : mk (n + 1) ⟶ Δ')
    (i : Fin (n + 1)) (hi : θ.toOrderHom (Fin.castSucc i) = θ.toOrderHom i.succ) :
    ∃ θ' : mk n ⟶ Δ', θ = σ i ≫ θ'
-- Mathlib/MeasureTheory/Measure/AEDisjoint.lean
@[simp]
theorem iUnion_right_iff [Countable ι] {t : ι → Set α} :
    AEDisjoint μ s (⋃ i, t i) ↔ ∀ i, AEDisjoint μ s (t i)
-- Mathlib/Logic/Equiv/Defs.lean
protected lemma exists_congr (h : ∀ a, p a ↔ q (e a)) : (∃ a, p a) ↔ ∃ b, q b
-- Mathlib/Algebra/MvPolynomial/Rename.lean
theorem killCompl_comp_rename : (killCompl hf).comp (rename f) = AlgHom.id R _
-- .lake/packages/lean4/src/lean/Init/Data/Int/Gcd.lean
theorem gcd_dvd_right {a b : Int} : (gcd a b : Int) ∣ b
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atBot_add_const_left (C : β) (hf : Tendsto f l atBot) :
    Tendsto (fun x => C + f x) l atBot
-- Mathlib/Algebra/ModEq.lean
protected theorem nsmul : a ≡ b [PMOD p] → n • a ≡ n • b [PMOD n • p]
-- Mathlib/Data/List/Basic.lean
theorem zipRight_eq_zipRight' : zipRight as bs = (zipRight' as bs).fst
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem inf_continuous' {f g : α → β} (hf : Continuous' f) (hg : Continuous' g) :
    Continuous' (f ⊓ g)
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[mono]
theorem prod_mono ⦃s₁ s₂ : NonUnitalSubring R⦄ (hs : s₁ ≤ s₂) ⦃t₁ t₂ : NonUnitalSubring S⦄
    (ht : t₁ ≤ t₂) : s₁.prod t₁ ≤ s₂.prod t₂
-- Mathlib/CategoryTheory/Closed/Monoidal.lean
@[simp]
theorem pre_id (A : C) [Closed A] : pre (𝟙 A) = 𝟙 _
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
@[simp]
theorem top_coe : ((⊤ : Submodule R M) : Set M) = Set.univ
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_piCongrLeft (f : δ' ≃ δ) : Measurable (piCongrLeft π f)
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
lemma copy_eq {m : MeasurableSpace α} {p : Set α → Prop} (h : ∀ s, p s ↔ MeasurableSet[m] s) :
    m.copy p h = m
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem domCongr_trans [AddCommMonoid M] (e : α ≃ β) (f : β ≃ γ) :
    (Finsupp.domCongr e).trans (Finsupp.domCongr f) =
      (Finsupp.domCongr (e.trans f) : (α →₀ M) ≃+ _)
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem ae_eq_trans {f g h : α → β} (h₁ : f =ᵐ[μ] g) (h₂ : g =ᵐ[μ] h) : f =ᵐ[μ] h
-- Mathlib/CategoryTheory/Limits/Shapes/Products.lean
@[reassoc (attr := simp)]
theorem Pi.reindex_inv_π (b : β) : (Pi.reindex ε f).inv ≫ Pi.π (f ∘ ε) b = Pi.π f (ε b)
-- Mathlib/CategoryTheory/NatIso.lean
@[simp]
theorem inv_map_inv_app (F : C ⥤ D ⥤ E) {X Y : C} (e : X ≅ Y) (Z : D) :
    inv ((F.map e.inv).app Z) = (F.map e.hom).app Z
-- Mathlib/Order/Iterate.lean
theorem seq_pos_lt_seq_of_lt_of_le (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h₀ : x 0 ≤ y 0)
    (hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n
-- Mathlib/RingTheory/PowerSeries/Basic.lean
/-- The `n`-th coefficient of the `k`-th power of a power series. -/
lemma coeff_pow (k n : ℕ) (φ : R⟦X⟧) :
    coeff R n (φ ^ k) = ∑ l ∈ finsuppAntidiag (range k) n, ∏ i ∈ range k, coeff R (l i) φ
-- Mathlib/Data/List/Indexes.lean
theorem findIdx_eq {p : α → Bool} {xs : List α} {i : ℕ} (h : i < xs.length) :
    xs.findIdx p = i ↔ p (xs.get ⟨i, h⟩) ∧ ∀ j (hji : j < i), ¬p (xs.get ⟨j, hji.trans h⟩)
-- Mathlib/Order/Filter/IndicatorFunction.lean
@[to_additive]
protected theorem Filter.EventuallyEq.mulIndicator [One β] {l : Filter α} {f g : α → β} {s : Set α}
    (hfg : f =ᶠ[l] g) : s.mulIndicator f =ᶠ[l] s.mulIndicator g
-- Mathlib/Data/Finset/Card.lean
@[simp]
theorem card_disjUnion (s t : Finset α) (h) : (s.disjUnion t h).card = s.card + t.card
-- Mathlib/Data/PFun.lean
theorem mem_core_res (f : α → β) (s : Set α) (t : Set β) (x : α) :
    x ∈ (res f s).core t ↔ x ∈ s → f x ∈ t
-- Mathlib/Analysis/Convex/Combination.lean
theorem convexHull_range_eq_exists_affineCombination (v : ι → E) : convexHull R (range v) =
    { x | ∃ (s : Finset ι) (w : ι → R), (∀ i ∈ s, 0 ≤ w i) ∧ s.sum w = 1 ∧
      s.affineCombination R v w = x }
-- Mathlib/Order/Filter/NAry.lean
@[simp]
theorem map₂_right [NeBot f] : map₂ (fun _ y => y) f g = g
-- Mathlib/Data/Matroid/Closure.lean
lemma Basis.eq_of_closure_subset (hI : M.Basis I X) (hJI : J ⊆ I) (hJ : X ⊆ M.closure J) :
    J = I
-- Mathlib/Topology/Homotopy/Basic.lean
@[continuity]
protected theorem continuous (F : HomotopyWith f₀ f₁ P) : Continuous F
-- Mathlib/Data/List/Iterate.lean
@[simp]
theorem range_map_iterate (n : ℕ) (f : α → α) (a : α) :
    (List.range n).map (f^[·] a) = List.iterate f a n
-- Mathlib/Topology/UniformSpace/AbstractCompletion.lean
theorem uniformContinuous_map : UniformContinuous (map f)
-- Mathlib/Topology/NhdsSet.lean
@[simp]
theorem nhdsSet_union (s t : Set X) : 𝓝ˢ (s ∪ t) = 𝓝ˢ s ⊔ 𝓝ˢ t
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
theorem fromSpec_image_basicOpen :
    hU.fromSpec ''ᵁ (PrimeSpectrum.basicOpen f) = X.basicOpen f
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem sum_add_distrib {ι} (f g : ι → Cardinal) : sum (f + g) = sum f + sum g
-- .lake/packages/lean4/src/lean/Init/Omega/Constraint.lean
theorem neg_sat : {c : Constraint} → {v : Int} → sat c v → sat (c.neg) (-v)
-- Mathlib/Logic/Nonempty.lean
theorem subsingleton_of_not_nonempty {α : Sort*} (h : ¬Nonempty α) : Subsingleton α
-- Mathlib/Logic/Basic.lean
theorem forall_and_right [Nonempty α] (p : α → Prop) (q : Prop) :
    (∀ x, p x ∧ q) ↔ (∀ x, p x) ∧ q
-- Mathlib/RingTheory/Localization/Basic.lean
/-- The localization of `R` at `M` as a quotient type is isomorphic to any other localization. -/
@[simps!]
noncomputable def algEquiv : Localization M ≃ₐ[R] S
-- Mathlib/Analysis/Convex/Side.lean
theorem sOppSide_smul_vsub_vadd_left {s : AffineSubspace R P} {x p₁ p₂ : P} (hx : x ∉ s)
    (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s) {t : R} (ht : t < 0) : s.SOppSide (t • (x -ᵥ p₁) +ᵥ p₂) x
-- Mathlib/GroupTheory/GroupAction/FixedPoints.lean
/--
If `g` and `h` commute, then `g` fixes `h • x` iff `g` fixes `x`.
This is equivalent to say that the set `fixedBy α g` is fixed by `h`.
-/
@[to_additive "If `g` and `h` commute, then `g` fixes `h +ᵥ x` iff `g` fixes `x`.
This is equivalent to say that the set `fixedBy α g` is fixed by `h`.
"]
theorem fixedBy_mem_fixedBy_of_commute {g h : G} (comm : Commute g h) :
    (fixedBy α g) ∈ fixedBy (Set α) h
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
/-- A category "has zero morphisms" if there is a designated "zero morphism" in each morphism space,
and compositions of zero morphisms with anything give the zero morphism. -/
class HasZeroMorphisms where
  /-- Every morphism space has zero -/
  [zero : ∀ X Y : C, Zero (X ⟶ Y)]
  /-- `f` composed with `0` is `0` -/
  comp_zero : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ (0 : Y ⟶ Z) = (0 : X ⟶ Z) := by aesop_cat
  /-- `0` composed with `f` is `0` -/
  zero_comp : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), (0 : X ⟶ Y) ≫ f = (0 : X ⟶ Z) := by aesop_cat
-- Mathlib/Order/Concept.lean
@[simp]
theorem intentClosure_union (s₁ s₂ : Set α) :
    intentClosure r (s₁ ∪ s₂) = intentClosure r s₁ ∩ intentClosure r s₂
-- Mathlib/Analysis/Normed/Field/Basic.lean
theorem Filter.Tendsto.zero_mul_isBoundedUnder_le {f g : ι → α} {l : Filter ι}
    (hf : Tendsto f l (𝓝 0)) (hg : IsBoundedUnder (· ≤ ·) l ((‖·‖) ∘ g)) :
    Tendsto (fun x => f x * g x) l (𝓝 0)
-- Mathlib/Algebra/Order/CauSeq/Completion.lean
@[simp]
theorem mk_smul {γ : Type*} [SMul γ β] [IsScalarTower γ β β] (c : γ) (f : CauSeq β abv) :
    c • mk f = mk (c • f)
-- Mathlib/Algebra/Star/Basic.lean
@[simp]
theorem star_star [InvolutiveStar R] (r : R) : star (star r) = r
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem eq_prod_three_roots (ha : P.a ≠ 0) (h3 : (map φ P).roots = {x, y, z}) :
    (map φ P).toPoly = C (φ P.a) * (X - C x) * (X - C y) * (X - C z)
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[simp]
theorem smul_normal (g : G) (H : Subgroup G) [h : Normal H] : MulAut.conj g • H = H
-- Mathlib/Data/List/MinMax.lean
@[simp, deprecated minimum_eq_top "Don't mix Option and WithTop" (since := "2024-05-27")]
theorem minimum_eq_none {l : List α} : l.minimum = none ↔ l = []
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] theorem mul_bmod_bmod : Int.bmod (x * Int.bmod y n) n = Int.bmod (x * y) n
-- Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean
/-- An alternative statement of the Stone-Weierstrass theorem,
for those who like their epsilons.

If `A` is a subalgebra of `C(X, ℝ)` which separates points (and `X` is compact),
every real-valued continuous function on `X` is within any `ε > 0` of some element of `A`.
-/
theorem exists_mem_subalgebra_near_continuousMap_of_separatesPoints (A : Subalgebra ℝ C(X, ℝ))
    (w : A.SeparatesPoints) (f : C(X, ℝ)) (ε : ℝ) (pos : 0 < ε) :
    ∃ g : A, ‖(g : C(X, ℝ)) - f‖ < ε
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem uniformity_basis_edist' (ε' : ℝ≥0∞) (hε' : 0 < ε') :
    (𝓤 α).HasBasis (fun ε : ℝ≥0∞ => ε ∈ Ioo 0 ε') fun ε => { p : α × α | edist p.1 p.2 < ε }
-- Mathlib/Algebra/GCDMonoid/Basic.lean
@[simp]
theorem normUnit_one : normUnit (1 : α) = 1
-- Mathlib/Data/Real/ConjExponents.lean
theorem one_div_ne_zero : 1 / p ≠ 0
-- Mathlib/Control/Lawful.lean
@[simp]
theorem run_bind (f : α → OptionT m β) :
    (x >>= f).run = x.run >>= fun
                              | some a => OptionT.run (f a)
                              | none   => pure none
-- Mathlib/Data/Finsupp/Multiset.lean
@[simp]
theorem toFinsupp_toMultiset (s : Multiset α) : Finsupp.toMultiset (toFinsupp s) = s
-- Mathlib/Data/Nat/PartENat.lean
theorem coe_le_iff (n : ℕ) (x : PartENat) : (n : PartENat) ≤ x ↔ ∀ h : x.Dom, n ≤ x.get h
-- Mathlib/SetTheory/Game/PGame.lean
theorem lf_of_le_moveLeft {x y : PGame} {i} (h : x ≤ y.moveLeft i) : x ⧏ y
-- Mathlib/Analysis/Convex/Cone/Basic.lean
@[simp]
theorem coe_inf : ((S ⊓ T : ConvexCone 𝕜 E) : Set E) = ↑S ∩ ↑T
-- Mathlib/Topology/Maps/Basic.lean
theorem Embedding.map_nhds_eq (hf : Embedding f) (x : X) :
    (𝓝 x).map f = 𝓝[range f] f x
-- Mathlib/Data/Finite/Defs.lean
/-- `Infinite α` is not `Finite`-/
theorem not_finite (α : Sort*) [Infinite α] [Finite α] : False
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
/-- Bijection between `α` and `ULift.{v} α` -/
theorem ULift.up_down {α : Type u} (b : ULift.{v} α) : Eq (up (down b)) b
-- Mathlib/Data/Set/Function.lean
theorem mapsTo_preimage (h : Semiconj f fa fb) {s t : Set β} (hb : MapsTo fb s t) :
    MapsTo fa (f ⁻¹' s) (f ⁻¹' t)
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean
/-- The cosine of the angle between two vectors is 0 if and only if the angle is π / 2. -/
theorem cos_eq_zero_iff_angle_eq_pi_div_two : cos (angle x y) = 0 ↔ angle x y = π / 2
-- Mathlib/Topology/Algebra/ConstMulAction.lean
/-- Class `ProperlyDiscontinuousSMul Γ T` says that the scalar multiplication `(•) : Γ → T → T`
is properly discontinuous, that is, for any pair of compact sets `K, L` in `T`, only finitely many
`γ:Γ` move `K` to have nontrivial intersection with `L`.
-/
class ProperlyDiscontinuousSMul (Γ : Type*) (T : Type*) [TopologicalSpace T] [SMul Γ T] :
    Prop where
  /-- Given two compact sets `K` and `L`, `γ • K ∩ L` is nonempty for finitely many `γ`. -/
  finite_disjoint_inter_image :
    ∀ {K L : Set T}, IsCompact K → IsCompact L → Set.Finite { γ : Γ | (γ • ·) '' K ∩ L ≠ ∅ }
-- Mathlib/Order/Bounds/Basic.lean
theorem Set.Nonempty.bddAbove_lowerBounds (hs : s.Nonempty) : BddAbove (lowerBounds s)
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
protected lemma mul_mul_div (a : α) (h : IsUnit b) : a * b * (1 / b) = a
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem symm_of_uniformity {s : Set (α × α)} (hs : s ∈ 𝓤 α) :
    ∃ t ∈ 𝓤 α, (∀ a b, (a, b) ∈ t → (b, a) ∈ t) ∧ t ⊆ s
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
/-- A mono factorisation of `f ≫ g`, where `g` is an isomorphism,
gives a mono factorisation of `f`. -/
@[simps]
def ofCompIso {Y' : C} {g : Y ⟶ Y'} [IsIso g] (F : MonoFactorisation (f ≫ g)) :
    MonoFactorisation f
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem cos_zero : cos (0 : Angle) = 1
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem Poly.denote_append (ctx : Context) (p q : Poly) : (p ++ q).denote ctx = p.denote ctx + q.denote ctx
-- Mathlib/Computability/Primrec.lean
theorem vector_toList_iff {n} {f : α → Vector β n} : (Primrec fun a => (f a).toList) ↔ Primrec f
-- Mathlib/LinearAlgebra/FiniteDimensional.lean
theorem injective_iff_surjective_of_finrank_eq_finrank [FiniteDimensional K V]
    [FiniteDimensional K V₂] (H : finrank K V = finrank K V₂) {f : V →ₗ[K] V₂} :
    Function.Injective f ↔ Function.Surjective f
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem neg_comp : (-p).comp q = -p.comp q
-- Mathlib/MeasureTheory/Measure/Sub.lean
theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
    (μ - ν).restrict s = μ.restrict s - ν.restrict s
-- Mathlib/Algebra/Lie/TensorProduct.lean
@[simp]
nonrec theorem map_tmul (f : M →ₗ⁅R,L⁆ P) (g : N →ₗ⁅R,L⁆ Q) (m : M) (n : N) :
    map f g (m ⊗ₜ n) = f m ⊗ₜ g n
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem prod_inf_prod {S T : NonUnitalSubalgebra R A} {S₁ T₁ : NonUnitalSubalgebra R B} :
    S.prod S₁ ⊓ T.prod T₁ = (S ⊓ T).prod (S₁ ⊓ T₁)
-- Mathlib/Tactic/LinearCombination.lean
theorem c_sub_pf [Sub α] (p : b = c) (a : α) : a - b = a - c
-- Mathlib/Algebra/CubicDiscriminant.lean
theorem card_roots_of_disc_ne_zero [DecidableEq K] (ha : P.a ≠ 0) (h3 : (map φ P).roots = {x, y, z})
    (hd : P.disc ≠ 0) : (map φ P).roots.toFinset.card = 3
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
@[simp]
lemma fromRows_mul (A₁ : Matrix m₁ n R) (A₂ : Matrix m₂ n R) (B : Matrix n m R) :
    fromRows A₁ A₂ * B = fromRows (A₁ * B) (A₂ * B)
-- Mathlib/Order/UpperLower/Basic.lean
theorem IsUpperSet.Ioi_subset (h : IsUpperSet s) ⦃a⦄ (ha : a ∈ s) : Ioi a ⊆ s
-- Mathlib/Data/Finset/Lattice.lean
@[simp]
theorem lt_sup'_iff : a < s.sup' H f ↔ ∃ b ∈ s, a < f b
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem eq_comm {a b : α} : a = b ↔ b = a
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- The oriented angle between two vectors is `π` if and only if the angle with the vectors
swapped is `π`. -/
theorem oangle_eq_pi_iff_oangle_rev_eq_pi {x y : V} : o.oangle x y = π ↔ o.oangle y x = π
-- Mathlib/Algebra/Field/Basic.lean
theorem inv_neg_one : (-1 : K)⁻¹ = -1
-- .lake/packages/lean4/src/lean/Init/Classical.lean
theorem byCases {p q : Prop} (hpq : p → q) (hnpq : ¬p → q) : q
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem singleton_union : {a} ∪ s = insert a s
-- Mathlib/Algebra/Order/Hom/Monoid.lean
theorem coe_comp_orderMonoidHom (f : β →*₀o γ) (g : α →*₀o β) :
    (f.comp g : α →*o γ) = (f : β →*o γ).comp g
-- Mathlib/Order/Interval/Set/Monotone.lean
protected theorem MonotoneOn.Icc (hf : MonotoneOn f s) (hg : AntitoneOn g s) :
    AntitoneOn (fun x => Icc (f x) (g x)) s
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem Measure.FiniteAtFilter.integrableAtFilter_of_tendsto_ae {l : Filter α}
    [IsMeasurablyGenerated l] (hfm : StronglyMeasurableAtFilter f l μ) (hμ : μ.FiniteAtFilter l) {b}
    (hf : Tendsto f (l ⊓ ae μ) (𝓝 b)) : IntegrableAtFilter f l μ
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
theorem gcd_ne_zero_left : m ≠ 0 → gcd m n ≠ 0
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem comp_inv_eq (α : X ⟶ Y) [IsIso α] {f : Z ⟶ Y} {g : Z ⟶ X} : f ≫ inv α = g ↔ f = g ≫ α
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
theorem singularPart_le (μ ν : Measure α) : μ.singularPart ν ≤ μ
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem ofDual_hnot (a : αᵒᵈ) : ofDual (￢a) = (ofDual a)ᶜ
-- Mathlib/Topology/Algebra/GroupWithZero.lean
theorem continuousOn_inv₀ : ContinuousOn (Inv.inv : G₀ → G₀) {0}ᶜ
-- Mathlib/Algebra/Module/Injective.lean
theorem ExtensionOf.ext_iff {a b : ExtensionOf i f} :
    a = b ↔ ∃ _ : a.domain = b.domain, ∀ ⦃x : a.domain⦄ ⦃y : b.domain⦄,
    (x : N) = y → a.toLinearPMap x = b.toLinearPMap y
-- Mathlib/Algebra/CharZero/Lemmas.lean
theorem RingHom.injective_nat (f : ℕ →+* R) [CharZero R] : Function.Injective f
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem lift_lt_univ' (c : Cardinal) : lift.{max (u + 1) v, u} c < univ.{u, v}
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem Monic.normalize_eq_self {p : R[X]} (hp : p.Monic) : normalize p = p
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem lift_card (a) : Cardinal.lift.{u,v} (card a)= card (lift.{u,v} a)
-- Mathlib/Data/Finset/Basic.lean
@[simp, norm_cast]
theorem coe_ssubset {s₁ s₂ : Finset α} : (s₁ : Set α) ⊂ s₂ ↔ s₁ ⊂ s₂
-- Mathlib/Algebra/Category/Grp/EpiMono.lean
@[to_additive]
theorem ker_eq_bot_of_mono [Mono f] : f.ker = ⊥
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma isUnit_X_of_Z_eq_zero {P : Fin 3 → F} (hP : W.Nonsingular P) (hPz : P z = 0) : IsUnit (P x)
-- Mathlib/Data/Matrix/Reflection.lean
/-- This can be use to prove
```lean
example (P : Matrix (Fin 2) (Fin 3) α → Prop) :
  (∃ x, P x) ↔ ∃ a b c d e f, P !![a, b, c; d, e, f] :=
(exists_iff _).symm
```
-/
theorem exists_iff : ∀ {m n} (P : Matrix (Fin m) (Fin n) α → Prop), Exists P ↔ ∃ x, P x
-- Mathlib/Algebra/Star/Unitary.lean
@[simp]
theorem mul_star_self_of_mem {U : R} (hU : U ∈ unitary R) : U * star U = 1
-- Mathlib/Data/QPF/Multivariate/Basic.lean
theorem suppPreservation_iff_isUniform : q.SuppPreservation ↔ q.IsUniform
-- Mathlib/Algebra/CharP/ExpChar.lean
/-- If a ring homomorphism `R →+* A` is injective then `A` has the same exponential characteristic
as `R`. -/
theorem expChar_of_injective_ringHom {R A : Type*}
    [Semiring R] [Semiring A] {f : R →+* A} (h : Function.Injective f)
    (q : ℕ) [hR : ExpChar R q] : ExpChar A q
-- Mathlib/Topology/Sets/Closeds.lean
@[simp]
theorem iInf_mk {ι} (s : ι → Set α) (h : ∀ i, IsClosed (s i)) :
    (⨅ i, ⟨s i, h i⟩ : Closeds α) = ⟨⋂ i, s i, isClosed_iInter h⟩
-- Mathlib/CategoryTheory/Monoidal/Preadditive.lean
@[ext]
theorem leftDistributor_ext₂_left {J : Type} [Fintype J]
    {X Y Z : C} {f : J → C} {g h : X ⊗ (Y ⊗ ⨁ f) ⟶ Z}
    (w : ∀ j, (X ◁ (Y ◁ biproduct.ι f j)) ≫ g = (X ◁ (Y ◁ biproduct.ι f j)) ≫ h) :
    g = h
-- Mathlib/Algebra/Lie/Weights/RootSystem.lean
lemma rootSpace_zsmul_add_ne_bot_iff_mem (n : ℤ) :
    rootSpace H (n • α + β) ≠ ⊥ ↔ n ∈ Finset.Icc (-chainBotCoeff α β : ℤ) (chainTopCoeff α β)
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem range_fst : NonUnitalRingHom.srange (fst R S) = ⊤
-- Mathlib/Data/Finset/Lattice.lean
theorem inf_of_mem {s : Finset β} (f : β → α) {b : β} (h : b ∈ s) :
    ∃ a : α, s.inf ((↑) ∘ f : β → WithTop α) = ↑a
-- Mathlib/Logic/Equiv/List.lean
@[simp]
theorem encode_list_nil : encode (@nil α) = 0
-- Mathlib/Order/Filter/Basic.lean
theorem NeBot.not_disjoint (hf : f.NeBot) (hs : s ∈ f) (ht : t ∈ f) : ¬Disjoint s t
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
@[simp]
theorem _root_.Matrix.nondegenerate_toBilin'_iff {M : Matrix ι ι R₃} :
    M.toBilin'.Nondegenerate ↔ M.Nondegenerate
-- Mathlib/RingTheory/Polynomial/ScaleRoots.lean
@[simp]
lemma scaleRoots_one (p : R[X]) :
    p.scaleRoots 1 = p
-- Mathlib/Topology/Algebra/Module/FiniteDimension.lean
@[simp]
theorem coe_toContinuousLinearEquiv_symm (e : E ≃ₗ[𝕜] F) :
    (e.toContinuousLinearEquiv.symm : F →ₗ[𝕜] E) = e.symm
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
protected theorem le_sup_right {a b : CauSeq α abs} : b ≤ a ⊔ b
-- Mathlib/Analysis/LocallyConvex/Polar.lean
/-- The map `B.polar : Set E → Set F` forms an order-reversing Galois connection with
`B.flip.polar : Set F → Set E`. We use `OrderDual.toDual` and `OrderDual.ofDual` to express
that `polar` is order-reversing. -/
theorem polar_gc :
    GaloisConnection (OrderDual.toDual ∘ B.polar) (B.flip.polar ∘ OrderDual.ofDual)
-- Mathlib/LinearAlgebra/DirectSum/TensorProduct.lean
@[simp]
theorem directSum_lof_tmul_lof (i₁ : ι₁) (m₁ : M₁ i₁) (i₂ : ι₂) (m₂ : M₂ i₂) :
    TensorProduct.directSum R S M₁ M₂ (DirectSum.lof S ι₁ M₁ i₁ m₁ ⊗ₜ DirectSum.lof R ι₂ M₂ i₂ m₂) =
      DirectSum.lof S (ι₁ × ι₂) (fun i => M₁ i.1 ⊗[R] M₂ i.2) (i₁, i₂) (m₁ ⊗ₜ m₂)
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
theorem closure_singleton_zero : closure ({0} : Set A) = ⊥
-- Mathlib/RingTheory/Localization/Submodule.lean
theorem isNoetherianRing (h : IsNoetherianRing R) : IsNoetherianRing S
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem succ_succ_ne_one (a : Fin n) : Fin.succ (Fin.succ a) ≠ 1
-- Mathlib/Algebra/Algebra/Hom/Rat.lean
@[simp]
theorem AlgHom.toRingHom_toRatAlgHom [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S]
    (f : R →ₐ[ℚ] S) : (f : R →+* S).toRatAlgHom = f
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem two_nsmul_eq_zero_iff {θ : Angle} : (2 : ℕ) • θ = 0 ↔ θ = 0 ∨ θ = π
-- Mathlib/NumberTheory/Modular.lean
theorem re_T_smul : (T • z).re = z.re + 1
-- Mathlib/RingTheory/DedekindDomain/Different.lean
lemma dual_involutive :
    Function.Involutive (dual A K : FractionalIdeal B⁰ L → FractionalIdeal B⁰ L)
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
@[deprecated filter_beq (since := "2023-12-14")]
theorem filter_beq' (l : List α) (a : α) : l.filter (a == ·) = replicate (count a l) a
-- Mathlib/CategoryTheory/Shift/InducedShiftSequence.lean
lemma shiftIso_hom_app_obj (n a a' : M) (ha' : n + a = a') (X : C) :
    (shiftIso L G M F' e' n a a' ha').hom.app (L.obj X) =
      (F' a).map ((L.commShiftIso n).inv.app X) ≫
        (e' a).hom.app (X⟦n⟧) ≫ (G.shiftIso n a a' ha').hom.app X ≫ (e' a').inv.app X
-- Mathlib/Data/Finset/Pointwise/Interval.lean
@[to_additive Ici_add_Ici_subset]
theorem Ici_mul_Ici_subset' [LocallyFiniteOrderTop α] (a b : α) : Ici a * Ici b ⊆ Ici (a * b)
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Ioo_subset_Ico_self : Ioo a b ⊆ Ico a b
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem decompose {x y : ℤ} : (⟨x, y⟩ : ℤ√d) = x + sqrtd (d := d) * y
-- Mathlib/Data/Set/NAry.lean
/-- Symmetric statement to `Set.image2_image_left_anticomm`. -/
theorem image_image2_antidistrib_left {g : γ → δ} {f' : β' → α → δ} {g' : β → β'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g' b) a) :
    (image2 f s t).image g = image2 f' (t.image g') s
-- Mathlib/Data/Nat/Hyperoperation.lean
@[simp]
theorem hyperoperation_three : hyperoperation 3 = (· ^ ·)
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem map_dfinsupp_sumAddHom [NonAssocSemiring R] [NonAssocSemiring S] [∀ i, AddZeroClass (β i)]
    (h : R →+* S) (f : Π₀ i, β i) (g : ∀ i, β i →+ R) :
    h (sumAddHom g f) = sumAddHom (fun i => h.toAddMonoidHom.comp (g i)) f
-- Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean
/-- The recurrence relation for the `Γ` function. -/
theorem Gamma_add_one (s : ℂ) (h2 : s ≠ 0) : Gamma (s + 1) = s * Gamma s
-- Mathlib/GroupTheory/GroupAction/Period.lean
@[to_additive]
theorem period_pos_of_orderOf_pos {m : M} (order_pos : 0 < orderOf m) (a : α) :
    0 < period m a
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem nonempty_of_mem {x u : PSet} (h : x ∈ u) : u.Nonempty