/-- Alternative constructor for the edge of `Λ[n, i]` with endpoints `a` and `b`,
assuming `3 ≤ n`. -/
@[simps!]
def edge₃ (n : ℕ) (i a b : Fin (n+1)) (hab : a ≤ b) (H : 3 ≤ n) :
    Λ[n, i] _[1]

(n : ℕ)
(i a b : Fin (n + 1))
(hab : a ≤ b)
(H : 3 ≤ n)

(↑(SSet.horn.edge₃ n i a b hab H)).down = SimplexCategory.Hom.mk { toFun := ![a, b], monotone' := ⋯ }


@[gcongr]
theorem logb_le_logb_of_le (h : 0 < x) (hxy : x ≤ y) : logb b x ≤ logb b y


@[simp] theorem truncate_truncate_of_le (x : BitVec w) (h : k ≤ l) :
    (x.truncate l).truncate k = x.truncate k

{w k l : Nat}
(x : BitVec w)
(h : k ≤ l)

BitVec.truncate k (BitVec.truncate l x) = BitVec.truncate k x


theorem isOrtho_def {B : BilinForm R M} {x y : M} : B.IsOrtho x y ↔ B x y = 0

{R : Type u_1}
{M : Type u_2}
[CommSemiring R]
[AddCommMonoid M]
[Module R M]
{B : LinearMap.BilinForm R M}
{x y : M}


lemma bodd_eq_one_and_ne_zero : ∀ n, bodd n = (1 &&& n != 0)


@[simp]
theorem mem_fixedPoints : x ∈ fixedPoints f ↔ IsFixedPt f x

x ∈ Function.fixedPoints f ↔ Function.IsFixedPt f x


/-- The `vectorSpan` of coplanar points is finite-dimensional. -/
theorem Coplanar.finiteDimensional_vectorSpan {s : Set P} (h : Coplanar k s) :
    FiniteDimensional k (vectorSpan k s)

{k : Type u_1}
{V : Type u_2}
{P : Type u_3}
[DivisionRing k]
[AddCommGroup V]
[Module k V]
[AffineSpace V P]
{s : Set P}
(h : Coplanar k s)


lemma lift_injective {f : {f : ℤ →+ A // f n = 0}} :
    Injective (lift n f) ↔ ∀ m, f.1 m = 0 → (m : ZMod n) = 0

(n : ℕ)
{A : Type u_2}
[AddGroup A]
{f : { f // f ↑n = 0 }}

Function.Injective ⇑((ZMod.lift n) f) ↔ ∀ (m : ℤ), ↑f m = 0 → ↑m = 0


/-- The `Submodule.LinearDisjoint.rank_inf_le_one_of_commute_of_flat_right`
for commutative rings. -/
theorem rank_inf_le_one_of_flat_right [Module.Flat R N] : Module.rank R ↥(M ⊓ N) ≤ 1

{R : Type u}
{S : Type v}
[CommRing R]
[CommRing S]
[Algebra R S]
{M N : Submodule R S}
(H : M.LinearDisjoint N)
[Module.Flat R ↥N]


theorem gcd_eq_right_iff_dvd : m ∣ n ↔ gcd n m = m


@[simp]
theorem gcd_one_left [NormalizedGCDMonoid α] (a : α) : gcd 1 a = 1

{α : Type u_1}
[CancelCommMonoidWithZero α]
[NormalizedGCDMonoid α]
(a : α)


theorem subsingleton_or_nontrivial_elim {p : Prop} {α : Type u}
    (h₁ : Subsingleton α → p) (h₂ : Nontrivial α → p) : p


@[simp]
theorem ker_inr : ker (inr R M M₂) = ⊥

{R : Type u}
{M : Type v}
{M₂ : Type w}
[Semiring R]
[AddCommMonoid M]
[AddCommMonoid M₂]
[Module R M]
[Module R M₂]

LinearMap.ker (LinearMap.inr R M M₂) = ⊥


theorem isLeast_nth_of_infinite (hf : (setOf p).Infinite) (n : ℕ) :
    IsLeast {i | p i ∧ ∀ k < n, nth p k < i} (nth p n)

{p : ℕ → Prop}
(hf : (setOf p).Infinite)
(n : ℕ)

IsLeast {i | p i ∧ ∀ k < n, Nat.nth p k < i} (Nat.nth p n)


/-- A Fraïssé class is a nonempty, isomorphism-invariant, essentially countable class of structures
satisfying the hereditary, joint embedding, and amalgamation properties. -/
class IsFraisse : Prop where
  is_nonempty : K.Nonempty
  FG : ∀ M : Bundled.{w} L.Structure, M ∈ K → Structure.FG L M
  is_equiv_invariant : ∀ M N : Bundled.{w} L.Structure, Nonempty (M ≃[L] N) → (M ∈ K ↔ N ∈ K)
  is_essentially_countable : (Quotient.mk' '' K).Countable
  hereditary : Hereditary K
  jointEmbedding : JointEmbedding K
  amalgamation : Amalgamation K

{K : Set (CategoryTheory.Bundled L.Structure)}

[self : FirstOrder.Language.IsFraisse K]


/-- General fencing theorem for continuous functions with an estimate on the derivative.
Let `f` and `B` be continuous functions on `[a, b]` such that

* `f a ≤ B a`;
* `B` has right derivative `B'` at every point of `[a, b)`;
* `f` has right derivative `f'` at every point of `[a, b)`;
* we have `f' x < B' x` whenever `f x = B x`.

Then `f x ≤ B x` everywhere on `[a, b]`. -/
theorem image_le_of_deriv_right_lt_deriv_boundary' {f f' : ℝ → ℝ} {a b : ℝ}
    (hf : ContinuousOn f (Icc a b)) (hf' : ∀ x ∈ Ico a b, HasDerivWithinAt f (f' x) (Ici x) x)
    {B B' : ℝ → ℝ} (ha : f a ≤ B a) (hB : ContinuousOn B (Icc a b))
    (hB' : ∀ x ∈ Ico a b, HasDerivWithinAt B (B' x) (Ici x) x)
    (bound : ∀ x ∈ Ico a b, f x = B x → f' x < B' x) : ∀ ⦃x⦄, x ∈ Icc a b → f x ≤ B x

(hf' : ∀ x ∈ Set.Ico a b, HasDerivWithinAt f (f' x) (Set.Ici x) x)

(hB' : ∀ x ∈ Set.Ico a b, HasDerivWithinAt B (B' x) (Set.Ici x) x)

(bound : ∀ x ∈ Set.Ico a b, f x = B x → f' x < B' x)


/-- The Hausdorff distance satisfies the triangle inequality. -/
theorem hausdorffDist_triangle (fin : hausdorffEdist s t ≠ ⊤) :
    hausdorffDist s u ≤ hausdorffDist s t + hausdorffDist t u

{α : Type u}
[PseudoMetricSpace α]
{s t u : Set α}
(fin : EMetric.hausdorffEdist s t ≠ ⊤)

Metric.hausdorffDist s u ≤ Metric.hausdorffDist s t + Metric.hausdorffDist t u


/-- On non-dependent functions, `Pi.mulSingle` is symmetric in the two indices. -/
@[to_additive "On non-dependent functions, `Pi.single` is symmetric in the two indices."]
theorem mulSingle_comm [One β] (i : I) (x : β) (i' : I) :
    (mulSingle i x : I → β) i' = (mulSingle i' x : I → β) i

{I : Type u}
{β : Type u_2}
[DecidableEq I]
[Zero β]
(i : I)
(x : β)
(i' : I)


@[simp, reassoc]
lemma mapBifunctorLeftUnitorCofan_inj (j : J) :
    (mapBifunctorLeftUnitorCofan F X e p hp Y j).inj ⟨⟨0, j⟩, hp j⟩ =
      (F.map (singleObjApplyIso (0 : I) X).hom).app (Y j) ≫ e.hom.app (Y j)

(F : CategoryTheory.Functor C (CategoryTheory.Functor D D))

(e : F.obj X ≅ CategoryTheory.Functor.id D)

[(Y : D) → CategoryTheory.Limits.PreservesColimit (CategoryTheory.Functor.empty C) (F.flip.obj Y)]

CategoryTheory.Limits.Cofan.inj (CategoryTheory.GradedObject.mapBifunctorLeftUnitorCofan F X e p hp Y j) ⟨(0, j), ⋯⟩ =
  CategoryTheory.CategoryStruct.comp ((F.map (CategoryTheory.GradedObject.singleObjApplyIso 0 X).hom).app (Y j))
    (e.hom.app (Y j))


lemma differentiableOn_rpow_const (p : ℝ) :
    DifferentiableOn ℝ (fun x => (x : ℝ) ^ p) {0}ᶜ

DifferentiableOn ℝ (fun x => x ^ p) {0}ᶜ


theorem or_eq_of_eq_false_left {a b : Prop} (h : a = False) : (a ∨ b) = b


theorem Monotone.intervalIntegrable {u : ℝ → E} {a b : ℝ} (hu : Monotone u) :
    IntervalIntegrable u μ a b


theorem integrable_congr' {f : α → β} {g : α → γ} (hf : AEStronglyMeasurable f μ)
    (hg : AEStronglyMeasurable g μ) (h : ∀ᵐ a ∂μ, ‖f a‖ = ‖g a‖) :
    Integrable f μ ↔ Integrable g μ

(hf : MeasureTheory.AEStronglyMeasurable f μ)

(hg : MeasureTheory.AEStronglyMeasurable g μ)

MeasureTheory.Integrable f μ ↔ MeasureTheory.Integrable g μ


@[simp]
theorem mem_map {f : R →+* S} {s : Subring R} {y : S} : y ∈ s.map f ↔ ∃ x ∈ s, f x = y

{R : Type u}
{S : Type v}
[Ring R]
[Ring S]
{f : R →+* S}
{s : Subring R}
{y : S}


theorem Infinite.exists_ne_map_eq_of_mapsTo {s : Set α} {t : Set β} {f : α → β} (hs : s.Infinite)
    (hf : MapsTo f s t) (ht : t.Finite) : ∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ f x = f y

{α : Type u}
{β : Type v}
{s : Set α}
{t : Set β}
{f : α → β}
(hs : s.Infinite)
(hf : Set.MapsTo f s t)
(ht : t.Finite)


theorem xz_sub {m n} (h : n ≤ m) :
    xz a1 (m - n) = xz a1 m * xz a1 n - d a1 * yz a1 m * yz a1 n

Pell.xz a1 (m - n) = Pell.xz a1 m * Pell.xz a1 n - ↑(Pell.d a1) * Pell.yz a1 m * Pell.yz a1 n


theorem apply_lt_nfpFamily (H : ∀ i, IsNormal (f i)) {a b} (hb : b < nfpFamily.{u, v} f a) (i) :
    f i b < nfpFamily.{u, v} f a

{f : ι → Ordinal.{max u v} → Ordinal.{max u v}}


theorem prodXSubSMul.eval (x : R) : (prodXSubSMul G R x).eval x = 0

(G : Type u_2)
[Group G]
[Fintype G]
(R : Type u_3)
[CommRing R]
[MulSemiringAction G R]
(x : R)

Polynomial.eval x (prodXSubSMul G R x) = 0


theorem variance_mul (c : ℝ) (X : Ω → ℝ) (μ : Measure Ω) :
    variance (fun ω => c * X ω) μ = c ^ 2 * variance X μ

{Ω : Type u_1}
{m : MeasurableSpace Ω}
(c : ℝ)
(X : Ω → ℝ)
(μ : MeasureTheory.Measure Ω)

ProbabilityTheory.variance (fun ω => c * X ω) μ = c ^ 2 * ProbabilityTheory.variance X μ


theorem dedup_sym2 [DecidableEq α] (m : Multiset α) : m.sym2.dedup = m.dedup.sym2

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


/-- If `K / E / F` is a field extension tower, such that `E / F` is purely inseparable, then
for any subset `S` of `K` such that `F(S) / F` is algebraic, the `E(S) / E` and `F(S) / F` have
the same separable degree. -/
theorem IntermediateField.sepDegree_adjoin_eq_of_isAlgebraic_of_isPurelyInseparable
    (S : Set K) [Algebra.IsAlgebraic F (adjoin F S)] [IsPurelyInseparable F E] :
    sepDegree E (adjoin E S) = sepDegree F (adjoin F S)

[Algebra.IsAlgebraic F ↥(IntermediateField.adjoin F S)]

Field.sepDegree E ↥(IntermediateField.adjoin E S) = Field.sepDegree F ↥(IntermediateField.adjoin F S)


@[simp]
theorem le_map_inv_iff (f : F) {a : α} {b : β} : a ≤ EquivLike.inv f b ↔ f a ≤ b

{F : Type u_1}
{α : Type u_2}
{β : Type u_3}
[LE α]
[LE β]
[EquivLike F α β]
[OrderIsoClass F α β]
(f : F)
{a : α}
{b : β}


/-- When `S₁.f`, `S₁.g`, `S₂.f` and `S₂.g` are all zero, the action on right homology of a
morphism `φ : S₁ ⟶ S₂` is given by the action `φ.τ₂` on the middle objects. -/
@[simps]
def ofZeros (φ : S₁ ⟶ S₂) (hf₁ : S₁.f = 0) (hg₁ : S₁.g = 0) (hf₂ : S₂.f = 0) (hg₂ : S₂.g = 0) :
    RightHomologyMapData φ (RightHomologyData.ofZeros S₁ hf₁ hg₁)
    (RightHomologyData.ofZeros S₂ hf₂ hg₂)

(CategoryTheory.ShortComplex.RightHomologyMapData.ofZeros φ hf₁ hg₁ hf₂ hg₂).φQ = φ.τ₂


protected theorem Tendsto.mul_const {f : Filter α} {m : α → ℝ≥0∞} {a b : ℝ≥0∞}
    (hm : Tendsto m f (𝓝 a)) (ha : a ≠ 0 ∨ b ≠ ∞) : Tendsto (fun x => m x * b) f (𝓝 (a * b))

{α : Type u_1}
{f : Filter α}
{m : α → ℝ≥0∞}
{a b : ℝ≥0∞}
(hm : Filter.Tendsto m f (𝓝 a))
(ha : a ≠ 0 ∨ b ≠ ⊤)

Filter.Tendsto (fun x => m x * b) f (𝓝 (a * b))


/-- If `α` has no zero divisors, then the product of two elements equals zero iff one of them
equals zero. -/
@[simp]
theorem mul_eq_zero : a * b = 0 ↔ a = 0 ∨ b = 0

{M₀ : Type u_1}
[MulZeroClass M₀]
[NoZeroDivisors M₀]
{a b : M₀}


@[simp] lemma pi_nil (t : ∀ i, List (α i)) :
    pi [] t = [Pi.nil α]

{ι : Type u_1}
[DecidableEq ι]
{α : ι → Type u_2}
(t : (i : ι) → List (α i))


lemma Pi.uniformContinuous_restrict (S : Set ι) :
    UniformContinuous (S.restrict : (∀ i : ι, α i) → (∀ i : S, α i))

{ι : Type u_1}
(α : ι → Type u)
[U : (i : ι) → UniformSpace (α i)]
(S : Set ι)


theorem lTensor_mul (f g : Module.End R N) : (f * g).lTensor M = f.lTensor M * g.lTensor M

{R : Type u_1}
[CommSemiring R]
(M : Type u_4)
{N : Type u_5}
[AddCommMonoid M]
[AddCommMonoid N]
[Module R M]
[Module R N]
(f g : Module.End R N)

LinearMap.lTensor M (f * g) = LinearMap.lTensor M f * LinearMap.lTensor M g


/-- An alternative statement of Weierstrass' theorem,
for those who like their epsilons.

Every real-valued continuous function on `[a,b]` is within any `ε > 0` of some polynomial.
-/
theorem exists_polynomial_near_continuousMap (a b : ℝ) (f : C(Set.Icc a b, ℝ)) (ε : ℝ)
    (pos : 0 < ε) : ∃ p : ℝ[X], ‖p.toContinuousMapOn _ - f‖ < ε

(a b : ℝ)
(f : C(↑(Set.Icc a b), ℝ))
(ε : ℝ)
(pos : 0 < ε)

∃ p, ‖p.toContinuousMapOn (Set.Icc a b) - f‖ < ε


lemma coeSubmodule_differentIdeal_fractionRing
    [NoZeroSMulDivisors A B] [Algebra.IsIntegral A B]
    [Algebra.IsSeparable (FractionRing A) (FractionRing B)]
    [FiniteDimensional (FractionRing A) (FractionRing B)] :
    coeSubmodule (FractionRing B) (differentIdeal A B) =
      1 / Submodule.traceDual A (FractionRing A) 1

IsLocalization.coeSubmodule (FractionRing B) (differentIdeal A B) = 1 / Submodule.traceDual A (FractionRing A) 1


theorem sigmaUnique_apply {β : α → Type*} [∀ a, Unique (β a)] (x : (a : α) × β a) :
    sigmaUnique α β x = x.1

{α : Type u_2}
{β : α → Type u_1}
[(a : α) → Unique (β a)]
(x : (a : α) × β a)


theorem map_mem_edgeSet {e : Sym2 V} (h : e ∈ G.edgeSet) : e.map f ∈ G'.edgeSet

{V : Type u_1}
{W : Type u_2}
{G : SimpleGraph V}
{G' : SimpleGraph W}
(f : G →g G')
{e : Sym2 V}
(h : e ∈ G.edgeSet)


theorem baseChangeAux_surj {σ : Type*} {f : MvPolynomial σ R →ₐ[R] A} (hf : Function.Surjective f) :
    Function.Surjective (Algebra.TensorProduct.map (AlgHom.id B B) f)

{R : Type w₁}
[CommRing R]
{A : Type w₂}
[CommRing A]
[Algebra R A]
(B : Type w₃)
[CommRing B]
[Algebra R B]
{σ : Type u_1}
{f : MvPolynomial σ R →ₐ[R] A}
(hf : Function.Surjective ⇑f)

Function.Surjective ⇑(Algebra.TensorProduct.map (AlgHom.id B B) f)


theorem trans_symm_eq_symm_trans_symm : (e.trans e').symm = e'.symm.trans e.symm

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
(e : PartialEquiv α β)
(e' : PartialEquiv β γ)


theorem sdiff_sdiff_self_left (s t : Finset α) : s \ (s \ t) = s ∩ t

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


lemma Basis.basis_closure_right (h : M.Basis I X) : M.Basis I (M.closure X)

{α : Type u_2}
{M : Matroid α}
{X I : Set α}
(h : M.Basis I X)


@[simp]
theorem symm_preimage_preimage {α β} (e : α ≃ β) (s : Set β) : e.symm ⁻¹' (e ⁻¹' s) = s

{α : Type u_1}
{β : Type u_2}
(e : α ≃ β)
(s : Set β)


@[reassoc (attr := simp, elementwise)]
lemma moduleCatCyclesIso_inv_iCycles :
    S.moduleCatCyclesIso.inv ≫ S.iCycles = (LinearMap.ker S.g).subtype

(S : CategoryTheory.ShortComplex (ModuleCat R))

CategoryTheory.CategoryStruct.comp S.moduleCatCyclesIso.inv S.iCycles = (LinearMap.ker S.g).subtype


theorem map_ofFunction_le {β} (f : α → β) :
    map f (OuterMeasure.ofFunction m m_empty) ≤
      OuterMeasure.ofFunction (fun s => m (f ⁻¹' s)) m_empty

{α : Type u_1}
{m : Set α → ℝ≥0∞}
{m_empty : m ∅ = 0}
{β : Type u_2}
(f : α → β)

(MeasureTheory.OuterMeasure.map f) (MeasureTheory.OuterMeasure.ofFunction m m_empty) ≤
  MeasureTheory.OuterMeasure.ofFunction (fun s => m (f ⁻¹' s)) m_empty


@[to_additive]
theorem comap_strictMono_of_surjective : StrictMono (comap f)

{M : Type u_1}
{N : Type u_2}
[Add M]
[Add N]
{f : AddHom M N}
(hf : Function.Surjective ⇑f)


/-- Flipping a square by switching the top-right and the bottom-left objects. -/
@[simps]
def flip (sq : Square C) : Square C

{C : Type u}
[CategoryTheory.Category.{v, u} C]
(sq : CategoryTheory.Square C)


@[simp]
theorem to_ofList (l : List (Lists α)) : toList (ofList l) = l


@[simp] theorem up_sup [Sup α] (a b : α) : up (a ⊔ b) = up a ⊔ up b

{ down := a ⊔ b } = { down := a } ⊔ { down := b }


@[to_additive]
theorem elim_div_div [Div γ] : Sum.elim (a / a') (b / b') = Sum.elim a b / Sum.elim a' b'

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
(a a' : α → γ)
(b b' : β → γ)
[Sub γ]

Sum.elim (a - a') (b - b') = Sum.elim a b - Sum.elim a' b'


/-- If, for all `x` in a set `s`, one has frequently `ρ a / μ a < p`, then `ρ s ≤ p * μ s`, as
proved in `measure_le_of_frequently_le`. Since `ρ a / μ a` tends almost everywhere to
`v.limRatioMeas hρ x`, the same property holds for sets `s` on which `v.limRatioMeas hρ < p`. -/
theorem measure_le_mul_of_subset_limRatioMeas_lt {p : ℝ≥0} {s : Set α}
    (h : s ⊆ {x | v.limRatioMeas hρ x < p}) : ρ s ≤ p * μ s

(hρ : ρ ≪ μ)

(h : s ⊆ {x | v.limRatioMeas hρ x < ↑p})

ρ s ≤ ↑p * μ s


theorem mem_rat_span_latticeBasis (x : K) :
    mixedEmbedding K x ∈ Submodule.span ℚ (Set.range (latticeBasis K))

(K : Type u_1)
[Field K]
[NumberField K]
(x : K)

(NumberField.mixedEmbedding K) x ∈ Submodule.span ℚ (Set.range ⇑(NumberField.mixedEmbedding.latticeBasis K))


theorem fst_of_isColimit {X Y : C} {t : BinaryBicone X Y} (ht : IsColimit t.toCocone) :
    t.fst = ht.desc (BinaryCofan.mk (𝟙 X) 0)

{t : CategoryTheory.Limits.BinaryBicone X Y}

(ht : CategoryTheory.Limits.IsColimit t.toCocone)

t.fst = ht.desc (CategoryTheory.Limits.BinaryCofan.mk (𝟙 X) 0)


@[simp, fun_prop]
theorem DifferentiableAt.mul (ha : DifferentiableAt 𝕜 a x) (hb : DifferentiableAt 𝕜 b x) :
    DifferentiableAt 𝕜 (fun y => a y * b y) x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{x : E}
{𝔸 : Type u_6}
[NormedRing 𝔸]
[NormedAlgebra 𝕜 𝔸]
{a b : E → 𝔸}
(ha : DifferentiableAt 𝕜 a x)
(hb : DifferentiableAt 𝕜 b x)


@[fun_prop]
theorem IsBoundedLinearMap.differentiableWithinAt (h : IsBoundedLinearMap 𝕜 f) :
    DifferentiableWithinAt 𝕜 f s x

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


theorem image₂_subset_left (ht : t ⊆ t') : image₂ f s t ⊆ image₂ f s t'

{α : Type u_1}
{β : Type u_3}
{γ : Type u_5}
[DecidableEq γ]
{f : α → β → γ}
{s : Finset α}
{t t' : Finset β}
(ht : t ⊆ t')

Finset.image₂ f s t ⊆ Finset.image₂ f s t'


/-- Isomorphic `PresheafedSpace`s have naturally isomorphic presheaves. -/
@[simps]
def sheafIsoOfIso (H : X ≅ Y) : Y.2 ≅ H.hom.base _* X.2

{X Y : AlgebraicGeometry.PresheafedSpace C}

(AlgebraicGeometry.PresheafedSpace.sheafIsoOfIso H).hom = H.hom.c


@[simp] theorem eq_true_eq_id : Eq True = id


theorem singleton_iff_unique_mem (s : Finset α) : (∃ a, s = {a}) ↔ ∃! a, a ∈ s


theorem Finite.card_pos_iff [Finite α] : 0 < Nat.card α ↔ Nonempty α


@[simp] protected theorem UInt64.sizeOf (a : UInt64) : sizeOf a = a.toNat + 2


theorem ofModuleMonoidAlgebra_obj_coe (M : ModuleCat.{u} (MonoidAlgebra k G)) :
    (ofModuleMonoidAlgebra.obj M : Type u) = RestrictScalars k (MonoidAlgebra k G) M

{k G : Type u}
[CommRing k]
[Monoid G]
(M : ModuleCat (MonoidAlgebra k G))

CoeSort.coe (Rep.ofModuleMonoidAlgebra.obj M) = RestrictScalars k (MonoidAlgebra k G) ↑M


theorem first_den_eq {gp : Pair K} (zeroth_s_eq : g.s.get? 0 = some gp) :
    g.dens 1 = gp.b

{K : Type u_1}
{g : GenContFract K}
[DivisionRing K]
{gp : GenContFract.Pair K}
(zeroth_s_eq : g.s.get? 0 = some gp)


theorem pred_eq_ppred (n : ℕ) : pred n = (ppred n).getD 0


theorem isClosed_iff {s : Set Γ₀} : IsClosed s ↔ (0 : Γ₀) ∈ s ∨ ∃ γ, γ ≠ 0 ∧ s ⊆ Ici γ

{Γ₀ : Type u_2}
[LinearOrderedCommGroupWithZero Γ₀]
{s : Set Γ₀}

IsClosed s ↔ 0 ∈ s ∨ ∃ γ, γ ≠ 0 ∧ s ⊆ Set.Ici γ


lemma ContinuousWithinAt.finset_sup'_apply (hne : s.Nonempty)
    (hs : ∀ i ∈ s, ContinuousWithinAt (f i) t x) :
    ContinuousWithinAt (fun a ↦ s.sup' hne (f · a)) t x

ContinuousWithinAt (fun a => s.sup' hne fun x => f x a) t x


theorem max_left_comm : ∀ a b c : α, max a (max b c) = max b (max a c)

{α : Type u}
[LinearOrder α]
(a b c : α)


theorem eval₂_comp_right {S₂} [CommSemiring S₂] (k : S₁ →+* S₂) (f : R →+* S₁) (g : σ → S₁) (p) :
    k (eval₂ f g p) = eval₂ k (k ∘ g) (map f p)

{R : Type u}
{S₁ : Type v}
{σ : Type u_1}
[CommSemiring R]
[CommSemiring S₁]
{S₂ : Type u_2}
[CommSemiring S₂]
(k : S₁ →+* S₂)
(f : R →+* S₁)
(g : σ → S₁)
(p : MvPolynomial σ R)

k (MvPolynomial.eval₂ f g p) = MvPolynomial.eval₂ k (⇑k ∘ g) ((MvPolynomial.map f) p)


@[simp]
theorem toDual_sup [SemilatticeSup α] [OrderBot α] (s : Finset β) (f : β → α) :
    toDual (s.sup f) = s.inf (toDual ∘ f)

{α : Type u_2}
{β : Type u_3}
[SemilatticeSup α]
[OrderBot α]
(s : Finset β)
(f : β → α)

OrderDual.toDual (s.sup f) = s.inf (⇑OrderDual.toDual ∘ f)


@[elab_as_elim]
theorem case_strongInductionOn {p : Multiset α → Prop} (s : Multiset α) (h₀ : p 0)
    (h₁ : ∀ a s, (∀ t ≤ s, p t) → p (a ::ₘ s)) : p s

(h₁ : ∀ (a : α) (s : Multiset α), (∀ t ≤ s, p t) → p (a ::ₘ s))


theorem coe_cons_eq_coe_append (l : List α) (a : α) :
    (↑(a :: l) : Cycle α) = (↑(l ++ [a]) : Cycle α)


theorem setToL1S_smul_real (T : Set α → E →L[ℝ] F)
    (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0) (h_add : FinMeasAdditive μ T) (c : ℝ)
    (f : α →₁ₛ[μ] E) : setToL1S T (c • f) = c • setToL1S T f

(h_zero : ∀ (s : Set α), MeasurableSet s → μ s = 0 → T s = 0)

(h_add : MeasureTheory.FinMeasAdditive μ T)

(f : ↥(MeasureTheory.Lp.simpleFunc E 1 μ))

MeasureTheory.L1.SimpleFunc.setToL1S T (c • f) = c • MeasureTheory.L1.SimpleFunc.setToL1S T f


@[simp]
theorem pullbackConeOfRightIso_π_app_right : (pullbackConeOfRightIso f g).π.app right = f ≫ inv g

{C : Type u}
[CategoryTheory.Category.{v, u} C]
{X Y Z : C}
(f : X ⟶ Z)
(g : Y ⟶ Z)
[CategoryTheory.IsIso g]

(CategoryTheory.Limits.pullbackConeOfRightIso f g).π.app CategoryTheory.Limits.WalkingCospan.right =
  f ≫ CategoryTheory.inv g


theorem unbounded_ge_iff [LinearOrder α] : Unbounded (· ≥ ·) s ↔ ∀ a, ∃ b ∈ s, b < a

{α : Type u_1}
{s : Set α}
[LinearOrder α]

Set.Unbounded (fun x x_1 => x ≥ x_1) s ↔ ∀ (a : α), ∃ b ∈ s, b < a


theorem le_nhdsAdjoint_iff' {a : α} {f : Filter α} {t : TopologicalSpace α} :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b ≠ a, @nhds α t b = pure b

{α : Type u}
{a : α}
{f : Filter α}
{t : TopologicalSpace α}

t ≤ nhdsAdjoint a f ↔ 𝓝 a ≤ pure a ⊔ f ∧ ∀ (b : α), b ≠ a → 𝓝 b = pure b


theorem integrallyClosed : IsIntegrallyClosed A

{A : Type u_2}
[CommRing A]
[IsDomain A]
(h : IsDedekindDomainInv A)


@[simp]
theorem mem_circle_iff_abs {z : ℂ} : z ∈ circle ↔ abs z = 1


@[simp] lemma ofENat_lt_nat {m : ℕ∞} {n : ℕ} : ofENat m < n ↔ m < n


theorem ofLE_continuous (h : A ≤ B) : Continuous (ofLE h)

{X : Type u_2}
[TopologicalSpace X]
{A B : DiscreteQuotient X}
(h : A ≤ B)


theorem ClosedEmbedding.paracompactSpace [ParacompactSpace Y] {e : X → Y} (he : ClosedEmbedding e) :
    ParacompactSpace X

{X : Type v}
{Y : Type w}
[TopologicalSpace X]
[TopologicalSpace Y]
[ParacompactSpace Y]
{e : X → Y}
(he : ClosedEmbedding e)


/-- If `0 < n`, then `DihedralGroup n` has `2n` elements.
-/
theorem card [NeZero n] : Fintype.card (DihedralGroup n) = 2 * n


@[simp] theorem pos_add_char (p : Pos) (c : Char) : (p + c).byteIdx = p.byteIdx + c.utf8Size


/-- Right scalar multiplication as an order isomorphism. -/
@[simps!]
def OrderIso.smulRight [PosSMulMono α β] [PosSMulReflectLE α β] {a : α} (ha : 0 < a) : β ≃o β

{α : Type u_1}
{β : Type u_2}
[GroupWithZero α]
[Preorder α]
[Preorder β]
[MulAction α β]
[PosSMulMono α β]
[PosSMulReflectLE α β]
{a : α}
(ha : 0 < a)
(b : β)

(RelIso.symm (OrderIso.smulRight ha)) b = a⁻¹ • b


/-- A verbose specialization of `threeAPFree.le_addRothNumber`, sometimes convenient in
practice. -/
theorem ThreeAPFree.le_rothNumberNat (s : Finset ℕ) (hs : ThreeAPFree (s : Set ℕ))
    (hsn : ∀ x ∈ s, x < n) (hsk : s.card = k) : k ≤ rothNumberNat n

{k n : ℕ}
(s : Finset ℕ)
(hs : ThreeAPFree ↑s)
(hsn : ∀ x ∈ s, x < n)
(hsk : s.card = k)


@[simp]
theorem trans_apply (e : P₁ ≃ᵃL[k] P₂) (e' : P₂ ≃ᵃL[k] P₃) (p : P₁) : e.trans e' p = e' (e p)

{k : Type u_1}
{P₁ : Type u_2}
{P₂ : Type u_3}
{P₃ : Type u_4}
{V₁ : Type u_6}
{V₂ : Type u_7}
{V₃ : Type u_8}
[Ring k]
[AddCommGroup V₁]
[Module k V₁]
[AddTorsor V₁ P₁]
[AddCommGroup V₂]
[Module k V₂]
[AddTorsor V₂ P₂]
[AddCommGroup V₃]
[Module k V₃]
[AddTorsor V₃ P₃]
[TopologicalSpace P₁]
[TopologicalSpace P₂]
[TopologicalSpace P₃]
(e : P₁ ≃ᵃL[k] P₂)
(e' : P₂ ≃ᵃL[k] P₃)
(p : P₁)


@[deprecated shiftLeft_add (since := "2024-06-02")]
theorem shiftLeft_shiftLeft {w : Nat} (x : BitVec w) (n m : Nat) :
    (x <<< n) <<< m = x <<< (n + m)


protected theorem differentiableAt : DifferentiableAt 𝕜 f x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
(f : 𝕜 →ᵃ[𝕜] E)
{x : 𝕜}


@[simp]
theorem cancel_left {g : CompleteLatticeHom β γ} {f₁ f₂ : CompleteLatticeHom α β}
    (hg : Injective g) : g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

{α : Type u_2}
{β : Type u_3}
{γ : Type u_4}
[CompleteLattice α]
[CompleteLattice β]
[CompleteLattice γ]
{g : CompleteLatticeHom β γ}
{f₁ f₂ : CompleteLatticeHom α β}
(hg : Function.Injective ⇑g)


theorem UInt16.ext_iff {x y : UInt16} : x = y ↔ x.toNat = y.toNat


@[simp]
lemma Fin.nndist_insertNth_insertNth {n : ℕ} {α : Fin (n + 1) → Type*}
    [∀ i, PseudoMetricSpace (α i)] (i : Fin (n + 1)) (x y : α i) (f g : ∀ j, α (i.succAbove j)) :
    nndist (i.insertNth x f) (i.insertNth y g) = max (nndist x y) (nndist f g)

[(i : Fin (n + 1)) → PseudoMetricSpace (α i)]


@[simp]
theorem top_prod_top : (⊤ : LowerSet α) ×ˢ (⊤ : LowerSet β) = ⊤

{α : Type u_1}
{β : Type u_2}
[Preorder α]
[Preorder β]


theorem iUnion_Ioc_intCast : ⋃ n : ℤ, Ioc (n : α) (n + 1) = Set.univ

(α : Type u_1)
[LinearOrderedRing α]
[Archimedean α]


theorem inter' (i : Fin N.succ) : dist (a.c i) (a.c (last N)) ≤ a.r i + a.r (last N)

{α : Type u_1}
[MetricSpace α]
{N : ℕ}
{τ : ℝ}
(a : Besicovitch.SatelliteConfig α N τ)
(i : Fin N.succ)

dist (a.c i) (a.c (Fin.last N)) ≤ a.r i + a.r (Fin.last N)


@[simp]
theorem cgf_zero_measure : cgf X (0 : Measure Ω) t = 0

{Ω : Type u_1}
{m : MeasurableSpace Ω}
{X : Ω → ℝ}
{t : ℝ}


theorem rotate_injective (n : ℕ) : Function.Injective fun l : List α => l.rotate n


@[simp]
theorem starₗᵢ_toContinuousLinearEquiv :
    (starₗᵢ 𝕜 : E ≃ₗᵢ⋆[𝕜] E).toContinuousLinearEquiv = (starL 𝕜 : E ≃L⋆[𝕜] E)

{𝕜 : Type u_1}
{E : Type u_2}
[CommSemiring 𝕜]
[StarRing 𝕜]
[SeminormedAddCommGroup E]
[StarAddMonoid E]
[NormedStarGroup E]
[Module 𝕜 E]
[StarModule 𝕜 E]

(starₗᵢ 𝕜).toContinuousLinearEquiv = starL 𝕜


theorem measure_diff_le_iff_le_add (hs : MeasurableSet s) (hst : s ⊆ t) (hs' : μ s ≠ ∞) {ε : ℝ≥0∞} :
    μ (t \ s) ≤ ε ↔ μ t ≤ μ s + ε

{α : Type u_1}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{s t : Set α}
(hs : MeasurableSet s)
(hst : s ⊆ t)
(hs' : μ s ≠ ⊤)
{ε : ENNReal}

μ (t \ s) ≤ ε ↔ μ t ≤ μ s + ε


/-- The natural cocone over the forgetful functor `Over X ⥤ T` with cocone point `X`. -/
@[simps]
def forgetCocone (X : T) : Limits.Cocone (forget X)

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

(CategoryTheory.Over.forgetCocone X).pt = X


theorem val_injective : Injective (val : Finset α → Multiset α)


theorem Iff.not_left (h : a ↔ ¬b) : ¬a ↔ b


@[simp]
theorem pair_mk_mk (f : α → β) (hf) (g : α → γ) (hg) :
    (mk f hf : α →ₘ[μ] β).pair (mk g hg) = mk (fun x => (f x, g x)) (hf.prod_mk hg)

(hf : MeasureTheory.AEStronglyMeasurable f μ)

(hg : MeasureTheory.AEStronglyMeasurable g μ)

(MeasureTheory.AEEqFun.mk f hf).pair (MeasureTheory.AEEqFun.mk g hg) = MeasureTheory.AEEqFun.mk (fun x => (f x, g x)) ⋯


@[fun_prop]
theorem hasFDerivAt_of_restrictScalars {g' : E →L[𝕜] F} (h : HasFDerivAt f g' x)
    (H : f'.restrictScalars 𝕜 = g') : HasFDerivAt f f' x

(H : ContinuousLinearMap.restrictScalars 𝕜 f' = g')


theorem exists_nhds_ne_neBot (X : Type*) [TopologicalSpace X] [CompactSpace X] [Infinite X] :
    ∃ z : X, (𝓝[≠] z).NeBot

(X : Type u_2)
[TopologicalSpace X]
[CompactSpace X]
[Infinite X]


theorem flag_succ (b : Basis (Fin n) R M) (k : Fin n) :
    b.flag k.succ = (R ∙ b k) ⊔ b.flag k.castSucc

{R : Type u_1}
{M : Type u_2}
[Semiring R]
[AddCommMonoid M]
[Module R M]
{n : ℕ}
(b : Basis (Fin n) R M)
(k : Fin n)

b.flag k.succ = Submodule.span R {b k} ⊔ b.flag k.castSucc


theorem genericPoint_eq_of_isOpenImmersion {X Y : Scheme} (f : X ⟶ Y) [H : IsOpenImmersion f]
    [hX : IrreducibleSpace X] [IrreducibleSpace Y] :
    f.1.base (genericPoint X) = genericPoint Y

[H : AlgebraicGeometry.IsOpenImmersion f]

[hX : IrreducibleSpace ↑↑X.toPresheafedSpace]

f.val.base (genericPoint ↑↑X.toPresheafedSpace) = genericPoint ↑↑Y.toPresheafedSpace


@[to_additive (attr := simp)]
theorem inv_lt_inv_iff : a⁻¹ < b⁻¹ ↔ b < a

[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]


/-- Characterize the boundedness of a set in terms of the finiteness of its emetric.diameter. -/
theorem isBounded_iff_ediam_ne_top : IsBounded s ↔ EMetric.diam s ≠ ⊤

{α : Type u}
[PseudoMetricSpace α]
{s : Set α}

Bornology.IsBounded s ↔ EMetric.diam s ≠ ⊤


/-- Each element of the group defines an additive monoid isomorphism.

This is a stronger version of `MulAction.toPermHom`. -/
@[simps]
def DistribMulAction.toAddAut : α →* AddAut β

(α : Type u)
(β : Type v)
[Group α]
[AddMonoid β]
[DistribMulAction α β]
(x : α)

(DistribMulAction.toAddAut α β) x = DistribMulAction.toAddEquiv β x


/-- Let `X` be a metric space. Let `K : ι → Set X` be a locally finite family of closed sets, let
`U : ι → Set X` be a family of open sets such that `K i ⊆ U i` for all `i`. Then there exists a
positive continuous function `δ : C(X, ℝ≥0)` such that for any `i` and `x ∈ K i`, we have
`Metric.closedBall x (δ x) ⊆ U i`. -/
theorem exists_continuous_nnreal_forall_closedBall_subset (hK : ∀ i, IsClosed (K i))
    (hU : ∀ i, IsOpen (U i)) (hKU : ∀ i, K i ⊆ U i) (hfin : LocallyFinite K) :
    ∃ δ : C(X, ℝ≥0), (∀ x, 0 < δ x) ∧ ∀ (i), ∀ x ∈ K i, closedBall x (δ x) ⊆ U i

{ι : Type u_1}
{X : Type u_2}
[MetricSpace X]
{K U : ι → Set X}
(hK : ∀ (i : ι), IsClosed (K i))
(hU : ∀ (i : ι), IsOpen (U i))
(hKU : ∀ (i : ι), K i ⊆ U i)
(hfin : LocallyFinite K)

∃ δ, (∀ (x : X), 0 < δ x) ∧ ∀ (i : ι), ∀ x ∈ K i, Metric.closedBall x ↑(δ x) ⊆ U i


@[simp]
theorem symm_trans_self (e : P₁ ≃ᵃ[k] P₂) : e.symm.trans e = refl k P₂

{k : Type u_1}
{P₁ : Type u_2}
{P₂ : Type u_3}
{V₁ : Type u_6}
{V₂ : Type u_7}
[Ring k]
[AddCommGroup V₁]
[Module k V₁]
[AffineSpace V₁ P₁]
[AddCommGroup V₂]
[Module k V₂]
[AffineSpace V₂ P₂]
(e : P₁ ≃ᵃ[k] P₂)


/-- A morphism which is a coequalizer for its kernel pair is an effective epi. -/
theorem effectiveEpiOfKernelPair {B X : C} (f : X ⟶ B) [HasPullback f f]
    (hc : IsColimit (Cofork.ofπ f pullback.condition)) : EffectiveEpi f

(hc : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Cofork.ofπ f ⋯))


theorem Countable.image2 {s : Set α} {t : Set β} (hs : s.Countable) (ht : t.Countable)
    (f : α → β → γ) : (image2 f s t).Countable

{α : Type u}
{β : Type v}
{γ : Type w}
{s : Set α}
{t : Set β}
(hs : s.Countable)
(ht : t.Countable)
(f : α → β → γ)


theorem Monic.add_of_left (hp : Monic p) (hpq : degree q < degree p) : Monic (p + q)

{R : Type u}
[Semiring R]
{p q : R[X]}
(hp : p.Monic)
(hpq : q.degree < p.degree)


theorem exp_eq_tsum_div : exp 𝕂 = fun x : 𝔸 => ∑' n : ℕ, x ^ n / n !

{𝕂 : Type u_1}
{𝔸 : Type u_2}
[Field 𝕂]
[DivisionRing 𝔸]
[Algebra 𝕂 𝔸]
[TopologicalSpace 𝔸]
[TopologicalRing 𝔸]

NormedSpace.exp 𝕂 = fun x => ∑' (n : ℕ), x ^ n / ↑n.factorial


theorem comp₂_toGerm (g : β → γ → δ) (hg : Continuous (uncurry g)) (f₁ : α →ₘ[μ] β)
    (f₂ : α →ₘ[μ] γ) : (comp₂ g hg f₁ f₂).toGerm = f₁.toGerm.map₂ g f₂.toGerm

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
{δ : Type u_4}
[MeasurableSpace α]
{μ : MeasureTheory.Measure α}
[TopologicalSpace β]
[TopologicalSpace γ]
[TopologicalSpace δ]
(g : β → γ → δ)
(hg : Continuous (Function.uncurry g))
(f₁ : α →ₘ[μ] β)
(f₂ : α →ₘ[μ] γ)

(MeasureTheory.AEEqFun.comp₂ g hg f₁ f₂).toGerm = Filter.Germ.map₂ g f₁.toGerm f₂.toGerm


@[to_additive]
theorem TendstoUniformly.div (hf : TendstoUniformly f g l) (hf' : TendstoUniformly f' g' l) :
    TendstoUniformly (f / f') (g / g') l

{α : Type u_1}
{β : Type u_2}
[UniformSpace α]
[Group α]
[UniformGroup α]
{ι : Type u_3}
{l : Filter ι}
{f f' : ι → β → α}
{g g' : β → α}
(hf : TendstoUniformly f g l)
(hf' : TendstoUniformly f' g' l)


@[simp]
theorem eventually_bind {f : Filter α} {m : α → Filter β} {p : β → Prop} :
    (∀ᶠ y in bind f m, p y) ↔ ∀ᶠ x in f, ∀ᶠ y in m x, p y

{α : Type u}
{β : Type v}
{f : Filter α}
{m : α → Filter β}
{p : β → Prop}

(∀ᶠ (y : β) in f.bind m, p y) ↔ ∀ᶠ (x : α) in f, ∀ᶠ (y : β) in m x, p y


@[to_additive]
theorem top_mul_of_one_le (hf : 1 ≤ f) : ⊤ * f = ⊤

{α : Type u_2}
[AddMonoid α]
{f : Filter α}
(hf : 0 ≤ f)


theorem card_fintypeIcc : Fintype.card (Set.Icc a b) = b + 1 - a

Fintype.card ↑(Set.Icc a b) = ↑b + 1 - ↑a


@[to_additive]
theorem norm_div_le_of_le {r₁ r₂ : ℝ} (H₁ : ‖a₁‖ ≤ r₁) (H₂ : ‖a₂‖ ≤ r₂) : ‖a₁ / a₂‖ ≤ r₁ + r₂

{E : Type u_6}
[SeminormedAddGroup E]
{a₁ a₂ : E}
{r₁ r₂ : ℝ}
(H₁ : ‖a₁‖ ≤ r₁)
(H₂ : ‖a₂‖ ≤ r₂)

‖a₁ - a₂‖ ≤ r₁ + r₂


@[reassoc (attr := simp)]
lemma stalkMap_hom_inv (e : X ≅ Y) (y : Y) :
    e.hom.stalkMap (e.inv.val.base y) ≫ e.inv.stalkMap y =
      Y.presheaf.stalkSpecializes (specializes_of_eq <| by simp)

{X Y : AlgebraicGeometry.LocallyRingedSpace}

AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap e.hom (e.inv.val.base y) ≫
    AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap e.inv y =
  Y.presheaf.stalkSpecializes ⋯


@[to_additive add_lt_of_neg_left]
theorem mul_lt_of_lt_one_left' [CovariantClass α α (swap (· * ·)) (· < ·)] (a : α) {b : α}
    (h : b < 1) :
    b * a < a


@[to_additive]
theorem union_mul_inter_subset_union : (s₁ ∪ s₂) * (t₁ ∩ t₂) ⊆ s₁ * t₁ ∪ s₂ * t₂

{α : Type u_2}
[DecidableEq α]
[Add α]
{s₁ s₂ t₁ t₂ : Finset α}


/-- See also `Order.pred_eq_of_covBy`. -/
lemma pred_le_of_wcovBy (h : a ⩿ b) : pred b ≤ a

{α : Type u_1}
[Preorder α]
[PredOrder α]
{a b : α}
(h : a ⩿ b)


theorem col_weak {μ : YoungDiagram} (T : SemistandardYoungTableau μ) {i1 i2 j : ℕ} (hi : i1 ≤ i2)
    (cell : (i2, j) ∈ μ) : T i1 j ≤ T i2 j


theorem indicatorConstLp_eq_toSpanSingleton_compLp {s : Set α} [NormedSpace ℝ F]
    (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (x : F) :
    indicatorConstLp 2 hs hμs x =
      (ContinuousLinearMap.toSpanSingleton ℝ x).compLp (indicatorConstLp 2 hs hμs (1 : ℝ))

{α : Type u_1}
{F : Type u_3}
{m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
[NormedAddCommGroup F]
{s : Set α}
[NormedSpace ℝ F]
(hs : MeasurableSet s)
(hμs : μ s ≠ ⊤)
(x : F)

MeasureTheory.indicatorConstLp 2 hs hμs x =
  (ContinuousLinearMap.toSpanSingleton ℝ x).compLp (MeasureTheory.indicatorConstLp 2 hs hμs 1)


theorem minimals_subset : minimals r s ⊆ s

{α : Type u_1}
(r : α → α → Prop)
(s : Set α)


theorem equiv_symm_apply (x : M) (n : ℕ) (y : K) (h : j y = x ^ p ^ n) :
    (equiv i j p).symm x = (iterateFrobeniusEquiv L p n).symm (i y)

{K : Type u_1}
{L : Type u_2}
{M : Type u_3}
[CommRing K]
[CommRing L]
[CommRing M]
(i : K →+* L)
(j : K →+* M)
(p : ℕ)
[ExpChar K p]
[ExpChar L p]
[ExpChar M p]
[PerfectRing L p]
[IsPerfectClosure i p]
[PerfectRing M p]
[IsPerfectClosure j p]
(x : M)
(n : ℕ)
(y : K)
(h : j y = x ^ p ^ n)

(IsPerfectClosure.equiv i j p).symm x = (iterateFrobeniusEquiv L p n).symm (i y)


@[to_additive] lemma le_iff_oneLePart_leOnePart (a b : α) : a ≤ b ↔ a⁺ᵐ ≤ b⁺ᵐ ∧ b⁻ᵐ ≤ a⁻ᵐ

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

a ≤ b ↔ a⁺ ≤ b⁺ ∧ b⁻ ≤ a⁻


theorem mul_self_eq_one_iff [NonAssocRing R] [NoZeroDivisors R] {a : R} :
    a * a = 1 ↔ a = 1 ∨ a = -1

{R : Type x}
[NonAssocRing R]
[NoZeroDivisors R]
{a : R}


theorem erase_idem (f : α →₀ M) (a : α) :
    erase a (erase a f) = erase a f

{α : Type u_1}
{M : Type u_5}
[Zero M]
(f : α →₀ M)
(a : α)

Finsupp.erase a (Finsupp.erase a f) = Finsupp.erase a f


/-- A semistandard Young tableau is a filling of the cells of a Young diagram by natural
numbers, such that the entries in each row are weakly increasing (left to right), and the entries
in each column are strictly increasing (top to bottom).

Here, a semistandard Young tableau is represented as an unrestricted function `ℕ → ℕ → ℕ` that, for
reasons of extensionality, is required to vanish outside `μ`. -/
structure SemistandardYoungTableau (μ : YoungDiagram) where
  /-- `entry i j` is value of the `(i, j)` entry of the SSYT `μ`. -/
  entry : ℕ → ℕ → ℕ
  /-- The entries in each row are weakly increasing (left to right). -/
  row_weak' : ∀ {i j1 j2 : ℕ}, j1 < j2 → (i, j2) ∈ μ → entry i j1 ≤ entry i j2
  /-- The entries in each column are strictly increasing (top to bottom). -/
  col_strict' : ∀ {i1 i2 j : ℕ}, i1 < i2 → (i2, j) ∈ μ → entry i1 j < entry i2 j
  /-- `entry` is required to be zero for all pairs `(i, j) ∉ μ`. -/
  zeros' : ∀ {i j}, (i, j) ∉ μ → entry i j = 0

{μ : YoungDiagram}
(self : SemistandardYoungTableau μ)
{i j : ℕ}


/-- See also `Module.Dual.eq_of_preReflection_mapsTo'` for a variant of this lemma which
applies when `Φ` does not span.

This rather technical-looking lemma exists because it is exactly what is needed to establish various
uniqueness results for root data / systems. One might regard this lemma as lying at the boundary of
linear algebra and combinatorics since the finiteness assumption is the key. -/
lemma Dual.eq_of_preReflection_mapsTo [CharZero R] [NoZeroSMulDivisors R M]
    {x : M} (hx : x ≠ 0) {Φ : Set M} (hΦ₁ : Φ.Finite) (hΦ₂ : span R Φ = ⊤) {f g : Dual R M}
    (hf₁ : f x = 2) (hf₂ : MapsTo (preReflection x f) Φ Φ)
    (hg₁ : g x = 2) (hg₂ : MapsTo (preReflection x g) Φ Φ) :
    f = g

(hf₂ : Set.MapsTo (⇑(Module.preReflection x f)) Φ Φ)

(hg₂ : Set.MapsTo (⇑(Module.preReflection x g)) Φ Φ)


{α : Type u_1}
[MeasurableSpace α]
(m : MeasureTheory.OuterMeasure α)


theorem card_Ioo : (Ioo f g).card = (∏ i ∈ f.support ∪ g.support, (Icc (f i) (g i)).card) - 2

{ι : Type u_1}
{α : ι → Type u_2}
[DecidableEq ι]
[(i : ι) → DecidableEq (α i)]
[(i : ι) → PartialOrder (α i)]
[(i : ι) → Zero (α i)]
[(i : ι) → LocallyFiniteOrder (α i)]
(f g : Π₀ (i : ι), α i)

(Finset.Ioo f g).card = ∏ i ∈ f.support ∪ g.support, (Finset.Icc (f i) (g i)).card - 2


/-- For `1 < s`, the topological sum of `ZetaAsymptotics.term (n + 1) s` over all `n : ℕ` is
`1 / (s - 1) - ζ s / s`.
-/
lemma term_tsum_of_lt {s : ℝ} (hs : 1 < s) :
    term_tsum s = (1 / (s - 1) - 1 / s * ∑' n : ℕ, 1 / (n + 1 : ℝ) ^ s)

ZetaAsymptotics.term_tsum s = 1 / (s - 1) - 1 / s * ∑' (n : ℕ), 1 / (↑n + 1) ^ s


theorem of_ringEquiv (k' : Type u) [Field k'] (e : k ≃+* k')
    [IsAlgClosed k] : IsAlgClosed k'

(k : Type u)
[Field k]
(k' : Type u)
[Field k']
(e : k ≃+* k')
[IsAlgClosed k]


/-- Transport a monoidal structure along an equivalence of (plain) categories.
-/
@[simps]
def transportStruct (e : C ≌ D) : MonoidalCategoryStruct.{v₂} D

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

λ_ X =
  e.functor.mapIso
      (((e.unitIso.app (𝟙_ C)).symm ⊗ CategoryTheory.Iso.refl (e.inverse.obj X)) ≪≫ λ_ (e.inverse.obj X)) ≪≫
    e.counitIso.app X


lemma of_id_fst : IsPullback (𝟙 _) f f (𝟙 _)

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
{X Z : C}
{f : X ⟶ Z}

CategoryTheory.IsPullback (𝟙 X) f f (𝟙 Z)


lemma Finset.insert_eq_cons {α : Type*} [DecidableEq α] (a : α) (s : Finset α) (h : a ∉ s) :
    insert a s = Finset.cons a s h

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


/-- The localization of a Dedekind domain at every nonzero prime ideal is a Dedekind domain. -/
theorem IsLocalization.AtPrime.isDedekindDomain [IsDedekindDomain A] (P : Ideal A) [P.IsPrime]
    (Aₘ : Type*) [CommRing Aₘ] [IsDomain Aₘ] [Algebra A Aₘ] [IsLocalization.AtPrime Aₘ P] :
    IsDedekindDomain Aₘ

(A : Type u_2)
[CommRing A]
[IsDomain A]
[IsDedekindDomain A]
(P : Ideal A)
[P.IsPrime]
(Aₘ : Type u_4)
[CommRing Aₘ]
[IsDomain Aₘ]
[Algebra A Aₘ]
[IsLocalization.AtPrime Aₘ P]


/-- An atlas member is `C^n` for any `n`. -/
theorem contMDiffOn_of_mem_maximalAtlas (h : e ∈ maximalAtlas I M) : ContMDiffOn I I n e e.source

(h : e ∈ SmoothManifoldWithCorners.maximalAtlas I M)


theorem disjoint_sup_right_of_disjoint_sup_left [Lattice α] [OrderBot α]
    [IsModularLattice α] (h : Disjoint a b) (hsup : Disjoint (a ⊔ b) c) :
    Disjoint a (b ⊔ c)

{α : Type u_1}
{a b c : α}
[Lattice α]
[OrderBot α]
[IsModularLattice α]
(h : Disjoint a b)
(hsup : Disjoint (a ⊔ b) c)


@[simp] theorem decide_not [g : Decidable p] [h : Decidable (Not p)] : decide (Not p) = !(decide p)

{p : Prop}
[g : Decidable p]
[h : Decidable ¬p]


@[to_additive]
theorem singleton_div_ball_one : {x} / ball 1 δ = ball x δ

{E : Type u_1}
[SeminormedCommGroup E]
(δ : ℝ)
(x : E)


@[simp]
theorem coe_sup (s t : Compacts α) : (↑(s ⊔ t) : Set α) = ↑s ∪ ↑t

{α : Type u_1}
[TopologicalSpace α]
(s t : TopologicalSpace.Compacts α)


theorem Filter.Tendsto.bddBelow_range [IsDirected α (· ≥ ·)] {u : ℕ → α}
    (h : Tendsto u atTop (𝓝 a)) : BddBelow (Set.range u)

(h : Filter.Tendsto u Filter.atTop (𝓝 a))


/-- The identity function semiconjugates any function to itself. -/
theorem id_left : Semiconj id ga ga


/-- If `f` is a sequence of functions which converges in measure to `g`, then there exists a
subsequence of `f` which converges a.e. to `g`. -/
theorem TendstoInMeasure.exists_seq_tendsto_ae (hfg : TendstoInMeasure μ f atTop g) :
    ∃ ns : ℕ → ℕ, StrictMono ns ∧ ∀ᵐ x ∂μ, Tendsto (fun i => f (ns i) x) atTop (𝓝 (g x))

(hfg : MeasureTheory.TendstoInMeasure μ f Filter.atTop g)

∃ ns, StrictMono ns ∧ ∀ᵐ (x : α) ∂μ, Filter.Tendsto (fun i => f (ns i) x) Filter.atTop (𝓝 (g x))


protected theorem map_inv (a : Aˣ) : (σ (a : A))⁻¹ = σ (↑a⁻¹ : A)

{𝕜 : Type u}
{A : Type v}
[Field 𝕜]
[Ring A]
[Algebra 𝕜 A]
(a : Aˣ)


lemma singularPart_eq_zero_iff_measure_eq_zero (κ η : Kernel α γ)
    [IsFiniteKernel κ] [IsFiniteKernel η] (a : α) :
    singularPart κ η a = 0 ↔ κ a (mutuallySingularSetSlice κ η a) = 0

[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ]

(κ.singularPart η) a = 0 ↔ (κ a) (κ.mutuallySingularSetSlice η a) = 0


@[to_additive] -- Porting note (#10618): simp can prove this (so removed simp)
theorem powCoprime_inv {G : Type*} [Group G] (h : (Nat.card G).Coprime n) {g : G} :
    powCoprime h g⁻¹ = (powCoprime h g)⁻¹

{n : ℕ}
{G : Type u_6}
[AddGroup G]
(h : (Nat.card G).Coprime n)
{g : G}

(nsmulCoprime h) (-g) = -(nsmulCoprime h) g


theorem mem_interior_iff_mem_nhds : x ∈ interior s ↔ s ∈ 𝓝 x

{X : Type u}
{x : X}
{s : Set X}
[TopologicalSpace X]


/-- Let `M` be a smooth manifold with corners with model `I` on `(E, H)`.
Then `VectorBundleCore I M` is the vector bundle core for the tangent bundle over `M`.
It is indexed by the atlas of `M`, with fiber `E` and its change of coordinates from the chart `i`
to the chart `j` at point `x : M` is the derivative of the composite
```
  I.symm   i.symm    j     I
E -----> H -----> M --> H --> E
```
within the set `range I ⊆ E` at `I (i x) : E`. -/
@[simps indexAt coordChange]
def tangentBundleCore : VectorBundleCore 𝕜 M E (atlas H M)

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_4}
[TopologicalSpace H]
(I : ModelWithCorners 𝕜 E H)
(M : Type u_6)
[TopologicalSpace M]
[ChartedSpace H M]
[SmoothManifoldWithCorners I M]
(i j : ↑(atlas H M))
(x : M)

(tangentBundleCore I M).coordChange i j x =
  fderivWithin 𝕜 (↑((↑j).extend I) ∘ ↑((↑i).extend I).symm) (Set.range ↑I) (↑((↑i).extend I) x)


lemma sUnion_diffFinset₀_subset (hC : IsSetSemiring C) (hs : s ∈ C) (hI : ↑I ⊆ C) :
    ⋃₀ (hC.diffFinset₀ hs hI : Set (Set α)) ⊆ s

{α : Type u_1}
{C : Set (Set α)}
{s : Set α}
{I : Finset (Set α)}
(hC : MeasureTheory.IsSetSemiring C)
(hs : s ∈ C)
(hI : ↑I ⊆ C)


theorem coe_zero_mem (s : AbsConvexOpenSets 𝕜 E) : (0 : E) ∈ (s : Set E)

{𝕜 : Type u_1}
{E : Type u_2}
[TopologicalSpace E]
[AddCommMonoid E]
[Zero E]
[SeminormedRing 𝕜]
[SMul 𝕜 E]
[SMul ℝ E]
(s : AbsConvexOpenSets 𝕜 E)


@[to_additive (attr := simp)]
theorem mul_comp [Mul γ] [ContinuousMul γ] (f₁ f₂ : C(β, γ)) (g : C(α, β)) :
    (f₁ * f₂).comp g = f₁.comp g * f₂.comp g

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
[TopologicalSpace α]
[TopologicalSpace β]
[TopologicalSpace γ]
[Mul γ]
[ContinuousMul γ]
(f₁ f₂ : C(β, γ))
(g : C(α, β))


theorem iInf_le_of_le (i : ι) (h : f i ≤ a) : iInf f ≤ a

{α : Type u_1}
{ι : Sort u_5}
[CompleteLattice α]
{f : ι → α}
{a : α}
(i : ι)
(h : f i ≤ a)


theorem continuousAt_add_bot_coe (a : ℝ) :
    ContinuousAt (fun p : EReal × EReal => p.1 + p.2) (⊥, a)

ContinuousAt (fun p => p.1 + p.2) (⊥, ↑a)


theorem independent_of_dfinsupp_lsum_injective (p : ι → Submodule R N)
    (h : Function.Injective (lsum ℕ (M := fun i ↦ ↥(p i)) fun i => (p i).subtype)) :
    Independent p

(h : Function.Injective ⇑((DFinsupp.lsum ℕ) fun i => (p i).subtype))


theorem abs_truncation_le_bound (f : α → ℝ) (A : ℝ) (x : α) : |truncation f A x| ≤ |A|

{α : Type u_1}
(f : α → ℝ)
(A : ℝ)
(x : α)

|ProbabilityTheory.truncation f A x| ≤ |A|


theorem sub_vecMul [Fintype m] (A : Matrix m n α) (x y : m → α) :
    (x - y) ᵥ* A = x ᵥ* A - y ᵥ* A

{m : Type u_2}
{n : Type u_3}
{α : Type v}
[NonUnitalNonAssocRing α]
[Fintype m]
(A : Matrix m n α)
(x y : m → α)


@[simp]
theorem U_add_two : ∀ n, U R (n + 2) = 2 * X * U R (n + 1) - U R n

Polynomial.Chebyshev.U R (n + 2) = 2 * Polynomial.X * Polynomial.Chebyshev.U R (n + 1) - Polynomial.Chebyshev.U R n


theorem uniformContinuous_sInf_dom {f : α → β} {u₁ : Set (UniformSpace α)} {u₂ : UniformSpace β}
    {u : UniformSpace α} (h₁ : u ∈ u₁) (hf : UniformContinuous[u, u₂] f) :
    UniformContinuous[sInf u₁, u₂] f

{α : Type ua}
{β : Type ub}
{f : α → β}
{u₁ : Set (UniformSpace α)}
{u₂ : UniformSpace β}
{u : UniformSpace α}
(h₁ : u ∈ u₁)
(hf : UniformContinuous f)


theorem mod_mem_iff {S : Ideal R} {x y : R} (hy : y ∈ S) : x % y ∈ S ↔ x ∈ S

{R : Type u}
[EuclideanDomain R]
{S : Ideal R}
{x y : R}
(hy : y ∈ S)


theorem pow_of_coprime (i : ℕ) (hi : i.Coprime k) : IsPrimitiveRoot (ζ ^ i) k

{M : Type u_1}
[CommMonoid M]
{k : ℕ}
{ζ : M}
(h : IsPrimitiveRoot ζ k)
(i : ℕ)
(hi : i.Coprime k)


theorem gramSchmidt_def'' (f : ι → E) (n : ι) :
    f n = gramSchmidt 𝕜 f n + ∑ i ∈ Iio n,
      (⟪gramSchmidt 𝕜 f i, f n⟫ / (‖gramSchmidt 𝕜 f i‖ : 𝕜) ^ 2) • gramSchmidt 𝕜 f i

(𝕜 : Type u_1)
{E : Type u_2}
[RCLike 𝕜]
[NormedAddCommGroup E]
[InnerProductSpace 𝕜 E]
{ι : Type u_3}
[LinearOrder ι]
[LocallyFiniteOrderBot ι]
[IsWellOrder ι fun x x_1 => x < x_1]
(f : ι → E)
(n : ι)

f n =
  gramSchmidt 𝕜 f n + ∑ i ∈ Finset.Iio n, (⟪gramSchmidt 𝕜 f i, f n⟫_𝕜 / ↑‖gramSchmidt 𝕜 f i‖ ^ 2) • gramSchmidt 𝕜 f i


/-- The functor `(Φ.LeftResolution X₂)ᵒᵖ ⥤ Φ.op.RightResolution (Opposite.op X₂)`. -/
@[simps]
def LeftResolution.opFunctor (X₂ : C₂) [W₁.IsMultiplicative] :
    (Φ.LeftResolution X₂)ᵒᵖ ⥤ Φ.op.RightResolution (Opposite.op X₂)

{W₁ : CategoryTheory.MorphismProperty C₁}

{W₂ : CategoryTheory.MorphismProperty C₂}

(Φ : CategoryTheory.LocalizerMorphism W₁ W₂)

∀ {X Y : (Φ.LeftResolution X₂)ᵒᵖ} (φ : X ⟶ Y),
  ((CategoryTheory.LocalizerMorphism.LeftResolution.opFunctor Φ X₂).map φ).f = φ.unop.f.op


theorem gcd_dvd_gcd_of_dvd_left {i k : ℤ} (j : ℤ) (H : i ∣ k) : gcd i j ∣ gcd k j


@[reassoc (attr := simp)]
lemma δ_comp : hS.δ i j hij ≫ HomologicalComplex.homologyMap S.f j = 0

{S : CategoryTheory.ShortComplex (HomologicalComplex C c)}


/-- **Strict inequality case of the Rearrangement Inequality**: Pointwise scalar multiplication of
`f` and `g`, which monovary together, is strictly decreased by a permutation if and only if
`f` and `g ∘ σ` do not monovary together. Stated by permuting the entries of `g`. -/
theorem MonovaryOn.sum_mul_comp_perm_lt_sum_mul_iff (hfg : MonovaryOn f g s)
    (hσ : {x | σ x ≠ x} ⊆ s) :
    ∑ i ∈ s, f i • g (σ i) < ∑ i ∈ s, f i • g i ↔ ¬MonovaryOn f (g ∘ σ) s

{ι : Type u_1}
{α : Type u_2}
[LinearOrderedRing α]
{s : Finset ι}
{σ : Equiv.Perm ι}
{f g : ι → α}
(hfg : MonovaryOn f g ↑s)
(hσ : {x | σ x ≠ x} ⊆ ↑s)

∑ i ∈ s, f i • g (σ i) < ∑ i ∈ s, f i • g i ↔ ¬MonovaryOn f (g ∘ ⇑σ) ↑s


theorem sInf_le_sSup (hs : s.Nonempty) : sInf s ≤ sSup s

{α : Type u_1}
[CompleteLattice α]
{s : Set α}
(hs : s.Nonempty)


@[simp]
theorem rightInv_coeff_one (p : FormalMultilinearSeries 𝕜 E F) (i : E ≃L[𝕜] F) :
    p.rightInv i 1 = (continuousMultilinearCurryFin1 𝕜 F E).symm i.symm

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
(p : FormalMultilinearSeries 𝕜 E F)
(i : E ≃L[𝕜] F)

p.rightInv i 1 = (continuousMultilinearCurryFin1 𝕜 F E).symm ↑i.symm


nonrec theorem HasDerivWithinAt.scomp (hg : HasDerivWithinAt g₁ g₁' t' (h x))
    (hh : HasDerivWithinAt h h' s x) (hst : MapsTo h s t') :
    HasDerivWithinAt (g₁ ∘ h) (h' • g₁') s x

{𝕜 : Type u}
[NontriviallyNormedField 𝕜]
{F : Type v}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
(x : 𝕜)
{s : Set 𝕜}
{𝕜' : Type u_1}
[NontriviallyNormedField 𝕜']
[NormedAlgebra 𝕜 𝕜']
[NormedSpace 𝕜' F]
[IsScalarTower 𝕜 𝕜' F]
{t' : Set 𝕜'}
{h : 𝕜 → 𝕜'}
{h' : 𝕜'}
{g₁ : 𝕜' → F}
{g₁' : F}
(hg : HasDerivWithinAt g₁ g₁' t' (h x))
(hh : HasDerivWithinAt h h' s x)
(hst : Set.MapsTo h s t')


@[to_additive]
theorem ThreeGPFree.mulRothNumber_eq (hs : ThreeGPFree (s : Set α)) :
    mulRothNumber s = s.card

{α : Type u_2}
[DecidableEq α]
[AddMonoid α]
{s : Finset α}
(hs : ThreeAPFree ↑s)


theorem bounded_le_inter_lt [LinearOrder α] (a : α) :
    Bounded (· ≤ ·) (s ∩ { b | a < b }) ↔ Bounded (· ≤ ·) s

{α : Type u_1}
{s : Set α}
[LinearOrder α]
(a : α)

Set.Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a < b}) ↔ Set.Bounded (fun x x_1 => x ≤ x_1) s


theorem transcendental_iff_injective {x : A} :
    Transcendental R x ↔ Function.Injective (Polynomial.aeval x : R[X] →ₐ[R] A)

{R : Type u}
{A : Type v}
[CommRing R]
[Ring A]
[Algebra R A]
{x : A}

Transcendental R x ↔ Function.Injective ⇑(Polynomial.aeval x)


/-- An element `y` is in the ω-limit of `x` w.r.t. `f` if the forward
    images of `x` frequently (w.r.t. `f`) falls within an arbitrary
    neighbourhood of `y`. -/
theorem mem_omegaLimit_singleton_iff_map_cluster_point (x : α) (y : β) :
    y ∈ ω f ϕ {x} ↔ MapClusterPt y f fun t ↦ ϕ t x

{τ : Type u_1}
{α : Type u_2}
{β : Type u_3}
[TopologicalSpace β]
(f : Filter τ)
(ϕ : τ → α → β)
(x : α)
(y : β)

y ∈ omegaLimit f ϕ {x} ↔ MapClusterPt y f fun t => ϕ t x


theorem verschiebung_coeff_add_one (x : 𝕎 R) (n : ℕ) :
    (verschiebung x).coeff (n + 1) = x.coeff n

{p : ℕ}
{R : Type u_1}
[hp : Fact (Nat.Prime p)]
[CommRing R]
(x : WittVector p R)
(n : ℕ)

(WittVector.verschiebung x).coeff (n + 1) = x.coeff n


@[simp, norm_cast]
theorem coe_zpow_unitSphere [NormedDivisionRing 𝕜] (x : sphere (0 : 𝕜) 1) (n : ℤ) :
    ↑(x ^ n) = (x : 𝕜) ^ n

{𝕜 : Type u_1}
[NormedDivisionRing 𝕜]
(x : ↑(Metric.sphere 0 1))
(n : ℤ)


protected theorem HasStrictFDerivAt.continuousAt (hf : HasStrictFDerivAt f f' x) :
    ContinuousAt f x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{f : E → F}
{f' : E →L[𝕜] F}
{x : E}
(hf : HasStrictFDerivAt f f' x)


theorem eq_mul_inverse_iff_mul_eq (x y z : M₀) (h : IsUnit z) : x = y * inverse z ↔ x * z = y

{M₀ : Type u_2}
[MonoidWithZero M₀]
(x y z : M₀)
(h : IsUnit z)


theorem eq_intCast' [AddGroupWithOne α] [FunLike F ℤ α] [AddMonoidHomClass F ℤ α]
    (f : F) (h₁ : f 1 = 1) :
    ∀ n : ℤ, f n = n

{F : Type u_1}
{α : Type u_3}
[AddGroupWithOne α]
[FunLike F ℤ α]
[AddMonoidHomClass F ℤ α]
(f : F)
(h₁ : f 1 = 1)
(n : ℤ)


@[simp]
theorem LinearMap.isometryOfOrthonormal_toLinearMap (f : E →ₗ[𝕜] E') {v : Basis ι 𝕜 E}
    (hv : Orthonormal 𝕜 v) (hf : Orthonormal 𝕜 (f ∘ v)) :
    (f.isometryOfOrthonormal hv hf).toLinearMap = f

{𝕜 : Type u_1}
{E : Type u_2}
[RCLike 𝕜]
[NormedAddCommGroup E]
[InnerProductSpace 𝕜 E]
{ι : Type u_4}
{E' : Type u_7}
[NormedAddCommGroup E']
[InnerProductSpace 𝕜 E']
(f : E →ₗ[𝕜] E')
{v : Basis ι 𝕜 E}
(hv : Orthonormal 𝕜 ⇑v)
(hf : Orthonormal 𝕜 (⇑f ∘ ⇑v))


theorem _root_.ENNReal.tsum_const_eq [MeasurableSingletonClass α] (c : ℝ≥0∞) :
    ∑' _ : α, c = c * Measure.count (univ : Set α)

{α : Type u_1}
[MeasurableSpace α]
[MeasurableSingletonClass α]
(c : ℝ≥0∞)

∑' (x : α), c = c * MeasureTheory.Measure.count Set.univ


theorem divided_by_X_pow_orderMul {f g : R⟦X⟧} (hf : f ≠ 0) (hg : g ≠ 0) :
    divided_by_X_pow_order hf * divided_by_X_pow_order hg =
      divided_by_X_pow_order (mul_ne_zero hf hg)

{R : Type u_1}
[CommRing R]
[IsDomain R]
{f g : PowerSeries R}
(hf : f ≠ 0)
(hg : g ≠ 0)

PowerSeries.divided_by_X_pow_order hf * PowerSeries.divided_by_X_pow_order hg = PowerSeries.divided_by_X_pow_order ⋯


theorem gcd_dvd_left (a b : R) : gcd a b ∣ a

{R : Type u}
[EuclideanDomain R]
[DecidableEq R]
(a b : R)


@[simp]
theorem coe_pointwise_smul (a : α) (S : Submonoid M) : ↑(a • S) = a • (S : Set M)

{α : Type u_1}
{M : Type u_3}
[Monoid M]
[Monoid α]
[MulDistribMulAction α M]
(a : α)
(S : Submonoid M)


protected theorem inter {s' t'} (h : e.IsImage s t) (h' : e.IsImage s' t') :
    e.IsImage (s ∩ s') (t ∩ t')

{α : Type u_1}
{β : Type u_2}
{e : PartialEquiv α β}
{s : Set α}
{t : Set β}
{s' : Set α}
{t' : Set β}
(h : e.IsImage s t)
(h' : e.IsImage s' t')


protected theorem map_neg (f : A' →ₑ+[φ] B') (x : A') : f (-x) = -f x

{M : Type u_1}
[Monoid M]
{N : Type u_2}
[Monoid N]
{φ : M →* N}
(A' : Type u_8)
[AddGroup A']
[DistribMulAction M A']
(B' : Type u_9)
[AddGroup B']
[DistribMulAction N B']
(f : A' →ₑ+[φ] B')
(x : A')


@[reassoc (attr := simp)]
lemma comp_descHomotopyZeroSucc {Y Z : C} {I : InjectiveResolution Y} {J : InjectiveResolution Z}
    (f : I.cocomplex ⟶ J.cocomplex) (n : ℕ) (g : I.cocomplex.X (n + 1) ⟶ J.cocomplex.X n)
    (g' : I.cocomplex.X (n + 2) ⟶ J.cocomplex.X (n + 1))
    (w : f.f (n + 1) = I.cocomplex.d (n + 1) (n + 2) ≫ g' + g ≫ J.cocomplex.d n (n + 1)) :
    I.cocomplex.d (n+2) (n+3) ≫ descHomotopyZeroSucc f n g g' w =
      f.f (n + 2) - g' ≫ J.cocomplex.d _ _

{I : CategoryTheory.InjectiveResolution Y}

{J : CategoryTheory.InjectiveResolution Z}

I.cocomplex.d (n + 2) (n + 3) ≫ CategoryTheory.InjectiveResolution.descHomotopyZeroSucc f n g g' w =
  f.f (n + 2) - g' ≫ J.cocomplex.d (n + 1) (n + 2)


@[fun_prop]
theorem ContinuousOn.zpow₀ (hf : ContinuousOn f s) (m : ℤ) (h : ∀ a ∈ s, f a ≠ 0 ∨ 0 ≤ m) :
    ContinuousOn (fun x => f x ^ m) s

{G₀ : Type u_3}
[GroupWithZero G₀]
[TopologicalSpace G₀]
[HasContinuousInv₀ G₀]
[ContinuousMul G₀]
{X : Type u_4}
[TopologicalSpace X]
{s : Set X}
{f : X → G₀}
(hf : ContinuousOn f s)
(m : ℤ)
(h : ∀ a ∈ s, f a ≠ 0 ∨ 0 ≤ m)


lemma intCast_mul_intCast_mul (h : Commute a b) (m n : ℤ) : Commute (m * a) (n * b)

{α : Type u_3}
[Ring α]
{a b : α}
(h : Commute a b)
(m n : ℤ)


@[simp]
theorem dimH_union (s t : Set X) : dimH (s ∪ t) = max (dimH s) (dimH t)

{X : Type u_2}
[EMetricSpace X]
(s t : Set X)


theorem injective_iff_surjective_of_equiv {f : α → β} (e : α ≃ β) : Injective f ↔ Surjective f

{α : Type u_1}
{β : Type u_2}
[Finite α]
{f : α → β}
(e : α ≃ β)

Function.Injective f ↔ Function.Surjective f


theorem evariance_lt_top_iff_memℒp [IsFiniteMeasure μ] (hX : AEStronglyMeasurable X μ) :
    evariance X μ < ∞ ↔ Memℒp X 2 μ

(hX : MeasureTheory.AEStronglyMeasurable X μ)

ProbabilityTheory.evariance X μ < ⊤ ↔ MeasureTheory.Memℒp X 2 μ


theorem mem_map (x : α) : x ∈ c → f x ∈ Chain.map c f

{α : Type u}
{β : Type v}
[Preorder α]
[Preorder β]
(c : OmegaCompletePartialOrder.Chain α)
{f : α →o β}
(x : α)


theorem isCompactOperator_iff_image_ball_subset_compact [ContinuousConstSMul 𝕜₂ M₂]
    (f : M₁ →ₛₗ[σ₁₂] M₂) {r : ℝ} (hr : 0 < r) :
    IsCompactOperator f ↔ ∃ K : Set M₂, IsCompact K ∧ f '' Metric.ball 0 r ⊆ K

{𝕜₁ : Type u_1}
{𝕜₂ : Type u_2}
[NontriviallyNormedField 𝕜₁]
[SeminormedRing 𝕜₂]
{σ₁₂ : 𝕜₁ →+* 𝕜₂}
{M₁ : Type u_3}
{M₂ : Type u_4}
[SeminormedAddCommGroup M₁]
[TopologicalSpace M₂]
[AddCommMonoid M₂]
[NormedSpace 𝕜₁ M₁]
[Module 𝕜₂ M₂]
[ContinuousConstSMul 𝕜₂ M₂]
(f : M₁ →ₛₗ[σ₁₂] M₂)
{r : ℝ}
(hr : 0 < r)

IsCompactOperator ⇑f ↔ ∃ K, IsCompact K ∧ ⇑f '' Metric.ball 0 r ⊆ K


theorem diam_eq_zero_iff : diam s = 0 ↔ s.Subsingleton

{γ : Type w}
[EMetricSpace γ]
{s : Set γ}


@[simp]
lemma Cotangent.val_smul'' (r : R) (x : P.Cotangent) : (r • x).val = r • x.val

{R : Type u}
{S : Type v}
[CommRing R]
[CommRing S]
[Algebra R S]
{P : Algebra.Generators R S}
(r : R)
(x : P.Cotangent)


theorem iInf_rayleigh_eq_iInf_rayleigh_sphere {r : ℝ} (hr : 0 < r) :
    ⨅ x : { x : E // x ≠ 0 }, rayleighQuotient T x =
      ⨅ x : sphere (0 : E) r, rayleighQuotient T x

{𝕜 : Type u_1}
[RCLike 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[InnerProductSpace 𝕜 E]
(T : E →L[𝕜] E)
{r : ℝ}
(hr : 0 < r)

⨅ x, T.rayleighQuotient ↑x = ⨅ x, T.rayleighQuotient ↑x


/-- See note [partially-applied ext lemmas]. -/
-- Porting note: higher `ext` priority
@[ext 1100]
theorem ext_hom (f g : CoprodI M →* N) (h : ∀ i, f.comp (of : M i →* _) = g.comp of) : f = g

(h : ∀ (i : ι), f.comp Monoid.CoprodI.of = g.comp Monoid.CoprodI.of)


@[to_additive (attr := simp)]
theorem lift_coe (x : α) : lift f x = f x

{α : Type u}
{β : Type v}
[Add α]
[AddZeroClass β]
(f : AddHom α β)
(x : α)


theorem IsUniversalColimit.whiskerEquivalence_iff {K : Type*} [Category K] (e : J ≌ K)
    {F : K ⥤ C} {c : Cocone F} :
    IsUniversalColimit (c.whisker e.functor) ↔ IsUniversalColimit c

{J : Type v'}
[CategoryTheory.Category.{u', v'} J]
{C : Type u}
[CategoryTheory.Category.{v, u} C]
{K : Type u_3}
[CategoryTheory.Category.{u_4, u_3} K]
(e : J ≌ K)
{F : CategoryTheory.Functor K C}
{c : CategoryTheory.Limits.Cocone F}

CategoryTheory.IsUniversalColimit (CategoryTheory.Limits.Cocone.whisker e.functor c) ↔
  CategoryTheory.IsUniversalColimit c


theorem IsCoprime.pow_left (H : IsCoprime x y) : IsCoprime (x ^ m) y

{R : Type u}
[CommSemiring R]
{x y : R}
{m : ℕ}
(H : IsCoprime x y)


lemma _root_.Commute.sum_left [NonUnitalNonAssocSemiring α] (s : Finset ι) (f : ι → α) (b : α)
    (h : ∀ i ∈ s, Commute (f i) b) : Commute (∑ i ∈ s, f i) b

{ι : Type u_1}
{α : Type u_2}
[NonUnitalNonAssocSemiring α]
(s : Finset ι)
(f : ι → α)
(b : α)
(h : ∀ i ∈ s, Commute (f i) b)


/-- `⊓` commutes with map. -/
theorem inf_map {X Y : C} (g : Y ⟶ X) [Mono g] (f₁ f₂) :
    (map g).obj (f₁ ⊓ f₂) = (map g).obj f₁ ⊓ (map g).obj f₂

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.Limits.HasPullbacks C]
{X Y : C}
(g : Y ⟶ X)
[CategoryTheory.Mono g]
(f₁ f₂ : CategoryTheory.Subobject Y)

(CategoryTheory.Subobject.map g).obj (f₁ ⊓ f₂) =
  (CategoryTheory.Subobject.map g).obj f₁ ⊓ (CategoryTheory.Subobject.map g).obj f₂


@[simp] theorem forM_nil' [Monad m] : ([] : List α).forM f = (pure .unit : m PUnit)

{m : Type u_1 → Type u_2}
{α : Type u_3}
{f : α → m PUnit}
[Monad m]


theorem tail_eq_drop (s : Stream' α) : tail s = drop 1 s


/-- See also `Nat.divModEquiv` for a similar statement as an `Equiv`. -/
protected lemma div_mod_unique (h : 0 < b) :
    a / b = d ∧ a % b = c ↔ c + b * d = a ∧ c < b


theorem isClosed_sigma_iff {s : Set (Sigma σ)} : IsClosed s ↔ ∀ i, IsClosed (Sigma.mk i ⁻¹' s)

{ι : Type u_5}
{σ : ι → Type u_7}
[(i : ι) → TopologicalSpace (σ i)]
{s : Set (Sigma σ)}

IsClosed s ↔ ∀ (i : ι), IsClosed (Sigma.mk i ⁻¹' s)


theorem take_succ {l : List α} {n : Nat} : l.take (n + 1) = l.take n ++ l[n]?.toList

List.take (n + 1) l = List.take n l ++ l[n]?.toList


/-- Conditions for an element to be multiplicatively central -/
@[to_additive]
structure IsMulCentral [Mul M] (z : M) : Prop where
  /-- multiplication commutes -/
  comm (a : M) : z * a = a * z
  /-- associative property for left multiplication -/
  left_assoc (b c : M) : z * (b * c) = (z * b) * c
  /-- middle associative multiplication property -/
  mid_assoc (a c : M) : (a * z) * c = a * (z * c)
  /-- associative property for right multiplication -/
  right_assoc (a b : M) : (a * b) * z = a * (b * z)

{M : Type u_1}
[Mul M]
{z : M}
(self : IsMulCentral z)
(b c : M)


theorem map_nhds_eq : map f (𝓝 a) = 𝓝 (f a)

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
[CompleteSpace 𝕜]
{f : 𝕜 → 𝕜}
{f' a : 𝕜}
(hf : HasStrictDerivAt f f' a)
(hf' : f' ≠ 0)


theorem range_le : Set.range (algebraMap R A) ≤ S

{R : Type u_2}
{A : Type u_3}
[CommSemiring R]
[StarRing R]
[Semiring A]
[StarRing A]
[Algebra R A]
[StarModule R A]
(S : StarSubalgebra R A)


lemma LeftHomologyData.exact_iff_epi_f' [S.HasHomology] (h : LeftHomologyData S) :
    S.Exact ↔ Epi h.f'

{C : Type u_1}
[CategoryTheory.Category.{u_3, u_1} C]
[CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C}
[S.HasHomology]
(h : S.LeftHomologyData)


theorem coeff_isPWOsupport (A : HVertexOperator Γ R V W) (v : V) :
    ((of R).symm (A v)).coeff.support.IsPWO

{Γ : Type u_1}
[PartialOrder Γ]
{R : Type u_2}
{V : Type u_3}
{W : Type u_4}
[CommRing R]
[AddCommGroup V]
[Module R V]
[AddCommGroup W]
[Module R W]
(A : HVertexOperator Γ R V W)
(v : V)

(Function.support ((HahnModule.of R).symm (A v)).coeff).IsPWO


@[simp]
theorem toDual_hnot (a : α) : toDual (￢a) = (toDual a)ᶜ

{α : Type u_2}
[CoheytingAlgebra α]
(a : α)

OrderDual.toDual (￢a) = (OrderDual.toDual a)ᶜ


/-- A function whose codomain's cardinality is infinite but strictly smaller than its domain's
has a fiber with cardinality strictly great than the codomain.
-/
theorem infinite_pigeonhole_card_lt {β α : Type u} (f : β → α) (w : #α < #β) (w' : ℵ₀ ≤ #α) :
    ∃ a : α, #α < #(f ⁻¹' {a})


theorem powers_eq_closure (n : M) : powers n = closure {n}

Submonoid.powers n = Submonoid.closure {n}


theorem InftyValuation.map_add_le_max' (x y : RatFunc Fq) :
    inftyValuationDef Fq (x + y) ≤ max (inftyValuationDef Fq x) (inftyValuationDef Fq y)

(Fq : Type)
[Field Fq]
[DecidableEq (RatFunc Fq)]
(x y : RatFunc Fq)

FunctionField.inftyValuationDef Fq (x + y) ≤
  max (FunctionField.inftyValuationDef Fq x) (FunctionField.inftyValuationDef Fq y)


theorem symm_bijective : Function.Bijective
    (PartialHomeomorph.symm : PartialHomeomorph X Y → PartialHomeomorph Y X)

{X : Type u_1}
{Y : Type u_3}
[TopologicalSpace X]
[TopologicalSpace Y]


theorem zero_limZero : LimZero (0 : CauSeq β abv)

{α : Type u_1}
{β : Type u_2}
[LinearOrderedField α]
[Ring β]
{abv : β → α}
[IsAbsoluteValue abv]


theorem wordProd_concat (i : B) (ω : List B) : π (ω.concat i) = π ω * s i

{B : Type u_1}
{W : Type u_3}
[Group W]
{M : CoxeterMatrix B}
(cs : CoxeterSystem M W)
(i : B)
(ω : List B)

cs.wordProd (ω.concat i) = cs.wordProd ω * cs.simple i


/-- The `αˣ` type is equivalent to a subtype of `α × α`. -/
@[simps]
def unitsEquivProdSubtype [Monoid α] : αˣ ≃ {p : α × α // p.1 * p.2 = 1 ∧ p.2 * p.1 = 1}

↑((unitsEquivProdSubtype α).symm p)⁻¹ = (↑p).2


theorem exists_norm_lt {r : ℝ} (hr : 0 < r) : ∃ x : α, 0 < ‖x‖ ∧ ‖x‖ < r

(α : Type u_1)
[NontriviallyNormedField α]
{r : ℝ}
(hr : 0 < r)


/-- The forgetful functor from the category of coalgebras, forgetting the coalgebraic structure. -/
@[simps]
def forget (F : C ⥤ C) : Coalgebra F ⥤ C

(A : CategoryTheory.Endofunctor.Coalgebra F)

(CategoryTheory.Endofunctor.Coalgebra.forget F).obj A = A.V


/-- Auxiliary definition for `Over.coprod`. -/
@[simps]
def Over.coprodObj [HasBinaryCoproducts C] {A : C} : Over A → Over A ⥤ Over A

∀ (a : CategoryTheory.Over A) {X Y : CategoryTheory.Over A} (k : X ⟶ Y),
  a.coprodObj.map k = CategoryTheory.Over.homMk (CategoryTheory.Limits.coprod.map (𝟙 ((𝟭 C).obj a.left)) k.left) ⋯


theorem _root_.LinearMapClass.ker_eq_bot : ker f = ⊥ ↔ Injective f

{R : Type u_1}
{R₂ : Type u_3}
{M : Type u_6}
{M₂ : Type u_8}
[Ring R]
[Ring R₂]
[AddCommGroup M]
[AddCommGroup M₂]
[Module R M]
[Module R₂ M₂]
{τ₁₂ : R →+* R₂}
(F : Type u_12)
[FunLike F M M₂]
[SemilinearMapClass F τ₁₂ M M₂]
{f : F}

LinearMap.ker f = ⊥ ↔ Function.Injective ⇑f


theorem card_nsmul (s : Multiset α) (n : ℕ) : card (n • s) = n * card s

Multiset.card (n • s) = n * Multiset.card s


@[to_additive]
theorem injective_ofQuotientStabilizer : Function.Injective (ofQuotientStabilizer α x)

(α : Type u)
{β : Type v}
[AddGroup α]
[AddAction α β]
(x : β)

Function.Injective (AddAction.ofQuotientStabilizer α x)


@[simp]
theorem isVonNBounded_empty : IsVonNBounded 𝕜 (∅ : Set E)

(𝕜 : Type u_1)
(E : Type u_3)
[SeminormedRing 𝕜]
[SMul 𝕜 E]
[Zero E]
[TopologicalSpace E]


theorem Continuous.congr {g : X → Y} (h : Continuous f) (h' : ∀ x, f x = g x) : Continuous g

{X : Type u_1}
{Y : Type u_2}
[TopologicalSpace X]
[TopologicalSpace Y]
{f g : X → Y}
(h : Continuous f)
(h' : ∀ (x : X), f x = g x)


@[simp, norm_cast] lemma cast_natCast (n : ℕ) : ((n : ℚ≥0) : α) = n

{α : Type u_3}
[DivisionSemiring α]
(n : ℕ)


theorem hasSum_integral_measure {ι} {m : MeasurableSpace α} {f : α → G} {μ : ι → Measure α}
    (hf : Integrable f (Measure.sum μ)) :
    HasSum (fun i => ∫ a, f a ∂μ i) (∫ a, f a ∂Measure.sum μ)

(hf : MeasureTheory.Integrable f (MeasureTheory.Measure.sum μ))

HasSum (fun i => ∫ (a : α), f a ∂μ i) (∫ (a : α), f a ∂MeasureTheory.Measure.sum μ)


theorem formula_mem_typeOf {φ : L.Formula α} :
    Formula.equivSentence φ ∈ T.typeOf v ↔ φ.Realize v

{L : FirstOrder.Language}
{T : L.Theory}
{α : Type w}
{M : Type w'}
[L.Structure M]
[Nonempty M]
[M ⊨ T]
{v : α → M}
{φ : L.Formula α}

FirstOrder.Language.Formula.equivSentence φ ∈ T.typeOf v ↔ φ.Realize v


theorem norm_sup_le_add (x y : α) : ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖

{α : Type u_1}
[NormedLatticeAddCommGroup α]
(x y : α)

‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖


theorem subNatNat_add_add (m n k : Nat) : subNatNat (m + k) (n + k) = subNatNat m n

Int.subNatNat (m + k) (n + k) = Int.subNatNat m n


theorem card_support (h : IsThreeCycle σ) : σ.support.card = 3

{α : Type u_1}
[Fintype α]
[DecidableEq α]
{σ : Equiv.Perm α}
(h : σ.IsThreeCycle)


@[simp]
theorem edgeFinset_sup [Fintype (edgeSet (G₁ ⊔ G₂))] [DecidableEq V] :
    (G₁ ⊔ G₂).edgeFinset = G₁.edgeFinset ∪ G₂.edgeFinset

{V : Type u_1}
{G₁ G₂ : SimpleGraph V}
[Fintype ↑G₁.edgeSet]
[Fintype ↑G₂.edgeSet]
[Fintype ↑(G₁ ⊔ G₂).edgeSet]
[DecidableEq V]


theorem thickening_subset_cthickening_of_le {δ₁ δ₂ : ℝ} (hle : δ₁ ≤ δ₂) (E : Set α) :
    thickening δ₁ E ⊆ cthickening δ₂ E

{α : Type u}
[PseudoEMetricSpace α]
{δ₁ δ₂ : ℝ}
(hle : δ₁ ≤ δ₂)
(E : Set α)

Metric.thickening δ₁ E ⊆ Metric.cthickening δ₂ E


@[simp]
theorem ι_add_mul_swap (x y : M) : ι R x * ι R y + ι R y * ι R x = 0

{R : Type u1}
[CommRing R]
{M : Type u2}
[AddCommGroup M]
[Module R M]
(x y : M)

(ExteriorAlgebra.ι R) x * (ExteriorAlgebra.ι R) y + (ExteriorAlgebra.ι R) y * (ExteriorAlgebra.ι R) x = 0


theorem degree_le_iff_coeff_zero (f : R[X]) (n : WithBot ℕ) :
    degree f ≤ n ↔ ∀ m : ℕ, n < m → coeff f m = 0

{R : Type u}
[Semiring R]
(f : R[X])
(n : WithBot ℕ)

f.degree ≤ n ↔ ∀ (m : ℕ), n < ↑m → f.coeff m = 0


@[simp]
theorem extend_comp (hf : Injective f) (g : α → γ) (e' : β → γ) : extend f g e' ∘ f = g

{α : Sort u_1}
{β : Sort u_2}
{γ : Sort u_3}
{f : α → β}
(hf : Function.Injective f)
(g : α → γ)
(e' : β → γ)


theorem _root_.Polynomial.toLaurent_X_pow (n : ℕ) : toLaurent (X ^ n : R[X]) = T n

Polynomial.toLaurent (Polynomial.X ^ n) = LaurentPolynomial.T ↑n


theorem sub_mem_Ico_iff_left : a - b ∈ Set.Ico c d ↔ a ∈ Set.Ico (c + b) (d + b)

{α : Type u_1}
[OrderedAddCommGroup α]
{a b c d : α}


lemma fib_lt_fib {m : ℕ} (hm : 2 ≤ m) : ∀ {n}, fib m < fib n ↔ m < n


theorem restrict_union_add_inter₀ (s : Set α) (ht : NullMeasurableSet t μ) :
    μ.restrict (s ∪ t) + μ.restrict (s ∩ t) = μ.restrict s + μ.restrict t

(ht : MeasureTheory.NullMeasurableSet t μ)


@[to_additive (attr := simp)]
theorem inv_ae : (ae μ)⁻¹ = ae μ

{G : Type u_1}
[MeasurableSpace G]
[AddGroup G]
[MeasurableAdd₂ G]
(μ : MeasureTheory.Measure G)
[MeasureTheory.SFinite μ]
[MeasurableNeg G]
[μ.IsAddLeftInvariant]

-MeasureTheory.ae μ = MeasureTheory.ae μ


theorem disjoint_iff_inf_le : Disjoint a b ↔ a ⊓ b ≤ ⊥

{α : Type u_1}
[SemilatticeInf α]
[OrderBot α]
{a b : α}


theorem erase_eq_empty_iff (s : Finset α) (a : α) : s.erase a = ∅ ↔ s = ∅ ∨ s = {a}

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


@[to_additive]
theorem finprod_eq_prod_plift_of_mulSupport_subset {f : α → M} {s : Finset (PLift α)}
    (hs : mulSupport (f ∘ PLift.down) ⊆ s) : ∏ᶠ i, f i = ∏ i ∈ s, f i.down

(hs : Function.mulSupport (f ∘ PLift.down) ⊆ ↑s)


theorem Ideal.closure_eq_of_isClosed (I : Ideal R) (hI : IsClosed (I : Set R)) : I.closure = I

{R : Type u_1}
[TopologicalSpace R]
[Ring R]
[TopologicalRing R]
(I : Ideal R)
(hI : IsClosed ↑I)


theorem congr_fun {f g : L₁ →ₗ⁅R⁆ L₂} (h : f = g) (x : L₁) : f x = g x

{R : Type u}
{L₁ : Type v}
{L₂ : Type w}
[CommRing R]
[LieRing L₁]
[LieAlgebra R L₁]
[LieRing L₂]
[LieAlgebra R L₂]
{f g : L₁ →ₗ⁅R⁆ L₂}
(h : f = g)
(x : L₁)


theorem ExprCnstr.toPoly_norm_eq (c : ExprCnstr) : c.toPoly.norm = c.toNormPoly


theorem sub_congr_left {x y z : PGame} (h : x ≈ y) : x - z ≈ y - z


theorem IsCoprime.of_mul_left_left (H : IsCoprime (x * y) z) : IsCoprime x z

{R : Type u}
[CommSemiring R]
{x y z : R}
(H : IsCoprime (x * y) z)


private theorem lintegral_rpow_tsum_coe_nnnorm_sub_le_tsum {f : ℕ → α → E}
    (hf : ∀ n, AEStronglyMeasurable (f n) μ) {p : ℝ} (hp1 : 1 ≤ p) {B : ℕ → ℝ≥0∞}
    (h :
      ∀ n,
        (∫⁻ a, (∑ i ∈ Finset.range (n + 1), ‖f (i + 1) a - f i a‖₊ : ℝ≥0∞) ^ p ∂μ) ≤
          (∑' i, B i) ^ p) :
    (∫⁻ a, (∑' i, ‖f (i + 1) a - f i a‖₊ : ℝ≥0∞) ^ p ∂μ) ^ (1 / p) ≤ ∑' i, B i

(hf : ∀ (n : ℕ), MeasureTheory.AEStronglyMeasurable (f n) μ)

{B : ℕ → ℝ≥0∞}

(h : ∀ (n : ℕ), ∫⁻ (a : α), (∑ i ∈ Finset.range (n + 1), ↑‖f (i + 1) a - f i a‖₊) ^ p ∂μ ≤ (∑' (i : ℕ), B i) ^ p)


protected theorem le_inf (f' f g : α →ₘ[μ] β) (hf : f' ≤ f) (hg : f' ≤ g) : f' ≤ f ⊓ g

{α : Type u_1}
{β : Type u_2}
[MeasurableSpace α]
{μ : MeasureTheory.Measure α}
[TopologicalSpace β]
[SemilatticeInf β]
[ContinuousInf β]
(f' f g : α →ₘ[μ] β)
(hf : f' ≤ f)
(hg : f' ≤ g)


lemma succAbove_castSucc_of_lt (p i : Fin n) (h : i < p) : succAbove p.castSucc i = i.castSucc


@[simp]
theorem eraseLead_X : eraseLead (X : R[X]) = 0


theorem IsConnected.nonempty {s : Set α} (h : IsConnected s) : s.Nonempty

{α : Type u}
[TopologicalSpace α]
{s : Set α}
(h : IsConnected s)


{α : Type u_2}
[Lattice α]
[LocallyFiniteOrder α]
{a b : α}


theorem appr_spec (n : ℕ) : ∀ x : ℤ_[p], x - appr x n ∈ Ideal.span {(p : ℤ_[p]) ^ n}

{p : ℕ}
[hp_prime : Fact (Nat.Prime p)]
(n : ℕ)
(x : ℤ_[p])


lemma _root_.MonotoneOn.mapsTo_uIcc (hf : MonotoneOn f (uIcc a b)) :
    MapsTo f (uIcc a b) (uIcc (f a) (f b))

{α : Type u_1}
{β : Type u_2}
[LinearOrder α]
[Lattice β]
{f : α → β}
{a b : α}
(hf : MonotoneOn f (Set.uIcc a b))

Set.MapsTo f (Set.uIcc a b) (Set.uIcc (f a) (f b))


/-- If the center of a Lie algebra is trivial, then the adjoint action is injective. -/
lemma injective_ad_of_center_eq_bot (h : LieAlgebra.center R L = ⊥) :
    Function.Injective (ad R L)

{R : Type u_1}
{L : Type u_2}
[CommRing R]
[LieRing L]
[LieAlgebra R L]
(h : LieAlgebra.center R L = ⊥)

Function.Injective ⇑(LieDerivation.ad R L)


theorem erase_comm [LawfulBEq α] (a b : α) (l : List α) :
    (l.erase a).erase b = (l.erase b).erase a

{α : Type u_1}
[BEq α]
[LawfulBEq α]
(a b : α)
(l : List α)


theorem ofNat_fmod (m n : Nat) : ↑(m % n) = fmod m n


theorem lt_or_le [LinearOrder α] {a b : α} (h : a ≤ b) (c : α) : a < c ∨ c ≤ b

{α : Type u_2}
[LinearOrder α]
{a b : α}
(h : a ≤ b)
(c : α)


theorem sign_inv (f : Perm α) : sign f⁻¹ = sign f

{α : Type u}
[DecidableEq α]
[Fintype α]
(f : Equiv.Perm α)


theorem mem_nhds_bot_iff {s : Set EReal} : s ∈ 𝓝 (⊥ : EReal) ↔ ∃ y : ℝ, Iio (y : EReal) ⊆ s


theorem isBounded_image (f : C₀(α, β)) (s : Set α) : IsBounded (f '' s)

{α : Type u}
{β : Type v}
[TopologicalSpace α]
[PseudoMetricSpace β]
[Zero β]
(f : α →C₀ β)
(s : Set α)


lemma quasiIso_iff_comp_right (φ : K ⟶ L) (φ' : L ⟶ M) [∀ i, K.HasHomology i]
    [∀ i, L.HasHomology i] [∀ i, M.HasHomology i]
    [hφ' : QuasiIso φ'] :
    QuasiIso (φ ≫ φ') ↔ QuasiIso φ


theorem HasConstantSpeedOnWith.Icc_Icc {x y z : ℝ} (hfs : HasConstantSpeedOnWith f (Icc x y) l)
    (hft : HasConstantSpeedOnWith f (Icc y z) l) : HasConstantSpeedOnWith f (Icc x z) l

(hfs : HasConstantSpeedOnWith f (Set.Icc x y) l)

(hft : HasConstantSpeedOnWith f (Set.Icc y z) l)

HasConstantSpeedOnWith f (Set.Icc x z) l


/-- A measure `μ` on `α ⧸ G` satisfying `QuotientMeasureEqMeasurePreimage` and having finite
covolume is a finite measure. -/
@[to_additive]
theorem QuotientMeasureEqMeasurePreimage.isFiniteMeasure_quotient
    (μ : Measure (Quotient α_mod_G)) [QuotientMeasureEqMeasurePreimage ν μ]
    [hasFun : HasFundamentalDomain G α ν] (h : covolume G α ν ≠ ∞) :
    IsFiniteMeasure μ

[MeasureTheory.VAddInvariantMeasure G α ν]

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

[hasFun : MeasureTheory.HasAddFundamentalDomain G α ν]

(h : MeasureTheory.addCovolume G α ν ≠ ⊤)


@[to_additive]
theorem iSup_eq_closure {ι : Sort*} (p : ι → Submonoid M) :
    ⨆ i, p i = Submonoid.closure (⋃ i, (p i : Set M))

{M : Type u_1}
[AddZeroClass M]
{ι : Sort u_4}
(p : ι → AddSubmonoid M)

⨆ i, p i = AddSubmonoid.closure (⋃ i, ↑(p i))


lemma norm_le_interpStrip_of_mem_verticalStrip_zero (z : ℂ)
    (hd : DiffContOnCl ℂ f (verticalStrip 0 1))
    (hB : BddAbove ((norm ∘ f) '' (verticalClosedStrip 0 1))) (hz : z ∈ verticalStrip 0 1) :
    ‖f z‖ ≤ ‖interpStrip f z‖

(hd : DiffContOnCl ℂ f (Complex.HadamardThreeLines.verticalStrip 0 1))

(hB : BddAbove (norm ∘ f '' Complex.HadamardThreeLines.verticalClosedStrip 0 1))

(hz : z ∈ Complex.HadamardThreeLines.verticalStrip 0 1)

‖f z‖ ≤ ‖Complex.HadamardThreeLines.interpStrip f z‖


theorem smul_eq_zero_iff_eq (a : α) {x : β} : a • x = 0 ↔ x = 0

{α : Type u}
{β : Type v}
[Group α]
[AddMonoid β]
[DistribMulAction α β]
(a : α)
{x : β}


@[simp]
theorem coeff_zero_C (a) : coeff 0 (C a : MvPolynomial σ R) = a

{R : Type u}
{σ : Type u_1}
[CommSemiring R]
(a : R)

MvPolynomial.coeff 0 (MvPolynomial.C a) = a


theorem mul_card_image_le_card_of_maps_to {f : α → β} {s : Finset α} {t : Finset β}
    (Hf : ∀ a ∈ s, f a ∈ t) (n : ℕ) (hn : ∀ a ∈ t, n ≤ (s.filter fun x ↦ f x = a).card) :
    n * t.card ≤ s.card

(hn : ∀ a ∈ t, n ≤ (Finset.filter (fun x => f x = a) s).card)


/--
Linear maps into a character module are exactly characters of the tensor product.
-/
@[simps!] noncomputable def homEquiv :
    (A →ₗ[R] CharacterModule B) ≃ₗ[R] CharacterModule (A ⊗[R] B)

(x : (addConGen (TensorProduct.Eqv R A B)).Quotient)

(CharacterModule.homEquiv c) x = AddCon.liftOn x ⇑(FreeAddMonoid.lift fun mn => (c.toAddMonoidHom mn.1) mn.2) ⋯


@[simp]
theorem coe_smul_adicCompletionIntegers (r : R) (x : v.adicCompletionIntegers K) :
    (↑(r • x) : v.adicCompletion K) = r • (x : v.adicCompletion K)

(v : IsDedekindDomain.HeightOneSpectrum R)

(x : ↥(IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers K v))


theorem map_comp (p q : R[X]) : map f (p.comp q) = (map f p).comp (map f q)

{R : Type u}
{S : Type v}
[Semiring R]
[Semiring S]
(f : R →+* S)
(p q : R[X])

Polynomial.map f (p.comp q) = (Polynomial.map f p).comp (Polynomial.map f q)


protected theorem lt_add_of_sub_right_lt {a b c : Int} (h : a - c < b) : a < b + c


@[to_additive exists_nhds_half_neg]
theorem exists_nhds_split_inv {s : Set G} (hs : s ∈ 𝓝 (1 : G)) :
    ∃ V ∈ 𝓝 (1 : G), ∀ v ∈ V, ∀ w ∈ V, v / w ∈ s

{G : Type w}
[TopologicalSpace G]
[AddGroup G]
[TopologicalAddGroup G]
{s : Set G}
(hs : s ∈ 𝓝 0)


/-- The set `codeSupp c k` is a finite set that witnesses the effective finiteness of the `tr`
Turing machine. Starting from the initial state `trNormal c k`, forward simulation uses only
states in `codeSupp c k`, so this is a finite state machine. Even though the underlying type of
state labels `Λ'` is infinite, for a given partial recursive function `c` and continuation `k`,
only finitely many states are accessed, corresponding roughly to subterms of `c`. -/
theorem tr_supports (c k) : @TM2.Supports _ _ _ _ ⟨trNormal c k⟩ tr (codeSupp c k)

(c : Turing.ToPartrec.Code)
(k : Turing.PartrecToTM2.Cont')

Turing.TM2.Supports Turing.PartrecToTM2.tr (Turing.PartrecToTM2.codeSupp c k)


@[simp]
theorem toDirectSum_ofDirectSum (x : ⨁ n, ⨂[R]^n M) :
    TensorAlgebra.toDirectSum (ofDirectSum x) = x

{R : Type u_1}
{M : Type u_2}
[CommSemiring R]
[AddCommMonoid M]
[Module R M]
(x : ⨁ (n : ℕ), ⨂[R]^n M)

TensorAlgebra.toDirectSum (TensorAlgebra.ofDirectSum x) = x


theorem Sublist.eq_of_length_le (s : l₁ <+ l₂) (h : length l₂ ≤ length l₁) : l₁ = l₂

∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+ l₂ → l₂.length ≤ l₁.length → l₁ = l₂


@[to_additive (attr := simp)]
theorem restrict_apply {N S : Type*} [MulOneClass N] [SetLike S M] [SubmonoidClass S M]
    (f : M →* N) (s : S) (x : s) : f.restrict s x = f x

{M : Type u_1}
[AddZeroClass M]
{N : Type u_6}
{S : Type u_7}
[AddZeroClass N]
[SetLike S M]
[AddSubmonoidClass S M]
(f : M →+ N)
(s : S)
(x : ↥s)


theorem toReal_pos_iff : 0 < a.toReal ↔ 0 < a ∧ a < ∞


@[simp]
theorem consCases_cons {P : (∀ i : Fin n.succ, α i) → Sort v} (h : ∀ x₀ x, P (Fin.cons x₀ x))
    (x₀ : α 0) (x : ∀ i : Fin n, α i.succ) : @consCases _ _ _ h (cons x₀ x) = h x₀ x

(h : (x₀ : α 0) → (x : (i : Fin n) → α i.succ) → P (Fin.cons x₀ x))

Fin.consCases h (Fin.cons x₀ x) = h x₀ x


@[simp] theorem not_true_eq_false : (¬ True) = False


/-- The functor `F.mapTriangle` commutes with the shift. -/
@[simps!]
noncomputable def mapTriangleCommShiftIso (n : ℤ) :
    Triangle.shiftFunctor C n ⋙ F.mapTriangle ≅ F.mapTriangle ⋙ Triangle.shiftFunctor D n

(X : CategoryTheory.Pretriangulated.Triangle C)

((F.mapTriangleCommShiftIso n).inv.app X).hom₁ = (F.commShiftIso n).inv.app X.obj₁


theorem mem_pointwise_smul_iff_inv_smul_mem {a : α} {S : Subgroup G} {x : G} :
    x ∈ a • S ↔ a⁻¹ • x ∈ S

{α : Type u_1}
{G : Type u_2}
[Group G]
[Group α]
[MulDistribMulAction α G]
{a : α}
{S : Subgroup G}
{x : G}

x ∈ a • S ↔ a⁻¹ • x ∈ S


lemma isAlgebraic_of_isLocalization {R} [CommRing R] (M : Submonoid R) (S) [CommRing S]
    [Nontrivial R] [Algebra R S] [IsLocalization M S] : Algebra.IsAlgebraic R S

{R : Type u_6}
[CommRing R]
(M : Submonoid R)
(S : Type u_7)
[CommRing S]
[Nontrivial R]
[Algebra R S]
[IsLocalization M S]


theorem pi_ext_iff : f = g ↔ ∀ i x, f (Pi.single i x) = g (Pi.single i x)

{R : Type u}
{M : Type v}
{ι : Type x}
[Semiring R]
{φ : ι → Type i}
[(i : ι) → AddCommMonoid (φ i)]
[(i : ι) → Module R (φ i)]
[Finite ι]
[DecidableEq ι]
[AddCommMonoid M]
[Module R M]
{f g : ((i : ι) → φ i) →ₗ[R] M}

f = g ↔ ∀ (i : ι) (x : φ i), f (Pi.single i x) = g (Pi.single i x)


@[simp] lemma op_tensorUnit : op (𝟙_ C) = 𝟙_ Cᵒᵖ

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


theorem Convex.openSegment_closure_interior_subset_interior {s : Set E} (hs : Convex 𝕜 s) {x y : E}
    (hx : x ∈ closure s) (hy : y ∈ interior s) : openSegment 𝕜 x y ⊆ interior s

{𝕜 : Type u_2}
{E : Type u_3}
[LinearOrderedField 𝕜]
[AddCommGroup E]
[Module 𝕜 E]
[TopologicalSpace E]
[TopologicalAddGroup E]
[ContinuousConstSMul 𝕜 E]
{s : Set E}
(hs : Convex 𝕜 s)
{x y : E}
(hx : x ∈ closure s)
(hy : y ∈ interior s)


@[to_additive (attr := simp)]
lemma map_comp_zpow' [DivInvMonoid G] [DivInvMonoid H] [MonoidHomClass F G H] (f : F)
    (hf : ∀ x : G, f x⁻¹ = (f x)⁻¹) (g : ι → G) (n : ℤ) : f ∘ (g ^ n) = f ∘ g ^ n

{ι : Type u_1}
{G : Type u_7}
{H : Type u_8}
{F : Type u_9}
[FunLike F G H]
[SubNegMonoid G]
[SubNegMonoid H]
[AddMonoidHomClass F G H]
(f : F)
(hf : ∀ (x : G), f (-x) = -f x)
(g : ι → G)
(n : ℤ)


@[to_additive (attr := simp) smul_ite]
lemma ite_pow (p : Prop) [Decidable p] (a b : α) (c : β) :
    (if p then a else b) ^ c = if p then a ^ c else b ^ c

{α : Type u_1}
{β : Type u_2}
[Pow α β]
(p : Prop)
[Decidable p]
(a b : α)
(c : β)


@[deprecated bind_pure_eq_map (since := "2024-03-24")]
theorem bind_ret_eq_map (f : α → β) (l : List α) : l.bind (List.ret ∘ f) = map f l

{α : Type u}
{β : Type v}
(f : α → β)
(l : List α)


@[to_additive]
theorem mul_left_cancel_iff : a * b = a * c ↔ b = c

{G : Type u_1}
[Add G]
[IsLeftCancelAdd G]
{a b c : G}


@[simp]
theorem dual_Iic : Iic (toDual a) = ofDual ⁻¹' Ici a

Set.Iic (OrderDual.toDual a) = ⇑OrderDual.ofDual ⁻¹' Set.Ici a


@[simp]
theorem fst_smul [SMul S R] [SMul S M] (s : S) (x : tsze R M) : (s • x).fst = s • x.fst

{S : Type u_2}
{R : Type u}
{M : Type v}
[SMul S R]
[SMul S M]
(s : S)
(x : tsze R M)


@[simp]
theorem sup_ndunion (s₁ s₂ : Multiset α) : (ndunion s₁ s₂).sup = s₁.sup ⊔ s₂.sup

{α : Type u_1}
[SemilatticeSup α]
[OrderBot α]
[DecidableEq α]
(s₁ s₂ : Multiset α)


@[measurability, fun_prop]
theorem Measurable.norm {f : β → α} (hf : Measurable f) : Measurable fun a => norm (f a)

{α : Type u_1}
{β : Type u_2}
[MeasurableSpace α]
[NormedAddCommGroup α]
[OpensMeasurableSpace α]
[MeasurableSpace β]
{f : β → α}
(hf : Measurable f)


@[simp]
theorem intCast_real_norm (x : ℤ[i]) : (x.norm : ℝ) = Complex.normSq (x : ℂ)

↑(Zsqrtd.norm x) = Complex.normSq (GaussianInt.toComplex x)


@[simp]
theorem compl_setOf_mem {φ : L[[α]].Sentence} :
    { p : T.CompleteType α | φ ∈ p }ᶜ = { p : T.CompleteType α | φ.not ∈ p }

{L : FirstOrder.Language}
{T : L.Theory}
{α : Type w}
{φ : L[[α]].Sentence}

{p | φ ∈ p}ᶜ = {p | FirstOrder.Language.Formula.not φ ∈ p}


protected theorem pow_mul (a m n : Nat) : a ^ (m * n) = (a ^ m) ^ n


theorem isRightAdjoint_TFAE (u : b ⟶ a) :
    List.TFAE [
      IsRightAdjoint u,
      HasAbsLeftKanLift u (𝟙 a),
      ∃ _ : HasLeftKanLift u (𝟙 a), LanLift.CommuteWith u (𝟙 a) u]

{B : Type u}
[CategoryTheory.Bicategory B]
{a b : B}
(u : b ⟶ a)

[CategoryTheory.Bicategory.IsRightAdjoint u,
    CategoryTheory.Bicategory.HasAbsLeftKanLift u (CategoryTheory.CategoryStruct.id a),
    ∃ (x : CategoryTheory.Bicategory.HasLeftKanLift u (CategoryTheory.CategoryStruct.id a)),
      CategoryTheory.Bicategory.LanLift.CommuteWith u (CategoryTheory.CategoryStruct.id a) u].TFAE


@[simp]
theorem lcm_zero : (0 : Multiset α).lcm = 1

{α : Type u_1}
[CancelCommMonoidWithZero α]
[NormalizedGCDMonoid α]


theorem not_mem_Ico_of_ge (hb : b ≤ c) : c ∉ Ico a b

{α : Type u_1}
[Preorder α]
{a b c : α}
(hb : b ≤ c)


@[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_lt_coe : (p : ℚ) < q ↔ p < q


theorem differentiable_inner : Differentiable ℝ fun p : E × E => ⟪p.1, p.2⟫

{𝕜 : Type u_1}
{E : Type u_2}
[RCLike 𝕜]
[NormedAddCommGroup E]
[InnerProductSpace 𝕜 E]
[NormedSpace ℝ E]


theorem Fix.ind_aux (a : q.P.A) (f : q.P.B a → q.P.W) :
    Fix.mk (abs ⟨a, fun x => ⟦f x⟧⟩) = ⟦⟨a, f⟩⟧

{F : Type u → Type u}
[q : QPF F]
(a : (QPF.P F).A)
(f : (QPF.P F).B a → (QPF.P F).W)

QPF.Fix.mk (QPF.abs ⟨a, fun x => ⟦f x⟧⟩) = ⟦WType.mk a f⟧


@[simp] protected theorem Matroidᵣ.lt_iff {M M' : Matroidᵣ α} :
    M < M' ↔ (M : Matroid α) <r (M' : Matroid α)

{α : Type u_1}
{M M' : Matroid.Matroidᵣ α}

M < M' ↔ M.toMatroid.StrictRestriction M'.toMatroid


@[to_additive (attr := simp)]
protected theorem mul_cancel {r : R} {s t : S} : ((s : R) /ₒ t) * (r /ₒ s) = r /ₒ t

{R : Type u_1}
[AddMonoid R]
{S : AddSubmonoid R}
[AddOreLocalization.AddOreSet S]
{r : R}
{s t : ↥S}


theorem coe_algebraMap_over_bot :
    (algebraMap (⊥ : IntermediateField F E) F : (⊥ : IntermediateField F E) → F) =
      IntermediateField.botEquiv F E

{F : Type u_1}
[Field F]
{E : Type u_2}
[Field E]
[Algebra F E]

⇑(algebraMap (↥⊥) F) = ⇑(IntermediateField.botEquiv F E)


@[simp]
theorem id_right (f : Arrow T) : CommaMorphism.right (𝟙 f) = 𝟙 f.right

{T : Type u}
[CategoryTheory.Category.{v, u} T]
(f : CategoryTheory.Arrow T)

(CategoryTheory.CategoryStruct.id f).right = CategoryTheory.CategoryStruct.id f.right


@[to_additive existing (attr := simp) zpow_addRight]
lemma zpow_mulRight : ∀ n : ℤ, Equiv.mulRight a ^ n = Equiv.mulRight (a ^ n)


/-- Makes a Galois connection from an order-preserving bijection. -/
theorem OrderIso.to_galoisConnection [Preorder α] [Preorder β] (oi : α ≃o β) :
    GaloisConnection oi oi.symm

{α : Type u}
{β : Type v}
[Preorder α]
[Preorder β]
(oi : α ≃o β)


theorem frontier_eq_inter_compl_interior :
    frontier s = (interior s)ᶜ ∩ (interior sᶜ)ᶜ

{X : Type u}
{s : Set X}
[TopologicalSpace X]


theorem map_range (f : A →ₐ[R] B) (g : C →ₐ[R] D) :
    (map f g).range = (includeLeft.comp f).range ⊔ (includeRight.comp g).range

{R : Type uR}
{A : Type uA}
{B : Type uB}
{C : Type uC}
{D : Type uD}
[CommSemiring R]
[Semiring A]
[Algebra R A]
[Semiring B]
[Algebra R B]
[Semiring C]
[Algebra R C]
[Semiring D]
[Algebra R D]
(f : A →ₐ[R] B)
(g : C →ₐ[R] D)

(Algebra.TensorProduct.map f g).range =
  (Algebra.TensorProduct.includeLeft.comp f).range ⊔ (Algebra.TensorProduct.includeRight.comp g).range


theorem copy_eq (S : Subsemiring R) (s : Set R) (hs : s = ↑S) : S.copy s hs = S

{R : Type u}
[NonAssocSemiring R]
(S : Subsemiring R)
(s : Set R)
(hs : s = ↑S)


theorem eq_of_le_of_card_le {s t : Multiset α} (h : s ≤ t) : card t ≤ card s → s = t

{α : Type u_1}
{s t : Multiset α}
(h : s ≤ t)

Multiset.card t ≤ Multiset.card s → s = t


theorem liftIco_coe_apply {f : 𝕜 → B} {x : 𝕜} (hx : x ∈ Ico a (a + p)) :
    liftIco p a f ↑x = f x

{𝕜 : Type u_1}
{B : Type u_2}
[LinearOrderedAddCommGroup 𝕜]
[TopologicalSpace 𝕜]
[OrderTopology 𝕜]
{p : 𝕜}
[hp : Fact (0 < p)]
{a : 𝕜}
[Archimedean 𝕜]
{f : 𝕜 → B}
{x : 𝕜}
(hx : x ∈ Set.Ico a (a + p))


theorem ramificationIdx_eq_normalizedFactors_count (hp0 : map f p ≠ ⊥) (hP : P.IsPrime)
    (hP0 : P ≠ ⊥) : ramificationIdx f p P = (normalizedFactors (map f p)).count P

{R : Type u}
[CommRing R]
{S : Type v}
[CommRing S]
{f : R →+* S}
{p : Ideal R}
{P : Ideal S}
[IsDedekindDomain S]
(hp0 : Ideal.map f p ≠ ⊥)
(hP : P.IsPrime)
(hP0 : P ≠ ⊥)

Ideal.ramificationIdx f p P = Multiset.count P (UniqueFactorizationMonoid.normalizedFactors (Ideal.map f p))


{R : Type u_3}
[CommRing R]
{c₁ c₂ : R}
(a b : ℍ[R,c₁,c₂])

(a * b).imI = a.re * b.imI + a.imI * b.re - c₂ * a.imJ * b.imK + c₂ * a.imK * b.imJ


protected lemma mul_le_mul_iff_of_pos_right (ha : 0 < a) : b * a ≤ c * a ↔ b ≤ c


@[simp]
theorem gcd_ndinsert (a : α) (s : Multiset α) : (ndinsert a s).gcd = GCDMonoid.gcd a s.gcd

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

(Multiset.ndinsert a s).gcd = gcd a s.gcd


@[simp]
theorem sections_zero : Sections (0 : Multiset (Multiset α)) = {0}


@[ext]
theorem Hom.ext {S₁ S₂ : Split C} (Φ₁ Φ₂ : Hom S₁ S₂) (h : ∀ n : ℕ, Φ₁.f n = Φ₂.f n) : Φ₁ = Φ₂

{C : Type u_1}
[CategoryTheory.Category.{u_2, u_1} C]
{S₁ S₂ : SimplicialObject.Split C}
(Φ₁ Φ₂ : S₁.Hom S₂)
(h : ∀ (n : ℕ), Φ₁.f n = Φ₂.f n)


theorem UniformContinuousOn.tendstoUniformlyOn [UniformSpace α] [UniformSpace γ] {x : α} {U : Set α}
    {V : Set β} {F : α → β → γ} (hF : UniformContinuousOn (↿F) (U ×ˢ V)) (hU : x ∈ U) :
    TendstoUniformlyOn F (F x) (𝓝[U] x) V

{F : α → β → γ}


theorem all_iff_forall {p : α → Bool} : all l p ↔ ∀ a ∈ l, p a

{α : Type u_1}
{l : List α}
{p : α → Bool}

l.all p = true ↔ ∀ (a : α), a ∈ l → p a = true


@[to_additive]
lemma pow_inj_mod {n m : ℕ} : x ^ n = x ^ m ↔ n % orderOf x = m % orderOf x

{G : Type u_1}
[AddLeftCancelMonoid G]
{x : G}
{n m : ℕ}

n • x = m • x ↔ n % addOrderOf x = m % addOrderOf x


@[to_additive]
theorem comp_mono (hp : p ≤ q) : p.comp f ≤ q.comp f

{E : Type u_4}
{F : Type u_5}
[Group E]
[Group F]
{p q : GroupSeminorm E}
(f : F →* E)
(hp : p ≤ q)


theorem Subperm.cons_right {α : Type _} {l l' : List α} (x : α) (h : l <+~ l') : l <+~ x :: l'


@[to_additive]
theorem _root_.FreeMonoid.mrange_lift {α} (f : α → M) :
    mrange (FreeMonoid.lift f) = closure (Set.range f)

{M : Type u_1}
[Monoid M]
{α : Type u_4}
(f : α → M)

MonoidHom.mrange (FreeMonoid.lift f) = Submonoid.closure (Set.range f)


theorem hom_left_act_hom' :
    ((regular R).tensorBimod P).actLeft ≫ hom P = (R.X ◁ hom P) ≫ P.actLeft

[(X : C) →
    CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)]

[(X : C) →
    CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
      (CategoryTheory.MonoidalCategory.tensorRight X)]

((Bimod.regular R).tensorBimod P).actLeft ≫ Bimod.LeftUnitorBimod.hom P = R.X ◁ Bimod.LeftUnitorBimod.hom P ≫ P.actLeft


theorem countable_bInter_mem {ι : Type*} {S : Set ι} (hS : S.Countable) {s : ∀ i ∈ S, Set α} :
    (⋂ i, ⋂ hi : i ∈ S, s i ‹_›) ∈ l ↔ ∀ i, ∀ hi : i ∈ S, s i ‹_› ∈ l

{α : Type u_2}
{l : Filter α}
[CountableInterFilter l]
{ι : Type u_4}
{S : Set ι}
(hS : S.Countable)
{s : (i : ι) → i ∈ S → Set α}

⋂ i, ⋂ (hi : i ∈ S), s i hi ∈ l ↔ ∀ (i : ι) (hi : i ∈ S), s i hi ∈ l


protected theorem IsSuccLimit.isMin (h : IsSuccLimit a) : IsMin a

{α : Type u_1}
[PartialOrder α]
[SuccOrder α]
{a : α}
[IsSuccArchimedean α]
(h : Order.IsSuccLimit a)


@[fun_prop]
theorem HasFDerivWithinAt.multiset_prod [DecidableEq ι] {u : Multiset ι} {x : E}
    (h : ∀ i ∈ u, HasFDerivWithinAt (g i ·) (g' i) s x) :
    HasFDerivWithinAt (fun x ↦ (u.map (g · x)).prod)
      (u.map fun i ↦ ((u.erase i).map (g · x)).prod • g' i).sum s x

(h : ∀ i ∈ u, HasFDerivWithinAt (fun x => g i x) (g' i) s x)

HasFDerivWithinAt (fun x => (Multiset.map (fun x_1 => g x_1 x) u).prod)
  (Multiset.map (fun i => (Multiset.map (fun x_1 => g x_1 x) (u.erase i)).prod • g' i) u).sum s x


theorem nhds_mkOfNhds (n : α → Filter α) (a : α) (h₀ : pure ≤ n)
    (h₁ : ∀ a, ∀ s ∈ n a, ∀ᶠ y in n a, s ∈ n y) :
    @nhds α (TopologicalSpace.mkOfNhds n) a = n a

(h₁ : ∀ (a : α), ∀ s ∈ n a, ∀ᶠ (y : α) in n a, s ∈ n y)


@[to_additive]
theorem tprod_le_one (h : ∀ i, f i ≤ 1) : ∏' i, f i ≤ 1

{ι : Type u_1}
{α : Type u_3}
[OrderedCommMonoid α]
[TopologicalSpace α]
[OrderClosedTopology α]
{f : ι → α}
(h : ∀ (i : ι), f i ≤ 1)


@[simp]
theorem leftZigzagIso_hom : (leftZigzagIso η ε).hom = leftZigzag η.hom ε.hom

(η : CategoryTheory.CategoryStruct.id a ≅ CategoryTheory.CategoryStruct.comp f g)

(ε : CategoryTheory.CategoryStruct.comp g f ≅ CategoryTheory.CategoryStruct.id b)

(CategoryTheory.Bicategory.leftZigzagIso η ε).hom = CategoryTheory.Bicategory.leftZigzag η.hom ε.hom


/-- The first projection of a product is a non-unital alg_hom. -/
@[simps]
def fst : A × B →ₙₐ[R] A

(R : Type u)
[Monoid R]
(A : Type v)
(B : Type w)
[NonUnitalNonAssocSemiring A]
[DistribMulAction R A]
[NonUnitalNonAssocSemiring B]
[DistribMulAction R B]
(self : A × B)

(NonUnitalAlgHom.fst R A B) self = self.1


theorem range_subset : Set.range (algebraMap R A) ⊆ S

{R : Type u}
{A : Type v}
[CommSemiring R]
[Semiring A]
[Algebra R A]
(S : Subalgebra R A)


@[simp]
theorem insertNone_eraseNone [DecidableEq (Option α)] (s : Finset (Option α)) :
    insertNone (eraseNone s) = insert none s

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

Finset.insertNone (Finset.eraseNone s) = insert none s


@[simp, norm_cast]
protected theorem coe_ofNat (n : ℕ) [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n : ℝ≥0) : ℝ) = OfNat.ofNat n


theorem norm_integral_le_norm (f : α →₁ₛ[μ] E) : ‖integral f‖ ≤ ‖f‖

(f : ↥(MeasureTheory.Lp.simpleFunc E 1 μ))

‖MeasureTheory.L1.SimpleFunc.integral f‖ ≤ ‖f‖


theorem SOppSide.left_not_mem {s : AffineSubspace R P} {x y : P} (h : s.SOppSide x y) : x ∉ s

{R : Type u_1}
{V : Type u_2}
{P : Type u_4}
[StrictOrderedCommRing R]
[AddCommGroup V]
[Module R V]
[AddTorsor V P]
{s : AffineSubspace R P}
{x y : P}
(h : s.SOppSide x y)


/-- Converse of "angles in same segment are equal" and "opposite angles of a cyclic quadrilateral
add to π", for oriented angles mod π, with a "concyclic" conclusion. -/
theorem concyclic_of_two_zsmul_oangle_eq_of_not_collinear {p₁ p₂ p₃ p₄ : P}
    (h : (2 : ℤ) • ∡ p₁ p₂ p₄ = (2 : ℤ) • ∡ p₁ p₃ p₄) (hn : ¬Collinear ℝ ({p₁, p₂, p₄} : Set P)) :
    Concyclic ({p₁, p₂, p₃, p₄} : Set P)

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

EuclideanGeometry.Concyclic {p₁, p₂, p₃, p₄}


lemma coe_sInf (hs : s.Nonempty) : ↑(sInf s) = ⨅ a ∈ s, (a : ℕ∞)


theorem natCast_kronecker [NonAssocSemiring α] [DecidableEq l] (a : ℕ) (B : Matrix m n α) :
    (a : Matrix l l α) ⊗ₖ B =
      Matrix.reindex (Equiv.prodComm _ _) (Equiv.prodComm _ _) (blockDiagonal fun _ => a • B)

{α : Type u_2}
{l : Type u_8}
{m : Type u_9}
{n : Type u_10}
[NonAssocSemiring α]
[DecidableEq l]
(a : ℕ)
(B : Matrix m n α)

Matrix.kroneckerMap (fun x x_1 => x * x_1) (↑a) B =
  (Matrix.reindex (Equiv.prodComm m l) (Equiv.prodComm n l)) (Matrix.blockDiagonal fun x => a • B)


@[simp]
theorem iInf_toSubalgebra {ι : Sort*} (S : ι → IntermediateField F E) :
    (iInf S).toSubalgebra = ⨅ i, (S i).toSubalgebra

{F : Type u_1}
[Field F]
{E : Type u_2}
[Field E]
[Algebra F E]
{ι : Sort u_3}
(S : ι → IntermediateField F E)


/-- If `P` is a submodule of `M` and `Q` a submodule of `N`,
and `f : M ≃ₗ N` maps `P` to `Q`, then `M ⧸ P` is equivalent to `N ⧸ Q`. -/
@[simps]
def Quotient.equiv {N : Type*} [AddCommGroup N] [Module R N] (P : Submodule R M)
    (Q : Submodule R N) (f : M ≃ₗ[R] N) (hf : P.map f = Q) : (M ⧸ P) ≃ₗ[R] N ⧸ Q

{R : Type u_1}
{M : Type u_2}
[Ring R]
[AddCommGroup M]
[Module R M]
{N : Type u_5}
[AddCommGroup N]
[Module R N]
(P : Submodule R M)
(Q : Submodule R N)
(f : M ≃ₗ[R] N)
(hf : Submodule.map f P = Q)
(a : M ⧸ P)

(Submodule.Quotient.equiv P Q f hf) a = (P.mapQ Q ↑f ⋯) a


theorem Range.isSubfield {K : Type*} [Field K] (f : F →+* K) : IsSubfield (Set.range f)

{F : Type u_1}
[Field F]
{K : Type u_2}
[Field K]
(f : F →+* K)


theorem iSup_add {ι : Sort*} {s : ι → ℝ≥0∞} [Nonempty ι] : iSup s + a = ⨆ b, s b + a

{a : ℝ≥0∞}
{ι : Sort u_4}
{s : ι → ℝ≥0∞}
[Nonempty ι]


@[to_additive] lemma lt_of_mabs_lt : |a|ₘ < b → a < b

{α : Type u_1}
[AddGroup α]
[LinearOrder α]
{a b : α}


lemma IsIntegralCurve.isIntegralCurveAt (h : IsIntegralCurve γ v) (t : ℝ) :
    IsIntegralCurveAt γ v t

{E : Type u_1}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
{H : Type u_2}
[TopologicalSpace H]
{I : ModelWithCorners ℝ E H}
{M : Type u_3}
[TopologicalSpace M]
[ChartedSpace H M]
[SmoothManifoldWithCorners I M]
{γ : ℝ → M}
{v : (x : M) → TangentSpace I x}
(h : IsIntegralCurve γ v)
(t : ℝ)


theorem revzip_powersetAux_lemma {α : Type*} [DecidableEq α] (l : List α) {l' : List (Multiset α)}
    (H : ∀ ⦃x : _ × _⦄, x ∈ revzip l' → x.1 + x.2 = ↑l) :
    revzip l' = l'.map fun x => (x, (l : Multiset α) - x)

(H : ∀ ⦃x : Multiset α × Multiset α⦄, x ∈ l'.revzip → x.1 + x.2 = ↑l)

l'.revzip = List.map (fun x => (x, ↑l - x)) l'


@[simp]
theorem coe_mul (e e' : P₁ ≃ᵃ[k] P₁) : ⇑(e * e') = e ∘ e'

{k : Type u_1}
{P₁ : Type u_2}
{V₁ : Type u_6}
[Ring k]
[AddCommGroup V₁]
[Module k V₁]
[AffineSpace V₁ P₁]
(e e' : P₁ ≃ᵃ[k] P₁)


@[simp]
theorem fst_inr [Zero R] (m : M) : (inr m : tsze R M).fst = 0

(R : Type u)
{M : Type v}
[Zero R]
(m : M)


theorem Pred.rec_iff {p : α → Prop} (hsucc : ∀ a, p a ↔ p (pred a)) {a b : α} (h : a ≤ b) :
    p a ↔ p b

(hsucc : ∀ (a : α), p a ↔ p (Order.pred a))


theorem QuotientMap.continuousOn_isOpen_iff {f : α → β} {g : β → γ} (h : QuotientMap f) {s : Set β}
    (hs : IsOpen s) : ContinuousOn g s ↔ ContinuousOn (g ∘ f) (f ⁻¹' s)

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
[TopologicalSpace α]
[TopologicalSpace β]
[TopologicalSpace γ]
{f : α → β}
{g : β → γ}
(h : QuotientMap f)
{s : Set β}
(hs : IsOpen s)


theorem map {v' : AddValuation R Γ₀} (f : Γ₀ →+ Γ'₀) (ht : f ⊤ = ⊤) (hf : Monotone f)
    (inf : Injective f) (h : v.IsEquiv v') : (v.map f ht hf).IsEquiv (v'.map f ht hf)

{R : Type u_3}
{Γ₀ : Type u_4}
{Γ'₀ : Type u_5}
[LinearOrderedAddCommMonoidWithTop Γ₀]
[LinearOrderedAddCommMonoidWithTop Γ'₀]
[Ring R]
{v v' : AddValuation R Γ₀}
(f : Γ₀ →+ Γ'₀)
(ht : f ⊤ = ⊤)
(hf : Monotone ⇑f)
(inf : Function.Injective ⇑f)
(h : v.IsEquiv v')

(AddValuation.map f ht hf v).IsEquiv (AddValuation.map f ht hf v')


@[simp]
theorem diagonal (F : C × D ⥤ E) (X X' : C) (f : X ⟶ X') (Y Y' : D) (g : Y ⟶ Y') :
    F.map ((𝟙 X, g) : (X, Y) ⟶ (X, Y')) ≫ F.map ((f, 𝟙 Y') : (X, Y') ⟶ (X', Y')) =
      F.map ((f, g) : (X, Y) ⟶ (X', Y'))

{C : Type u₁}
{D : Type u₂}
{E : Type u₃}
[CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.Category.{v₂, u₂} D]
[CategoryTheory.Category.{v₃, u₃} E]
(F : C × D ⥤ E)
(X X' : C)
(f : X ⟶ X')
(Y Y' : D)
(g : Y ⟶ Y')

F.map (𝟙 X, g) ≫ F.map (f, 𝟙 Y') = F.map (f, g)


@[to_additive (attr := simp)]
theorem coe_mrangeRestrict {N} [MulOneClass N] (f : M →* N) (x : M) :
    (f.mrangeRestrict x : N) = f x

{M : Type u_1}
[MulOneClass M]
{N : Type u_6}
[MulOneClass N]
(f : M →* N)
(x : M)


/-- The type of morphisms in the category `Φ.RightResolution X₂` (when `W₁` is multiplicative). -/
@[ext]
structure Hom (R R' : Φ.RightResolution X₂) where
  /-- a morphism in the source category -/
  f : R.X₁ ⟶ R'.X₁
  hf : W₁ f
  comm : R.w ≫ Φ.functor.map f = R'.w := by aesop_cat

{W₁ : CategoryTheory.MorphismProperty C₁}

{W₂ : CategoryTheory.MorphismProperty C₂}

{Φ : CategoryTheory.LocalizerMorphism W₁ W₂}


theorem card_le_one_iff : s.card ≤ 1 ↔ ∀ {a b}, a ∈ s → b ∈ s → a = b

s.card ≤ 1 ↔ ∀ {a b : α}, a ∈ s → b ∈ s → a = b


@[reassoc]
theorem leftUnitor_tensor_inv (X Y : C) :
    (λ_ (X ⊗ Y)).inv = (λ_ X).inv ▷ Y ≫ (α_ (𝟙_ C) X Y).hom

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

(CategoryTheory.MonoidalCategory.leftUnitor (CategoryTheory.MonoidalCategory.tensorObj X Y)).inv =
  CategoryTheory.CategoryStruct.comp
    (CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.MonoidalCategory.leftUnitor X).inv Y)
    (CategoryTheory.MonoidalCategory.associator (𝟙_ C) X Y).hom


theorem Subgroup.val_conj_smul {H : Subgroup G} [H.Normal] (g : ConjAct G) (h : H) :
    ↑(g • h) = g • (h : G)

{G : Type u_3}
[Group G]
{H : Subgroup G}
[H.Normal]
(g : ConjAct G)
(h : ↥H)


@[to_additive]
theorem finprod_curry₃ {γ : Type*} (f : α × β × γ → M) (h : (mulSupport f).Finite) :
    ∏ᶠ abc, f abc = ∏ᶠ (a) (b) (c), f (a, b, c)

{α : Type u_1}
{β : Type u_2}
{M : Type u_5}
[AddCommMonoid M]
{γ : Type u_7}
(f : α × β × γ → M)
(h : (Function.support f).Finite)

∑ᶠ (abc : α × β × γ), f abc = ∑ᶠ (a : α) (b : β) (c : γ), f (a, b, c)


protected theorem isClosed (K : ProperCone 𝕜 E) : IsClosed (K : Set E)

{𝕜 : Type u_1}
[OrderedSemiring 𝕜]
{E : Type u_2}
[AddCommMonoid E]
[TopologicalSpace E]
[Module 𝕜 E]
(K : ProperCone 𝕜 E)


@[gcongr]
theorem lmarginal_mono {f g : (∀ i, π i) → ℝ≥0∞} (hfg : f ≤ g) : ∫⋯∫⁻_s, f ∂μ ≤ ∫⋯∫⁻_s, g ∂μ

{μ : (i : δ) → MeasureTheory.Measure (π i)}

∫⋯∫⁻_s, f ∂μ ≤ ∫⋯∫⁻_s, g ∂μ


protected theorem sdiff_self (s₁ : Finset α) : s₁ \ s₁ = ∅

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


@[reassoc (attr := simp)]
theorem inl_inr_pushoutAssoc_inv [HasPushout (g₃ ≫ (pushout.inr _ _ : X₂ ⟶ Y₁)) g₄]
    [HasPushout g₁ (g₂ ≫ (pushout.inl _ _ : X₂ ⟶ Y₂))] :
    pushout.inl _ _ ≫ pushout.inr _ _ ≫ (pushoutAssoc g₁ g₂ g₃ g₄).inv =
      pushout.inr _ _ ≫ pushout.inl _ _

[CategoryTheory.Limits.HasPushout (g₃ ≫ CategoryTheory.Limits.pushout.inr g₁ g₂) g₄]

[CategoryTheory.Limits.HasPushout g₁ (g₂ ≫ CategoryTheory.Limits.pushout.inl g₃ g₄)]

CategoryTheory.Limits.pushout.inl g₃ g₄ ≫
    CategoryTheory.Limits.pushout.inr g₁ (g₂ ≫ CategoryTheory.Limits.pushout.inl g₃ g₄) ≫
      (CategoryTheory.Limits.pushoutAssoc g₁ g₂ g₃ g₄).inv =
  CategoryTheory.Limits.pushout.inr g₁ g₂ ≫
    CategoryTheory.Limits.pushout.inl (g₃ ≫ CategoryTheory.Limits.pushout.inr g₁ g₂) g₄


theorem continuous_integral_comp_L1 (L : E →L[𝕜] F) :
    Continuous fun φ : X →₁[μ] E => ∫ x : X, L (φ x) ∂μ

{X : Type u_1}
{E : Type u_3}
{F : Type u_4}
[MeasurableSpace X]
{μ : MeasureTheory.Measure X}
{𝕜 : Type u_5}
[RCLike 𝕜]
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
[NormedSpace ℝ F]
(L : E →L[𝕜] F)

Continuous fun φ => ∫ (x : X), L (↑↑φ x) ∂μ


/-- A dependent version of `Subgroup.closure_induction`.  -/
@[to_additive (attr := elab_as_elim) "A dependent version of `AddSubgroup.closure_induction`. "]
theorem closure_induction' {p : ∀ x, x ∈ closure k → Prop}
    (mem : ∀ (x) (h : x ∈ k), p x (subset_closure h)) (one : p 1 (one_mem _))
    (mul : ∀ x hx y hy, p x hx → p y hy → p (x * y) (mul_mem hx hy))
    (inv : ∀ x hx, p x hx → p x⁻¹ (inv_mem hx)) {x} (hx : x ∈ closure k) : p x hx

{p : (x : G) → x ∈ AddSubgroup.closure k → Prop}

(mul :
  ∀ (x : G) (hx : x ∈ AddSubgroup.closure k) (y : G) (hy : y ∈ AddSubgroup.closure k), p x hx → p y hy → p (x + y) ⋯)

(inv : ∀ (x : G) (hx : x ∈ AddSubgroup.closure k), p x hx → p (-x) ⋯)


theorem card_cliqueFinset_le : (G.cliqueFinset n).card ≤ (card α).choose n

{α : Type u_1}
{G : SimpleGraph α}
[Fintype α]
[DecidableEq α]
[DecidableRel G.Adj]
{n : ℕ}

(G.cliqueFinset n).card ≤ (Fintype.card α).choose n


@[simp]
theorem rtakeWhile_concat_neg (x : α) (h : ¬p x) : rtakeWhile p (l ++ [x]) = []

{α : Type u_1}
(p : α → Bool)
(l : List α)
(x : α)
(h : ¬p x = true)


lemma shiftFunctorComm_zero_hom_app (a : A) :
    (shiftFunctorComm C a 0).hom.app X =
      (shiftFunctorZero C A).hom.app (X⟦a⟧) ≫ ((shiftFunctorZero C A).inv.app X)⟦a⟧'

{C : Type u}
{A : Type u_1}
[CategoryTheory.Category.{v, u} C]
[AddCommMonoid A]
[CategoryTheory.HasShift C A]
{X : C}
(a : A)

(CategoryTheory.shiftFunctorComm C a 0).hom.app X =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctorZero C A).hom.app ((CategoryTheory.shiftFunctor C a).obj X))
    ((CategoryTheory.shiftFunctor C a).map ((CategoryTheory.shiftFunctorZero C A).inv.app X))


@[simp]
theorem coe_sInf : (↑(sInf S) : Set P) = ⋂ s ∈ S, ↑s

{P : Type u_1}
[SemilatticeSup P]
[OrderBot P]
{S : Set (Order.Ideal P)}


theorem abs_sign_of_nonzero {z : ℤ} (hz : z ≠ 0) : |z.sign| = 1


/-- A special case of `eq_intCast'` that happens to be true definitionally -/
@[simp]
theorem algebraMap_int_eq : algebraMap ℤ R = Int.castRingHom R


lemma iInf_coe_eq_top : ⨅ i, (f i : ℝ≥0∞) = ⊤ ↔ IsEmpty ι