ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The direction of the sup of two nonempty affine subspaces is the sup of the two directions and
of any one difference between points in the two subspaces. -/
theorem direction_sup {s1 s2 : AffineSubspace k P} {p1 p2 : P} (hp1 : p1 ∈ s1) (hp2 : p2 ∈ s2) :
    (s1 ⊔ s2).direction = s1.direction ⊔ s2.direction ⊔ k ∙ p2 -ᵥ p1
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[to_additive (attr := simp)]
theorem coe_monoidHom (f : α →*o β) : ((f : α →* β) : α → β) = f
-- Mathlib/MeasureTheory/Constructions/Polish/EmbeddingReal.lean
/-- Any standard Borel space is measurably equivalent to a subset of the reals. -/
theorem exists_subset_real_measurableEquiv : ∃ s : Set ℝ, MeasurableSet s ∧ Nonempty (α ≃ᵐ s)
-- Mathlib/Topology/Algebra/Nonarchimedean/Bases.lean
/-- A family of additive subgroups on a ring `A` is a subgroups basis if it satisfies some
axioms ensuring there is a topology on `A` which is compatible with the ring structure and
admits this family as a basis of neighborhoods of zero. -/
structure RingSubgroupsBasis {A ι : Type*} [Ring A] (B : ι → AddSubgroup A) : Prop where
  /-- Condition for `B` to be a filter basis on `A`. -/
  inter : ∀ i j, ∃ k, B k ≤ B i ⊓ B j
  /-- For each set `B` in the submodule basis on `A`, there is another basis element `B'` such
   that the set-theoretic product `B' * B'` is in `B`. -/
  mul : ∀ i, ∃ j, (B j : Set A) * B j ⊆ B i
  /-- For any element `x : A` and any set `B` in the submodule basis on `A`,
    there is another basis element `B'` such that `B' * x` is in `B`. -/
  leftMul : ∀ x : A, ∀ i, ∃ j, (B j : Set A) ⊆ (x * ·) ⁻¹' B i
  /-- For any element `x : A` and any set `B` in the submodule basis on `A`,
    there is another basis element `B'` such that `x * B'` is in `B`. -/
  rightMul : ∀ x : A, ∀ i, ∃ j, (B j : Set A) ⊆ (· * x) ⁻¹' B i
-- Mathlib/Order/RelClasses.lean
lemma ne_of_not_superset [IsRefl α (· ⊆ ·)] : ¬a ⊆ b → b ≠ a
-- Mathlib/Algebra/Category/ModuleCat/Differentials/Basic.lean
@[simp]
lemma map_d (b : B) : map fac (d b) = d (g' b)
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma mem_ofUnits_iff_toUnits_mem (H : Subgroup Gˣ) (x : G) : x ∈ H.ofUnits ↔ (toUnits x) ∈ H
-- Mathlib/GroupTheory/Sylow.lean
/-- If `H` is a `p`-subgroup of `G`, then the index of `H` inside its normalizer is congruent
  mod `p` to the index of `H`.  -/
theorem card_quotient_normalizer_modEq_card_quotient [Finite G] {p : ℕ} {n : ℕ} [hp : Fact p.Prime]
    {H : Subgroup G} (hH : Nat.card H = p ^ n) :
    Nat.card (normalizer H ⧸ Subgroup.comap ((normalizer H).subtype : normalizer H →* G) H) ≡
      Nat.card (G ⧸ H) [MOD p]
-- Mathlib/Algebra/Algebra/Opposite.lean
@[simp]
theorem toLinearMap_fromOpposite (f : A →ₐ[R] B) (hf : ∀ x y, Commute (f x) (f y)) :
    (f.fromOpposite hf).toLinearMap = f.toLinearMap ∘ₗ (opLinearEquiv R (M := A)).symm
-- Mathlib/Algebra/Group/Units.lean
@[to_additive (attr := simp, norm_cast)]
theorem val_mul : (↑(a * b) : α) = a * b
-- Mathlib/Algebra/Order/Sub/Defs.lean
@[simp]
theorem tsub_zero (a : α) : a - 0 = a
-- Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
lemma fderiv_fourierChar_neg_bilinear_left_apply (v y : V) (w : W) :
    fderiv ℝ (fun v ↦ (𝐞 (-L v w) : ℂ)) v y = -2 * π * I * L y w * 𝐞 (-L v w)
-- .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Omega/MinNatAbs.lean
theorem nonzeroMinimum_pos {xs : List Nat} (m : a ∈ xs) (h : a ≠ 0) : 0 < xs.nonzeroMinimum
-- Mathlib/NumberTheory/Liouville/LiouvilleNumber.lean
/-- An upper estimate on the remainder. This estimate works with `m ∈ ℝ` satisfying `1 < m` and is
stronger than the estimate `LiouvilleNumber.remainder_lt` below. However, the latter estimate is
more useful for the proof. -/
theorem remainder_lt' (n : ℕ) {m : ℝ} (m1 : 1 < m) :
    remainder m n < (1 - 1 / m)⁻¹ * (1 / m ^ (n + 1)!)
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.sup_pure (hl : l.HasBasis p s) (x : α) :
    (l ⊔ pure x).HasBasis p fun i => s i ∪ {x}
-- Mathlib/Data/Sum/Lattice.lean
@[simp] lemma inr_inf (b₁ b₂ : β) : (inrₗ (b₁ ⊓ b₂) : α ⊕ β) = inrₗ b₁ ⊓ inrₗ b₂
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
@[reassoc (attr := simp)]
theorem app_appIso_inv (U) :
    f.app U ≫ (f.appIso (f ⁻¹ᵁ U)).inv =
      Y.presheaf.map (homOfLE (Set.image_preimage_subset f.1.base U.1)).op
-- Mathlib/Topology/ContinuousOn.lean
theorem ite_inter_closure_eq_of_inter_frontier_eq {s s' t : Set α}
    (ht : s ∩ frontier t = s' ∩ frontier t) : t.ite s s' ∩ closure t = s ∩ closure t
-- Mathlib/CategoryTheory/Monoidal/Mod_.lean
@[simp]
theorem comp_hom' {M N K : Mod_ A} (f : M ⟶ N) (g : N ⟶ K) :
    (f ≫ g).hom = f.hom ≫ g.hom
-- Mathlib/Algebra/Group/Pi/Lemmas.lean
@[to_additive]
theorem mulSingle_mono : Monotone (Pi.mulSingle i : f i → ∀ i, f i)
-- Mathlib/Logic/Function/Basic.lean
theorem invFun_surjective (hf : Injective f) : Surjective (invFun f)
-- Mathlib/Algebra/Squarefree/Basic.lean
theorem Squarefree.eq_zero_or_one_of_pow_of_not_isUnit [CommMonoid R] {x : R} {n : ℕ}
    (h : Squarefree (x ^ n)) (h' : ¬ IsUnit x) :
    n = 0 ∨ n = 1
-- Mathlib/Algebra/BigOperators/Pi.lean
@[to_additive]
theorem MonoidHom.functions_ext [Finite I] (G : Type*) [CommMonoid G] (g h : (∀ i, Z i) →* G)
    (H : ∀ i x, g (Pi.mulSingle i x) = h (Pi.mulSingle i x)) : g = h
-- Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean
@[simp]
theorem Finsupp.toFreeAbelianGroup_comp_toFinsupp :
    toFreeAbelianGroup.comp toFinsupp = AddMonoidHom.id (FreeAbelianGroup X)
-- Mathlib/MeasureTheory/Measure/Sub.lean
theorem sub_eq_zero_of_le (h : μ ≤ ν) : μ - ν = 0
-- Mathlib/Data/List/Sym.lean
protected theorem Sublist.sym2 {xs ys : List α} (h : xs <+ ys) : xs.sym2 <+ ys.sym2
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[simp]
theorem comap_bot : (⊥ : MeasurableSpace α).comap g = ⊥
-- Mathlib/FieldTheory/IntermediateField.lean
@[simp]
theorem restrictScalars_toSubfield {E : IntermediateField L' L} :
    (E.restrictScalars K).toSubfield = E.toSubfield
-- Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean
private theorem Gamma_integrand_intervalIntegrable (s : ℂ) {X : ℝ} (hs : 0 < s.re) (hX : 0 ≤ X) :
    IntervalIntegrable (fun x => (-x).exp * x ^ (s - 1) : ℝ → ℂ) volume 0 X
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem map_smul [DecidableEq ι] (i : ι) (r : R) (x : M) :
    f (update v i (r • x)) = r • f (update v i x)
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Univ.lean
@[simp]
lemma univ_coeff_eval₂Hom (M : n × n → S) (i : ℕ) :
    MvPolynomial.eval₂Hom f M ((univ R n).coeff i) =
      (charpoly (Matrix.of M.curry)).coeff i
-- Mathlib/LinearAlgebra/Prod.lean
theorem snd_map_snd : (Submodule.snd R M M₂).map (LinearMap.snd R M M₂) = ⊤
-- Mathlib/Geometry/Manifold/MFDeriv/FDeriv.lean
/-- For maps between vector spaces, `MDifferentiableWithinAt` and `DifferentiableWithinAt`
coincide -/
theorem mdifferentiableWithinAt_iff_differentiableWithinAt :
    MDifferentiableWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') f s x ↔ DifferentiableWithinAt 𝕜 f s x
-- Mathlib/Algebra/Group/Subgroup/ZPowers.lean
theorem forall_zpowers {x : G} {p : zpowers x → Prop} : (∀ g, p g) ↔ ∀ m : ℤ, p ⟨x ^ m, m, rfl⟩
-- Mathlib/Topology/Algebra/Field.lean
/-- If `f` is a function `α → 𝕜` which is continuous on a preconnected set `S`, and
`f ^ 2 = 1` on `S`, then either `f = 1` on `S`, or `f = -1` on `S`. -/
theorem IsPreconnected.eq_one_or_eq_neg_one_of_sq_eq [Ring 𝕜] [NoZeroDivisors 𝕜]
    (hS : IsPreconnected S) (hf : ContinuousOn f S) (hsq : EqOn (f ^ 2) 1 S) :
    EqOn f 1 S ∨ EqOn f (-1) S
-- Mathlib/MeasureTheory/Measure/OpenPos.lean
@[simp] lemma measure_closedBall_pos_iff {X : Type*} [MetricSpace X] {m : MeasurableSpace X}
    (μ : Measure X) [IsOpenPosMeasure μ] [NoAtoms μ] {x : X} {r : ℝ} :
    0 < μ (closedBall x r) ↔ 0 < r
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
theorem image_of_isOpenImmersion (f : X ⟶ Y) [H : IsOpenImmersion f] :
    IsAffineOpen (f ''ᵁ U)
-- Mathlib/Order/Antisymmetrization.lean
@[simp]
theorem ofAntisymmetrization_lt_ofAntisymmetrization_iff {a b : Antisymmetrization α (· ≤ ·)} :
    ofAntisymmetrization (· ≤ ·) a < ofAntisymmetrization (· ≤ ·) b ↔ a < b
-- Mathlib/CategoryTheory/Monoidal/Types/Basic.lean
@[simp] theorem associator_inv_apply_1_2 {X Y Z : Type u} {x} :
    (((α_ X Y Z).inv : X ⊗ Y ⊗ Z → (X ⊗ Y) ⊗ Z) x).1.2 = x.2.1
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
/-- A preadditive category has an equalizer for `f` and `g` if it has a kernel for `f - g`. -/
theorem hasEqualizer_of_hasKernel [HasKernel (f - g)] : HasEqualizer f g
-- Mathlib/Topology/UniformSpace/Basic.lean
@[to_additive (attr := simp)]
theorem comap_uniformity_mulOpposite [UniformSpace α] :
    comap (fun p : α × α => (MulOpposite.op p.1, MulOpposite.op p.2)) (𝓤 αᵐᵒᵖ) = 𝓤 α
-- Mathlib/Order/Interval/Set/Pi.lean
theorem image_update_uIcc_right (f : ∀ i, α i) (i : ι) (b : α i) :
    update f i '' uIcc (f i) b = uIcc f (update f i b)
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem snd_smul [SMul S R] [SMul S M] (s : S) (x : tsze R M) : (s • x).snd = s • x.snd
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
lemma prod_fiberwise_eq_prod_filter (s : Finset ι) (t : Finset κ) (g : ι → κ) (f : ι → α) :
    ∏ j ∈ t, ∏ i ∈ s.filter fun i ↦ g i = j, f i = ∏ i ∈ s.filter fun i ↦ g i ∈ t, f i
-- Mathlib/Order/Hom/Set.lean
@[simp]
theorem coe_orderIsoOfSurjective : (orderIsoOfSurjective f h_mono h_surj : α → β) = f
-- Mathlib/Algebra/Algebra/Subalgebra/Tower.lean
@[simp]
lemma range_isScalarTower_toAlgHom [CommSemiring R] [CommSemiring A]
    [Algebra R A] (S : Subalgebra R A) :
    LinearMap.range (IsScalarTower.toAlgHom R S A) = Subalgebra.toSubmodule S
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive (attr := simp)]
theorem inv_symm : (Equiv.inv G).symm = Equiv.inv G
-- Mathlib/Algebra/Group/Nat.lean
lemma succ_mod_two_eq_zero_iff {m : ℕ} : (m + 1) % 2 = 0 ↔ m % 2 = 1
-- Mathlib/Algebra/Group/Units/Hom.lean
@[to_additive (attr := simp)]
theorem coe_map_inv (f : M →* N) (u : Mˣ) : ↑(map f u)⁻¹ = f ↑u⁻¹
-- Mathlib/Algebra/Group/Units.lean
@[to_additive (attr := ext)]
theorem ext : Function.Injective (val : αˣ → α)
-- Mathlib/Control/Bitraversable/Lemmas.lean
@[higher_order tsnd_id]
theorem id_tsnd : ∀ {α β} (x : t α β), tsnd (F := Id) pure x = pure x
-- Mathlib/Algebra/Group/Indicator.lean
@[to_additive (attr := simp)]
theorem piecewise_eq_mulIndicator [DecidablePred (· ∈ s)] : s.piecewise f 1 = s.mulIndicator f
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean
@[simp]
theorem Differentiable.arctan (hc : Differentiable ℝ f) : Differentiable ℝ fun x => arctan (f x)
-- Mathlib/Order/Bounds/Basic.lean
theorem IsLeast.isLeast_image2_of_isGreatest (ha : IsLeast s a) (hb : IsGreatest t b) :
    IsLeast (Set.image2 f s t) (f a b)
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem norm_setIntegral_le_of_norm_le_const_ae {C : ℝ} (hs : μ s < ∞)
    (hC : ∀ᵐ x ∂μ.restrict s, ‖f x‖ ≤ C) : ‖∫ x in s, f x ∂μ‖ ≤ C * (μ s).toReal
-- Mathlib/CategoryTheory/Sites/Subsheaf.lean
theorem Subpresheaf.eq_sheafify (h : Presieve.IsSheaf J F) (hG : Presieve.IsSheaf J G.toPresheaf) :
    G = G.sheafify J
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Ioo_self : Ioo a a = ∅
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive (attr := simp, nolint simpNF)]
lemma finEquivZPowers_symm_apply (x : G) (hx) (n : ℕ) :
    (finEquivZPowers x hx).symm ⟨x ^ n, ⟨n, by simp⟩⟩ =
    ⟨n % orderOf x, Nat.mod_lt _ hx.orderOf_pos⟩
-- Mathlib/Order/UpperLower/Basic.lean
theorem IsLowerSet.compl (hs : IsLowerSet s) : IsUpperSet sᶜ
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
theorem epi_of_epi_right {A B : StructuredArrow S T} (f : A ⟶ B) [h : Epi f.right] : Epi f
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem MonoidHom.map_frobenius : f (frobenius R p x) = frobenius S p (f x)
-- Mathlib/Algebra/Quandle.lean
@[simp]
theorem self_invAct_invAct_eq {x y : R} : (x ◃⁻¹ x) ◃⁻¹ y = x ◃⁻¹ y
-- Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean
theorem mapMono_id : mapMono K (𝟙 Δ) = 𝟙 _
-- Mathlib/LinearAlgebra/Matrix/Symmetric.lean
/-- This is the `iff` version of `Matrix.isSymm.fromBlocks`. -/
theorem isSymm_fromBlocks_iff {A : Matrix m m α} {B : Matrix m n α} {C : Matrix n m α}
    {D : Matrix n n α} : (A.fromBlocks B C D).IsSymm ↔ A.IsSymm ∧ Bᵀ = C ∧ Cᵀ = B ∧ D.IsSymm
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem _root_.Commute.exp [T2Space 𝔸] {x y : 𝔸} (h : Commute x y) : Commute (exp 𝕂 x) (exp 𝕂 y)
-- Mathlib/Algebra/Category/Grp/Basic.lean
@[to_additive (attr := ext)]
lemma ext {X Y : Grp} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[simp]
theorem pointwise_smul_le_pointwise_smul_iff {a : α} {S T : Subgroup G} : a • S ≤ a • T ↔ S ≤ T
-- Mathlib/RingTheory/Polynomial/Opposites.lean
@[simp]
theorem opRingEquiv_symm_X : (opRingEquiv R).symm (X : Rᵐᵒᵖ[X]) = op X
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[simp]
theorem hasStrictFDerivAt_pi' :
    HasStrictFDerivAt Φ Φ' x ↔ ∀ i, HasStrictFDerivAt (fun x => Φ x i) ((proj i).comp Φ') x
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- A base angle of an isosceles triangle is acute, oriented angle-at-point form. -/
theorem abs_oangle_right_toReal_lt_pi_div_two_of_dist_eq {p₁ p₂ p₃ : P}
    (h : dist p₁ p₂ = dist p₁ p₃) : |(∡ p₁ p₂ p₃).toReal| < π / 2
-- Mathlib/Order/Bounds/Basic.lean
theorem IsLUB.nonempty [NoMinOrder α] (hs : IsLUB s a) : s.Nonempty
-- Mathlib/LinearAlgebra/Projection.lean
/-- The idempotent endomorphisms of a module with range equal to a submodule are in 1-1
correspondence with linear maps to the submodule that restrict to the identity on the submodule. -/
@[simps] def isIdempotentElemEquiv :
    { f : Module.End R E // IsIdempotentElem f ∧ range f = p } ≃
    { f : E →ₗ[R] p // ∀ x : p, f x = x }
-- Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean
@[simp]
theorem zero_caratheodory : (0 : OuterMeasure α).caratheodory = ⊤
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem decide_True  : decide True  = true
-- Mathlib/Topology/Instances/Rat.lean
theorem uniformContinuous_add : UniformContinuous fun p : ℚ × ℚ => p.1 + p.2
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean
@[reassoc (attr := simp)]
theorem inl_comp_pushoutSymmetry_inv [HasPushout f g] :
    pushout.inl _ _ ≫ (pushoutSymmetry f g).inv = pushout.inr _ _
-- Mathlib/Algebra/Associated/Basic.lean
@[simp]
theorem not_prime_one : ¬Prime (1 : α)
-- Mathlib/Algebra/Order/Monovary.lean
lemma AntivaryOn.pow_left₀ (hf : ∀ i ∈ s, 0 ≤ f i) (hfg : AntivaryOn f g s) (n : ℕ) :
    AntivaryOn (f ^ n) g s
-- Mathlib/Algebra/Divisibility/Basic.lean
@[trans]
theorem dvd_trans : a ∣ b → b ∣ c → a ∣ c
-- Mathlib/Analysis/Seminorm.lean
theorem ball_finset_sup (p : ι → Seminorm 𝕜 E) (s : Finset ι) (x : E) {r : ℝ} (hr : 0 < r) :
    ball (s.sup p) x r = s.inf fun i => ball (p i) x r
-- Mathlib/Algebra/Order/Floor.lean
theorem map_ceil (f : F) (hf : StrictMono f) (a : α) : ⌈f a⌉₊ = ⌈a⌉₊
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem iff_false (p : Prop) : (p ↔ False) = ¬p
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem map_ciInf_set (e : α ≃o β) {s : Set γ} {f : γ → α} (hf : BddBelow (f '' s))
    (hne : s.Nonempty) : e (⨅ i : s, f i) = ⨅ i : s, e (f i)
-- Mathlib/Dynamics/PeriodicPts.lean
/-- The definition of a periodic orbit, in terms of `List.map`. -/
theorem periodicOrbit_def (f : α → α) (x : α) :
    periodicOrbit f x = (List.range (minimalPeriod f x)).map fun n => f^[n] x
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformity_lift_le_comp {f : Set (α × α) → Filter β} (h : Monotone f) :
    ((𝓤 α).lift fun s => f (s ○ s)) ≤ (𝓤 α).lift f
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem any_eq_true (p : α → Bool) (as : Array α) :
    any as p ↔ ∃ i : Fin as.size, p as[i]
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem eq_single_iff_length {n : ℕ} (h : 0 < n) {c : Composition n} :
    c = single n h ↔ c.length = 1
-- Mathlib/Algebra/Category/ModuleCat/Presheaf/ChangeOfRings.lean
/-- The restriction of scalars of presheaves of modules, on objects. -/
@[simps]
noncomputable def restrictScalarsBundledCore (M' : PresheafOfModules R') (α : R ⟶ R') :
    BundledCorePresheafOfModules R
-- Mathlib/Order/WellFoundedSet.lean
theorem iff_forall_not_isBadSeq (r : α → α → Prop) (s : Set α) :
    s.PartiallyWellOrderedOn r ↔ ∀ f, ¬IsBadSeq r s f
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem castSucc_castLT (i : Fin (n + 1)) (h : (i : Nat) < n) :
    castSucc (castLT i h) = i
-- Mathlib/RingTheory/Multiplicity.lean
theorem dvd_iff_multiplicity_pos {a b : α} : (0 : PartENat) < multiplicity a b ↔ a ∣ b
-- Mathlib/LinearAlgebra/QuotientPi.lean
/-- The quotient of a direct sum is the direct sum of quotients. -/
@[simps!]
def quotientPi [Fintype ι] [DecidableEq ι] (p : ∀ i, Submodule R (Ms i)) :
    ((∀ i, Ms i) ⧸ pi Set.univ p) ≃ₗ[R] ∀ i, Ms i ⧸ p i
-- Mathlib/Topology/MetricSpace/GromovHausdorff.lean
theorem ghDist_le_nonemptyCompacts_dist (p q : NonemptyCompacts X) :
    dist p.toGHSpace q.toGHSpace ≤ dist p q
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_eq_mul_prod_diff_singleton [DecidableEq α] {s : Finset α} {i : α} (h : i ∈ s)
    (f : α → β) : ∏ x ∈ s, f x = f i * ∏ x ∈ s \ {i}, f x
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem ωSup_bind {β γ : Type v} (c : Chain α) (f : α →o Part β) (g : α →o β → Part γ) :
    ωSup (c.map (f.partBind g)) = ωSup (c.map f) >>= ωSup (c.map g)
-- Mathlib/CategoryTheory/Filtered/Basic.lean
/-- `coeq_condition f f'`, for morphisms `f f' : j ⟶ j'`, is the proof that
`f ≫ coeqHom f f' = f' ≫ coeqHom f f'`.
-/
@[reassoc]
theorem coeq_condition {j j' : C} (f f' : j ⟶ j') : f ≫ coeqHom f f' = f' ≫ coeqHom f f'
-- Mathlib/Algebra/ModEq.lean
protected theorem zsmul_add (z : ℤ) : a ≡ b [PMOD p] → z • p + a ≡ b [PMOD p]
-- Mathlib/Topology/Covering.lean
theorem mem_toTrivialization_baseSet {x : X} {I : Type*} [TopologicalSpace I]
    (h : IsEvenlyCovered f x I) : x ∈ h.toTrivialization.baseSet
-- Mathlib/Algebra/Group/UniqueProds.lean
@[to_additive]
theorem mt (h : UniqueMul A B a0 b0) :
    ∀ ⦃a b⦄, a ∈ A → b ∈ B → a ≠ a0 ∨ b ≠ b0 → a * b ≠ a0 * b0
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem lt_mul_of_lt_mul_left [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α} (h : a < b * c)
    (hle : c ≤ d) :
    a < b * d
-- Mathlib/Order/RelClasses.lean
theorem transitive_gt [Preorder α] : Transitive (@GT.gt α _)
-- Mathlib/Order/Disjoint.lean
@[simp]
theorem disjoint_self : Disjoint a a ↔ a = ⊥
-- Mathlib/RingTheory/PowerBasis.lean
/-- `PowerBasis.map pb (e : S ≃ₐ[R] S')` is the power basis for `S'` generated by `e pb.gen`. -/
@[simps dim gen basis]
noncomputable def map (pb : PowerBasis R S) (e : S ≃ₐ[R] S') : PowerBasis R S'
-- Mathlib/Algebra/Group/Pi/Lemmas.lean
@[to_additive (attr := simp)]
theorem curry_one [∀ a b, One (γ a b)] : Sigma.curry (1 : (i : Σ a, β a) → γ i.1 i.2) = 1
-- Mathlib/Algebra/MvPolynomial/Monad.lean
theorem aeval_bind₂ [Algebra S T] (f : σ → T) (g : R →+* MvPolynomial σ S) (φ : MvPolynomial σ R) :
    aeval f (bind₂ g φ) = eval₂Hom ((↑(aeval f : _ →ₐ[S] _) : _ →+* _).comp g) f φ
-- Mathlib/Probability/Cdf.lean
/-- The measure associated to the cdf of a probability measure is the same probability measure. -/
lemma measure_cdf [IsProbabilityMeasure μ] : (cdf μ).measure = μ
-- Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean
/-- Given a `k`-linear `G`-representation `A`, `diagonalHomEquiv` is a `k`-linear isomorphism of
the set of representation morphisms `Hom(k[Gⁿ⁺¹], A)` with `Fun(Gⁿ, A)`. This lemma says that this
sends a morphism of representations `f : k[Gⁿ⁺¹] ⟶ A` to the function
`(g₁, ..., gₙ) ↦ f(1, g₁, g₁g₂, ..., g₁g₂...gₙ).` -/
theorem diagonalHomEquiv_apply (f : Rep.ofMulAction k G (Fin (n + 1) → G) ⟶ A) (x : Fin n → G) :
    diagonalHomEquiv n A f x = f.hom (Finsupp.single (Fin.partialProd x) 1)
-- Mathlib/CategoryTheory/Limits/ExactFunctor.lean
@[simp]
theorem ExactFunctor.forget_obj (F : C ⥤ₑ D) : (ExactFunctor.forget C D).obj F = F.1
-- Mathlib/CategoryTheory/Generator.lean
theorem isCodetecting_iff_isCoseparating [HasCoequalizers C] [Balanced C] {𝒢 : Set C} :
    IsCodetecting 𝒢 ↔ IsCoseparating 𝒢
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem mem_toAddSubgroup {s : Subfield K} {x : K} : x ∈ s.toAddSubgroup ↔ x ∈ s
-- Mathlib/Data/List/Sym.lean
protected theorem Sublist.sym (n : ℕ) {xs ys : List α} (h : xs <+ ys) : xs.sym n <+ ys.sym n
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_predicate (f : R → R) (a : A) : p (cfcₙ f a)
-- Mathlib/Data/Set/Card.lean
theorem encard_le_encard_of_injOn (hf : MapsTo f s t) (f_inj : InjOn f s) :
    s.encard ≤ t.encard
-- Mathlib/Algebra/Module/Submodule/Localization.lean
lemma LinearMap.localized'_ker_eq_ker_localizedMap (g : M →ₗ[R] P) :
    Submodule.localized' S p f (LinearMap.ker g) =
      LinearMap.ker ((IsLocalizedModule.map p f f' g).extendScalarsOfIsLocalization p S)
-- Mathlib/Order/BooleanAlgebra.lean
theorem le_iff_eq_sup_sdiff (hz : z ≤ y) (hx : x ≤ y) : x ≤ z ↔ y = z ⊔ y \ x
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[simp]
theorem coe_ringEquiv_refl : (OrderRingIso.refl α : α ≃+* α) = RingEquiv.refl α
-- Mathlib/NumberTheory/FunctionField.lean
@[simp]
theorem inftyValuation_of_nonzero {x : RatFunc Fq} (hx : x ≠ 0) :
    inftyValuationDef Fq x = Multiplicative.ofAdd x.intDegree
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
lemma HasFDerivAt.hasLineDerivAt (hf : HasFDerivAt f L x) (v : E) :
    HasLineDerivAt 𝕜 f (L v) x v
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp] lemma edgeSet_eq_empty : G.edgeSet = ∅ ↔ G = ⊥
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem untrop_add (x y : Tropical R) : untrop (x + y) = min (untrop x) (untrop y)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem disjoint_comm : Disjoint l₁ l₂ ↔ Disjoint l₂ l₁
-- Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean
theorem f_add_nat_eq (hf_feq : ∀ {y : ℝ}, 0 < y → f (y + 1) = f y + log y) (hx : 0 < x) (n : ℕ) :
    f (x + n) = f x + ∑ m ∈ Finset.range n, log (x + m)
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive (attr := simp)]
lemma inv_pow (a : α) : ∀ n : ℕ, a⁻¹ ^ n = (a ^ n)⁻¹
-- Mathlib/Data/Set/Image.lean
theorem mem_range_of_mem_image (f : α → β) (s) {x : β} (h : x ∈ f '' s) : x ∈ range f
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem HasDerivAt.inner {f g : ℝ → E} {f' g' : E} {x : ℝ} :
    HasDerivAt f f' x → HasDerivAt g g' x →
      HasDerivAt (fun t => ⟪f t, g t⟫) (⟪f x, g'⟫ + ⟪f', g x⟫) x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem derivWithin_csinh (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
    derivWithin (fun x => Complex.sinh (f x)) s x = Complex.cosh (f x) * derivWithin f s x
-- Mathlib/Data/Nat/Choose/Basic.lean
@[simp]
theorem choose_zero_right (n : ℕ) : choose n 0 = 1
-- Mathlib/Order/Filter/Extr.lean
theorem isMaxFilter_const {b : β} : IsMaxFilter (fun _ => b) l a
-- Mathlib/Analysis/Convex/Side.lean
theorem WOppSide.map {s : AffineSubspace R P} {x y : P} (h : s.WOppSide x y) (f : P →ᵃ[R] P') :
    (s.map f).WOppSide (f x) (f y)
-- Mathlib/Topology/Irreducible.lean
theorem irreducibleSpace_def (X : Type*) [TopologicalSpace X] :
    IrreducibleSpace X ↔ IsIrreducible (⊤ : Set X)
-- Mathlib/LinearAlgebra/BilinearForm/Basic.lean
@[simp]
theorem add_apply (x y : M) : (B + D) x y = B x y + D x y
-- Mathlib/SetTheory/Game/PGame.lean
theorem rightMoves_add : ∀ x y : PGame.{u}, (x + y).RightMoves = (x.RightMoves ⊕ y.RightMoves)
-- Mathlib/NumberTheory/FLT/Four.lean
/-- We can assume that a minimal solution to `a ^ 4 + b ^ 4 = c ^ 2` has `a` odd. -/
theorem exists_odd_minimal {a b c : ℤ} (h : Fermat42 a b c) :
    ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1
-- Mathlib/Data/Finset/Pointwise.lean
theorem zero_mem_smul_finset_iff (ha : a ≠ 0) : (0 : β) ∈ a • t ↔ (0 : β) ∈ t