@[simp]
theorem fpowerSeriesBilinear_radius (f : E →L[𝕜] F →L[𝕜] G) (x : E × F) :
    (f.fpowerSeriesBilinear x).radius = ∞

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{G : Type u_4}
[NormedAddCommGroup G]
[NormedSpace 𝕜 G]
(f : E →L[𝕜] F →L[𝕜] G)
(x : E × F)


@[simp]
theorem dist_eq {α β F : Type*} [PseudoMetricSpace α] [PseudoMetricSpace β] [FunLike F α β]
    [DilationClass F α β] (f : F) (x y : α) :
    dist (f x) (f y) = ratio f * dist x y

{α : Type u_6}
{β : Type u_7}
{F : Type u_8}
[PseudoMetricSpace α]
[PseudoMetricSpace β]
[FunLike F α β]
[DilationClass F α β]
(f : F)
(x y : α)

dist (f x) (f y) = ↑(Dilation.ratio f) * dist x y


theorem wOppSide_iff_exists_wbtw {s : AffineSubspace R P} {x y : P} :
    s.WOppSide x y ↔ ∃ p ∈ s, Wbtw R x p y

{R : Type u_1}
{V : Type u_2}
{P : Type u_4}
[LinearOrderedField R]
[AddCommGroup V]
[Module R V]
[AddTorsor V P]
{s : AffineSubspace R P}
{x y : P}


@[simp]
theorem star_eq_self {c₁ c₂ : R} {a : ℍ[R,c₁,c₂]} : star a = a ↔ a = a.re

{R : Type u_3}
[CommRing R]
[NoZeroDivisors R]
[CharZero R]
{c₁ c₂ : R}
{a : ℍ[R,c₁,c₂]}


theorem continuous_coeRingHom : Continuous (coeRingHom : α → Completion α)

{α : Type u_1}
[Ring α]
[UniformSpace α]
[TopologicalRing α]
[UniformAddGroup α]


/-- A lax functor `F` between bicategories `B` and `C` consists of a function between objects
`F.obj`, a function between 1-morphisms `F.map`, and a function between 2-morphisms `F.map₂`.

Unlike functors between categories, `F.map` do not need to strictly commute with the composition,
and do not need to strictly preserve the identity. Instead, there are specified 2-morphisms
`𝟙 (F.obj a) ⟶ F.map (𝟙 a)` and `F.map f ≫ F.map g ⟶ F.map (f ≫ g)`.

`F.map₂` strictly commute with compositions and preserve the identity. They also preserve the
associator, the left unitor, and the right unitor modulo some adjustments of domains and codomains
of 2-morphisms.
-/
structure LaxFunctor (B: Type u₁) [Bicategory.{w₁, v₁} B] (C : Type u₂) [Bicategory.{w₂, v₂} C]
    extends PrelaxFunctor B C where
  /-- The 2-morphism underlying the lax unity constraint. -/
  mapId (a : B) : 𝟙 (obj a) ⟶ map (𝟙 a)
  /-- The 2-morphism underlying the lax functoriality constraint. -/
  mapComp {a b c : B} (f : a ⟶ b) (g : b ⟶ c) : map f ≫ map g ⟶ map (f ≫ g)
  /-- Naturality of the lax functoriality constraight, on the left. -/
  mapComp_naturality_left :
    ∀ {a b c : B} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c),
      mapComp f g ≫ map₂ (η ▷ g) = map₂ η ▷ map g ≫ mapComp f' g:= by aesop_cat
  /-- Naturality of the lax functoriality constraight, on the right. -/
  mapComp_naturality_right :
    ∀ {a b c : B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g'),
     mapComp f g ≫ map₂ (f ◁ η) = map f ◁ map₂ η ≫ mapComp f g' := by aesop_cat
  /-- Lax associativity -/
  map₂_associator :
    ∀ {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
      mapComp f g ▷ map h ≫ mapComp (f ≫ g) h ≫ map₂ (α_ f g h).hom =
      (α_ (map f) (map g) (map h)).hom ≫ map f ◁ mapComp g h ≫ mapComp f (g ≫ h) := by aesop_cat
  /-- Lax left unity -/
  map₂_leftUnitor :
    ∀ {a b : B} (f : a ⟶ b),
      map₂ (λ_ f).inv = (λ_ (map f)).inv ≫ mapId a ▷ map f ≫ mapComp (𝟙 a) f := by aesop_cat
  /-- Lax right unity -/
  map₂_rightUnitor :
    ∀ {a b : B} (f : a ⟶ b),
      map₂ (ρ_ f).inv = (ρ_ (map f)).inv ≫ map f ◁ mapId b ≫ mapComp f (𝟙 b) := by aesop_cat

{B : Type u₁}
[CategoryTheory.Bicategory B]
{C : Type u₂}
[CategoryTheory.Bicategory C]
(self : CategoryTheory.LaxFunctor B C)
{a b c d : B}
(f : a ⟶ b)
(g : b ⟶ c)
(h : c ⟶ d)

CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (self.mapComp f g) (self.map h))
    (CategoryTheory.CategoryStruct.comp (self.mapComp (CategoryTheory.CategoryStruct.comp f g) h)
      (self.map₂ (CategoryTheory.Bicategory.associator f g h).hom)) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator (self.map f) (self.map g) (self.map h)).hom
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (self.map f) (self.mapComp g h))
      (self.mapComp f (CategoryTheory.CategoryStruct.comp g h)))


@[simp]
theorem fract_int_add (m : ℤ) (a : α) : fract (↑m + a) = fract a

{α : Type u_2}
[LinearOrderedRing α]
[FloorRing α]
(m : ℤ)
(a : α)


theorem starConvex_singleton (x : E) : StarConvex 𝕜 x {x}

{𝕜 : Type u_1}
{E : Type u_2}
[OrderedSemiring 𝕜]
[AddCommMonoid E]
[Module 𝕜 E]
(x : E)


theorem Gamma_nat_eq_factorial (n : ℕ) : Gamma (n + 1) = n !


/-- Reinterpret a bot homomorphism as a top homomorphism between the dual lattices. -/
@[simps]
protected def dual :
    BotHom α β ≃ TopHom αᵒᵈ βᵒᵈ

{α : Type u_2}
{β : Type u_3}
[LE α]
[OrderBot α]
[LE β]
[OrderBot β]
(f : TopHom αᵒᵈ βᵒᵈ)
(a : αᵒᵈ)


@[to_additive]
theorem multiset_noncommProd_mem (S : Submonoid M) (m : Multiset M) (comm) (h : ∀ x ∈ m, x ∈ S) :
    m.noncommProd comm ∈ S

{M : Type u_1}
[Monoid M]
(S : Submonoid M)
(m : Multiset M)
(comm : {x | x ∈ m}.Pairwise Commute)
(h : ∀ x ∈ m, x ∈ S)


theorem extendScalars_le_iff (E' : IntermediateField F L) :
    extendScalars h ≤ E' ↔ E ≤ E'.toSubfield

{L : Type u_2}
[Field L]
{F E : Subfield L}
(h : F ≤ E)
(E' : IntermediateField (↥F) L)

Subfield.extendScalars h ≤ E' ↔ E ≤ E'.toSubfield


/-- Cancellation subtracting the results of two subtractions. -/
@[simp]
theorem vsub_sub_vsub_cancel_left (p₁ p₂ p₃ : P) : p₃ -ᵥ p₂ - (p₃ -ᵥ p₁) = p₁ -ᵥ p₂

{G : Type u_1}
{P : Type u_2}
[AddCommGroup G]
[AddTorsor G P]
(p₁ p₂ p₃ : P)


@[simp]
theorem GradeZero.smul_eq_mul (a b : A 0) : a • b = a * b

{ι : Type u_1}
{A : ι → Type u_2}
[AddZeroClass ι]
[GradedMonoid.GMul A]
(a b : A 0)


/-- For the equality, see `cthickening_cthickening`. -/
@[simp]
theorem cthickening_cthickening_subset (hε : 0 ≤ ε) (hδ : 0 ≤ δ) (s : Set α) :
    cthickening ε (cthickening δ s) ⊆ cthickening (ε + δ) s

{α : Type u}
[PseudoEMetricSpace α]
{δ ε : ℝ}
(hε : 0 ≤ ε)
(hδ : 0 ≤ δ)
(s : Set α)

Metric.cthickening ε (Metric.cthickening δ s) ⊆ Metric.cthickening (ε + δ) s


/-- See `lt_of_tsub_lt_tsub_left` for a stronger statement in a linear order. -/
theorem lt_of_tsub_lt_tsub_left_of_le [ContravariantClass α α (· + ·) (· < ·)] (hca : c ≤ a)
    (h : a - b < a - c) : c < b

[CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]

[ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]

[ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1]


@[simp]
theorem derivative_mul {f g : R[X]} : derivative (f * g) = derivative f * g + f * derivative g

Polynomial.derivative (f * g) = Polynomial.derivative f * g + f * Polynomial.derivative g


theorem modEq_sub_iff_add_modEq' : a ≡ b - c [PMOD p] ↔ c + a ≡ b [PMOD p]

{α : Type u_1}
[AddCommGroup α]
{p a b c : α}


@[simp]
lemma Basis.baseChange_repr_tmul (b : Basis ι R M) (x y i) :
    (b.baseChange S).repr (x ⊗ₜ y) i = b.repr y i • x

{R : Type u_1}
(S : Type u_2)
{M : Type u_3}
{ι : Type u_5}
[CommSemiring R]
[Semiring S]
[Algebra R S]
[AddCommMonoid M]
[Module R M]
(b : Basis ι R M)
(x : S)
(y : M)
(i : ι)

((Basis.baseChange S b).repr (x ⊗ₜ[R] y)) i = (b.repr y) i • x


lemma ssubset_iff_sdiff_singleton : s ⊂ t ↔ ∃ a ∈ t, s ⊆ t \ {a}


theorem iInf_insert (a : α) (s : Finset α) (t : α → β) :
    ⨅ x ∈ insert a s, t x = t a ⊓ ⨅ x ∈ s, t x

{α : Type u_2}
{β : Type u_3}
[CompleteLattice β]
[DecidableEq α]
(a : α)
(s : Finset α)
(t : α → β)


theorem argmin_cons (f : α → β) (a : α) (l : List α) :
    argmin f (a :: l) =
      Option.casesOn (argmin f l) (some a) fun c => if f c < f a then some c else some a

{α : Type u_1}
{β : Type u_2}
[LinearOrder β]
(f : α → β)
(a : α)
(l : List α)

List.argmin f (a :: l) = Option.casesOn (List.argmin f l) (some a) fun c => if f c < f a then some c else some a


theorem isBounded_pi : IsBounded (pi univ S) ↔ (∃ i, S i = ∅) ∨ ∀ i, IsBounded (S i)

{ι : Type u_3}
{π : ι → Type u_4}
[(i : ι) → Bornology (π i)]
{S : (i : ι) → Set (π i)}

Bornology.IsBounded (Set.univ.pi S) ↔ (∃ i, S i = ∅) ∨ ∀ (i : ι), Bornology.IsBounded (S i)


@[to_additive]
theorem iInter₂_smul_subset (s : ∀ i, κ i → Set α) (t : Set β) :
    (⋂ (i) (j), s i j) • t ⊆ ⋂ (i) (j), s i j • t

{α : Type u_2}
{β : Type u_3}
{ι : Sort u_5}
{κ : ι → Sort u_6}
[SMul α β]
(s : (i : ι) → κ i → Set α)
(t : Set β)

(⋂ i, ⋂ j, s i j) • t ⊆ ⋂ i, ⋂ j, s i j • t


theorem integrable_indicator_iff (hs : MeasurableSet s) :
    Integrable (indicator s f) μ ↔ IntegrableOn f s μ

{α : Type u_1}
{E : Type u_3}
[MeasurableSpace α]
[NormedAddCommGroup E]
{f : α → E}
{s : Set α}
{μ : MeasureTheory.Measure α}
(hs : MeasurableSet s)

MeasureTheory.Integrable (s.indicator f) μ ↔ MeasureTheory.IntegrableOn f s μ


/-- Rotating a vector by the angle to another vector gives the second vector if and only if the
norms are equal. -/
@[simp]
theorem rotation_oangle_eq_iff_norm_eq (x y : V) : o.rotation (o.oangle x y) x = y ↔ ‖x‖ = ‖y‖

[Fact (FiniteDimensional.finrank ℝ V = 2)]

(o.rotation (o.oangle x y)) x = y ↔ ‖x‖ = ‖y‖


@[to_additive]
theorem Filter.HasBasis.uniformity_of_nhds_one_inv_mul {ι} {p : ι → Prop} {U : ι → Set α}
    (h : (𝓝 (1 : α)).HasBasis p U) :
    (𝓤 α).HasBasis p fun i => { x : α × α | x.1⁻¹ * x.2 ∈ U i }

{α : Type u_1}
[UniformSpace α]
[Group α]
[UniformGroup α]
{ι : Sort u_3}
{p : ι → Prop}
{U : ι → Set α}
(h : (𝓝 1).HasBasis p U)

(𝓤 α).HasBasis p fun i => {x | x.1⁻¹ * x.2 ∈ U i}


theorem hasFDerivAtFilter_id (x : E) (L : Filter E) : HasFDerivAtFilter id (id 𝕜 E) x L

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
(x : E)
(L : Filter E)

HasFDerivAtFilter id (ContinuousLinearMap.id 𝕜 E) x L


theorem rel_comp_apply₂ {X Y Z : RelCat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : X) (z : Z) :
    (f ≫ g) x z ↔ ∃ y, f x y ∧ g y z

{X Y Z : CategoryTheory.RelCat}
(f : X ⟶ Y)
(g : Y ⟶ Z)
(x : X)
(z : Z)

CategoryTheory.CategoryStruct.comp f g x z ↔ ∃ y, f x y ∧ g y z


protected theorem codRestrict (h : Monotone f) {s : Set β} (hs : ∀ x, f x ∈ s) :
    Monotone (s.codRestrict f hs)

{α : Type u_1}
{β : Type u_2}
[Preorder α]
[Preorder β]
{f : α → β}
(h : Monotone f)
{s : Set β}
(hs : ∀ (x : α), f x ∈ s)


theorem isUnit_den_zero : IsUnit (den A (0 : K) : A)

{A : Type u_4}
[CommRing A]
[IsDomain A]
[UniqueFactorizationMonoid A]
{K : Type u_5}
[Field K]
[Algebra A K]
[IsFractionRing A K]


/-- Evaluation of the trivial character -/
@[simp]
theorem one_apply_coe (a : Rˣ) : (1 : MulChar R R') a = 1

{R : Type u_1}
[CommMonoid R]
{R' : Type u_2}
[CommMonoidWithZero R']
(a : Rˣ)


theorem add (hf : IsBoundedLinearMap 𝕜 f) (hg : IsBoundedLinearMap 𝕜 g) :
    IsBoundedLinearMap 𝕜 fun e => f e + g e

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{f g : E → F}
(hf : IsBoundedLinearMap 𝕜 f)
(hg : IsBoundedLinearMap 𝕜 g)


@[simp, norm_cast]
theorem cast_finsupp_sum [CommRing R] (g : α → M → ℤ) :
    (↑(f.sum g) : R) = f.sum fun a b => ↑(g a b)

{α : Type u_1}
{M : Type u_5}
{R : Type u_11}
[Zero M]
(f : α →₀ M)
[CommRing R]
(g : α → M → ℤ)


@[to_additive]
theorem quotientQuotientEquivQuotientAux_mk_mk (x : G) :
    quotientQuotientEquivQuotientAux N M h (x : G ⧸ N) = x

{G : Type u}
[Group G]
(N : Subgroup G)
[nN : N.Normal]
(M : Subgroup G)
[nM : M.Normal]
(h : N ≤ M)
(x : G)

(QuotientGroup.quotientQuotientEquivQuotientAux N M h) ↑↑x = ↑x


theorem typein_injective (r : α → α → Prop) [IsWellOrder α r] : Injective (typein r)

{α : Type u}
(r : α → α → Prop)
[IsWellOrder α r]


@[simp]
theorem top_toNonUnitalSubalgebra :
    (⊤ : NonUnitalStarSubalgebra R A).toNonUnitalSubalgebra = ⊤

{R : Type u}
{A : Type v}
[CommSemiring R]
[StarRing R]
[NonUnitalSemiring A]
[StarRing A]
[Module R A]
[IsScalarTower R A A]
[SMulCommClass R A A]
[StarModule R A]


@[simp]
theorem compRight_compLeft (B : BilinForm R M) (l r : M →ₗ[R] M) :
    (B.compRight r).compLeft l = B.comp l r

{R : Type u_1}
{M : Type u_2}
[CommSemiring R]
[AddCommMonoid M]
[Module R M]
(B : LinearMap.BilinForm R M)
(l r : M →ₗ[R] M)


@[simp]
theorem star_inv_intCast_smul [DivisionRing R] [AddCommGroup M] [Module R M] [StarAddMonoid M]
    (n : ℤ) (x : M) : star ((n⁻¹ : R) • x) = (n⁻¹ : R) • star x

{R : Type u_1}
{M : Type u_2}
[DivisionRing R]
[AddCommGroup M]
[Module R M]
[StarAddMonoid M]
(n : ℤ)
(x : M)


theorem eq {x y : PSet} : mk x = mk y ↔ Equiv x y


@[simp] lemma induceHom_id (G : SimpleGraph V) (s) :
    induceHom (Hom.id : G →g G) (Set.mapsTo_id s) = Hom.id

{V : Type u_1}
(G : SimpleGraph V)
(s : Set V)

SimpleGraph.induceHom SimpleGraph.Hom.id ⋯ = SimpleGraph.Hom.id


@[simp]
theorem mapEquiv_refl : mapEquiv (RingEquiv.refl R) = RingEquiv.refl _

{R : Type u_1}
[CommRing R]
[LocalRing R]

LocalRing.ResidueField.mapEquiv (RingEquiv.refl R) = RingEquiv.refl (LocalRing.ResidueField R)


theorem castSucc_pred_add_one_eq {a : Fin (n + 1)} (ha : a ≠ 0) :
    (a.pred ha).castSucc + 1 = a


lemma natAbs_surjective : natAbs.Surjective


theorem IntegrableOn.congr_fun_ae (h : IntegrableOn f s μ) (hst : f =ᵐ[μ.restrict s] g) :
    IntegrableOn g s μ

{α : Type u_1}
{E : Type u_3}
[MeasurableSpace α]
[NormedAddCommGroup E]
{f g : α → E}
{s : Set α}
{μ : MeasureTheory.Measure α}
(h : MeasureTheory.IntegrableOn f s μ)
(hst : f =ᵐ[μ.restrict s] g)


/-- Given `n+1` objects of `C`, a cofan for the last `n` with point `c₁.pt`
and a binary cofan on `c₁.X` and `f 0`, we can build a cofan for all `n+1`.

In `extendCofanIsColimit` we show that if the two given cofans are colimits,
then this cofan is also a colimit.
-/

@[simps!] -- Porting note: removed semireducible config
def extendCofan {n : ℕ} {f : Fin (n + 1) → C} (c₁ : Cofan fun i : Fin n => f i.succ)
    (c₂ : BinaryCofan (f 0) c₁.pt) : Cofan f

(c₁ : CategoryTheory.Limits.Cofan fun i => f i.succ)

(c₂ : CategoryTheory.Limits.BinaryCofan (f 0) c₁.pt)

(CategoryTheory.extendCofan c₁ c₂).pt = c₂.pt


@[to_additive (attr := simp)]
theorem prod_nil : ([] : List M).prod = 1


theorem exp_mul_I_periodic : Function.Periodic (fun x => exp (x * I)) (2 * π)

Function.Periodic (fun x => Complex.exp (x * Complex.I)) (2 * ↑Real.pi)


@[gcongr] lemma verts_mono {H H' : G.Subgraph} (h : H ≤ H') : H.verts ⊆ H'.verts

{V : Type u}
{G : SimpleGraph V}
{H H' : G.Subgraph}
(h : H ≤ H')


theorem of_equiv_iff {β} (e : β ≃ α) {f : σ → β} :
    haveI := Primcodable.ofEquiv α e
    (Primrec fun a => e (f a)) ↔ Primrec f

{α : Type u_1}
{σ : Type u_3}
[Primcodable α]
[Primcodable σ]
{β : Type u_4}
(e : β ≃ α)
{f : σ → β}


theorem rootMultiplicity_eq_zero {p : R[X]} {x : R} (h : ¬IsRoot p x) : rootMultiplicity x p = 0

{R : Type u}
[CommRing R]
{p : R[X]}
{x : R}
(h : ¬p.IsRoot x)


@[simp] protected theorem add_sub_cancel (n m : Nat) : n + m - m = n


@[simp]
theorem toFun_eq_coe (h : HomotopyEquiv X Y) : (h.toFun : X → Y) = h

{X : Type u}
{Y : Type v}
[TopologicalSpace X]
[TopologicalSpace Y]
(h : X ≃ₕ Y)


@[to_additive (attr := simp)]
protected lemma inv_mul_cancel_left (h : IsUnit a) : ∀ b, a⁻¹ * (a * b) = b

{α : Type u}
[DivisionMonoid α]
{a : α}
(h : IsUnit a)
(b : α)


theorem trop_max_def (x y : Tropical R) : max x y = trop (max (untrop x) (untrop y))

{R : Type u}
[LinearOrder R]
(x y : Tropical R)

max x y = Tropical.trop (max (Tropical.untrop x) (Tropical.untrop y))


theorem span_singleton_mul_right_unit {a : α} (h2 : IsUnit a) (x : α) :
    span ({x * a} : Set α) = span {x}

{α : Type u}
[CommSemiring α]
{a : α}
(h2 : IsUnit a)
(x : α)


@[simp] lemma map_id_id (r : α → β → Prop) : Relation.Map r id id = r

{α : Type u_1}
{β : Type u_2}
(r : α → β → Prop)


@[simp] theorem addNat_mk (n i : Nat) (hi : i < m) :
    addNat ⟨i, hi⟩ n = ⟨i + n, Nat.add_lt_add_right hi n⟩


theorem pow_antitone_exp {a : ℝ≥0} (m n : ℕ) (mn : m ≤ n) (a1 : a ≤ 1) : a ^ n ≤ a ^ m


@[simp] lemma op_inv_rightUnitor (X : C) : (ρ_ X).inv.op = (ρ_ (op X)).hom

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.MonoidalCategory C]
(X : C)

(CategoryTheory.MonoidalCategory.rightUnitor X).inv.op =
  (CategoryTheory.MonoidalCategory.rightUnitor (Opposite.op X)).hom


@[simp]
theorem bind_assoc (s : Computation α) (f : α → Computation β) (g : β → Computation γ) :
    bind (bind s f) g = bind s fun x : α => bind (f x) g

{α : Type u}
{β : Type v}
{γ : Type w}
(s : Computation α)
(f : α → Computation β)
(g : β → Computation γ)

(s.bind f).bind g = s.bind fun x => (f x).bind g


@[simp]
lemma _root_.absorbs_iInter {ι : Sort*} [Finite ι] {s : ι → Set α} :
    Absorbs G₀ (⋂ i, s i) t ↔ ∀ i, Absorbs G₀ (s i) t

{G₀ : Type u_1}
{α : Type u_2}
[GroupWithZero G₀]
[Bornology G₀]
[MulAction G₀ α]
{t : Set α}
{ι : Sort u_3}
[Finite ι]
{s : ι → Set α}

Absorbs G₀ (⋂ i, s i) t ↔ ∀ (i : ι), Absorbs G₀ (s i) t


/-- A ring isomorphism sends zero to zero. -/
protected theorem map_zero : f 0 = 0

{R : Type u_4}
{S : Type u_5}
[NonUnitalNonAssocSemiring R]
[NonUnitalNonAssocSemiring S]
(f : R ≃+* S)


theorem of_c_eq_zero (ha : P.a = 0) (hb : P.b = 0) (hc : P.c = 0) : P.toPoly = C P.d

{R : Type u_1}
{P : Cubic R}
[Semiring R]
(ha : P.a = 0)
(hb : P.b = 0)
(hc : P.c = 0)


@[reassoc]
lemma mapHomologicalComplexUpToQuasiIsoFactorsh_hom_app (K : HomologicalComplex C c) :
    (F.mapHomologicalComplexUpToQuasiIsoFactorsh c).hom.app
        ((HomotopyCategory.quotient _ _).obj K) =
      (F.mapHomologicalComplexUpToQuasiIso c).map
          ((HomologicalComplexUpToQuasiIso.quotientCompQhIso C c).hom.app K) ≫
        (F.mapHomologicalComplexUpToQuasiIsoFactors c).hom.app K ≫
          (HomologicalComplexUpToQuasiIso.quotientCompQhIso D c).inv.app _ ≫
            HomologicalComplexUpToQuasiIso.Qh.map
              ((F.mapHomotopyCategoryFactors c).inv.app K)

[(HomotopyCategory.quotient C c).IsLocalization (HomologicalComplex.homotopyEquivalences C c)]

(F.mapHomologicalComplexUpToQuasiIsoFactorsh c).hom.app ((HomotopyCategory.quotient C c).obj K) =
  (F.mapHomologicalComplexUpToQuasiIso c).map ((HomologicalComplexUpToQuasiIso.quotientCompQhIso C c).hom.app K) ≫
    (F.mapHomologicalComplexUpToQuasiIsoFactors c).hom.app K ≫
      (HomologicalComplexUpToQuasiIso.quotientCompQhIso D c).inv.app ((F.mapHomologicalComplex c).obj K) ≫
        HomologicalComplexUpToQuasiIso.Qh.map ((F.mapHomotopyCategoryFactors c).inv.app K)


/-- A vector equals a rotation of that vector if and only if the vector or the angle is zero. -/
theorem eq_rotation_self_iff (x : V) (θ : Real.Angle) : x = o.rotation θ x ↔ x = 0 ∨ θ = 0

[Fact (FiniteDimensional.finrank ℝ V = 2)]


theorem dvd_mul_of_dvd_left (h : a ∣ b) (c : α) : a ∣ b * c

{α : Type u_1}
[Semigroup α]
{a b : α}
(h : a ∣ b)
(c : α)


theorem Monotone.isBoundedUnder_le_comp_iff [Nonempty β] [LinearOrder β] [Preorder γ] [NoMaxOrder γ]
    {g : β → γ} {f : α → β} {l : Filter α} (hg : Monotone g) (hg' : Tendsto g atTop atTop) :
    IsBoundedUnder (· ≤ ·) l (g ∘ f) ↔ IsBoundedUnder (· ≤ ·) l f

(hg' : Filter.Tendsto g Filter.atTop Filter.atTop)

Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (g ∘ f) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l f


theorem coe_injective : @Function.Injective (VectorMeasure α M) (Set α → M) (⇑)

{α : Type u_1}
{m : MeasurableSpace α}
{M : Type u_3}
[AddCommMonoid M]
[TopologicalSpace M]


@[mono]
theorem mono {s' t'} (hs : s ⊆ s') (ht : t ⊆ t') :
    IsMetricSeparated s' t' → IsMetricSeparated s t

{X : Type u_1}
[EMetricSpace X]
{s t s' t' : Set X}
(hs : s ⊆ s')
(ht : t ⊆ t')


@[to_additive (attr := simp)]
theorem toWord_eq_nil_iff {x : FreeGroup α} : x.toWord = [] ↔ x = 1

{α : Type u}
[DecidableEq α]
{x : FreeGroup α}


theorem mono_measure (h : AEMeasurable f μ) (h' : ν ≤ μ) : AEMeasurable f ν

{α : Type u_2}
{β : Type u_3}
{m0 : MeasurableSpace α}
[MeasurableSpace β]
{f : α → β}
{μ ν : MeasureTheory.Measure α}
(h : AEMeasurable f μ)
(h' : ν ≤ μ)


@[simp] lemma den_mul_eq_num (q : ℚ) : q.den * q = q.num


theorem not_mem_range_self {n : Nat} : n ∉ range n


@[simp]
theorem center_eq_top (A : Type*) [NonUnitalCommSemiring A] [StarRing A] [Module R A]
    [IsScalarTower R A A] [SMulCommClass R A A] [StarModule R A] : center R A = ⊤

(R : Type u)
[CommSemiring R]
[StarRing R]
(A : Type u_1)
[NonUnitalCommSemiring A]
[StarRing A]
[Module R A]
[IsScalarTower R A A]
[SMulCommClass R A A]
[StarModule R A]


theorem map_map {g : β → γ} {f : α → β} (hg : Measurable g) (hf : Measurable f) :
    (μ.map f).map g = μ.map (g ∘ f)

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
{m0 : MeasurableSpace α}
[MeasurableSpace β]
[MeasurableSpace γ]
{μ : MeasureTheory.Measure α}
{g : β → γ}
{f : α → β}
(hg : Measurable g)
(hf : Measurable f)

MeasureTheory.Measure.map g (MeasureTheory.Measure.map f μ) = MeasureTheory.Measure.map (g ∘ f) μ


theorem nnnorm_entry_le_entrywise_sup_nnnorm (A : Matrix m n α) {i : m} {j : n} : ‖A i j‖₊ ≤ ‖A‖₊

{m : Type u_3}
{n : Type u_4}
{α : Type u_5}
[Fintype m]
[Fintype n]
[SeminormedAddCommGroup α]
(A : Matrix m n α)
{i : m}
{j : n}

‖A i j‖₊ ≤ ‖A‖₊


theorem adapted_process (hs : ∀ n, MeasurableSet[ℱ n] (s n)) : Adapted ℱ (process s)

{Ω : Type u_1}
{m0 : MeasurableSpace Ω}
{ℱ : MeasureTheory.Filtration ℕ m0}
{s : ℕ → Set Ω}
(hs : ∀ (n : ℕ), MeasurableSet (s n))

MeasureTheory.Adapted ℱ (MeasureTheory.BorelCantelli.process s)


@[simp]
theorem exists_mem_algebraMap_eq {x : R} {I : Ideal R} (h : S ≤ nonZeroDivisors R) :
    (∃ x', x' ∈ I ∧ algebraMap R P x' = algebraMap R P x) ↔ x ∈ I

{R : Type u_1}
[CommRing R]
{S : Submonoid R}
(P : Type u_2)
[CommRing P]
[Algebra R P]
[loc : IsLocalization S P]
{x : R}
{I : Ideal R}
(h : S ≤ R⁰)

(∃ x' ∈ I, (algebraMap R P) x' = (algebraMap R P) x) ↔ x ∈ I


theorem inter_inter_distrib_right (s t u : Set α) : s ∩ t ∩ u = s ∩ u ∩ (t ∩ u)


@[to_additive]
theorem map_div_right_eq_self (μ : Measure G) [IsMulRightInvariant μ] (g : G) :
    map (· / g) μ = μ

{G : Type u_2}
[MeasurableSpace G]
[SubNegMonoid G]
(μ : MeasureTheory.Measure G)
[μ.IsAddRightInvariant]
(g : G)

MeasureTheory.Measure.map (fun x => x - g) μ = μ


@[elab_as_elim]
theorem induction_on₂ {α' β' : Type*} [MeasurableSpace α'] [TopologicalSpace β'] {μ' : Measure α'}
    (f : α →ₘ[μ] β) (f' : α' →ₘ[μ'] β') {p : (α →ₘ[μ] β) → (α' →ₘ[μ'] β') → Prop}
    (H : ∀ f hf f' hf', p (mk f hf) (mk f' hf')) : p f f'

(H :
  ∀ (f : α → β) (hf : MeasureTheory.AEStronglyMeasurable f μ) (f' : α' → β')
    (hf' : MeasureTheory.AEStronglyMeasurable f' μ'),
    p (MeasureTheory.AEEqFun.mk f hf) (MeasureTheory.AEEqFun.mk f' hf'))


@[simp]
lemma toNNReal_neg_algebraMap (r : ℝ≥0) : (- algebraMap ℝ C(X, ℝ) r).toNNReal = 0

{X : Type u_1}
[TopologicalSpace X]
(r : NNReal)

(-(algebraMap ℝ C(X, ℝ)) ↑r).toNNReal = 0


@[simp] lemma ofNat'_one {h : 0 < n} [NeZero n] : (Fin.ofNat' 1 h : Fin n) = 1


theorem AEFinStronglyMeasurable.ae_nonneg_of_forall_setIntegral_nonneg {f : α → ℝ}
    (hf : AEFinStronglyMeasurable f μ)
    (hf_int_finite : ∀ s, MeasurableSet s → μ s < ∞ → IntegrableOn f s μ)
    (hf_zero : ∀ s, MeasurableSet s → μ s < ∞ → 0 ≤ ∫ x in s, f x ∂μ) : 0 ≤ᵐ[μ] f

(hf : MeasureTheory.AEFinStronglyMeasurable f μ)

(hf_int_finite : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → MeasureTheory.IntegrableOn f s μ)

(hf_zero : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → 0 ≤ ∫ (x : α) in s, f x ∂μ)


theorem lift_card_closure_le :
    Cardinal.lift.{u, w} #(closure L s) ≤
      max ℵ₀ (Cardinal.lift.{u, w} #s + Cardinal.lift.{w, u} #(Σi, L.Functions i))

{L : FirstOrder.Language}
{M : Type w}
[L.Structure M]
{s : Set M}

Cardinal.lift.{u, w} (Cardinal.mk ↥((FirstOrder.Language.Substructure.closure L).toFun s)) ≤
  max Cardinal.aleph0
    (Cardinal.lift.{u, w} (Cardinal.mk ↑s) + Cardinal.lift.{w, u} (Cardinal.mk ((i : ℕ) × L.Functions i)))


@[to_additive (attr := simp)] theorem mrange_inl_sup_mrange_inr :
    MonoidHom.mrange (inl : M →* M ∗ N) ⊔ MonoidHom.mrange (inr : N →* M ∗ N) = ⊤

{M : Type u_1}
{N : Type u_2}
[AddZeroClass M]
[AddZeroClass N]

AddMonoidHom.mrange AddMonoid.Coprod.inl ⊔ AddMonoidHom.mrange AddMonoid.Coprod.inr = ⊤


theorem toNat_apply_of_aleph0_le {c : Cardinal} (h : ℵ₀ ≤ c) : toNat c = 0

{c : Cardinal.{u_1}}
(h : Cardinal.aleph0 ≤ c)


@[simp]
theorem join_join (SS : Seq (Seq1 (Seq1 α))) :
    Seq.join (Seq.join SS) = Seq.join (Seq.map join SS)

(SS : Stream'.Seq (Stream'.Seq1 (Stream'.Seq1 α)))

SS.join.join = (Stream'.Seq.map Stream'.Seq1.join SS).join


lemma eq_zero_of_absolutelyContinuous_of_mutuallySingular {μ ν : Measure α}
    (h_ac : μ ≪ ν) (h_ms : μ ⟂ₘ ν) :
    μ = 0

{α : Type u_1}
{m0 : MeasurableSpace α}
{μ ν : MeasureTheory.Measure α}
(h_ac : μ ≪ ν)
(h_ms : μ ⟂ₘ ν)


/-- The Gelfand transform is spectrum-preserving. -/
theorem spectrum.gelfandTransform_eq (a : A) :
    spectrum ℂ (gelfandTransform ℂ A a) = spectrum ℂ a

{A : Type u_1}
[NormedCommRing A]
[NormedAlgebra ℂ A]
[CompleteSpace A]
(a : A)

spectrum ℂ ((WeakDual.gelfandTransform ℂ A) a) = spectrum ℂ a


/-- The type of Compact Hausdorff topological spaces satisfying an additional property `P`. -/
structure CompHausLike where
  /-- The underlying topological space of an object of `CompHausLike P`. -/
  toTop : TopCat
  /-- The underlying topological space is compact. -/
  [is_compact : CompactSpace toTop]
  /-- The underlying topological space is T2. -/
  [is_hausdorff : T2Space toTop]
  /-- The underlying topological space satisfies P. -/
  prop : P toTop

{P : TopCat → Prop}
(self : CompHausLike P)


@[to_additive (attr := ext)]
theorem MulOneClass.ext {M : Type u} : ∀ ⦃m₁ m₂ : MulOneClass M⦄, m₁.mul = m₂.mul → m₁ = m₂


@[simp]
protected theorem linearIsometry_apply_single {i : ι} (x : G i) :
    hV.linearIsometry (lp.single 2 i x) = V i x

{ι : Type u_1}
{𝕜 : Type u_2}
[RCLike 𝕜]
{E : Type u_3}
[NormedAddCommGroup E]
[InnerProductSpace 𝕜 E]
[cplt : CompleteSpace E]
{G : ι → Type u_4}
[(i : ι) → NormedAddCommGroup (G i)]
[(i : ι) → InnerProductSpace 𝕜 (G i)]
{V : (i : ι) → G i →ₗᵢ[𝕜] E}
(hV : OrthogonalFamily 𝕜 G V)
{i : ι}
(x : G i)

hV.linearIsometry (lp.single 2 i x) = (V i) x


theorem truncation_eq_of_nonneg {f : α → ℝ} {A : ℝ} (h : ∀ x, 0 ≤ f x) :
    truncation f A = indicator (Set.Ioc 0 A) id ∘ f

{α : Type u_1}
{f : α → ℝ}
{A : ℝ}
(h : ∀ (x : α), 0 ≤ f x)

ProbabilityTheory.truncation f A = (Set.Ioc 0 A).indicator id ∘ f


theorem mul_max : a * max b c = max (a * b) (a * c)


/-- `smul` by a `k : M` over a ring is injective, if `k` is not a zero divisor.
The general theory of such `k` is elaborated by `IsSMulRegular`.
The typeclass that restricts all terms of `M` to have this property is `NoZeroSMulDivisors`. -/
theorem smul_cancel_of_non_zero_divisor {M R : Type*} [Monoid M] [NonUnitalNonAssocRing R]
    [DistribMulAction M R] (k : M) (h : ∀ x : R, k • x = 0 → x = 0) {a b : R} (h' : k • a = k • b) :
    a = b

{M : Type u_1}
{R : Type u_2}
[Monoid M]
[NonUnitalNonAssocRing R]
[DistribMulAction M R]
(k : M)
(h : ∀ (x : R), k • x = 0 → x = 0)
{a b : R}
(h' : k • a = k • b)


/-- Composition on the left by a (continuous) homomorphism of topological monoids, as a
`MonoidHom`. Similar to `MonoidHom.compLeft`. -/
@[to_additive (attr := simps)
"Composition on the left by a (continuous) homomorphism of topological `AddMonoid`s, as an
`AddMonoidHom`. Similar to `AddMonoidHom.comp_left`."]
protected def _root_.MonoidHom.compLeftContinuous {γ : Type*} [Monoid β] [ContinuousMul β]
    [TopologicalSpace γ] [Monoid γ] [ContinuousMul γ] (g : β →* γ) (hg : Continuous g) :
    C(α, β) →* C(α, γ)

(α : Type u_1)
{β : Type u_2}
[TopologicalSpace α]
[TopologicalSpace β]
{γ : Type u_3}
[AddMonoid β]
[ContinuousAdd β]
[TopologicalSpace γ]
[AddMonoid γ]
[ContinuousAdd γ]
(g : β →+ γ)
(hg : Continuous ⇑g)
(f : C(α, β))

(AddMonoidHom.compLeftContinuous α g hg) f = { toFun := ⇑g, continuous_toFun := hg }.comp f


lemma measurableSet_sigmaFiniteSet (μ : Measure α) [SFinite μ] :
    MeasurableSet μ.sigmaFiniteSet

{α : Type u_1}
{mα : MeasurableSpace α}
(μ : MeasureTheory.Measure α)
[MeasureTheory.SFinite μ]


theorem coe_injective {α β} : @Injective (α ↪ β) (α → β) (fun f ↦ ↑f)


@[to_additive (attr := simp)]
theorem prod_map_div : (m.map fun i => f i / g i).prod = (m.map f).prod / (m.map g).prod

{ι : Type u_2}
{α : Type u_3}
[SubtractionCommMonoid α]
{m : Multiset ι}
{f g : ι → α}

(Multiset.map (fun i => f i - g i) m).sum = (Multiset.map f m).sum - (Multiset.map g m).sum


@[to_additive const_add]
theorem MonotoneOn.const_mul' [CovariantClass α α (· * ·) (· ≤ ·)] (hf : MonotoneOn f s) (a : α) :
    MonotoneOn (fun x => a * f x) s

[CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]


/-- Down-compressing decreases the VC-dimension. -/
lemma vcDim_compress_le (a : α) (𝒜 : Finset (Finset α)) : (𝓓 a 𝒜).vcDim ≤ 𝒜.vcDim

{α : Type u_1}
[DecidableEq α]
(a : α)
(𝒜 : Finset (Finset α))


@[simp]
theorem supported_univ : supported M R (Set.univ : Set α) = ⊤

{α : Type u_1}
{M : Type u_2}
{R : Type u_5}
[Semiring R]
[AddCommMonoid M]
[Module R M]


theorem remainingToString {it} (h : ValidFor l r it) : it.remainingToString = ⟨r⟩

{l r : List Char}
{it : String.Iterator}
(h : String.Iterator.ValidFor l r it)


/-- The power series expansion of `Complex.sin`. -/
theorem Complex.hasSum_sin (z : ℂ) :
    HasSum (fun n : ℕ => (-1) ^ n * z ^ (2 * n + 1) / ↑(2 * n + 1)!) (Complex.sin z)


@[simp, mfld_simps]
theorem singletonChartedSpace_chartAt_eq (h : e.source = Set.univ) {x : α} :
    @chartAt H _ α _ (e.singletonChartedSpace h) x = e

{H : Type u}
[TopologicalSpace H]
{α : Type u_5}
[TopologicalSpace α]
(e : PartialHomeomorph α H)
(h : e.source = Set.univ)
{x : α}


@[simp] theorem run_set [Monad m] (s s' : σ) : (set s' : StateT σ m PUnit).run s = pure (⟨⟩, s')

{m : Type u_1 → Type u_2}
{σ : Type u_1}
[Monad m]
(s s' : σ)


/-- A structure containing informations on the way a space `H` embeds in a
model vector space `E` over the field `𝕜`. This is all what is needed to
define a smooth manifold with model space `H`, and model vector space `E`.
-/
@[ext] -- Porting note(#5171): was nolint has_nonempty_instance
structure ModelWithCorners (𝕜 : Type*) [NontriviallyNormedField 𝕜] (E : Type*)
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] (H : Type*) [TopologicalSpace H] extends
    PartialEquiv H E where
  source_eq : source = univ
  unique_diff' : UniqueDiffOn 𝕜 toPartialEquiv.target
  continuous_toFun : Continuous toFun := by continuity
  continuous_invFun : Continuous invFun := by continuity

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_3}
[TopologicalSpace H]
(self : ModelWithCorners 𝕜 E H)


/-- An order isomorphism between the domains and codomains of two prosets of
order homomorphisms gives an order isomorphism between the two function prosets. -/
@[simps apply symm_apply]
def arrowCongr {α β γ δ} [Preorder α] [Preorder β] [Preorder γ] [Preorder δ]
    (f : α ≃o γ) (g : β ≃o δ) : (α →o β) ≃o (γ →o δ)

{α : Type u_6}
{β : Type u_7}
{γ : Type u_8}
{δ : Type u_9}
[Preorder α]
[Preorder β]
[Preorder γ]
[Preorder δ]
(f : α ≃o γ)
(g : β ≃o δ)
(p : α →o β)

(f.arrowCongr g) p = (↑g).comp (p.comp ↑f.symm)


@[simp]
lemma pairing_same : P.pairing i i = 2

{ι : Type u_1}
{R : Type u_2}
{M : Type u_3}
{N : Type u_4}
[CommRing R]
[AddCommGroup M]
[Module R M]
[AddCommGroup N]
[Module R N]
(P : RootPairing ι R M N)
(i : ι)


theorem iterate_bijective (h : Bijective f') : ∀ n : ℕ, Bijective (f' ^ n)

{R : Type u_1}
{M : Type u_5}
[Semiring R]
[AddCommMonoid M]
[Module R M]
{f' : M →ₗ[R] M}
(h : Function.Bijective ⇑f')
(n : ℕ)


@[to_additive (attr := simp)]
theorem self_comp_symm (e : M ≃* N) : e ∘ e.symm = id

{M : Type u_6}
{N : Type u_7}
[Add M]
[Add N]
(e : M ≃+ N)


/-- For `F : J ⥤ C`, given a cone `c : Cone F`, and a natural isomorphism `α : H ≅ H'` for functors
`H H' : C ⥤ D`, the postcomposition of the cone `H.mapCone` using the isomorphism `α` is
isomorphic to the cone `H'.mapCone`.
-/
@[simps!]
def postcomposeWhiskerLeftMapCone {H H' : C ⥤ D} (α : H ≅ H') (c : Cone F) :
    (Cones.postcompose (whiskerLeft F α.hom : _)).obj (mapCone H c) ≅ mapCone H' c

{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄}
[CategoryTheory.Category.{v₄, u₄} D]
{F : J ⥤ C}
{H H' : C ⥤ D}
(α : H ≅ H')
(c : CategoryTheory.Limits.Cone F)

(CategoryTheory.Functor.postcomposeWhiskerLeftMapCone α c).inv.hom = α.inv.app c.pt


@[simp]
lemma chainLength_neg :
    chainLength (-α) β = chainLength α β

{K : Type u_1}
{L : Type u_2}
[Field K]
[CharZero K]
[LieRing L]
[LieAlgebra K L]
[LieAlgebra.IsKilling K L]
[FiniteDimensional K L]
{H : LieSubalgebra K L}
[H.IsCartanSubalgebra]
[LieModule.IsTriangularizable K (↥H) L]
(α β : LieModule.Weight K (↥H) L)

LieAlgebra.IsKilling.chainLength (-α) β = LieAlgebra.IsKilling.chainLength α β


theorem Function.Injective.of_sigma_map {f₁ : α₁ → α₂} {f₂ : ∀ a, β₁ a → β₂ (f₁ a)}
    (h : Injective (Sigma.map f₁ f₂)) (a : α₁) : Injective (f₂ a)

{f₁ : α₁ → α₂}

(h : Function.Injective (Sigma.map f₁ f₂))


/-- The functor `G ↦ k[G]`, from the category of magmas to the category of
non-unital, non-associative algebras over `k` is adjoint to the forgetful functor in the other
direction. -/
@[simps apply_apply symm_apply]
def liftMagma [Module k A] [IsScalarTower k A A] [SMulCommClass k A A] :
    (Multiplicative G →ₙ* A) ≃ (k[G] →ₙₐ[k] A)

(k : Type u₁)
{G : Type u₂}
[Semiring k]
[Add G]
{A : Type u₃}
[NonUnitalNonAssocSemiring A]
[Module k A]
[IsScalarTower k A A]
[SMulCommClass k A A]
(F : AddMonoidAlgebra k G →ₙₐ[k] A)

(AddMonoidAlgebra.liftMagma k).symm F = F.toMulHom.comp (AddMonoidAlgebra.ofMagma k G)


EisensteinSeries.r1 z = 1 / ((z.re / z.im) ^ 2 + 1)


theorem sum_nat_eq_add_sum_succ (f : ℕ → Cardinal.{u}) :
    Cardinal.sum f = f 0 + Cardinal.sum fun i => f (i + 1)


/-- The map to the restriction of a presheafed space along the canonical inclusion from the top
subspace.
-/
@[simps]
def toRestrictTop (X : PresheafedSpace C) : X ⟶ X.restrict (Opens.openEmbedding ⊤)

(X : AlgebraicGeometry.PresheafedSpace C)

X.toRestrictTop.base = (TopologicalSpace.Opens.inclusionTopIso ↑X).inv


lemma inductionOn'_sub_one (hz : z ≤ b) :
    (z - 1).inductionOn' b H0 Hs Hp = Hp z hz (z.inductionOn' b H0 Hs Hp)

{Hs : (k : ℤ) → b ≤ k → C k → C (k + 1)}

{Hp : (k : ℤ) → k ≤ b → C k → C (k - 1)}


theorem Monic.mul_left_ne_zero (hp : Monic p) {q : R[X]} (hq : q ≠ 0) : q * p ≠ 0

{R : Type u}
[Semiring R]
{p : R[X]}
(hp : p.Monic)
{q : R[X]}
(hq : q ≠ 0)


/-- If the sign of the angle between two vectors is negative, the vectors are not equal. -/
theorem ne_of_oangle_sign_eq_neg_one {x y : V} (h : (o.oangle x y).sign = -1) : x ≠ y

[Fact (FiniteDimensional.finrank ℝ V = 2)]


theorem ae_eq_mk {f : α → β} (hfm : AEStronglyMeasurable' m f μ) : f =ᵐ[μ] hfm.mk f

(hfm : MeasureTheory.AEStronglyMeasurable' m f μ)

f =ᵐ[μ] MeasureTheory.AEStronglyMeasurable'.mk f hfm


theorem mapsTo_closedBall (hf : Isometry f) (x : α) (r : ℝ) :
    MapsTo f (Metric.closedBall x r) (Metric.closedBall (f x) r)

{α : Type u}
{β : Type v}
[PseudoMetricSpace α]
[PseudoMetricSpace β]
{f : α → β}
(hf : Isometry f)
(x : α)
(r : ℝ)

Set.MapsTo f (Metric.closedBall x r) (Metric.closedBall (f x) r)


theorem nth_mul_coeff' (n : ℕ) :
    ∃ f : TruncatedWittVector p (n + 1) k → TruncatedWittVector p (n + 1) k → k,
    ∀ x y : 𝕎 k, f (truncateFun (n + 1) x) (truncateFun (n + 1) y) =
      (x * y).coeff (n + 1) - y.coeff (n + 1) * x.coeff 0 ^ p ^ (n + 1) -
        x.coeff (n + 1) * y.coeff 0 ^ p ^ (n + 1)

(p : ℕ)
[hp : Fact (Nat.Prime p)]
(k : Type u_1)
[CommRing k]
[CharP k p]
(n : ℕ)

∃ f,
  ∀ (x y : WittVector p k),
    f (WittVector.truncateFun (n + 1) x) (WittVector.truncateFun (n + 1) y) =
      (x * y).coeff (n + 1) - y.coeff (n + 1) * x.coeff 0 ^ p ^ (n + 1) - x.coeff (n + 1) * y.coeff 0 ^ p ^ (n + 1)


@[to_additive]
theorem multipliable_const_iff [Infinite β] [T2Space G] (a : G) :
    Multipliable (fun _ : β ↦ a) ↔ a = 1

{β : Type u_2}
{G : Type u_5}
[TopologicalSpace G]
[AddCommGroup G]
[TopologicalAddGroup G]
[Infinite β]
[T2Space G]
(a : G)


@[to_additive]
lemma mul_le_prod {i j : ι} (hf : ∀ i ∈ s, 1 ≤ f i) (hi : i ∈ s) (hj : j ∈ s) (hne : i ≠ j) :
    f i * f j ≤ ∏ k ∈ s, f k

{ι : Type u_1}
{N : Type u_5}
[OrderedCommMonoid N]
{f : ι → N}
{s : Finset ι}
{i j : ι}
(hf : ∀ i ∈ s, 1 ≤ f i)
(hi : i ∈ s)
(hj : j ∈ s)
(hne : i ≠ j)


theorem StarModule.selfAdjointPart_add_skewAdjointPart (x : A) :
    (selfAdjointPart R x : A) + skewAdjointPart R x = x

(R : Type u_1)
{A : Type u_2}
[Semiring R]
[StarMul R]
[TrivialStar R]
[AddCommGroup A]
[Module R A]
[StarAddMonoid A]
[StarModule R A]
[Invertible 2]
(x : A)

↑((selfAdjointPart R) x) + ↑((skewAdjointPart R) x) = x


@[aesop unsafe apply (rule_sets := [finsetNonempty])]
theorem Nonempty.inl {s t : Finset α} (h : s.Nonempty) : (s ∪ t).Nonempty

{α : Type u_1}
[DecidableEq α]
{s t : Finset α}
(h : s.Nonempty)


theorem MeasurableSet.congr {s t : Set α} (hs : MeasurableSet s) (h : s = t) : MeasurableSet t

{α : Type u_1}
{m : MeasurableSpace α}
{s t : Set α}
(hs : MeasurableSet s)
(h : s = t)


lemma comap_add (hf : MeasurableEmbedding f) (μ ν : Measure β) :
    (μ + ν).comap f = μ.comap f + ν.comap f

{α : Type u_1}
{β : Type u_2}
{m0 : MeasurableSpace α}
{m1 : MeasurableSpace β}
{f : α → β}
(hf : MeasurableEmbedding f)
(μ ν : MeasureTheory.Measure β)

MeasureTheory.Measure.comap f (μ + ν) = MeasureTheory.Measure.comap f μ + MeasureTheory.Measure.comap f ν


/-- The functor forgetting the differential in a complex, obtaining a graded object. -/
@[simps]
def forget : HomologicalComplex V c ⥤ GradedObject ι V

∀ {X Y : HomologicalComplex V c} (f : X ⟶ Y) (i : ι), (HomologicalComplex.forget V c).map f i = f.f i


theorem prod_dvd_prod_of_dvd [CommMonoid β] {S : Multiset α} (g1 g2 : α → β)
    (h : ∀ a ∈ S, g1 a ∣ g2 a) : (Multiset.map g1 S).prod ∣ (Multiset.map g2 S).prod

{α : Type u_3}
{β : Type u_4}
[CommMonoid β]
{S : Multiset α}
(g1 g2 : α → β)
(h : ∀ a ∈ S, g1 a ∣ g2 a)


@[simp]
theorem mul_right_apply_of_ne (a b : n) (hbj : b ≠ j) (M : Matrix n n α) :
    (M * stdBasisMatrix i j c) a b = 0

{n : Type u_3}
{α : Type u_5}
[DecidableEq n]
[Semiring α]
(i j : n)
(c : α)
[Fintype n]
(a b : n)
(hbj : b ≠ j)
(M : Matrix n n α)

(M * Matrix.stdBasisMatrix i j c) a b = 0


theorem contDiffWithinAt_ext_coord_change [SmoothManifoldWithCorners I M] (x x' : M) {y : E}
    (hy : y ∈ ((extChartAt I x').symm ≫ extChartAt I x).source) :
    ContDiffWithinAt 𝕜 ⊤ (extChartAt I x ∘ (extChartAt I x').symm) (range I) y

ContDiffWithinAt 𝕜 ⊤ (↑(extChartAt I x) ∘ ↑(extChartAt I x').symm) (Set.range ↑I) y


theorem append_cons (as : List α) (b : α) (bs : List α) : as ++ b :: bs = as ++ [b] ++ bs

{α : Type u}
(as : List α)
(b : α)
(bs : List α)

as ++ b :: bs = as ++ b :: List.nil ++ bs


lemma filter_piFinset_of_not_mem (t : ∀ a, Finset (δ a)) (a : α) (x : δ a) (hx : x ∉ t a) :
    (piFinset t).filter (· a = x) = ∅

{α : Type u_1}
[DecidableEq α]
[Fintype α]
{δ : α → Type u_3}
[(a : α) → DecidableEq (δ a)]
(t : (a : α) → Finset (δ a))
(a : α)
(x : δ a)
(hx : x ∉ t a)

Finset.filter (fun x_1 => x_1 a = x) (Fintype.piFinset t) = ∅


@[to_additive (attr := simp)]
theorem div_bot : f / ⊥ = ⊥


lemma hasHomology_of_isIsoLeftRightHomologyComparison [S.HasLeftHomology]
    [S.HasRightHomology] [h : IsIso S.leftRightHomologyComparison] :
    S.HasHomology

[h : CategoryTheory.IsIso S.leftRightHomologyComparison]


@[simp] lemma toAddMonoidHom_apply (ψ : AddChar A M) (a : A) :
    ψ.toAddMonoidHom a = Additive.ofMul (ψ a)

{A : Type u_1}
{M : Type u_3}
[AddMonoid A]
[Monoid M]
(ψ : AddChar A M)
(a : A)


theorem contDiff_const_smul (c : R) : ContDiff 𝕜 n fun p : F => c • p

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{F : Type uF}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{n : ℕ∞}
{R : Type u_3}
[Semiring R]
[Module R F]
[SMulCommClass 𝕜 R F]
[ContinuousConstSMul R F]
(c : R)


lemma _root_.fderivWithin_continuousLinearEquiv_comp (L : G ≃L[𝕜] G') (f : E → (F →L[𝕜] G))
    (hs : UniqueDiffWithinAt 𝕜 s x) :
    fderivWithin 𝕜 (fun x ↦ (L : G →L[𝕜] G').comp (f x)) s x =
      (((ContinuousLinearEquiv.refl 𝕜 F).arrowCongr L)) ∘L (fderivWithin 𝕜 f s x)

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{G : Type u_4}
[NormedAddCommGroup G]
[NormedSpace 𝕜 G]
{G' : Type u_5}
[NormedAddCommGroup G']
[NormedSpace 𝕜 G']
{x : E}
{s : Set E}
(L : G ≃L[𝕜] G')
(f : E → F →L[𝕜] G)
(hs : UniqueDiffWithinAt 𝕜 s x)

fderivWithin 𝕜 (fun x => (↑L).comp (f x)) s x =
  (↑((ContinuousLinearEquiv.refl 𝕜 F).arrowCongr L)).comp (fderivWithin 𝕜 f s x)


/-- A submonoid contains the monoid's 1. -/
@[to_additive "An `AddSubmonoid` contains the monoid's 0."]
protected theorem one_mem : (1 : M) ∈ S

{M : Type u_1}
[AddZeroClass M]
(S : AddSubmonoid M)


protected theorem ContDiffOn.derivWithin (hf : ContDiffOn 𝕜 n f₂ s₂) (hs : UniqueDiffOn 𝕜 s₂)
    (hmn : m + 1 ≤ n) : ContDiffOn 𝕜 m (derivWithin f₂ s₂) s₂

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{F : Type uF}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{m n : ℕ∞}
{f₂ : 𝕜 → F}
{s₂ : Set 𝕜}
(hf : ContDiffOn 𝕜 n f₂ s₂)
(hs : UniqueDiffOn 𝕜 s₂)
(hmn : m + 1 ≤ n)


@[simp]
theorem map_bihimp (a b : α) : f (a ⇔ b) = f a ⇔ f b

{F : Type u_1}
{α : Type u_2}
{β : Type u_3}
[FunLike F α β]
[HeytingAlgebra α]
[HeytingAlgebra β]
[HeytingHomClass F α β]
(f : F)
(a b : α)


@[simp] theorem rev_rev (i : Fin n) : rev (rev i) = i


theorem IsBaseChange.algHom_ext (g₁ g₂ : N →ₗ[S] Q) (e : ∀ x, g₁ (f x) = g₂ (f x)) : g₁ = g₂

{R : Type u_1}
{M : Type v₁}
{N : Type v₂}
{S : Type v₃}
[AddCommMonoid M]
[AddCommMonoid N]
[CommSemiring R]
[CommSemiring S]
[Algebra R S]
[Module R M]
[Module R N]
[Module S N]
[IsScalarTower R S N]
{f : M →ₗ[R] N}
(h : IsBaseChange S f)
{Q : Type u_3}
[AddCommMonoid Q]
[Module S Q]
(g₁ g₂ : N →ₗ[S] Q)
(e : ∀ (x : M), g₁ (f x) = g₂ (f x))


∀ (x x_1 : ℝ),
  Real.sup x x_1 =
    match x, x_1 with
    | { cauchy := x }, { cauchy := y } => { cauchy := Quotient.map₂ (fun x x_2 => x ⊔ x_2) ⋯ x y }


theorem ofFractionRing_sub (p q : FractionRing K[X]) :
    ofFractionRing (p - q) = ofFractionRing p - ofFractionRing q

{K : Type u}
[CommRing K]
(p q : FractionRing K[X])

{ toFractionRing := p - q } = { toFractionRing := p } - { toFractionRing := q }


private theorem mul_le_of_limit_aux {α β r s} [IsWellOrder α r] [IsWellOrder β s] {c}
    (h : IsLimit (type s)) (H : ∀ b' < type s, type r * b' ≤ c) (l : c < type r * type s) :
    False

(H : ∀ b' < Ordinal.type s, Ordinal.type r * b' ≤ c)

(l : c < Ordinal.type r * Ordinal.type s)


theorem ext_lookup {s₁ s₂ : Finmap β} : (∀ x, s₁.lookup x = s₂.lookup x) → s₁ = s₂

{α : Type u}
{β : α → Type v}
[DecidableEq α]
{s₁ s₂ : Finmap β}

(∀ (x : α), Finmap.lookup x s₁ = Finmap.lookup x s₂) → s₁ = s₂


theorem induction_on_exists_not {P : ∀ {m}, L.BoundedFormula α m → Prop} (φ : L.BoundedFormula α n)
    (hqf : ∀ {m} {ψ : L.BoundedFormula α m}, IsQF ψ → P ψ)
    (hnot : ∀ {m} {φ : L.BoundedFormula α m}, P φ → P φ.not)
    (hex : ∀ {m} {φ : L.BoundedFormula α (m + 1)}, P φ → P φ.ex)
    (hse : ∀ {m} {φ₁ φ₂ : L.BoundedFormula α m},
      Theory.SemanticallyEquivalent ∅ φ₁ φ₂ → (P φ₁ ↔ P φ₂)) :
    P φ

{P : {m : ℕ} → L.BoundedFormula α m → Prop}

(hqf : ∀ {m : ℕ} {ψ : L.BoundedFormula α m}, ψ.IsQF → P ψ)

(hnot : ∀ {m : ℕ} {φ : L.BoundedFormula α m}, P φ → P φ.not)

(hex : ∀ {m : ℕ} {φ : L.BoundedFormula α (m + 1)}, P φ → P φ.ex)

(hse : ∀ {m : ℕ} {φ₁ φ₂ : L.BoundedFormula α m}, ∅.SemanticallyEquivalent φ₁ φ₂ → (P φ₁ ↔ P φ₂))


theorem sizeUpTo_succ' (i : Fin c.length) :
    c.sizeUpTo ((i : ℕ) + 1) = c.sizeUpTo i + c.blocksFun i

{n : ℕ}
(c : Composition n)
(i : Fin c.length)

c.sizeUpTo (↑i + 1) = c.sizeUpTo ↑i + c.blocksFun i


theorem stream_zero (v : K) : IntFractPair.stream v 0 = some (IntFractPair.of v)

{K : Type u_1}
[LinearOrderedField K]
[FloorRing K]
(v : K)

GenContFract.IntFractPair.stream v 0 = some (GenContFract.IntFractPair.of v)


@[to_additive]
protected theorem mul_inv (hab : Commute a b) : (a * b)⁻¹ = a⁻¹ * b⁻¹

{G : Type u_1}
[SubtractionMonoid G]
{a b : G}
(hab : AddCommute a b)


theorem coe_mono : Monotone ((↑) : ℚ≥0 → ℚ)


/-- The continuous homomorphism given by swapping components. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by swapping components."]
def swap : ContinuousMonoidHom (A × B) (B × A)

(A : Type u_2)
(B : Type u_3)
[Monoid A]
[Monoid B]
[TopologicalSpace A]
[TopologicalSpace B]
(i : A × B)

(ContinuousMonoidHom.swap A B) i =
  ((ContinuousMonoidHom.snd A B).toMonoidHom i, (ContinuousMonoidHom.fst A B).toMonoidHom i)


@[simp]
theorem sum_of (j : ι) (x : AdicCompletion I (M j)) :
    sum I M ((DirectSum.of (fun i ↦ AdicCompletion I (M i)) j) x) =
      map I (lof R ι M j) x

{R : Type u_1}
[CommRing R]
(I : Ideal R)
{ι : Type u_6}
[DecidableEq ι]
(M : ι → Type u_7)
[(i : ι) → AddCommGroup (M i)]
[(i : ι) → Module R (M i)]
(j : ι)
(x : AdicCompletion I (M j))

(AdicCompletion.sum I M) ((DirectSum.of (fun i => AdicCompletion I (M i)) j) x) =
  (AdicCompletion.map I (DirectSum.lof R ι M j)) x


theorem span_mono {s t : Set α} : s ⊆ t → span s ≤ span t


/-- Makes a `OneHom` inverse from the bijective inverse of a `OneHom` -/
@[to_additive (attr := simps)
  "Make a `ZeroHom` inverse from the bijective inverse of a `ZeroHom`"]
def OneHom.inverse [One M] [One N]
    (f : OneHom M N) (g : N → M)
    (h₁ : Function.LeftInverse g f) :
  OneHom N M

{M : Type u_6}
{N : Type u_7}
[One M]
[One N]
(f : OneHom M N)
(g : N → M)
(h₁ : Function.LeftInverse g ⇑f)


@[to_additive]
theorem mem_rightTransversals_iff_existsUnique_mul_inv_mem :
    S ∈ rightTransversals T ↔ ∀ g : G, ∃! s : S, g * (s : G)⁻¹ ∈ T

{G : Type u_1}
[AddGroup G]
{S T : Set G}

S ∈ AddSubgroup.rightTransversals T ↔ ∀ (g : G), ∃! s, g + -↑s ∈ T


@[simp]
theorem types_id_apply (X : Type u) (x : X) : (𝟙 X : X → X) x = x

CategoryTheory.CategoryStruct.id X x = x


theorem Heap.WF.of_rankGT (hlt : s.rankGT n) (h : Heap.WF le n' s) : s.WF le (n+1)

∀ {α : Type u_1} {le : α → α → Bool} {n' : Nat} {s : Batteries.BinomialHeap.Imp.Heap α} {n : Nat},
  s.rankGT n → Batteries.BinomialHeap.Imp.Heap.WF le n' s → Batteries.BinomialHeap.Imp.Heap.WF le (n + 1) s


theorem wcovBy_iff : x ⩿ y ↔ x.1 ⩿ y.1 ∧ x.2 = y.2 ∨ x.2 ⩿ y.2 ∧ x.1 = y.1

{α : Type u_1}
{β : Type u_2}
[PartialOrder α]
[PartialOrder β]
{x y : α × β}


@[simp]
theorem ContinuousLinearEquiv.uniqueDiffOn_image_iff (e : E ≃L[𝕜] F) :
    UniqueDiffOn 𝕜 (e '' s) ↔ UniqueDiffOn 𝕜 s

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{s : Set E}
(e : E ≃L[𝕜] F)

UniqueDiffOn 𝕜 (⇑e '' s) ↔ UniqueDiffOn 𝕜 s


theorem map_comp_map (f : M →ₗ[R'] N) (g : N →ₗ[R'] P) :
    map (g.comp f) = (map g).comp (map f)

{R' : Type u}
{M : Type v}
[CommSemiring R']
[AddCommMonoid M]
[Module R' M]
[Module R'ᵐᵒᵖ M]
[IsCentralScalar R' M]
{N : Type u_3}
{P : Type u_4}
[AddCommMonoid N]
[Module R' N]
[Module R'ᵐᵒᵖ N]
[IsCentralScalar R' N]
[AddCommMonoid P]
[Module R' P]
[Module R'ᵐᵒᵖ P]
[IsCentralScalar R' P]
(f : M →ₗ[R'] N)
(g : N →ₗ[R'] P)

TrivSqZeroExt.map (g ∘ₗ f) = (TrivSqZeroExt.map g).comp (TrivSqZeroExt.map f)


/-- Left multiplying by an invertible matrix does not change the rank -/
@[simp]
lemma rank_mul_eq_right_of_isUnit_det [Fintype m] [DecidableEq m]
    (A : Matrix m m R) (B : Matrix m n R) (hA : IsUnit A.det) :
    (A * B).rank = B.rank

{m : Type u_2}
{n : Type u_3}
{R : Type u_5}
[Fintype n]
[CommRing R]
[Fintype m]
[DecidableEq m]
(A : Matrix m m R)
(B : Matrix m n R)
(hA : IsUnit A.det)


theorem one_le_mul_of_one_le_of_one_le [ZeroLEOneClass α] [PosMulMono α]
    (ha : 1 ≤ a) (hb : 1 ≤ b) : (1 : α) ≤ a * b

{α : Type u}
[Semiring α]
[Preorder α]
{a b : α}
[ZeroLEOneClass α]
[PosMulMono α]
(ha : 1 ≤ a)
(hb : 1 ≤ b)


@[simp]
theorem Finset.toFinset_coe (s : Finset α) [Fintype (s : Set α)] : (s : Set α).toFinset = s

{α : Type u_1}
(s : Finset α)
[Fintype ↑↑s]


theorem sInf_mem {s : Set ℕ} (h : s.Nonempty) : sInf s ∈ s


theorem OuterMeasure.coe_mkMetric [MeasurableSpace X] [BorelSpace X] (m : ℝ≥0∞ → ℝ≥0∞) :
    ⇑(OuterMeasure.mkMetric m : OuterMeasure X) = Measure.mkMetric m

{X : Type u_2}
[EMetricSpace X]
[MeasurableSpace X]
[BorelSpace X]
(m : ℝ≥0∞ → ℝ≥0∞)

⇑(MeasureTheory.OuterMeasure.mkMetric m) = ⇑(MeasureTheory.Measure.mkMetric m)


theorem preimage_nhdsWithin_coinduced' {π : α → β} {s : Set β} {t : Set α} {a : α} (h : a ∈ t)
    (hs : s ∈ @nhds β (.coinduced (fun x : t => π x) inferInstance) (π a)) :
    π ⁻¹' s ∈ 𝓝[t] a

{α : Type u_1}
{β : Type u_2}
[TopologicalSpace α]
{π : α → β}
{s : Set β}
{t : Set α}
{a : α}
(h : a ∈ t)
(hs : s ∈ 𝓝 (π a))


protected theorem Associated.dvd' [Monoid α] {a b : α} (h : a ~ᵤ b) : b ∣ a

{α : Type u_1}
[Monoid α]
{a b : α}
(h : a ~ᵤ b)


theorem ite_eq_of_subset_left (t : Set α) {s₁ s₂ : Set α} (h : s₁ ⊆ s₂) :
    t.ite s₁ s₂ = s₁ ∪ (s₂ \ t)

{α : Type u}
(t : Set α)
{s₁ s₂ : Set α}
(h : s₁ ⊆ s₂)


@[simp, norm_cast]
theorem coe_eq_one {x : ℝ} : (x : ℝ*) = 1 ↔ x = 1


theorem eq_diag_path : (πₘ f).map p ≫ ⟦H.evalAt x₁⟧ = H.diagonalPath' p ∧
    (⟦H.evalAt x₀⟧ ≫ (πₘ g).map p : fromTop (f x₀) ⟶ fromTop (g x₁)) = H.diagonalPath' p

(p : FundamentalGroupoid.fromTop x₀ ⟶ FundamentalGroupoid.fromTop x₁)

(π.map f).map p ≫ ⟦H.evalAt x₁⟧ = H.diagonalPath' p ∧ ⟦H.evalAt x₀⟧ ≫ (π.map g).map p = H.diagonalPath' p


lemma prod_nonneg (h0 : ∀ i ∈ s, 0 ≤ f i) : 0 ≤ ∏ i ∈ s, f i

{ι : Type u_1}
{R : Type u_2}
[CommMonoidWithZero R]
[PartialOrder R]
[ZeroLEOneClass R]
[PosMulMono R]
{f : ι → R}
{s : Finset ι}
(h0 : ∀ i ∈ s, 0 ≤ f i)


@[simp]
theorem DirectSum.IsInternal.isometryL2OfOrthogonalFamily_symm_apply [DecidableEq ι]
    {V : ι → Submodule 𝕜 E} (hV : DirectSum.IsInternal V)
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) (w : PiLp 2 fun i => V i) :
    (hV.isometryL2OfOrthogonalFamily hV').symm w = ∑ i, (w i : E)

(hV' : OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ)

(hV.isometryL2OfOrthogonalFamily hV').symm w = ∑ i : ι, ↑(w i)


/-- The seminorm controls the Schwartz estimate for any fixed `x`. -/
theorem le_seminorm (k n : ℕ) (f : 𝓢(E, F)) (x : E) :
    ‖x‖ ^ k * ‖iteratedFDeriv ℝ n f x‖ ≤ SchwartzMap.seminorm 𝕜 k n f

(𝕜 : Type u_1)
{E : Type u_4}
{F : Type u_5}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
[NormedAddCommGroup F]
[NormedSpace ℝ F]
[NormedField 𝕜]
[NormedSpace 𝕜 F]
[SMulCommClass ℝ 𝕜 F]
(k n : ℕ)
(f : SchwartzMap E F)
(x : E)

‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f) x‖ ≤ (SchwartzMap.seminorm 𝕜 k n) f


@[simp, nolint simpNF]
theorem evenToNeg_ι (Q' : QuadraticForm R M) (h : Q' = -Q) (m₁ m₂ : M) :
    evenToNeg Q Q' h ((even.ι Q).bilin m₁ m₂) = -(even.ι Q').bilin m₁ m₂

{R : Type u_1}
{M : Type u_2}
[CommRing R]
[AddCommGroup M]
[Module R M]
(Q Q' : QuadraticForm R M)
(h : Q' = -Q)
(m₁ m₂ : M)

(CliffordAlgebra.evenToNeg Q Q' h) (((CliffordAlgebra.even.ι Q).bilin m₁) m₂) =
  -((CliffordAlgebra.even.ι Q').bilin m₁) m₂


@[simp]
theorem setOf_false : { _a : α | False } = ∅


theorem iInf_range : ∀ {g : β → α} {f : ι → β}, ⨅ b ∈ range f, g b = ⨅ i, g (f i)

{α : Type u_1}
{β : Type u_2}
{ι : Sort u_5}
[CompleteLattice α]
{g : β → α}
{f : ι → β}


theorem closure_iUnion {ι} (s : ι → Set R) : closure (⋃ i, s i) = ⨆ i, closure (s i)

{R : Type u}
[NonAssocSemiring R]
{ι : Sort u_1}
(s : ι → Set R)

Subsemiring.closure (⋃ i, s i) = ⨆ i, Subsemiring.closure (s i)


@[to_additive]
theorem csInf_inv (hs₀ : s.Nonempty) (hs₁ : BddAbove s) : sInf s⁻¹ = (sSup s)⁻¹

[CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]

[CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]


/-- A continuous monotone function between (conditionally) complete linear ordered spaces sends a
`Filter.liminf` to the `Filter.liminf` of the images (if the filter is bounded from below and
frequently bounded from above). -/
theorem Monotone.map_liminf_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
    (f_cont : ContinuousAt f (F.liminf a))
    (cobdd : F.IsCoboundedUnder (· ≥ ·) a := by isBoundedDefault)
    (bdd_below : F.IsBoundedUnder (· ≥ ·) a := by isBoundedDefault) :
    f (F.liminf a) = F.liminf (f ∘ a)

(f_cont : ContinuousAt f (Filter.liminf a F))

(cobdd : Filter.IsCoboundedUnder (fun x x_1 => x ≥ x_1) F a := by isBoundedDefault)

(bdd_below : Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) F a := by isBoundedDefault)

f (Filter.liminf a F) = Filter.liminf (f ∘ a) F


theorem some_injective (α : Type*) : Function.Injective (@some α)


@[simp] theorem ge_iff_le [LE α] {x y : α} : x ≥ y ↔ y ≤ x


@[simp] theorem iff_or_self (a b : Prop) : (b ↔ a ∨ b) ↔ (a → b)


theorem upcrossingsBefore_zero : upcrossingsBefore a b f 0 ω = 0

{Ω : Type u_1}
{a b : ℝ}
{f : ℕ → Ω → ℝ}
{ω : Ω}

MeasureTheory.upcrossingsBefore a b f 0 ω = 0


theorem support_toPath_subset {u v : V} (p : G.Walk u v) :
    (p.toPath : G.Walk u v).support ⊆ p.support

{V : Type u}
{G : SimpleGraph V}
[DecidableEq V]
{u v : V}
(p : G.Walk u v)


@[reassoc]
lemma stalkMap_congr_point {X Y : LocallyRingedSpace.{u}} (f : X ⟶ Y) (x x' : X) (hxx' : x = x') :
    f.stalkMap x ≫ X.presheaf.stalkSpecializes (specializes_of_eq hxx'.symm) =
      Y.presheaf.stalkSpecializes (specializes_of_eq <| hxx' ▸ rfl) ≫ f.stalkMap x'

{X Y : AlgebraicGeometry.LocallyRingedSpace}

AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x ≫ X.presheaf.stalkSpecializes ⋯ =
  Y.presheaf.stalkSpecializes ⋯ ≫ AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x'


theorem integral_mul_upcrossingsBefore_le_integral [IsFiniteMeasure μ] (hf : Submartingale f ℱ μ)
    (hfN : ∀ ω, a ≤ f N ω) (hfzero : 0 ≤ f 0) (hab : a < b) :
    (b - a) * μ[upcrossingsBefore a b f N] ≤ μ[f N]

{f : ℕ → Ω → ℝ}

(hf : MeasureTheory.Submartingale f ℱ μ)

(b - a) * ∫ (x : Ω), ↑(MeasureTheory.upcrossingsBefore a b f N x) ∂μ ≤ ∫ (x : Ω), f N x ∂μ


@[to_additive]
theorem smul_set_subset_smul {s : Set α} : a ∈ s → a • t ⊆ s • t

{α : Type u_2}
{β : Type u_3}
[SMul α β]
{t : Set β}
{a : α}
{s : Set α}


theorem toPadicInt_comp_fromPadicInt : (toPadicInt p).comp (fromPadicInt p) = RingHom.id ℤ_[p]

(WittVector.toPadicInt p).comp (WittVector.fromPadicInt p) = RingHom.id ℤ_[p]


theorem add_apply [AddZeroClass β] [ContinuousAdd β] (f g : C_c(α, β)) : (f + g) x = f x + g x

{α : Type u_2}
{β : Type u_3}
[TopologicalSpace α]
[TopologicalSpace β]
(x : α)
[AddZeroClass β]
[ContinuousAdd β]
(f g : α →C_c β)


@[to_additive]
lemma map_injective {f : M →* N} (hf : Function.Injective f) :
    Function.Injective (map f)

{M : Type u}
{N : Type v}
[Monoid M]
[Monoid N]
{f : M →* N}
(hf : Function.Injective ⇑f)


@[simp] theorem neg_gcd {a b : Int} : gcd (-a) b = gcd a b


@[simp] lemma one_mem_slitPlane : 1 ∈ slitPlane


theorem image_compl_eq {f : α → β} {s : Set α} (H : Bijective f) : f '' sᶜ = (f '' s)ᶜ

{α : Type u_1}
{β : Type u_2}
{f : α → β}
{s : Set α}
(H : Function.Bijective f)


/-- When the first map `S.f` is zero, this is the homology data on `S` given
by the chosen `kernel S.g` -/
@[simps]
noncomputable def ofHasKernel (hf : S.f = 0) [HasKernel S.g] :
    S.HomologyData

(CategoryTheory.ShortComplex.HomologyData.ofHasKernel S hf).right =
  CategoryTheory.ShortComplex.RightHomologyData.ofHasKernel S hf


theorem fg_finset_sup {ι : Type*} (s : Finset ι) (N : ι → Submodule R M) (h : ∀ i ∈ s, (N i).FG) :
    (s.sup N).FG

{R : Type u_1}
{M : Type u_2}
[Semiring R]
[AddCommMonoid M]
[Module R M]
{ι : Type u_3}
(s : Finset ι)
(N : ι → Submodule R M)
(h : ∀ i ∈ s, (N i).FG)


/-- Given two families of generators `S[X] → T` and `R[Y] → S`,
we may constuct the family of generators `R[X, Y] → T`. -/
@[simps val, simps (config := .lemmasOnly) vars σ]
noncomputable
def comp (Q : Generators S T) (P : Generators R S) : Generators R T

{R : Type u}
{S : Type v}
[CommRing R]
[CommRing S]
[Algebra R S]
{T : Type u_1}
[CommRing T]
[Algebra R T]
[Algebra S T]
[IsScalarTower R S T]
(Q : Algebra.Generators S T)
(P : Algebra.Generators R S)

∀ (a : Q.vars ⊕ P.vars), (Q.comp P).val a = Sum.elim Q.val (⇑(algebraMap S T) ∘ P.val) a


@[simp]
theorem iicsInfHom_apply (a : α) : iicsInfHom a = Iic a

{α : Type u_1}
[CompleteLattice α]
(a : α)


@[simp]
theorem volume_Ioo {a b : ℝ} : volume (Ioo a b) = ofReal (b - a)

MeasureTheory.volume (Set.Ioo a b) = ENNReal.ofReal (b - a)


@[simp]
theorem toPGame_equiv_iff {a b : Ordinal} : (a.toPGame ≈ b.toPGame) ↔ a = b


theorem continuousOn_symm {s} : ContinuousOn I.symm s

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_3}
[TopologicalSpace H]
(I : ModelWithCorners 𝕜 E H)
{s : Set E}


/-- The counit isomorphism induced by `N₁Γ₀` -/
@[simps!]
def η : Γ ⋙ N ≅ 𝟭 (ChainComplex C ℕ)

(CategoryTheory.Idempotents.DoldKan.η.hom.app X).f i =
  ((CategoryTheory.Idempotents.toKaroubiEquivalence (ChainComplex C ℕ)).inverse.map
          (AlgebraicTopology.DoldKan.N₁Γ₀.hom.app X)).f
      i ≫
    ((CategoryTheory.Idempotents.toKaroubiEquivalence (ChainComplex C ℕ)).unitIso.inv.app X).f i


@[simp]
theorem constantCoeff_exp : constantCoeff A (exp A) = 1

(PowerSeries.constantCoeff A) (PowerSeries.exp A) = 1


theorem Ioc_mem_nhdsSet_Icc (h : a < b) (h' : c < d) : Ioc a d ∈ 𝓝ˢ (Icc b c)

{α : Type u_1}
[LinearOrder α]
[TopologicalSpace α]
[OrderClosedTopology α]
{a b c d : α}
(h : a < b)
(h' : c < d)


theorem ClusterPt.of_nhds_le {f : Filter X} (H : 𝓝 x ≤ f) : ClusterPt x f

{X : Type u}
{x : X}
[TopologicalSpace X]
{f : Filter X}
(H : 𝓝 x ≤ f)


theorem mem_iff_generator_dvd (S : Ideal R) [S.IsPrincipal] {x : R} : x ∈ S ↔ generator S ∣ x

{R : Type u}
[CommRing R]
(S : Ideal R)
[Submodule.IsPrincipal S]
{x : R}

x ∈ S ↔ Submodule.IsPrincipal.generator S ∣ x


theorem isJacobson_of_surjective [H : IsJacobson R] :
    (∃ f : R →+* S, Function.Surjective ↑f) → IsJacobson S

{R : Type u_1}
{S : Type u_2}
[CommRing R]
[CommRing S]
[H : Ideal.IsJacobson R]

(∃ f, Function.Surjective ⇑f) → Ideal.IsJacobson S


@[to_additive sum_le_sum_of_subset]
theorem prod_le_prod_of_subset' (h : s ⊆ t) : ∏ x ∈ s, f x ≤ ∏ x ∈ t, f x

{ι : Type u_1}
{M : Type u_4}
[CanonicallyOrderedCommMonoid M]
{f : ι → M}
{s t : Finset ι}
(h : s ⊆ t)


theorem eventuallyConst_preimage {s : Set β} {f : α → β} :
    EventuallyConst (f ⁻¹' s) l ↔ EventuallyConst s (map f l)

{α : Type u_1}
{β : Type u_2}
{l : Filter α}
{s : Set β}
{f : α → β}

Filter.EventuallyConst (f ⁻¹' s) l ↔ Filter.EventuallyConst s (Filter.map f l)


@[simp]
theorem whiskerLeft_id' (F : C ⥤ D) {G : D ⥤ E} : whiskerLeft F (𝟙 G) = 𝟙 (F.comp G)

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
{D : Type u₂}
[CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃}
[CategoryTheory.Category.{v₃, u₃} E]
(F : CategoryTheory.Functor C D)
{G : CategoryTheory.Functor D E}

CategoryTheory.whiskerLeft F (CategoryTheory.CategoryStruct.id G) = CategoryTheory.CategoryStruct.id (F.comp G)


theorem IsLittleO.add_isBigO (h₁ : f₁ =o[l] g) (h₂ : f₂ =O[l] g) : (fun x => f₁ x + f₂ x) =O[l] g

{α : Type u_1}
{F : Type u_4}
{E' : Type u_6}
[Norm F]
[SeminormedAddCommGroup E']
{g : α → F}
{l : Filter α}
{f₁ f₂ : α → E'}
(h₁ : f₁ =o[l] g)
(h₂ : f₂ =O[l] g)


theorem infEdist_le_edist_add_infEdist : infEdist x s ≤ edist x y + infEdist y s

{α : Type u}
[PseudoEMetricSpace α]
{x y : α}
{s : Set α}

EMetric.infEdist x s ≤ edist x y + EMetric.infEdist y s


@[simp]
theorem ofRelIsoLT_apply {α β} [PartialOrder α] [PartialOrder β]
    (e : ((· < ·) : α → α → Prop) ≃r ((· < ·) : β → β → Prop)) (x : α) : ofRelIsoLT e x = e x


@[to_additive sum_lt_sum_of_nonempty]
theorem prod_lt_prod_of_nonempty' (hs : s.Nonempty) (hlt : ∀ i ∈ s, f i < g i) :
    ∏ i ∈ s, f i < ∏ i ∈ s, g i

{ι : Type u_1}
{M : Type u_4}
[OrderedCancelCommMonoid M]
{f g : ι → M}
{s : Finset ι}
(hs : s.Nonempty)
(hlt : ∀ i ∈ s, f i < g i)


@[to_additive (attr := simp)]
theorem MulHom.toMulEquiv_symm_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
    (h₁ : g.comp f = MulHom.id _) (h₂ : f.comp g = MulHom.id _) :
    (MulEquiv.symm (MulHom.toMulEquiv f g h₁ h₂) : N → M) = ↑g

{M : Type u_6}
{N : Type u_7}
[Mul M]
[Mul N]
(f : M →ₙ* N)
(g : N →ₙ* M)
(h₁ : g.comp f = MulHom.id M)
(h₂ : f.comp g = MulHom.id N)


/-- A subgroup `S` of a topological group `G` acts on `G` properly discontinuously on the left, if
it is discrete in the sense that `S ∩ K` is finite for all compact `K`. (See also
`DiscreteTopology`.) -/
@[to_additive
  "A subgroup `S` of an additive topological group `G` acts on `G` properly
  discontinuously on the left, if it is discrete in the sense that `S ∩ K` is finite for all compact
  `K`. (See also `DiscreteTopology`."]
theorem Subgroup.properlyDiscontinuousSMul_of_tendsto_cofinite (S : Subgroup G)
    (hS : Tendsto S.subtype cofinite (cocompact G)) : ProperlyDiscontinuousSMul S G

(hS : Filter.Tendsto (⇑S.subtype) Filter.cofinite (Filter.cocompact G))


@[simp] lemma union_eq_left : s ∪ t = s ↔ t ⊆ s

{α : Type u_1}
[DecidableEq α]
{s t : Finset α}


@[to_additive (attr := simp)]
theorem ball_mul : ball x δ * s = x • thickening δ s

{E : Type u_1}
[SeminormedAddCommGroup E]
(δ : ℝ)
(s : Set E)
(x : E)

Metric.ball x δ + s = x +ᵥ Metric.thickening δ s


@[to_additive (attr := simp)]
theorem inl_apply (x) : inl M N x = (x, 1)

{M : Type u_5}
{N : Type u_6}
[AddZeroClass M]
[AddZeroClass N]
(x : M)


theorem isCaratheodory_iff_le' {s : Set α} :
    IsCaratheodory m s ↔ ∀ t, m (t ∩ s) + m (t \ s) ≤ m t

{α : Type u}
(m : MeasureTheory.OuterMeasure α)
{s : Set α}

m.IsCaratheodory s ↔ ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t


@[simp] protected theorem neg_zero : -(0:Int) = 0


theorem endTensorEndAlgHom_apply (f : End A M) (g : End R N) :
    endTensorEndAlgHom (R := R) (S := S) (A := A) (M := M) (N := N) (f ⊗ₜ[R] g)
      = AlgebraTensorModule.map f g

{R : Type u_1}
{S : Type u_2}
{A : Type u_3}
{M : Type u_4}
{N : Type u_5}
[CommSemiring R]
[CommSemiring S]
[Semiring A]
[AddCommMonoid M]
[AddCommMonoid N]
[Algebra R S]
[Algebra S A]
[Algebra R A]
[Module R M]
[Module S M]
[Module A M]
[Module R N]
[IsScalarTower R A M]
[IsScalarTower S A M]
[IsScalarTower R S M]
(f : Module.End A M)
(g : Module.End R N)

Module.endTensorEndAlgHom (f ⊗ₜ[R] g) = TensorProduct.AlgebraTensorModule.map f g


lemma restrictSubtype_base_iff {B : Set X} : (M.restrictSubtype X).Base B ↔ M.Basis' B X

{α : Type u_1}
{X : Set α}
{M : Matroid α}
{B : Set ↑X}

(M.restrictSubtype X).Base B ↔ M.Basis' (↑B) X


/-- Linear map between the function spaces `I → M₂` and `I → M₃`, induced by a linear map `f`
between `M₂` and `M₃`. -/
@[simps]
protected def compLeft (f : M₂ →ₗ[R] M₃) (I : Type*) : (I → M₂) →ₗ[R] I → M₃

{R : Type u}
{M₂ : Type w}
{M₃ : Type y}
[Semiring R]
[AddCommMonoid M₂]
[Module R M₂]
[AddCommMonoid M₃]
[Module R M₃]
(f : M₂ →ₗ[R] M₃)
(I : Type u_1)
(h : I → M₂)

∀ (a : I), (f.compLeft I) h a = (⇑f ∘ h) a


@[simp]
theorem Iic_pure (a : α) : Iic (pure a : Filter α) = {⊥, pure a}


theorem isPathConnected_range [PathConnectedSpace X] {f : X → Y} (hf : Continuous f) :
    IsPathConnected (range f)

{X : Type u_1}
{Y : Type u_2}
[TopologicalSpace X]
[TopologicalSpace Y]
[PathConnectedSpace X]
{f : X → Y}
(hf : Continuous f)


@[simp]
theorem lift_of (x : α) : lift f (of x) = f x

{α : Type u}
{R : Type v}
[Ring R]
(f : α → R)
(x : α)


theorem exp_blockDiagonal (v : m → Matrix n n 𝔸) :
    exp 𝕂 (blockDiagonal v) = blockDiagonal (exp 𝕂 v)

(𝕂 : Type u_1)
{m : Type u_2}
{n : Type u_3}
{𝔸 : Type u_6}
[Fintype m]
[DecidableEq m]
[Fintype n]
[DecidableEq n]
[Field 𝕂]
[Ring 𝔸]
[TopologicalSpace 𝔸]
[TopologicalRing 𝔸]
[Algebra 𝕂 𝔸]
[T2Space 𝔸]
(v : m → Matrix n n 𝔸)

NormedSpace.exp 𝕂 (Matrix.blockDiagonal v) = Matrix.blockDiagonal (NormedSpace.exp 𝕂 v)


@[to_additive]
theorem prod_apply_ite {s : Finset α} {p : α → Prop} {_hp : DecidablePred p} (f g : α → γ)
    (h : γ → β) :
    (∏ x ∈ s, h (if p x then f x else g x)) =
      (∏ x ∈ s.filter p, h (f x)) * ∏ x ∈ s.filter fun x => ¬p x, h (g x)

{α : Type u_3}
{β : Type u_4}
{γ : Type u_5}
[CommMonoid β]
{s : Finset α}
{p : α → Prop}
{_hp : DecidablePred p}
(f g : α → γ)
(h : γ → β)

∏ x ∈ s, h (if p x then f x else g x) =
  (∏ x ∈ Finset.filter p s, h (f x)) * ∏ x ∈ Finset.filter (fun x => ¬p x) s, h (g x)


@[simp] theorem getElem!_fin [GetElem? Cont Nat Elem Dom] (a : Cont) (i : Fin n)
    [Decidable (Dom a i)] [Inhabited Elem] : a[i]! = a[i.1]!

{Cont : Type u_1}
{Elem : Type u_2}
{Dom : Cont → Nat → Prop}
{n : Nat}
[GetElem? Cont Nat Elem Dom]
(a : Cont)
(i : Fin n)
[Decidable (Dom a ↑i)]
[Inhabited Elem]


theorem fderiv_fst : fderiv 𝕜 Prod.fst p = fst 𝕜 E F

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{p : E × F}

fderiv 𝕜 Prod.fst p = ContinuousLinearMap.fst 𝕜 E F


theorem of_equiv {β} {e : β ≃ α} :
    haveI := Primcodable.ofEquiv α e
    Primrec e

{α : Type u_1}
[Primcodable α]
{β : Type u_4}
{e : β ≃ α}


theorem OrthonormalBasis.measurePreserving_repr (b : OrthonormalBasis ι ℝ F) :
    MeasurePreserving b.repr volume volume

{ι : Type u_1}
{F : Type u_3}
[Fintype ι]
[NormedAddCommGroup F]
[InnerProductSpace ℝ F]
[FiniteDimensional ℝ F]
[MeasurableSpace F]
[BorelSpace F]
(b : OrthonormalBasis ι ℝ F)

MeasureTheory.MeasurePreserving (⇑b.repr) MeasureTheory.volume MeasureTheory.volume


/-- A weighted sum over `s.subtype pred` equals one over `s.filter pred`. -/
theorem weightedVSub_subtype_eq_filter (w : ι → k) (p : ι → P) (pred : ι → Prop)
    [DecidablePred pred] :
    ((s.subtype pred).weightedVSub (fun i => p i) fun i => w i) =
      (s.filter pred).weightedVSub p w

{k : Type u_1}
{V : Type u_2}
{P : Type u_3}
[Ring k]
[AddCommGroup V]
[Module k V]
[S : AffineSpace V P]
{ι : Type u_4}
(s : Finset ι)
(w : ι → k)
(p : ι → P)
(pred : ι → Prop)
[DecidablePred pred]

(((Finset.subtype pred s).weightedVSub fun i => p ↑i) fun i => w ↑i) = ((Finset.filter pred s).weightedVSub p) w


/-- Predicate for additive monoid homomorphisms
(deprecated -- use the bundled `MonoidHom` version). -/
structure IsAddMonoidHom [AddZeroClass α] [AddZeroClass β] (f : α → β) extends IsAddHom f :
  Prop where
  /-- The proposition that `f` preserves the additive identity. -/
  map_zero : f 0 = 0

{α : Type u}
{β : Type v}
[AddZeroClass α]
[AddZeroClass β]
{f : α → β}
(self : IsAddMonoidHom f)


@[to_additive]
theorem image_inter_mulSupport_eq {s : Set β} {g : β → α} :
    g '' s ∩ mulSupport f = g '' (s ∩ mulSupport (f ∘ g))

{α : Type u_1}
{β : Type u_2}
{M : Type u_3}
[One M]
{f : α → M}
{s : Set β}
{g : β → α}

g '' s ∩ Function.mulSupport f = g '' (s ∩ Function.mulSupport (f ∘ g))


theorem preimage_image_eq_image (i j : D.J) (U : Set (𝖣.U i)) :
    𝖣.ι j ⁻¹' (𝖣.ι i '' U) = D.f _ _ '' ((D.t j i ≫ D.f _ _) ⁻¹' U)

(D : TopCat.GlueData)
(i j : D.J)
(U : Set ↑(D.U i))

⇑(D.ι j) ⁻¹' (⇑(D.ι i) '' U) = ⇑(D.f j i) '' (⇑(D.t j i ≫ D.f i j) ⁻¹' U)


theorem div_add_mod' (m k : ℕ+) : (div m k * k + mod m k : ℕ) = m


protected theorem nonempty : (p : Set M).Nonempty

{R : Type u}
{M : Type v}
[Semiring R]
[AddCommMonoid M]
{module_M : Module R M}
(p : Submodule R M)


theorem toList_nodup (s : CompositionSeries X) : s.toList.Nodup

{X : Type u}
[Lattice X]
[JordanHolderLattice X]
(s : CompositionSeries X)


theorem Ideal.homogeneousCore'_eq_sSup :
    I.homogeneousCore' 𝒜 = sSup { J : Ideal A | J.IsHomogeneous 𝒜 ∧ J ≤ I }

{ι : Type u_1}
{σ : Type u_2}
{A : Type u_4}
[Semiring A]
[DecidableEq ι]
[AddMonoid ι]
[SetLike σ A]
[AddSubmonoidClass σ A]
(𝒜 : ι → σ)
[GradedRing 𝒜]
(I : Ideal A)

Ideal.homogeneousCore' 𝒜 I = sSup {J | Ideal.IsHomogeneous 𝒜 J ∧ J ≤ I}


lemma smul_neg_iff_of_neg_left (ha : a < 0) : a • b < 0 ↔ 0 < b

{α : Type u_1}
{β : Type u_2}
{a : α}
{b : β}
[OrderedRing α]
[OrderedAddCommGroup β]
[Module α β]
[PosSMulStrictMono α β]
[PosSMulReflectLT α β]
(ha : a < 0)


theorem inter_eventuallyEq_right {s t : Set α} {l : Filter α} :
    (s ∩ t : Set α) =ᶠ[l] t ↔ ∀ᶠ x in l, x ∈ t → x ∈ s

{α : Type u}
{s t : Set α}
{l : Filter α}

s ∩ t =ᶠ[l] t ↔ ∀ᶠ (x : α) in l, x ∈ t → x ∈ s


@[simp]
theorem imK_fst_dualNumberEquiv (q : Quaternion (DualNumber R)) :
    (dualNumberEquiv q).fst.imK = q.imK.fst

{R : Type u_1}
[CommRing R]
(q : Quaternion (DualNumber R))

(TrivSqZeroExt.fst (Quaternion.dualNumberEquiv q)).imK = TrivSqZeroExt.fst q.imK


@[simp]
theorem log_one_right (b : ℕ) : log b 1 = 0


@[simp]
theorem zero_inter (s : Multiset α) : 0 ∩ s = 0

{α : Type u_1}
[DecidableEq α]
(s : Multiset α)


@[simp]
theorem transpose_one [DecidableEq n] [Zero α] [One α] : (1 : Matrix n n α)ᵀ = 1

{n : Type u_3}
{α : Type v}
[DecidableEq n]
[Zero α]
[One α]


theorem choice_isSome_iff_nonempty {α : Type _} : (choice α).isSome ↔ Nonempty α

(Option.choice α).isSome = true ↔ Nonempty α


@[to_additive (attr := simp)]
theorem leftInvEquiv_symm_eq_inv (x : S) : ((S.leftInvEquiv hS).symm x : M) = (x : M)⁻¹

{M : Type u_1}
[AddCommGroup M]
(S : AddSubmonoid M)
(hS : S ≤ IsAddUnit.addSubmonoid M)
(x : ↥S)


@[simp]
lemma indicatorConstLp_univ :
    indicatorConstLp p .univ (measure_ne_top μ _) c = Lp.const p μ c

{α : Type u_1}
{E : Type u_2}
{m0 : MeasurableSpace α}
(p : ℝ≥0∞)
(μ : MeasureTheory.Measure α)
[NormedAddCommGroup E]
[MeasureTheory.IsFiniteMeasure μ]
(c : E)

MeasureTheory.indicatorConstLp p ⋯ ⋯ c = (MeasureTheory.Lp.const p μ) c


theorem IsTopologicalBasis.inf_induced {γ} [s : TopologicalSpace β] {B₁ : Set (Set α)}
    {B₂ : Set (Set β)} (h₁ : IsTopologicalBasis B₁) (h₂ : IsTopologicalBasis B₂) (f₁ : γ → α)
    (f₂ : γ → β) :
    IsTopologicalBasis (t := induced f₁ t ⊓ induced f₂ s) (image2 (f₁ ⁻¹' · ∩ f₂ ⁻¹' ·) B₁ B₂)

(h₁ : TopologicalSpace.IsTopologicalBasis B₁)

(h₂ : TopologicalSpace.IsTopologicalBasis B₂)

(f₁ : γ → α)

(f₂ : γ → β)

TopologicalSpace.IsTopologicalBasis (Set.image2 (fun x x_1 => f₁ ⁻¹' x ∩ f₂ ⁻¹' x_1) B₁ B₂)


theorem toAddSubgroup_injective : Injective (toAddSubgroup : Submodule R M → AddSubgroup M)

{R : Type u}
{M : Type v}
[Ring R]
[AddCommGroup M]
{module_M : Module R M}


protected theorem Subsingleton.helim {α β : Sort u} [h₁ : Subsingleton α] (h₂ : α = β) (a : α) (b : β) : HEq a b


theorem ofNat_iff {α β σ} [Denumerable α] [Denumerable β] [Primcodable σ] {f : α → β → σ} :
    Primrec₂ f ↔ Primrec₂ fun m n : ℕ => f (ofNat α m) (ofNat β n)

{α : Type u_4}
{β : Type u_5}
{σ : Type u_6}
[Denumerable α]
[Denumerable β]
[Primcodable σ]
{f : α → β → σ}

Primrec₂ f ↔ Primrec₂ fun m n => f (Denumerable.ofNat α m) (Denumerable.ofNat β n)


lemma pullback_eq (f : X ⟶ Y) :
    pullback A f = forget A Y ⋙ Presheaf.pullback A f ⋙ presheafToSheaf _ _

TopCat.Sheaf.pullback A f =
  TopCat.Sheaf.forget A Y ⋙
    TopCat.Presheaf.pullback A f ⋙ CategoryTheory.presheafToSheaf (Opens.grothendieckTopology ↑X) A


@[simp]
theorem union_val (s t : Finset α) : (s ∪ t).1 = s.1 ∪ t.1

{α : Type u_1}
[DecidableEq α]
(s t : Finset α)


@[simp]
theorem removeUnop_id (F : Cᵒᵖ ⥤ Dᵒᵖ) : NatTrans.removeUnop (𝟙 F.unop) = 𝟙 F

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
{D : Type u₂}
[CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ)

CategoryTheory.NatTrans.removeUnop (CategoryTheory.CategoryStruct.id F.unop) = CategoryTheory.CategoryStruct.id F


theorem map_isUnit_of_le (hS : S ≤ A⁰) (s : S) : IsUnit (algebraMap A K s)

{A : Type u_1}
(K : Type u_2)
[CommRing A]
(S : Submonoid A)
[CommRing K]
[Algebra A K]
[IsFractionRing A K]
(hS : S ≤ nonZeroDivisors A)
(s : ↥S)


@[simp]
theorem factors_le {a b : Associates α} : a.factors ≤ b.factors ↔ a ≤ b

{α : Type u_1}
[CancelCommMonoidWithZero α]
[UniqueFactorizationMonoid α]
{a b : Associates α}


theorem HasAntitoneBasis.hasBasis_ge [Preorder ι] [IsDirected ι (· ≤ ·)] {l : Filter α}
    {s : ι → Set α} (hs : l.HasAntitoneBasis s) (i : ι) : l.HasBasis (fun j => i ≤ j) s

{α : Type u_1}
{ι : Type u_4}
[Preorder ι]
[IsDirected ι fun x x_1 => x ≤ x_1]
{l : Filter α}
{s : ι → Set α}
(hs : l.HasAntitoneBasis s)
(i : ι)


/-- One can prove `QuotientMeasureEqMeasurePreimage` by checking behavior with respect to a single
fundamental domain. -/
@[to_additive]
lemma IsFundamentalDomain.quotientMeasureEqMeasurePreimage {μ : Measure (Quotient α_mod_G)}
    {s : Set α} (fund_dom_s : IsFundamentalDomain G s ν) (h : μ = (ν.restrict s).map π) :
    QuotientMeasureEqMeasurePreimage ν μ

[MeasureTheory.VAddInvariantMeasure G α ν]

{μ : MeasureTheory.Measure (Quotient (AddAction.orbitRel G α))}

(fund_dom_s : MeasureTheory.IsAddFundamentalDomain G s ν)

(h : μ = MeasureTheory.Measure.map (Quotient.mk (AddAction.orbitRel G α)) (ν.restrict s))


theorem center_le_centralizer {R} [Semiring R] (s) : center R ≤ centralizer s

Subsemiring.center R ≤ Subsemiring.centralizer s


protected theorem sub_min_sub_right : ∀ (a b c : Nat), min (a - c) (b - c) = min a b - c


theorem app_injective_of_stalkFunctor_map_injective {F : Sheaf C X} {G : Presheaf C X} (f : F.1 ⟶ G)
    (U : Opens X) (h : ∀ x : U, Function.Injective ((stalkFunctor C x.val).map f)) :
    Function.Injective (f.app (op U))

(h : ∀ (x : ↥U), Function.Injective ⇑((TopCat.Presheaf.stalkFunctor C ↑x).map f))

Function.Injective ⇑(f.app (Opposite.op U))


/-- A strictly monotone function with a right inverse is an order isomorphism. -/
@[simps (config := .asFn)]
def orderIsoOfRightInverse (g : β → α) (hg : Function.RightInverse g f) : α ≃o β

{α : Type u_2}
{β : Type u_3}
[LinearOrder α]
[Preorder β]
(f : α → β)
(h_mono : StrictMono f)
(g : β → α)
(hg : Function.RightInverse g f)

⇑(RelIso.symm (StrictMono.orderIsoOfRightInverse f h_mono g hg)) = g


theorem Tendsto.neBot {f : α → β} {x : Filter α} {y : Filter β} (h : Tendsto f x y) [hx : NeBot x] :
    NeBot y

{α : Type u}
{β : Type v}
{f : α → β}
{x : Filter α}
{y : Filter β}
(h : Filter.Tendsto f x y)
[hx : x.NeBot]


@[simp]
theorem invOf_nonneg [Invertible a] : 0 ≤ ⅟ a ↔ 0 ≤ a

{α : Type u_1}
[LinearOrderedSemiring α]
{a : α}
[Invertible a]

0 ≤ ⅟a ↔ 0 ≤ a


theorem IsLeast.minimals_eq [PartialOrder α] (h : IsLeast s a) : minimals (· ≤ ·) s = {a}

{α : Type u_1}
{s : Set α}
{a : α}
[PartialOrder α]
(h : IsLeast s a)


theorem sup'_product_right {t : Finset γ} (h : (s ×ˢ t).Nonempty) (f : β × γ → α) :
    (s ×ˢ t).sup' h f = t.sup' h.snd fun i' => s.sup' h.fst fun i => f ⟨i, i'⟩

{α : Type u_2}
{β : Type u_3}
{γ : Type u_4}
[SemilatticeSup α]
{s : Finset β}
{t : Finset γ}
(h : (s ×ˢ t).Nonempty)
(f : β × γ → α)

(s ×ˢ t).sup' h f = t.sup' ⋯ fun i' => s.sup' ⋯ fun i => f (i, i')


theorem eq_max {a b c : α} (h₁ : a ≤ c) (h₂ : b ≤ c) (h₃ : ∀ {d}, a ≤ d → b ≤ d → c ≤ d) :
    c = max a b

{α : Type u}
[LinearOrder α]
{a b c : α}
(h₁ : a ≤ c)
(h₂ : b ≤ c)
(h₃ : ∀ {d : α}, a ≤ d → b ≤ d → c ≤ d)


@[simp] theorem inv_val : ↑A⁻¹ = (star A : Matrix n n α)

{n : Type u}
[DecidableEq n]
[Fintype n]
{α : Type v}
[CommRing α]
[StarRing α]
(A : ↥(Matrix.unitaryGroup n α))


/-- The inclusion of locally-constant functions into continuous functions as a linear map. -/
@[simps]
def toContinuousMapLinearMap (R : Type*) [Semiring R] [AddCommMonoid Y] [Module R Y]
    [ContinuousAdd Y] [ContinuousConstSMul R Y] : LocallyConstant X Y →ₗ[R] C(X, Y)

{X : Type u_1}
{Y : Type u_2}
[TopologicalSpace X]
[TopologicalSpace Y]
(R : Type u_3)
[Semiring R]
[AddCommMonoid Y]
[Module R Y]
[ContinuousAdd Y]
[ContinuousConstSMul R Y]
(f : LocallyConstant X Y)

(LocallyConstant.toContinuousMapLinearMap R) f = ↑f


theorem Expr.of_cancel_lt (ctx : Context) (a b c d : Expr) (h : Poly.cancel a.inc.toNormPoly b.toNormPoly = (c.inc.toPoly, d.toPoly)) : (a.denote ctx < b.denote ctx) = (c.denote ctx < d.denote ctx)

(h : a.inc.toNormPoly.cancel b.toNormPoly = (c.inc.toPoly, d.toPoly))

(Nat.Linear.Expr.denote ctx a < Nat.Linear.Expr.denote ctx b) =
  (Nat.Linear.Expr.denote ctx c < Nat.Linear.Expr.denote ctx d)


@[simp]
theorem natDegree_taylor (p : R[X]) (r : R) : natDegree (taylor r p) = natDegree p

{R : Type u_1}
[Semiring R]
(p : Polynomial R)
(r : R)

((Polynomial.taylor r) p).natDegree = p.natDegree


/-- Simplification of the integral of `sin x ^ m * cos x ^ n`, case `m` and `n` are both even. -/
theorem integral_sin_pow_even_mul_cos_pow_even (m n : ℕ) :
    (∫ x in a..b, sin x ^ (2 * m) * cos x ^ (2 * n)) =
      ∫ x in a..b, ((1 - cos (2 * x)) / 2) ^ m * ((1 + cos (2 * x)) / 2) ^ n


@[fun_prop]
theorem hasFDerivAt_of_subsingleton [h : Subsingleton E] (f : E → F) (x : E) :
    HasFDerivAt f (0 : E →L[𝕜] F) x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
[h : Subsingleton E]
(f : E → F)
(x : E)


theorem setOf_isOpen_injective : Injective fun t : TopologicalSpace α => { s | IsOpen[t] s }

Function.Injective fun t => {s | IsOpen s}


@[to_additive]
protected theorem UniformFun.hasBasis_nhds_one :
    (𝓝 1 : Filter (α →ᵤ G)).HasBasis (fun V : Set G => V ∈ (𝓝 1 : Filter G)) fun V =>
      { f : α → G | ∀ x, f x ∈ V }

{α : Type u_1}
{G : Type u_2}
[Group G]
[UniformSpace G]
[UniformGroup G]

(𝓝 1).HasBasis (fun V => V ∈ 𝓝 1) fun V => {f | ∀ (x : α), f x ∈ V}


/-- A symmetric relation `r : α → α → Prop` is "function-like"
(for each `a` there exists a unique `b` such that `r a b`)
if and only if it is `(f · = ·)` for some involutive function `f`. -/
protected lemma Symmetric.forall_existsUnique_iff {r : α → α → Prop} (hr : Symmetric r) :
    (∀ a, ∃! b, r a b) ↔ ∃ f : α → α, Involutive f ∧ ∀ {a b}, r a b ↔ f a = b

{α : Sort u_1}
{r : α → α → Prop}
(hr : Symmetric r)

(∀ (a : α), ∃! b, r a b) ↔ ∃ f, Function.Involutive f ∧ ∀ {a b : α}, r a b ↔ f a = b


theorem le_of_tendsto_of_tendsto {f g : β → α} {b : Filter β} {a₁ a₂ : α} [NeBot b]
    (hf : Tendsto f b (𝓝 a₁)) (hg : Tendsto g b (𝓝 a₂)) (h : f ≤ᶠ[b] g) : a₁ ≤ a₂

{α : Type u}
{β : Type v}
[TopologicalSpace α]
[Preorder α]
[t : OrderClosedTopology α]
{f g : β → α}
{b : Filter β}
{a₁ a₂ : α}
[b.NeBot]
(hf : Filter.Tendsto f b (𝓝 a₁))
(hg : Filter.Tendsto g b (𝓝 a₂))
(h : f ≤ᶠ[b] g)


@[simp]
theorem lTensor_tmul (m : M) (n : N) : f.lTensor M (m ⊗ₜ n) = m ⊗ₜ f n

{R : Type u_1}
[CommSemiring R]
(M : Type u_4)
{N : Type u_5}
{P : Type u_6}
[AddCommMonoid M]
[AddCommMonoid N]
[AddCommMonoid P]
[Module R M]
[Module R N]
[Module R P]
(f : N →ₗ[R] P)
(m : M)
(n : N)

(LinearMap.lTensor M f) (m ⊗ₜ[R] n) = m ⊗ₜ[R] f n


@[reassoc (attr := simp)]
theorem IsSplitEpi.id {X Y : C} (f : X ⟶ Y) [hf : IsSplitEpi f] : section_ f ≫ f = 𝟙 Y

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
{X Y : C}
(f : X ⟶ Y)
[hf : CategoryTheory.IsSplitEpi f]

CategoryTheory.CategoryStruct.comp (CategoryTheory.section_ f) f = CategoryTheory.CategoryStruct.id Y


/-- We prefer to use the bundled `revAt` over unbundled `revAtFun`. -/
@[simp]
theorem revAtFun_eq (N i : ℕ) : revAtFun N i = revAt N i

Polynomial.revAtFun N i = (Polynomial.revAt N) i


/-- The obvious homotopy between two equal morphisms of short complexes. -/
@[simps]
def ofEq (h : φ₁ = φ₂) : Homotopy φ₁ φ₂

{C : Type u_1}
[CategoryTheory.Category.{u_2, u_1} C]
[CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C}
{φ₁ φ₂ : S₁ ⟶ S₂}
(h : φ₁ = φ₂)

(CategoryTheory.ShortComplex.Homotopy.ofEq h).h₂ = 0


theorem LinearIndependent.units_smul {v : ι → M} (hv : LinearIndependent R v) (w : ι → Rˣ) :
    LinearIndependent R (w • v)

{ι : Type u'}
{R : Type u_2}
{M : Type u_4}
[Ring R]
[AddCommGroup M]
[Module R M]
{v : ι → M}
(hv : LinearIndependent R v)
(w : ι → Rˣ)


theorem nnnorm_symm_pos [RingHomIsometric σ₁₂] [Nontrivial E] (e : E ≃SL[σ₁₂] F) :
    0 < ‖(e.symm : F →SL[σ₂₁] E)‖₊

{𝕜 : Type u_1}
{𝕜₂ : Type u_2}
{E : Type u_4}
{F : Type u_6}
[NormedAddCommGroup E]
[NormedAddCommGroup F]
[NontriviallyNormedField 𝕜]
[NontriviallyNormedField 𝕜₂]
[NormedSpace 𝕜 E]
[NormedSpace 𝕜₂ F]
{σ₁₂ : 𝕜 →+* 𝕜₂}
{σ₂₁ : 𝕜₂ →+* 𝕜}
[RingHomInvPair σ₁₂ σ₂₁]
[RingHomInvPair σ₂₁ σ₁₂]
[RingHomIsometric σ₂₁]
[RingHomIsometric σ₁₂]
[Nontrivial E]
(e : E ≃SL[σ₁₂] F)


theorem kroneckerMap_map (f : α → β → γ) (g : γ → γ') (A : Matrix l m α) (B : Matrix n p β) :
    (kroneckerMap f A B).map g = kroneckerMap (fun a b => g (f a b)) A B

{α : Type u_2}
{β : Type u_4}
{γ : Type u_6}
{γ' : Type u_7}
{l : Type u_8}
{m : Type u_9}
{n : Type u_10}
{p : Type u_11}
(f : α → β → γ)
(g : γ → γ')
(A : Matrix l m α)
(B : Matrix n p β)

(Matrix.kroneckerMap f A B).map g = Matrix.kroneckerMap (fun a b => g (f a b)) A B


theorem inner_re_symm (x y : F) : re ⟪x, y⟫ = re ⟪y, x⟫

{𝕜 : Type u_1}
{F : Type u_3}
[RCLike 𝕜]
[AddCommGroup F]
[Module 𝕜 F]
[c : InnerProductSpace.Core 𝕜 F]
(x y : F)


theorem image_update_Ioo_left (f : ∀ i, α i) (i : ι) (a : α i) :
    update f i '' Ioo a (f i) = Ioo (update f i a) f

{ι : Type u_1}
{α : ι → Type u_2}
[DecidableEq ι]
[(i : ι) → PartialOrder (α i)]
(f : (i : ι) → α i)
(i : ι)
(a : α i)

Function.update f i '' Set.Ioo a (f i) = Set.Ioo (Function.update f i a) f


@[to_additive]
theorem Subgroup.of_normal [Group G] (s : Set G) (h : IsSubgroup s) (n : IsNormalSubgroup s) :
    Subgroup.Normal (Subgroup.of h)

{G : Type u_1}
[Group G]
(s : Set G)
(h : IsSubgroup s)
(n : IsNormalSubgroup s)


@[simp]
theorem orElse_eq_none (o o' : Option α) : (o <|> o') = none ↔ o = none ∧ o' = none

(HOrElse.hOrElse o fun x => o') = none ↔ o = none ∧ o' = none


@[to_additive]
theorem inv_mem_inv (ha : a ∈ s) : a⁻¹ ∈ s⁻¹

{α : Type u_2}
[OrderedAddCommGroup α]
(s : NonemptyInterval α)
(a : α)
(ha : a ∈ s)


@[simp, norm_cast] lemma cast_max (p q : ℚ≥0) : (↑(max p q) : K) = max (p : K) (q : K)

{K : Type u_5}
[LinearOrderedSemifield K]
(p q : ℚ≥0)


/-- Lebesgue dominated convergence theorem for filters with a countable basis -/
theorem tendsto_setToFun_filter_of_dominated_convergence (hT : DominatedFinMeasAdditive μ T C) {ι}
    {l : Filter ι} [l.IsCountablyGenerated] {fs : ι → α → E} {f : α → E} (bound : α → ℝ)
    (hfs_meas : ∀ᶠ n in l, AEStronglyMeasurable (fs n) μ)
    (h_bound : ∀ᶠ n in l, ∀ᵐ a ∂μ, ‖fs n a‖ ≤ bound a) (bound_integrable : Integrable bound μ)
    (h_lim : ∀ᵐ a ∂μ, Tendsto (fun n => fs n a) l (𝓝 (f a))) :
    Tendsto (fun n => setToFun μ T hT (fs n)) l (𝓝 <| setToFun μ T hT f)

(hT : MeasureTheory.DominatedFinMeasAdditive μ T C)

(hfs_meas : ∀ᶠ (n : ι) in l, MeasureTheory.AEStronglyMeasurable (fs n) μ)

(h_bound : ∀ᶠ (n : ι) in l, ∀ᵐ (a : α) ∂μ, ‖fs n a‖ ≤ bound a)

(bound_integrable : MeasureTheory.Integrable bound μ)

(h_lim : ∀ᵐ (a : α) ∂μ, Filter.Tendsto (fun n => fs n a) l (𝓝 (f a)))

Filter.Tendsto (fun n => MeasureTheory.setToFun μ T hT (fs n)) l (𝓝 (MeasureTheory.setToFun μ T hT f))


theorem vars_rename [DecidableEq τ] (f : σ → τ) (φ : MvPolynomial σ R) :
    (rename f φ).vars ⊆ φ.vars.image f

{R : Type u}
{σ : Type u_1}
{τ : Type u_2}
[CommSemiring R]
[DecidableEq τ]
(f : σ → τ)
(φ : MvPolynomial σ R)

((MvPolynomial.rename f) φ).vars ⊆ Finset.image f φ.vars


@[to_additive]
lemma Multipliable.of_finite [Finite β] {f : β → α} : Multipliable f

{α : Type u_1}
{β : Type u_2}
[AddCommMonoid α]
[TopologicalSpace α]
[Finite β]
{f : β → α}


theorem add_pf_add_zero (a : R) : a + 0 = a


theorem map_comp_cons (f : α → β) (t) : map f ∘ cons t = cons (f t) ∘ map f

{α : Type u_1}
{β : Type v}
(f : α → β)
(t : α)

Multiset.map f ∘ Multiset.cons t = Multiset.cons (f t) ∘ Multiset.map f


@[simp]
theorem mod_self (a : Ordinal) : a % a = 0


@[to_additive]
theorem multipliable_one : Multipliable (fun _ ↦ 1 : β → α)

{α : Type u_1}
{β : Type u_2}
[CommMonoid α]
[TopologicalSpace α]


theorem QuasiconvexOn.sup [SemilatticeSup β] (hf : QuasiconvexOn 𝕜 s f)
    (hg : QuasiconvexOn 𝕜 s g) : QuasiconvexOn 𝕜 s (f ⊔ g)

{𝕜 : Type u_1}
{E : Type u_2}
{β : Type u_4}
[OrderedSemiring 𝕜]
[AddCommMonoid E]
[SMul 𝕜 E]
{s : Set E}
{f g : E → β}
[SemilatticeSup β]
(hf : QuasiconvexOn 𝕜 s f)
(hg : QuasiconvexOn 𝕜 s g)


theorem Dep.not_indep (hD : M.Dep D) : ¬ M.Indep D

{α : Type u_1}
{M : Matroid α}
{D : Set α}
(hD : M.Dep D)


@[simp]
theorem det_nonsing_inv : A⁻¹.det = Ring.inverse A.det

{n : Type u'}
{α : Type v}
[Fintype n]
[DecidableEq n]
[CommRing α]
(A : Matrix n n α)


protected theorem mul_inv_rev (a b : tsze R M) :
    (a * b)⁻¹ = b⁻¹ * a⁻¹

{R : Type u}
{M : Type v}
[DivisionSemiring R]
[AddCommGroup M]
[Module Rᵐᵒᵖ M]
[Module R M]
[SMulCommClass R Rᵐᵒᵖ M]
(a b : tsze R M)


/-- The Euler product for the Riemann ζ function, valid for `s.re > 1`.
This version is stated in terms of `tprod`. -/
theorem riemannZeta_eulerProduct_tprod (hs : 1 < s.re) :
    ∏' p : Primes, (1 - (p : ℂ) ^ (-s))⁻¹ = riemannZeta s

∏' (p : Nat.Primes), (1 - ↑↑p ^ (-s))⁻¹ = riemannZeta s


/-- The equivalence `(∀ i, β i) ≃ β ⋆` when the domain of `β` only contains `⋆` -/
@[simps (config := .asFn)]
def piUnique [Unique α] (β : α → Sort*) : (∀ i, β i) ≃ β default

{α : Sort u}
[Unique α]
(β : α → Sort u_1)

⇑(Equiv.piUnique β) = fun f => f default


/-- If `K / E / F` is an extension tower such that `E / F` is separable,
`x : K` is separable over `E`, then it's also separable over `F`. -/
theorem IsSeparable.of_algebra_isSeparable_of_isSeparable [Algebra E K] [IsScalarTower F E K]
    [Algebra.IsSeparable F E] {x : K} (hsep : IsSeparable E x) : IsSeparable F x

(F : Type u)
{E : Type v}
[Field F]
[Field E]
[Algebra F E]
{K : Type w}
[Field K]
[Algebra F K]
[Algebra E K]
[IsScalarTower F E K]
[Algebra.IsSeparable F E]
{x : K}
(hsep : IsSeparable E x)


@[to_additive (attr := simp)] lemma op_one [One α] : op (1 : α) = 1


@[to_additive]
theorem isNormalSubgroup_of_commGroup [CommGroup G] {s : Set G} (hs : IsSubgroup s) :
    IsNormalSubgroup s

{G : Type u_1}
[CommGroup G]
{s : Set G}
(hs : IsSubgroup s)


theorem rank_mul_le_right [StrongRankCondition R] (A : Matrix m n R) (B : Matrix n o R) :
    (A * B).rank ≤ B.rank

{m : Type u_2}
{n : Type u_3}
{o : Type u_4}
{R : Type u_5}
[Fintype n]
[Fintype o]
[CommRing R]
[StrongRankCondition R]
(A : Matrix m n R)
(B : Matrix n o R)


@[simp]
theorem cofinite_eq_bot_iff : @cofinite α = ⊥ ↔ Finite α


theorem IsLocalization.lift_algebraMap_eq_algebraMap :
    IsLocalization.lift (M := M) (IsLocalization.map_units_map_submonoid S Sₘ) =
      algebraMap Rₘ Sₘ

[i : IsLocalization (Algebra.algebraMapSubmonoid S M) Sₘ]

IsLocalization.lift ⋯ = algebraMap Rₘ Sₘ


/--
The contravariant functor turning comonoid objects into monoid objects in the opposite category.
-/
@[simps] def Comon_ToMon_OpOp : Comon_ C ⥤ (Mon_ (Cᵒᵖ))ᵒᵖ

(C : Type u₁)
[CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.MonoidalCategory C]
(A : Comon_ C)

(Comon_.Comon_ToMon_OpOp C).obj A = Opposite.op (Comon_.Comon_ToMon_OpOp_obj' C A)


lemma Even.eval_neg (x : ZMod m) (hψ : ψ.Even) : ψ (- x) = ψ x

{S : Type}
[CommRing S]
{m : ℕ}
(ψ : DirichletCharacter S m)
(x : ZMod m)
(hψ : ψ.Even)


theorem encode_lt_comp (cf cg) :
    encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg)

Encodable.encode cf < Encodable.encode (cf.comp cg) ∧ Encodable.encode cg < Encodable.encode (cf.comp cg)


theorem span_range_eq_iSup {ι : Sort*} {v : ι → M} : span R (range v) = ⨆ i, R ∙ v i

{R : Type u_1}
{M : Type u_4}
[Semiring R]
[AddCommMonoid M]
[Module R M]
{ι : Sort u_9}
{v : ι → M}

Submodule.span R (Set.range v) = ⨆ i, Submodule.span R {v i}


/-- When `D` is a braided monoidal category,
commutative monoid objects in `C ⥤ D` are the same thing
as functors from `C` into the commutative monoid objects of `D`.
-/
@[simps]
def commMonFunctorCategoryEquivalence : CommMon_ (C ⥤ D) ≌ C ⥤ CommMon_ D

(C : Type u₁)
[CategoryTheory.Category.{v₁, u₁} C]
(D : Type u₂)
[CategoryTheory.Category.{v₂, u₂} D]
[CategoryTheory.MonoidalCategory D]
[CategoryTheory.BraidedCategory D]

(CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence C D).inverse =
  CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse


@[simp]
theorem lift.principalSeg_coe :
    (lift.principalSeg.{u, v} : Ordinal → Ordinal) = lift.{max (u + 1) v}

⇑Ordinal.lift.principalSeg.toRelEmbedding = Ordinal.lift.{max (u + 1) v, u}


theorem IntegralClosure.comap_ne_bot [Nontrivial R] {I : Ideal (integralClosure R S)}
    (I_ne_bot : I ≠ ⊥) : I.comap (algebraMap R (integralClosure R S)) ≠ ⊥

{R : Type u_1}
[CommRing R]
{S : Type u_2}
[CommRing S]
[Algebra R S]
[IsDomain S]
[Nontrivial R]
{I : Ideal ↥(integralClosure R S)}
(I_ne_bot : I ≠ ⊥)

Ideal.comap (algebraMap R ↥(integralClosure R S)) I ≠ ⊥


@[to_additive]
theorem prod_hom (l : List M) {F : Type*} [FunLike F M N] [MonoidHomClass F M N] (f : F) :
    (l.map f).prod = f l.prod

{M : Type u_4}
{N : Type u_5}
[Monoid M]
[Monoid N]
(l : List M)
{F : Type u_8}
[FunLike F M N]
[MonoidHomClass F M N]
(f : F)


@[aesop unsafe 10% (rule_sets := [Matroid])]
theorem Coindep.subset_ground (hX : M.Coindep X) : X ⊆ M.E

{α : Type u_1}
{M : Matroid α}
{X : Set α}
(hX : M.Coindep X)


@[simp]
theorem map_id : map (LinearMap.id : M →ₗ[R'] M) = AlgHom.id R' _

{R' : Type u}
{M : Type v}
[CommSemiring R']
[AddCommMonoid M]
[Module R' M]
[Module R'ᵐᵒᵖ M]
[IsCentralScalar R' M]

TrivSqZeroExt.map LinearMap.id = AlgHom.id R' (tsze R' M)


theorem isMinOn_iff : IsMinOn f s a ↔ ∀ x ∈ s, f a ≤ f x

{α : Type u}
{β : Type v}
[Preorder β]
{f : α → β}
{s : Set α}
{a : α}


@[simp]
theorem congr_symm_apply (f : A ≃ₐ[S] B) (g : C ≃ₐ[R] D) (x) :
    (congr f g).symm x = (map (f.symm : B →ₐ[S] A) (g.symm : D →ₐ[R] C)) x

{R : Type uR}
{S : Type uS}
{A : Type uA}
{B : Type uB}
{C : Type uC}
{D : Type uD}
[CommSemiring R]
[CommSemiring S]
[Algebra R S]
[Semiring A]
[Algebra R A]
[Algebra S A]
[IsScalarTower R S A]
[Semiring B]
[Algebra R B]
[Algebra S B]
[IsScalarTower R S B]
[Semiring C]
[Algebra R C]
[Semiring D]
[Algebra R D]
(f : A ≃ₐ[S] B)
(g : C ≃ₐ[R] D)
(x : B ⊗[R] D)

(Algebra.TensorProduct.congr f g).symm x = (Algebra.TensorProduct.map ↑f.symm ↑g.symm) x


/-- A `RingFilterBasis` on a ring is a `FilterBasis` satisfying some additional axioms.
  Example : if `R` is a topological ring then the neighbourhoods of the identity are a
  `RingFilterBasis`. Conversely given a `RingFilterBasis` on a ring `R`, one can define a
  topology on `R` which is compatible with the ring structure. -/
class RingFilterBasis (R : Type u) [Ring R] extends AddGroupFilterBasis R where
  mul' : ∀ {U}, U ∈ sets → ∃ V ∈ sets, V * V ⊆ U
  mul_left' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x ↦ x₀ * x) ⁻¹' U
  mul_right' : ∀ (x₀ : R) {U}, U ∈ sets → ∃ V ∈ sets, V ⊆ (fun x ↦ x * x₀) ⁻¹' U

{R : Type u}
[Ring R]
[self : RingFilterBasis R]
(x₀ : R)
{U : Set R}

U ∈ AddGroupFilterBasis.toFilterBasis.sets → ∃ V ∈ AddGroupFilterBasis.toFilterBasis.sets, V ⊆ (fun x => x₀ * x) ⁻¹' U


theorem reverse_involute :
    ∀ a : CliffordAlgebra Q, reverse (involute a) = involute (reverse a)

{R : Type u_1}
[CommRing R]
{M : Type u_2}
[AddCommGroup M]
[Module R M]
{Q : QuadraticForm R M}
(a : CliffordAlgebra Q)

CliffordAlgebra.reverse (CliffordAlgebra.involute a) = CliffordAlgebra.involute (CliffordAlgebra.reverse a)


theorem coe_injective : @Injective (M ≃ₛₗ[σ] M₂) (M → M₂) CoeFun.coe

{R : Type u_1}
{S : Type u_7}
{M : Type u_8}
{M₂ : Type u_10}
[Semiring R]
[Semiring S]
[AddCommMonoid M]
[AddCommMonoid M₂]
[Module R M]
[Module S M₂]
{σ : R →+* S}
{σ' : S →+* R}
[RingHomInvPair σ σ']
[RingHomInvPair σ' σ]


lemma mapₐ_surjective_of_surjective (f : A →ₐ[R] B) (hf : Function.Surjective f) :
    Function.Surjective (mapₐ M Rₚ Aₚ Bₚ f)

[IsLocalization (Algebra.algebraMapSubmonoid A M) Aₚ]

[IsLocalization (Algebra.algebraMapSubmonoid B M) Bₚ]

Function.Surjective ⇑(IsLocalization.mapₐ M Rₚ Aₚ Bₚ f)


@[to_additive]
theorem Multipliable.map_tprod [CommMonoid γ] [TopologicalSpace γ] [T2Space γ] (hf : Multipliable f)
    {G} [FunLike G α γ] [MonoidHomClass G α γ] (g : G) (hg : Continuous g) :
    g (∏' i, f i) = ∏' i, g (f i)

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
[AddCommMonoid α]
[TopologicalSpace α]
{f : β → α}
[AddCommMonoid γ]
[TopologicalSpace γ]
[T2Space γ]
(hf : Summable f)
{G : Type u_5}
[FunLike G α γ]
[AddMonoidHomClass G α γ]
(g : G)
(hg : Continuous ⇑g)


@[simp]
theorem refl_trans (e : α ≃o β) : (refl α).trans e = e

{α : Type u_2}
{β : Type u_3}
[LE α]
[LE β]
(e : α ≃o β)


@[simp]
theorem cancel_right {g₁ g₂ : SupHom β γ} {f : SupHom α β} (hf : Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂

{α : Type u_3}
{β : Type u_4}
{γ : Type u_5}
[Sup α]
[Sup β]
[Sup γ]
{g₁ g₂ : SupHom β γ}
{f : SupHom α β}
(hf : Function.Surjective ⇑f)


lemma finsetInf'_mem_infClosure {ι : Type*} {t : Finset ι} (ht : t.Nonempty) {f : ι → α}
    (hf : ∀ i ∈ t, f i ∈ s) : t.inf' ht f ∈ infClosure s

{α : Type u_2}
[SemilatticeInf α]
{s : Set α}
{ι : Type u_4}
{t : Finset ι}
(ht : t.Nonempty)
{f : ι → α}
(hf : ∀ i ∈ t, f i ∈ s)


/-- Assumes left covariance.
The lemma assuming right covariance is `Right.mul_lt_one'`. -/
@[to_additive "Assumes left covariance.
The lemma assuming right covariance is `Right.add_neg'`."]
theorem Left.mul_lt_one' [CovariantClass α α (· * ·) (· ≤ ·)] {a b : α} (ha : a < 1) (hb : b < 1) :
    a * b < 1

[CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]


/-- An element of the unit group of a nonzero monoid with zero represented as an element
    of the monoid is nonzero. -/
@[simp]
theorem ne_zero [Nontrivial M₀] (u : M₀ˣ) : (u : M₀) ≠ 0

{M₀ : Type u_2}
[MonoidWithZero M₀]
[Nontrivial M₀]
(u : M₀ˣ)


theorem finiteInterClosure_insert {A : Set α} (cond : FiniteInter S) (P)
    (H : P ∈ finiteInterClosure (insert A S)) : P ∈ S ∨ ∃ Q ∈ S, P = A ∩ Q

(H : P ∈ FiniteInter.finiteInterClosure (insert A S))


theorem univ_pi_update_univ [DecidableEq ι] (i : ι) (s : Set (α i)) :
    pi univ (update (fun j : ι => (univ : Set (α j))) i s) = eval i ⁻¹' s

{ι : Type u_1}
{α : ι → Type u_2}
[DecidableEq ι]
(i : ι)
(s : Set (α i))

Set.univ.pi (Function.update (fun j => Set.univ) i s) = Function.eval i ⁻¹' s


@[simp]
theorem symm_apply_apply (x : E) : e.symm (e x) = x

{R : Type u_1}
{R₂ : Type u_2}
{E : Type u_5}
{E₂ : Type u_6}
[Semiring R]
[Semiring R₂]
{σ₁₂ : R →+* R₂}
{σ₂₁ : R₂ →+* R}
[RingHomInvPair σ₁₂ σ₂₁]
[RingHomInvPair σ₂₁ σ₁₂]
[SeminormedAddCommGroup E]
[SeminormedAddCommGroup E₂]
[Module R E]
[Module R₂ E₂]
(e : E ≃ₛₗᵢ[σ₁₂] E₂)
(x : E)


theorem sym2_insert [DecidableEq α] (a : α) (s : Finset α) :
    (insert a s).sym2 = ((insert a s).image fun b => s(a, b)) ∪ s.sym2

{α : Type u_1}
[DecidableEq α]
(a : α)
(s : Finset α)

(insert a s).sym2 = Finset.image (fun b => s(a, b)) (insert a s) ∪ s.sym2


theorem mem_mul_span_singleton {x y : R} {I : Ideal R} : x ∈ I * span {y} ↔ ∃ z ∈ I, z * y = x

{R : Type u}
[CommSemiring R]
{x y : R}
{I : Ideal R}

x ∈ I * Ideal.span {y} ↔ ∃ z ∈ I, z * y = x


theorem edist_comm : G.edist u v = G.edist v u

{V : Type u_1}
{G : SimpleGraph V}
{u v : V}


protected theorem nonneg_of_neg_nonpos {a : Int} (h : -a ≤ 0) : 0 ≤ a


@[measurability]
theorem measurable_exp : Measurable exp


/-- If two quadratic forms from `A ⊗[R] M₂` agree on elements of the form `1 ⊗ m`, they are equal.

In other words, if a base change exists for a quadratic form, it is unique.

Note that unlike `QuadraticForm.baseChange`, this does not need `Invertible (2 : R)`. -/
@[ext]
theorem baseChange_ext ⦃Q₁ Q₂ : QuadraticForm A (A ⊗[R] M₂)⦄
    (h : ∀ m, Q₁ (1 ⊗ₜ m) = Q₂ (1 ⊗ₜ m)) :
    Q₁ = Q₂


@[simp]
theorem IsSheafFor.valid_glue (t : IsSheafFor P R) {x : FamilyOfElements P R} (hx : x.Compatible)
    (f : Y ⟶ X) (Hf : R f) : P.map f.op (t.amalgamate x hx) = x f Hf

{P : CategoryTheory.Functor Cᵒᵖ (Type w)}

(t : CategoryTheory.Presieve.IsSheafFor P R)

{x : CategoryTheory.Presieve.FamilyOfElements P R}


theorem inter_union_distrib_right (s t u : Finset α) : s ∩ t ∪ u = (s ∪ u) ∩ (t ∪ u)

{α : Type u_1}
[DecidableEq α]
(s t u : Finset α)


@[simp, norm_cast] lemma isConjExponent_coe : (p : ℝ).IsConjExponent q ↔ p.IsConjExponent q

(↑p).IsConjExponent ↑q ↔ p.IsConjExponent q


@[simp]
theorem lanLiftCompIsoWhisker_hom_right :
    (lanLiftCompIsoWhisker f g h).hom.right = lanLiftDesc ((lanLiftLeftLift f g).whisker h)

[CategoryTheory.Bicategory.LanLift.CommuteWith f g h]

(CategoryTheory.Bicategory.LanLift.CommuteWith.lanLiftCompIsoWhisker f g h).hom.right =
  CategoryTheory.Bicategory.lanLiftDesc ((CategoryTheory.Bicategory.lanLiftLeftLift f g).whisker h)


@[to_additive]
theorem div_union : s / (t₁ ∪ t₂) = s / t₁ ∪ s / t₂

{α : Type u_2}
[Sub α]
{s t₁ t₂ : Set α}


theorem embDomainRingHom_C [NonAssocSemiring R] {f : Γ →+ Γ'} {hfi : Function.Injective f}
    {hf : ∀ g g' : Γ, f g ≤ f g' ↔ g ≤ g'} {r : R} : embDomainRingHom f hfi hf (C r) = C r

{hf : ∀ (g g' : Γ), f g ≤ f g' ↔ g ≤ g'}

(HahnSeries.embDomainRingHom f hfi hf) (HahnSeries.C r) = HahnSeries.C r


/-- If `s` and `t` are two fundamental domains of the same action, then their measures are equal. -/
@[to_additive "If `s` and `t` are two fundamental domains of the same action, then their measures
  are equal."]
protected theorem measure_eq (hs : IsFundamentalDomain G s μ) (ht : IsFundamentalDomain G t μ) :
    μ s = μ t

[MeasureTheory.VAddInvariantMeasure G α μ]

(hs : MeasureTheory.IsAddFundamentalDomain G s μ)

(ht : MeasureTheory.IsAddFundamentalDomain G t μ)


theorem map_eq_top_or_isMaximal_of_surjective (hf : Function.Surjective f) {I : Ideal R}
    (H : IsMaximal I) : map f I = ⊤ ∨ IsMaximal (map f I)

{R : Type u}
{S : Type v}
{F : Type u_1}
[Ring R]
[Ring S]
[FunLike F R S]
[RingHomClass F R S]
(f : F)
(hf : Function.Surjective ⇑f)
{I : Ideal R}
(H : I.IsMaximal)

Ideal.map f I = ⊤ ∨ (Ideal.map f I).IsMaximal


theorem sup_mul : (M ⊔ N) * P = M * P ⊔ N * P

{R : Type u}
[CommSemiring R]
{A : Type v}
[Semiring A]
[Algebra R A]
(M N P : Submodule R A)


theorem Definable.preimage_comp (f : α → β) {s : Set (α → M)} (h : A.Definable L s) :
    A.Definable L ((fun g : β → M => g ∘ f) ⁻¹' s)

{M : Type w}
{A : Set M}
{L : FirstOrder.Language}
[L.Structure M]
{α : Type u₁}
{β : Type u_1}
(f : α → β)
{s : Set (α → M)}
(h : A.Definable L s)


/-- Bilinear functions are `C^∞`.
-/
theorem IsBoundedBilinearMap.contDiff (hb : IsBoundedBilinearMap 𝕜 b) : ContDiff 𝕜 n b

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type uE}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type uF}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{G : Type uG}
[NormedAddCommGroup G]
[NormedSpace 𝕜 G]
{b : E × F → G}
{n : ℕ∞}
(hb : IsBoundedBilinearMap 𝕜 b)


/-- (Impl)
The natural transformation given by the coalgebra structure maps, used to construct a cone `c` with
point `limit (D ⋙ forget T)`.
 -/
@[simps]
def γ : D ⋙ forget T ⟶ (D ⋙ forget T) ⋙ ↑T

{D : CategoryTheory.Functor J T.Coalgebra}

CategoryTheory.Comonad.ForgetCreatesLimits'.γ.app j = (D.obj j).a


theorem bihimp_left_comm : a ⇔ (b ⇔ c) = b ⇔ (a ⇔ c)

{α : Type u_2}
[BooleanAlgebra α]
(a b c : α)


@[to_additive existing (attr := simp) zpow_addLeft]
lemma zpow_mulLeft (n : ℤ) : Equiv.mulLeft a ^ n = Equiv.mulLeft (a ^ n)


theorem TendstoUniformlyOnFilter.prod {ι' β' : Type*} [UniformSpace β'] {F' : ι' → α → β'}
    {f' : α → β'} {q : Filter ι'} (h : TendstoUniformlyOnFilter F f p p')
    (h' : TendstoUniformlyOnFilter F' f' q p') :
    TendstoUniformlyOnFilter (fun (i : ι × ι') a => (F i.1 a, F' i.2 a)) (fun a => (f a, f' a))
      (p ×ˢ q) p'

{F : ι → α → β}

TendstoUniformlyOnFilter (fun i a => (F i.1 a, F' i.2 a)) (fun a => (f a, f' a)) (p ×ˢ q) p'


theorem two_add_one_eq_three [AddMonoidWithOne R] : 2 + 1 = (3 : R)


/-- The ternary Cantor set is closed. -/
lemma isClosed_cantorSet : IsClosed cantorSet


/-- Any two nonzero left-invariant measures are absolutely continuous w.r.t. each other. -/
@[to_additive
" Any two nonzero left-invariant measures are absolutely continuous w.r.t. each other. "]
theorem absolutelyContinuous_of_isMulLeftInvariant [IsMulLeftInvariant ν] (hν : ν ≠ 0) : μ ≪ ν

{G : Type u_1}
[MeasurableSpace G]
[AddGroup G]
[MeasurableAdd₂ G]
(μ ν : MeasureTheory.Measure G)
[MeasureTheory.SFinite ν]
[MeasureTheory.SFinite μ]
[MeasurableNeg G]
[μ.IsAddLeftInvariant]
[ν.IsAddLeftInvariant]
(hν : ν ≠ 0)


lemma isInt_emod_neg {a b : ℤ} {r : ℕ} (h : IsNat (a % -b) r) : IsNat (a % b) r

(h : Mathlib.Meta.NormNum.IsNat (a % -b) r)