ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Logic/Equiv/Set.lean
@[simp]
theorem insert_apply_right {α} {s : Set.{u} α} [DecidablePred (· ∈ s)] {a : α} (H : a ∉ s) (b : s) :
    Equiv.Set.insert H ⟨b, Or.inr b.2⟩ = Sum.inl b
-- Mathlib/CategoryTheory/Monoidal/Subcategory.lean
/-- A property `C → Prop` is a monoidal predicate if it is closed under `𝟙_` and `⊗`.
-/
class MonoidalPredicate : Prop where
  prop_id : P (𝟙_ C) := by aesop_cat
  prop_tensor : ∀ {X Y}, P X → P Y → P (X ⊗ Y) := by aesop_cat
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem ord_injective : Injective ord
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
@[simp]
lemma natDegree_preΨ' {n : ℕ} (h : (n : R) ≠ 0) :
    (W.preΨ' n).natDegree = (n ^ 2 - if Even n then 4 else 1) / 2
-- Mathlib/FieldTheory/Adjoin.lean
theorem extendScalars_adjoin {K : IntermediateField F E} {S : Set E} (h : K ≤ adjoin F S) :
    extendScalars h = adjoin K S
-- Mathlib/GroupTheory/GroupAction/Group.lean
protected theorem MulAction.surjective₀ (ha : a ≠ 0) : Function.Surjective (a • · : β → β)
-- Mathlib/Algebra/Associated/Basic.lean
theorem dvdNotUnit_of_lt {a b : Associates α} (hlt : a < b) : DvdNotUnit a b
-- Mathlib/Data/Int/Defs.lean
lemma natAbs_le_of_dvd_ne_zero (hmn : m ∣ n) (hn : n ≠ 0) : natAbs m ≤ natAbs n
-- Mathlib/Data/Nat/Digits.lean
theorem digits_def' :
    ∀ {b : ℕ} (_ : 1 < b) {n : ℕ} (_ : 0 < n), digits b n = (n % b) :: digits b (n / b)
-- Mathlib/RingTheory/Bialgebra/Equiv.lean
@[simp]
theorem coe_toAlgEquiv : ⇑(e : A ≃ₐ[R] B) = e
-- Mathlib/Algebra/Homology/Embedding/IsSupported.lean
lemma isZero_iff_isStrictlySupported_and_isStrictlySupportedOutside :
    IsZero K ↔ K.IsStrictlySupported e ∧ K.IsStrictlySupportedOutside e
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean
@[simp]
theorem pushoutCoconeOfLeftIso_ι_app_left : (pushoutCoconeOfLeftIso f g).ι.app left = inv f ≫ g
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem coe_comp (f : BoundedLatticeHom β γ) (g : BoundedLatticeHom α β) :
    (f.comp g : α → γ) = f ∘ g
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem lt_rootMultiplicity_iff_isRoot_iterate_derivative
    [CharZero R] {p : R[X]} {t : R} {n : ℕ} (h : p ≠ 0) :
    n < p.rootMultiplicity t ↔ ∀ m ≤ n, (derivative^[m] p).IsRoot t
-- Mathlib/GroupTheory/Complement.lean
@[to_additive]
theorem inv_toFun_mul_mem (hS : S ∈ Subgroup.leftTransversals (H : Set G)) (g : G) :
    (toFun hS g : G)⁻¹ * g ∈ H
-- Mathlib/Algebra/Group/Hom/Basic.lean
@[to_additive (attr := simp)]
theorem mul_apply {M N} [Mul M] [CommSemigroup N] (f g : M →ₙ* N) (x : M) :
    (f * g) x = f x * g x
-- Mathlib/Order/Heyting/Basic.lean
theorem compl_sup_distrib (a b : α) : (a ⊔ b)ᶜ = aᶜ ⊓ bᶜ
-- Mathlib/Data/Finsupp/Antidiagonal.lean
@[to_additive]
theorem prod_antidiagonal_swap {M : Type*} [CommMonoid M] (n : α →₀ ℕ)
    (f : (α →₀ ℕ) → (α →₀ ℕ) → M) :
    ∏ p ∈ antidiagonal n, f p.1 p.2 = ∏ p ∈ antidiagonal n, f p.2 p.1
-- Mathlib/Order/Filter/AtTopBot.lean
theorem _root_.StrictMono.tendsto_atTop {φ : ℕ → ℕ} (h : StrictMono φ) : Tendsto φ atTop atTop
-- Mathlib/LinearAlgebra/CliffordAlgebra/Prod.lean
@[simp]
lemma ofProd_ι_mk (m₁ : M₁) (m₂ : M₂) :
    ofProd Q₁ Q₂ (ι _ (m₁, m₂)) = ι Q₁ m₁ ᵍ⊗ₜ 1 + 1 ᵍ⊗ₜ ι Q₂ m₂
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[simp]
theorem coe_sdiff (s t : Subtype (MeasurableSet : Set α → Prop)) : ↑(s \ t) = (s : Set α) \ t
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem preimage_spanningSetsIndex_singleton (μ : Measure α) [SigmaFinite μ] (n : ℕ) :
    spanningSetsIndex μ ⁻¹' {n} = disjointed (spanningSets μ) n
-- Mathlib/Algebra/DirectLimit.lean
theorem lift_unique [IsDirected ι (· ≤ ·)] (F : DirectLimit G f →ₗ[R] P) (x) :
    F x =
      lift R ι G f (fun i => F.comp <| of R ι G f i)
        (fun i j hij x => by rw [LinearMap.comp_apply, of_f]; rfl) x
-- Mathlib/RingTheory/WittVector/StructurePolynomial.lean
theorem wittStructureInt_vars [Fintype idx] (Φ : MvPolynomial idx ℤ) (n : ℕ) :
    (wittStructureInt p Φ n).vars ⊆ Finset.univ ×ˢ Finset.range (n + 1)
-- Mathlib/RingTheory/PowerBasis.lean
theorem natDegree_minpolyGen [Nontrivial A] (pb : PowerBasis A S) :
    natDegree (minpolyGen pb) = pb.dim
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem Monotone.mul [PosMulMono α] [MulPosMono α]
    (hf : Monotone f) (hg : Monotone g) (hf₀ : ∀ x, 0 ≤ f x) (hg₀ : ∀ x, 0 ≤ g x) :
    Monotone (f * g)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem LipschitzWith.comp_memℒp {α E F} {K} [MeasurableSpace α] {μ : Measure α}
    [NormedAddCommGroup E] [NormedAddCommGroup F] {f : α → E} {g : E → F} (hg : LipschitzWith K g)
    (g0 : g 0 = 0) (hL : Memℒp f p μ) : Memℒp (g ∘ f) p μ
-- Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean
/-- The lower part of the first column of the snake diagram is exact. -/
lemma exact_C₁_down : (ShortComplex.mk S.v₁₂.τ₁ S.v₂₃.τ₁
    (by rw [← comp_τ₁, S.w₁₃, zero_τ₁])).Exact
-- Mathlib/Topology/Order.lean
theorem le_nhdsAdjoint_iff {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b ≠ a, IsOpen[t] {b}
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem X_pow_eq_monomial : X n ^ e = monomial (Finsupp.single n e) (1 : R)
-- Mathlib/Algebra/Group/Hom/Basic.lean
@[to_additive (attr := simp)]
lemma comp_div (f : G →* H) (g h : M →* G) : f.comp (g / h) = f.comp g / f.comp h
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp, norm_cast] lemma coe_mk' (f : ∀ i, β i) (s) : ⇑(⟨f, s⟩ : Π₀ i, β i) = f
-- Mathlib/RingTheory/Ideal/Operations.lean
/-- This duplicates the global `smul_eq_mul`, but doesn't have to unfold anywhere near as much to
apply. -/
protected theorem _root_.Ideal.smul_eq_mul (I J : Ideal R) : I • J = I * J
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[simp]
theorem vsub_eq_empty : s -ᵥ t = ∅ ↔ s = ∅ ∨ t = ∅
-- Mathlib/Data/Finset/Option.lean
@[simp]
theorem mem_toFinset {a : α} {o : Option α} : a ∈ o.toFinset ↔ a ∈ o
-- Mathlib/Topology/DiscreteQuotient.lean
theorem exists_of_compat [CompactSpace X] (Qs : (Q : DiscreteQuotient X) → Q)
    (compat : ∀ (A B : DiscreteQuotient X) (h : A ≤ B), ofLE h (Qs _) = Qs _) :
    ∃ x : X, ∀ Q : DiscreteQuotient X, Q.proj x = Qs _
-- Mathlib/Computability/TuringMachine.lean
@[simp]
theorem ListBlank.tail_cons {Γ} [Inhabited Γ] (a : Γ) : ∀ l : ListBlank Γ, (l.cons a).tail = l
-- Mathlib/Tactic/ComputeDegree.lean
theorem natDegree_one_le : natDegree (1 : R[X]) ≤ 0
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
nonrec theorem HasDerivWithinAt.sub (hf : HasDerivWithinAt f f' s x)
    (hg : HasDerivWithinAt g g' s x) : HasDerivWithinAt (fun x => f x - g x) (f' - g') s x
-- Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean
theorem tsum_unop [T2Space α] {f : β → αᵐᵒᵖ} :
    ∑' x, unop (f x) = unop (∑' x, f x)
-- Mathlib/Order/Disjoint.lean
theorem isCompl_bot_top : IsCompl (⊥ : α) ⊤
-- Mathlib/GroupTheory/Complement.lean
@[to_additive]
theorem isComplement_singleton_right {g : G} : IsComplement S {g} ↔ S = univ
-- .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Omega/MinNatAbs.lean
theorem nonzeroMinimum_le {xs : List Nat} (m : a ∈ xs) (h : a ≠ 0) : xs.nonzeroMinimum ≤ a
-- Mathlib/Data/Set/Image.lean
theorem range_image (f : α → β) : range (image f) = 𝒫 range f
-- Mathlib/Topology/Order/NhdsSet.lean
theorem hasBasis_nhdsSet_Ici_Ici (a : α) [NeBot (𝓝[<] a)] :
    HasBasis (𝓝ˢ (Ici a)) (· < a) Ici
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem liftAlgHom_apply_div (p q : K[X]) :
    liftAlgHom φ hφ (algebraMap _ _ p / algebraMap _ _ q) = φ p / φ q
-- Mathlib/Analysis/Normed/Group/HomCompletion.lean
theorem NormedAddGroupHom.extension_def (f : NormedAddGroupHom G H) (v : G) :
    f.extension v = Completion.extension f v
-- Mathlib/Algebra/Group/Conj.lean
@[simp]
theorem isConj_one_left {a : α} : IsConj a 1 ↔ a = 1
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[to_additive (attr := simp, norm_cast)]
lemma coe_eq_one : (a : WithTop α) = 1 ↔ a = 1
-- Mathlib/Analysis/SpecificLimits/Basic.lean
/-- The sum of `2⁻¹ ^ i` for `n ≤ i` equals `2 * 2⁻¹ ^ n`. -/
theorem tsum_geometric_inv_two_ge (n : ℕ) :
    (∑' i, ite (n ≤ i) ((2 : ℝ)⁻¹ ^ i) 0) = 2 * 2⁻¹ ^ n
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- The product of two monotone functions is monotone. -/
@[to_additive add "The sum of two monotone functions is monotone."]
theorem Monotone.mul' [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (swap (· * ·)) (· ≤ ·)] (hf : Monotone f) (hg : Monotone g) :
    Monotone fun x => f x * g x
-- Mathlib/Combinatorics/HalesJewett.lean
/-- The **multidimensional Hales-Jewett theorem**, aka **extended Hales-Jewett theorem**: For any
finite types `η`, `α` and `κ`, there exists a finite type `ι` such that whenever the hypercube
`ι → α` is `κ`-colored, there is a monochromatic combinatorial subspace of dimension `η`. -/
theorem exists_mono_in_high_dimension (α κ η) [Finite α] [Finite κ] [Finite η] :
    ∃ (ι : Type) (_ : Fintype ι), ∀ C : (ι → α) → κ, ∃ l : Subspace η α ι, l.IsMono C
-- Mathlib/GroupTheory/Perm/List.lean
@[simp]
theorem formPerm_mem_iff_mem : l.formPerm x ∈ l ↔ x ∈ l
-- Mathlib/Topology/Algebra/Module/Star.lean
theorem continuous_decomposeProdAdjoint_symm [TopologicalAddGroup A] :
    Continuous (StarModule.decomposeProdAdjoint R A).symm
-- Mathlib/Data/Finsupp/Order.lean
theorem subset_support_tsub [DecidableEq ι] {f1 f2 : ι →₀ α} :
    f1.support \ f2.support ⊆ (f1 - f2).support
-- Mathlib/Data/List/InsertNth.lean
@[simp]
theorem insertNth_succ_cons (s : List α) (hd x : α) (n : ℕ) :
    insertNth (n + 1) x (hd :: s) = hd :: insertNth n x s
-- Mathlib/Topology/MetricSpace/Gluing.lean
@[simp]
theorem dist_ne {i j : ι} (h : i ≠ j) (x : E i) (y : E j) :
    dist (⟨i, x⟩ : Σk, E k) ⟨j, y⟩ = dist x (Nonempty.some ⟨x⟩) + 1 + dist (Nonempty.some ⟨y⟩) y
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem sign_eq_one_of_pos {a : Int} (h : 0 < a) : sign a = 1
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem pred_lt_pred : ∀ {n m}, n ≠ 0 → n < m → pred n < pred m
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive (attr := simp) card_nsmul_eq_zero']
theorem pow_card_eq_one' {G : Type*} [Group G] {x : G} : x ^ Nat.card G = 1
-- Mathlib/GroupTheory/QuotientGroup.lean
/-- Two `MonoidHom`s from a quotient group are equal if their compositions with
`QuotientGroup.mk'` are equal.

See note [partially-applied ext lemmas]. -/
@[to_additive (attr := ext 1100) "Two `AddMonoidHom`s from an additive quotient group are equal if
 their compositions with `AddQuotientGroup.mk'` are equal.

 See note [partially-applied ext lemmas]. "]
theorem monoidHom_ext ⦃f g : G ⧸ N →* M⦄ (h : f.comp (mk' N) = g.comp (mk' N)) : f = g
-- Mathlib/RingTheory/Polynomial/Content.lean
theorem dvd_content_iff_C_dvd {p : R[X]} {r : R} : r ∣ p.content ↔ C r ∣ p
-- Mathlib/Algebra/Homology/HomotopyCategory/ShortExact.lean
lemma quasiIso_descShortComplex : QuasiIso (descShortComplex S)
-- Mathlib/Algebra/ContinuedFractions/Translations.lean
theorem terminatedAt_iff_partNum_none : g.TerminatedAt n ↔ g.partNums.get? n = none
-- Mathlib/Data/Finset/Interval.lean
/-- Cardinality of an `Iio` of finsets. -/
theorem card_Iio_finset : (Iio s).card = 2 ^ s.card - 1
-- Mathlib/FieldTheory/Adjoin.lean
theorem comap_map (f : L →ₐ[K] L') (S : IntermediateField K L) : (S.map f).comap f = S
-- Mathlib/RingTheory/Valuation/Basic.lean
@[simp]
theorem map_div (v : AddValuation K Γ₀) {x y : K} : v (x / y) = v x - v y
-- Mathlib/Algebra/Regular/Basic.lean
/-- The element `0` is left-regular if and only if `R` is trivial. -/
theorem IsLeftRegular.subsingleton (h : IsLeftRegular (0 : R)) : Subsingleton R
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem continuous_pow (hf : Continuous f) (n : ℕ) : Continuous (f ^ n : CircleDeg1Lift)
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
@[simp] theorem prev_zero (s : Substring) : s.prev 0 = 0
-- Mathlib/Algebra/Polynomial/Mirror.lean
theorem mirror_natDegree : p.mirror.natDegree = p.natDegree
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
lemma pow_pos_iff (hn : n ≠ 0) : 0 < a ^ n ↔ 0 < a
-- Mathlib/Order/UpperLower/Basic.lean
@[simp, norm_cast]
theorem coe_sSup (S : Set (UpperSet α)) : (↑(sSup S) : Set α) = ⋂ s ∈ S, ↑s
-- Mathlib/Order/BoundedOrder.lean
theorem eq_top_or_lt_top (a : α) : a = ⊤ ∨ a < ⊤
-- Mathlib/Order/Atoms.lean
/-- A lattice is coatomistic iff every element is an `sInf` of a set of coatoms. -/
class IsCoatomistic : Prop where
  /-- Every element is a `sInf` of a set of coatoms. -/
  eq_sInf_coatoms : ∀ b : α, ∃ s : Set α, b = sInf s ∧ ∀ a, a ∈ s → IsCoatom a
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
@[simp]
lemma rightHomologyMap'_add :
    rightHomologyMap' (φ + φ') h₁ h₂ = rightHomologyMap' φ h₁ h₂ +
      rightHomologyMap' φ' h₁ h₂
-- Mathlib/Topology/Algebra/MulAction.lean
theorem ContinuousSMul.induced {R : Type*} {α : Type*} {β : Type*} {F : Type*} [FunLike F α β]
    [Semiring R] [AddCommMonoid α] [AddCommMonoid β] [Module R α] [Module R β]
    [TopologicalSpace R] [LinearMapClass F R α β] [tβ : TopologicalSpace β] [ContinuousSMul R β]
    (f : F) : @ContinuousSMul R α _ _ (tβ.induced f)
-- Mathlib/Order/Iterate.lean
theorem iterate_pos_le_iff_map_le' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x n}
    (hn : 0 < n) : f^[n] x ≤ g^[n] x ↔ f x ≤ g x
-- Mathlib/Analysis/Normed/Field/UnitBall.lean
@[simp]
theorem unitSphereToUnits_apply_coe [NormedDivisionRing 𝕜] (x : sphere (0 : 𝕜) 1) :
    (unitSphereToUnits 𝕜 x : 𝕜) = x
-- Mathlib/ModelTheory/Substructures.lean
theorem map_strictMono_of_injective : StrictMono (map f)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem hasStrictDerivAt_cos (x : ℝ) : HasStrictDerivAt cos (-sin x) x
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem zpowers_eq {k : ℕ+} {ζ : Rˣ} (h : IsPrimitiveRoot ζ k) :
    Subgroup.zpowers ζ = rootsOfUnity k R
-- Mathlib/Data/Nat/Totient.lean
/-- When `p` is prime, then the totient of `p ^ (n + 1)` is `p ^ n * (p - 1)` -/
theorem totient_prime_pow_succ {p : ℕ} (hp : p.Prime) (n : ℕ) : φ (p ^ (n + 1)) = p ^ n * (p - 1)
-- Mathlib/MeasureTheory/Group/Measure.lean
@[to_additive]
theorem measurePreserving_inv (μ : Measure G) [IsInvInvariant μ] : MeasurePreserving Inv.inv μ μ
-- Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean
@[simp]
theorem tprodL_coe : (tprodL 𝕜).toMultilinearMap = tprod 𝕜 (s := E)
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive (attr := simp)]
theorem div_lt_div_iff_left (a : α) : a / b < a / c ↔ c < b
-- Mathlib/Data/DFinsupp/Basic.lean
@[to_additive (attr := simp)]
theorem prod_eq_prod_fintype [Fintype ι] [∀ i, Zero (β i)] [∀ (i : ι) (x : β i), Decidable (x ≠ 0)]
    -- Porting note: `f` was a typeclass argument
    [CommMonoid γ] (v : Π₀ i, β i) {f : ∀ i, β i → γ} (hf : ∀ i, f i 0 = 1) :
    v.prod f = ∏ i, f i (DFinsupp.equivFunOnFintype v i)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Div.lean
protected theorem div_eq_of_lt_le (lo : k * n ≤ m) (hi : m < (k + 1) * n) : m / n = k
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem map_equiv_eq_comap_symm (f : M ≃* N) (K : Submonoid M) :
    K.map f.toMonoidHom = K.comap f.symm.toMonoidHom
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- The cartesian product of `C^n` functions is `C^n`. -/
theorem ContDiff.prod {f : E → F} {g : E → G} (hf : ContDiff 𝕜 n f) (hg : ContDiff 𝕜 n g) :
    ContDiff 𝕜 n fun x : E => (f x, g x)
-- Mathlib/Topology/Order/IntermediateValue.lean
theorem intermediate_value_Ioo {a b : α} (hab : a ≤ b) {f : α → δ} (hf : ContinuousOn f (Icc a b)) :
    Ioo (f a) (f b) ⊆ f '' Ioo a b
-- Mathlib/AlgebraicGeometry/Restrict.lean
@[simp, reassoc]
lemma germ_stalkIso_inv {X : Scheme.{u}} (U : X.Opens) (V : U.toScheme.Opens) (x : U)
    (hx : x ∈ V) : X.presheaf.germ ⟨x.val, show x.val ∈ U.ι ''ᵁ V from ⟨x, hx, rfl⟩⟩ ≫
      (U.stalkIso x).inv = U.toScheme.presheaf.germ ⟨x, hx⟩
-- Mathlib/CategoryTheory/Limits/Final.lean
/-- When `F` is cofinal, and `F ⋙ G` has a colimit, then `G` has a colimit also.

We can't make this an instance, because `F` is not determined by the goal.
(Even if this weren't a problem, it would cause a loop with `comp_hasColimit`.)
-/
theorem hasColimit_of_comp [HasColimit (F ⋙ G)] : HasColimit G
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma eq_one_iff_conductor_eq_one (hn : n ≠ 0) : χ = 1 ↔ conductor χ = 1
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem _root_.Set.smul_mem_center (r : R) {a : A} (ha : a ∈ Set.center A) :
    r • a ∈ Set.center A
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive]
nonrec lemma orbitRel.Quotient.mapsTo_smul_orbit (g : G) (x : orbitRel.Quotient G α) :
    Set.MapsTo (g • ·) x.orbit x.orbit
-- Mathlib/Combinatorics/SetFamily/Compression/UV.lean
/-- Compressing a family is idempotent. -/
@[simp]
theorem compression_idem (u v : α) (s : Finset α) : 𝓒 u v (𝓒 u v s) = 𝓒 u v s
-- Mathlib/Order/Lattice.lean
@[simp]
theorem snd_inf [Inf α] [Inf β] (p q : α × β) : (p ⊓ q).snd = p.snd ⊓ q.snd
-- Mathlib/Data/Nat/Digits.lean
theorem digits_one (b n) (n0 : 0 < n) (nb : n < b) : Nat.digits b n = [n] ∧ 1 < b ∧ 0 < n
-- Mathlib/Algebra/Field/Subfield.lean
theorem field_closure_preimage_le (f : K →+* L) (s : Set L) :
    closure (f ⁻¹' s) ≤ (closure s).comap f
-- Mathlib/Topology/Instances/ENNReal.lean
theorem tsum_sub {f : ℕ → ℝ≥0∞} {g : ℕ → ℝ≥0∞} (h₁ : ∑' i, g i ≠ ∞) (h₂ : g ≤ f) :
    ∑' i, (f i - g i) = ∑' i, f i - ∑' i, g i
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem bihimp_fst [GeneralizedHeytingAlgebra α] [GeneralizedHeytingAlgebra β] (a b : α × β) :
    (a ⇔ b).1 = a.1 ⇔ b.1
-- Mathlib/Order/Synonym.lean
@[simp]
theorem toDual_le_toDual [LE α] {a b : α} : toDual a ≤ toDual b ↔ b ≤ a
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem zero_nmem_multiset_map_X_add_C {α : Type*} (m : Multiset α) (f : α → R) :
    (0 : R[X]) ∉ m.map fun a => X + C (f a)
-- Mathlib/Combinatorics/SimpleGraph/Matching.lean
lemma IsMatching.induce_connectedComponent (h : M.IsMatching) (c : ConnectedComponent G) :
    (M.induce (M.verts ∩ c.supp)).IsMatching
-- Mathlib/Algebra/Order/Module/Defs.lean
private theorem smul_ne_zero_of_pos_of_ne_zero [Preorder α] (ha : 0 < a) (hb : b ≠ 0) : a • b ≠ 0
-- Mathlib/Data/Nat/Bitwise.lean
@[simp]
theorem bit_true : bit true = (2 * · + 1)
-- Mathlib/Algebra/Group/Subgroup/MulOpposite.lean
@[to_additive (attr := simp)]
theorem mem_unop {x : G} {S : Subgroup Gᵐᵒᵖ} : x ∈ S.unop ↔ MulOpposite.op x ∈ S
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem lt_of_lt_of_le {n m k : Nat} : n < m → m ≤ k → n < k
-- Mathlib/Topology/DerivedSet.lean
theorem AccPt.map {β : Type*} [TopologicalSpace β] {F : Filter X} {x : X}
    (h : AccPt x F) {f : X → β} (hf1 : ContinuousAt f x) (hf2 : Function.Injective f) :
    AccPt (f x) (map f F)
-- Mathlib/Data/PFun.lean
@[simp]
theorem mem_dom (f : α →. β) (x : α) : x ∈ Dom f ↔ ∃ y, y ∈ f x
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
theorem lineMap_apply_module' (p₀ p₁ : V1) (c : k) : lineMap p₀ p₁ c = c • (p₁ - p₀) + p₀
-- Mathlib/GroupTheory/GroupAction/Hom.lean
protected theorem map_zero (f : A →ₑ+[φ] B) : f 0 = 0
-- Mathlib/Data/Sym/Card.lean
/-- Type **stars and bars** for the case `n = 2`. -/
protected theorem card [Fintype α] : card (Sym2 α) = Nat.choose (card α + 1) 2
-- Mathlib/Order/UpperLower/Basic.lean
@[simp] lemma Iic_ne_bot : Iic a ≠ ⊥
-- Mathlib/Topology/Homeomorph.lean
/-- If the codomain of a homeomorphism is a locally connected space, then the domain is also
a locally connected space. -/
theorem locallyConnectedSpace [i : LocallyConnectedSpace Y] (h : X ≃ₜ Y) :
    LocallyConnectedSpace X
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem add_re : (a + b).re = a.re + b.re
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
theorem image_eq_preimage (e : α ≃ᵐ β) (s : Set α) : e '' s = e.symm ⁻¹' s
-- Mathlib/Data/Fintype/Card.lean
theorem bijective_iff_injective_and_card (f : α → β) :
    Bijective f ↔ Injective f ∧ card α = card β
-- Mathlib/Data/Fin/Tuple/Basic.lean
theorem insertNth_binop (op : ∀ j, α j → α j → α j) (i : Fin (n + 1)) (x y : α i)
    (p q : ∀ j, α (i.succAbove j)) :
    (i.insertNth (op i x y) fun j ↦ op _ (p j) (q j)) = fun j ↦
      op j (i.insertNth x p j) (i.insertNth y q j)
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma Exact.isZero_X₂_iff (hS : S.Exact) : IsZero S.X₂ ↔ S.f = 0 ∧ S.g = 0
-- Mathlib/Order/InitialSeg.lean
@[simp]
theorem ofIsEmpty_top (r : α → α → Prop) [IsEmpty α] {b : β} (H : ∀ b', ¬s b' b) :
    (ofIsEmpty r H).top = b
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- **Fundamental theorem of calculus-1**: if `f : ℝ → E` is integrable on `a..b` and `f` is
continuous at `b`, then `u ↦ ∫ x in a..u, f x` has derivative `f b` at `b`. -/
theorem integral_hasDerivAt_right (hf : IntervalIntegrable f volume a b)
    (hmeas : StronglyMeasurableAtFilter f (𝓝 b)) (hb : ContinuousAt f b) :
    HasDerivAt (fun u => ∫ x in a..u, f x) (f b) b
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_compl_mul_prod [Fintype α] [DecidableEq α] (s : Finset α) (f : α → β) :
    (∏ i ∈ sᶜ, f i) * ∏ i ∈ s, f i = ∏ i, f i
-- Mathlib/Algebra/Order/Field/Power.lean
lemma zpow_neg_two_nonneg (a : α) : 0 ≤ a ^ (-2 : ℤ)
-- Mathlib/AlgebraicGeometry/Cover/Open.lean
@[simp]
lemma OpenCover.comp_app {X : Scheme.{u}} {𝓤 𝓥 𝓦 : X.OpenCover}
    (f : 𝓤 ⟶ 𝓥) (g : 𝓥 ⟶ 𝓦) (j : 𝓤.J) :
    (f ≫ g).app j = f.app j ≫ g.app _
-- Mathlib/Algebra/Quaternion.lean
@[norm_cast]
theorem coe_intCast (z : ℤ) : ↑(z : R) = (z : ℍ[R,c₁,c₂])
-- Mathlib/Algebra/Ring/BooleanRing.lean
@[simp]
theorem toBoolAlg_add (a b : α) : toBoolAlg (a + b) = toBoolAlg a ∆ toBoolAlg b
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Dvd.lean
theorem mod_eq_zero_of_dvd {m n : Nat} (H : m ∣ n) : n % m = 0
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
lemma bypass_eq_self_of_length_le {u v : V} (p : G.Walk u v) (h : p.length ≤ p.bypass.length) :
    p.bypass = p
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp]
theorem take_eq_nil_iff {l : List α} {k : Nat} : l.take k = [] ↔ l = [] ∨ k = 0
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
lemma absolutelyContinuous_sum_right {μs : ι → Measure α} (i : ι) (hνμ : ν ≪ μs i) :
    ν ≪ Measure.sum μs
-- Mathlib/LinearAlgebra/Matrix/DotProduct.lean
/-- Note that this applies to `ℂ` via `Complex.strictOrderedCommRing`. -/
@[simp]
theorem dotProduct_self_star_eq_zero {v : n → R} : dotProduct v (star v) = 0 ↔ v = 0
-- Mathlib/Data/Set/Lattice.lean
theorem subset_iInter {t : Set β} {s : ι → Set β} (h : ∀ i, t ⊆ s i) : t ⊆ ⋂ i, s i
-- Mathlib/Algebra/Order/Ring/Basic.lean
theorem pow_le_one_iff_of_nonneg (ha : 0 ≤ a) (hn : n ≠ 0) : a ^ n ≤ 1 ↔ a ≤ 1
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem two_mul_arctan {x : ℝ} (h₁ : -1 < x) (h₂ : x < 1) :
    2 * arctan x = arctan (2 * x / (1 - x ^ 2))
-- Mathlib/ModelTheory/LanguageMap.lean
theorem constantsOn_constants : (constantsOn α).Constants = α
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- A function on `[0, 1]` with the norm of the derivative within `[0, 1]`
bounded by `C` satisfies `‖f 1 - f 0‖ ≤ C`, `HasDerivWithinAt`
version. -/
theorem norm_image_sub_le_of_norm_deriv_le_segment_01' {f' : ℝ → E} {C : ℝ}
    (hf : ∀ x ∈ Icc (0 : ℝ) 1, HasDerivWithinAt f (f' x) (Icc (0 : ℝ) 1) x)
    (bound : ∀ x ∈ Ico (0 : ℝ) 1, ‖f' x‖ ≤ C) : ‖f 1 - f 0‖ ≤ C
-- Mathlib/LinearAlgebra/Dual.lean
theorem ker_dualMap_eq_dualCoannihilator_range (f : M →ₗ[R] M') :
    LinearMap.ker f.dualMap = (Dual.eval R M' ∘ₗ f).range.dualCoannihilator
-- Mathlib/Order/CompleteBooleanAlgebra.lean
theorem sSup_disjoint_iff {s : Set α} : Disjoint (sSup s) a ↔ ∀ b ∈ s, Disjoint b a
-- Mathlib/Data/Finsupp/Basic.lean
theorem mapRange.addEquiv_trans (f : M ≃+ N) (f₂ : N ≃+ P) :
    (mapRange.addEquiv (f.trans f₂) : (α →₀ M) ≃+ (α →₀ P)) =
      (mapRange.addEquiv f).trans (mapRange.addEquiv f₂)
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
theorem sub_apply (m : ι → M) : (f - g) m = f m - g m
-- Mathlib/Algebra/Group/Int.lean
lemma eq_one_or_neg_one_of_mul_eq_neg_one' (h : u * v = -1) : u = 1 ∧ v = -1 ∨ u = -1 ∧ v = 1