@[simp]
theorem linear_eq_linearIsometry : f.linear = f.linearIsometry.toLinearMap

{𝕜 : Type u_1}
{V : Type u_2}
{V₂ : Type u_5}
{P : Type u_10}
{P₂ : Type u_11}
[NormedField 𝕜]
[SeminormedAddCommGroup V]
[NormedSpace 𝕜 V]
[PseudoMetricSpace P]
[NormedAddTorsor V P]
[SeminormedAddCommGroup V₂]
[NormedSpace 𝕜 V₂]
[PseudoMetricSpace P₂]
[NormedAddTorsor V₂ P₂]
(f : P →ᵃⁱ[𝕜] P₂)


theorem sub_eq_zero_of_upcrossingsBefore_lt (hab : a < b) (hn : upcrossingsBefore a b f N ω < n) :
    stoppedValue f (upperCrossingTime a b f N (n + 1)) ω -
      stoppedValue f (lowerCrossingTime a b f N n) ω = 0

{f : ℕ → Ω → ℝ}

(hn : MeasureTheory.upcrossingsBefore a b f N ω < n)

MeasureTheory.stoppedValue f (MeasureTheory.upperCrossingTime a b f N (n + 1)) ω -
    MeasureTheory.stoppedValue f (MeasureTheory.lowerCrossingTime a b f N n) ω =
  0


/-- An auxiliary equivalence useful in the proofs about
`FormalMultilinearSeries.changeOriginSeries`: the set of triples `(k, l, s)`, where `s` is a
`Finset (Fin (k + l))` of cardinality `l` is equivalent to the set of pairs `(n, s)`, where `s` is a
`Finset (Fin n)`.

The forward map sends `(k, l, s)` to `(k + l, s)` and the inverse map sends `(n, s)` to
`(n - Finset.card s, Finset.card s, s)`. The actual definition is less readable because of problems
with non-definitional equalities. -/
@[simps]
def changeOriginIndexEquiv :
    (Σ k l : ℕ, { s : Finset (Fin (k + l)) // s.card = l }) ≃ Σ n : ℕ, Finset (Fin n)

↑(FormalMultilinearSeries.changeOriginIndexEquiv.symm s).snd.snd = Finset.map (finCongr ⋯).toEmbedding s.snd


theorem map_comp (f₂ : P →ₗ[R] P') (f₁ : M →ₗ[R] P) (g₂ : Q →ₗ[R] Q') (g₁ : N →ₗ[R] Q) :
    map (f₂.comp f₁) (g₂.comp g₁) = (map f₂ g₂).comp (map f₁ g₁)

{R : Type u_1}
[CommSemiring R]
{M : Type u_4}
{N : Type u_5}
{P : Type u_6}
{Q : Type u_7}
[AddCommMonoid M]
[AddCommMonoid N]
[AddCommMonoid P]
[AddCommMonoid Q]
[Module R M]
[Module R N]
[Module R P]
[Module R Q]
{P' : Type u_10}
{Q' : Type u_11}
[AddCommMonoid P']
[Module R P']
[AddCommMonoid Q']
[Module R Q']
(f₂ : P →ₗ[R] P')
(f₁ : M →ₗ[R] P)
(g₂ : Q →ₗ[R] Q')
(g₁ : N →ₗ[R] Q)

TensorProduct.map (f₂ ∘ₗ f₁) (g₂ ∘ₗ g₁) = TensorProduct.map f₂ g₂ ∘ₗ TensorProduct.map f₁ g₁


theorem smoothAt_prod_iff (f : M → M' × N') {x : M} :
    SmoothAt I (I'.prod J') f x ↔ SmoothAt I I' (Prod.fst ∘ f) x ∧ SmoothAt I J' (Prod.snd ∘ f) x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{H : Type u_3}
[TopologicalSpace H]
{I : ModelWithCorners 𝕜 E H}
{M : Type u_4}
[TopologicalSpace M]
[ChartedSpace H M]
{E' : Type u_5}
[NormedAddCommGroup E']
[NormedSpace 𝕜 E']
{H' : Type u_6}
[TopologicalSpace H']
{I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7}
[TopologicalSpace M']
[ChartedSpace H' M']
{F' : Type u_14}
[NormedAddCommGroup F']
[NormedSpace 𝕜 F']
{G' : Type u_15}
[TopologicalSpace G']
{J' : ModelWithCorners 𝕜 F' G'}
{N' : Type u_16}
[TopologicalSpace N']
[ChartedSpace G' N']
(f : M → M' × N')
{x : M}


@[to_additive]
lemma inv_mul_cancel_assoc (h : Commute a b) : a⁻¹ * (b * a) = b

{G : Type u_1}
[AddGroup G]
{a b : G}
(h : AddCommute a b)


theorem lift_lift_apply (x : N) : lift g (lift i j p) p x = lift (g.comp i) j p x

{K : Type u_1}
{L : Type u_2}
{M : Type u_3}
{N : Type u_4}
[CommRing K]
[CommRing L]
[CommRing M]
[CommRing N]
(i : K →+* L)
(j : K →+* M)
(g : L →+* N)
(p : ℕ)
[ExpChar K p]
[ExpChar L p]
[ExpChar M p]
[ExpChar N p]
[PerfectRing M p]
[IsPRadical i p]
[IsPRadical g p]
[IsPRadical (g.comp i) p]
(x : N)

(PerfectRing.lift g (PerfectRing.lift i j p) p) x = (PerfectRing.lift (g.comp i) j p) x


theorem exists_isSubordinate_chartAt_source :
    ∃ f : SmoothPartitionOfUnity M I M univ, f.IsSubordinate (fun x ↦ (chartAt H x).source)

{E : Type uE}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
[FiniteDimensional ℝ E]
{H : Type uH}
[TopologicalSpace H]
(I : ModelWithCorners ℝ E H)
(M : Type uM)
[TopologicalSpace M]
[ChartedSpace H M]
[SmoothManifoldWithCorners I M]
[T2Space M]
[SigmaCompactSpace M]

∃ f, f.IsSubordinate fun x => (chartAt H x).source


@[simp]
theorem mem_compRel {α : Type u} {r₁ r₂ : Set (α × α)} {x y : α} :
    (x, y) ∈ r₁ ○ r₂ ↔ ∃ z, (x, z) ∈ r₁ ∧ (z, y) ∈ r₂


theorem prodCongr_refl_right (e : β₁ ≃ β₂) :
    prodCongr e (Equiv.refl α₁) = prodCongrLeft fun _ => e

{α₁ : Type u_3}
{β₁ : Type u_1}
{β₂ : Type u_2}
(e : β₁ ≃ β₂)

e.prodCongr (Equiv.refl α₁) = Equiv.prodCongrLeft fun x => e


lemma bit_le : ∀ (b : Bool) {m n : ℕ}, m ≤ n → bit b m ≤ bit b n


theorem Filter.EventuallyEq.fderivWithin_eq (hs : f₁ =ᶠ[𝓝[s] x] f) (hx : f₁ x = f x) :
    fderivWithin 𝕜 f₁ s x = fderivWithin 𝕜 f s x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{F : Type u_3}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{f f₁ : E → F}
{x : E}
{s : Set E}
(hs : f₁ =ᶠ[𝓝[s] x] f)
(hx : f₁ x = f x)


@[simp] theorem drop_empty {n : Nat} : "".drop n = ""


@[simp]
theorem quot_out_zero : Quot.out (0 : Associates α) = 0


theorem card_support_eq_zero : p.support.card = 0 ↔ p = 0


theorem tmul_one_mul_coe_tmul {i₂ : ι} (a₁ : A) (a₂ : 𝒜 i₂) (b₂ : B) :
    (a₁ ᵍ⊗ₜ[R] (1 : B) * (a₂ : A) ᵍ⊗ₜ[R] b₂ : 𝒜 ᵍ⊗[R] ℬ) = (a₁ * a₂ : A) ᵍ⊗ₜ (b₂ : B)

{R : Type u_1}
{ι : Type u_2}
{A : Type u_3}
{B : Type u_4}
[CommSemiring ι]
[Module ι (Additive ℤˣ)]
[DecidableEq ι]
[CommRing R]
[Ring A]
[Ring B]
[Algebra R A]
[Algebra R B]
(𝒜 : ι → Submodule R A)
(ℬ : ι → Submodule R B)
[GradedAlgebra 𝒜]
[GradedAlgebra ℬ]
{i₂ : ι}
(a₁ : A)
(a₂ : ↥(𝒜 i₂))
(b₂ : B)

a₁ ᵍ⊗ₜ[R] 1 * ↑a₂ ᵍ⊗ₜ[R] b₂ = (a₁ * ↑a₂) ᵍ⊗ₜ[R] b₂


@[to_additive (attr := simp)]
theorem mk_coe (e : M ≃* N) (e' h₁ h₂ h₃) : (⟨⟨e, e', h₁, h₂⟩, h₃⟩ : M ≃* N) = e

(h₃ :
  ∀ (x y : M),
    { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun (x + y) =
      { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun x +
        { toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂ }.toFun y)

{ toFun := ⇑e, invFun := e', left_inv := h₁, right_inv := h₂, map_add' := h₃ } = e


/-- If `p` is an independent family of submodules of a `R`-finite module `M`, then the
number of nontrivial subspaces in the family `p` is bounded above by the dimension of `M`.

Note that the `Fintype` hypothesis required here can be provided by
`CompleteLattice.Independent.fintypeNeBotOfFiniteDimensional`. -/
theorem CompleteLattice.Independent.subtype_ne_bot_le_finrank
    {p : ι → Submodule R M} (hp : CompleteLattice.Independent p) [Fintype { i // p i ≠ ⊥ }] :
    Fintype.card { i // p i ≠ ⊥ } ≤ finrank R M

{R : Type u}
{M : Type v}
{ι : Type w}
[Ring R]
[AddCommGroup M]
[Module R M]
[StrongRankCondition R]
[Module.Finite R M]
[NoZeroSMulDivisors R M]
{p : ι → Submodule R M}
(hp : CompleteLattice.Independent p)
[Fintype { i // p i ≠ ⊥ }]

Fintype.card { i // p i ≠ ⊥ } ≤ FiniteDimensional.finrank R M


@[reassoc (attr := simp)]
theorem σ_comp_πSummand_id_eq_zero {n : ℕ} (i : Fin (n + 1)) :
    X.σ i ≫ s.πSummand (IndexSet.id (op [n + 1])) = 0

{C : Type u_1}
[CategoryTheory.Category.{u_2, u_1} C]
{X : CategoryTheory.SimplicialObject C}
(s : SimplicialObject.Splitting X)
[CategoryTheory.Preadditive C]
{n : ℕ}
(i : Fin (n + 1))

X.σ i ≫ s.πSummand (SimplicialObject.Splitting.IndexSet.id (Opposite.op [n + 1])) = 0


@[to_additive]
protected theorem mul_inv (s s' : S) : ((s : R) /ₒ s') * ((s' : R) /ₒ s) = 1

{R : Type u_1}
[Monoid R]
{S : Submonoid R}
[OreLocalization.OreSet S]
(s s' : ↥S)


/-- `limit F` is functorial in `F`, when `C` has all limits of shape `J`. -/
@[simps]
def lim : (J ⥤ C) ⥤ C

CategoryTheory.Limits.lim.obj F = CategoryTheory.Limits.limit F


/-- If `Y` is in the essential image of `F` then it is in the essential image of `F'` as long as
`F ≅ F'`.
-/
theorem essImage.ofNatIso {F' : C ⥤ D} (h : F ≅ F') {Y : D} (hY : Y ∈ essImage F) :
    Y ∈ essImage F'

{C : Type u₁}
{D : Type u₂}
[CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.Category.{v₂, u₂} D]
{F F' : CategoryTheory.Functor C D}
(h : F ≅ F')
{Y : D}
(hY : Y ∈ F.essImage)


theorem isCodetecting_op_iff (𝒢 : Set C) : IsCodetecting 𝒢.op ↔ IsDetecting 𝒢

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

CategoryTheory.IsCodetecting 𝒢.op ↔ CategoryTheory.IsDetecting 𝒢


theorem pred_lt_of_lt {n m : Nat} (h : m < n) : pred n < n


/--
A `omega` problem.

This is a hybrid structure:
it contains both `Expr` objects giving proofs of the "ground" assumptions
(or rather continuations which will produce the proofs when needed)
and internal representations of the linear constraints that we manipulate in the algorithm.

While the algorithm is running we do not synthesize any new `Expr` proofs: proof extraction happens
only once we've found a contradiction.
-/
structure Problem where
  /-- The ground assumptions that the algorithm starts from. -/
  assumptions : Array Proof := ∅
  /-- The number of variables in the problem. -/
  numVars : Nat := 0
  /-- The current constraints, indexed by their coefficients. -/
  constraints : HashMap Coeffs Fact := ∅
  /--
  The coefficients for which `constraints` contains an exact constraint (i.e. an equality).
  -/
  equalities : HashSet Coeffs := ∅
  /--
  Equations that have already been used to eliminate variables,
  along with the variable which was removed, and its coefficient (either `1` or `-1`).
  The earlier elements are more recent,
  so if these are being reapplied it is essential to use `List.foldr`.
  -/
  eliminations : List (Fact × Nat × Int) := []
  /-- Whether the problem is possible. -/
  possible : Bool := true
  /-- If the problem is impossible, then `proveFalse?` will contain a proof of `False`. -/
  proveFalse? : Option Proof := none
  /-- Invariant between `possible` and `proveFalse?`. -/
  proveFalse?_spec : possible || proveFalse?.isSome := by rfl
  /--
  If we have found a contradiction,
  `explanation?` will contain a human readable account of the deriviation.
  -/
  explanation? : Thunk String := ""

(self.possible || self.proveFalse?.isSome) = true


theorem hasFiniteFPowerSeriesAt_const {c : F} {e : E} :
    HasFiniteFPowerSeriesAt (fun _ => c) (constFormalMultilinearSeries 𝕜 E c) e 1

{𝕜 : Type u_1}
{E : Type u_2}
{F : Type u_3}
[NontriviallyNormedField 𝕜]
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{c : F}
{e : E}

HasFiniteFPowerSeriesAt (fun x => c) (constFormalMultilinearSeries 𝕜 E c) e 1


/-- The induced functor `Sheaf K A ⥤ Sheaf J A` given by `F.op ⋙ _`
if `F` is a continuous functor.
-/
@[simps!]
def sheafPushforwardContinuous : Sheaf K A ⥤ Sheaf J A

(J : CategoryTheory.GrothendieckTopology C)

(K : CategoryTheory.GrothendieckTopology D)

∀ {X Y : CategoryTheory.Sheaf K A} (f : X ⟶ Y) (X_1 : Cᵒᵖ),
  ((F.sheafPushforwardContinuous A J K).map f).val.app X_1 = f.val.app (Opposite.op (F.obj (Opposite.unop X_1)))


lemma zpow_two_nonneg (a : α) : 0 ≤ a ^ (2 : ℤ)

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


@[simp]
theorem symm_symm (e : A ≃⋆+* B) : e.symm.symm = e

{A : Type u_1}
{B : Type u_2}
[Add A]
[Add B]
[Mul A]
[Mul B]
[Star A]
[Star B]
(e : A ≃⋆+* B)


@[simp]
theorem cons_bagInter_of_neg (l₁ : List α) (h : a ∉ l₂) :
    (a :: l₁).bagInter l₂ = l₁.bagInter l₂

{α : Type u_1}
{l₂ : List α}
{a : α}
[DecidableEq α]
(l₁ : List α)
(h : ¬a ∈ l₂)


@[simp, rclike_simps]
theorem inv_I : (I : K)⁻¹ = -I


theorem dropLast_append_cons : dropLast (l₁ ++ b::l₂) = l₁ ++ dropLast (b::l₂)

∀ {α : Type u_1} {l₁ : List α} {b : α} {l₂ : List α}, (l₁ ++ b :: l₂).dropLast = l₁ ++ (b :: l₂).dropLast


theorem normalizerCondition_of_isNilpotent [h : IsNilpotent G] : NormalizerCondition G

{G : Type u_1}
[Group G]
[h : Group.IsNilpotent G]


theorem nat_casesOn {f : α → ℕ} {g : α → σ} {h : α → ℕ → σ} (hf : Computable f) (hg : Computable g)
    (hh : Computable₂ h) :
    Computable fun a => Nat.casesOn (motive := fun _ => σ) (f a) (g a) (h a)

{α : Type u_1}
{σ : Type u_4}
[Primcodable α]
[Primcodable σ]
{f : α → ℕ}
{g : α → σ}
{h : α → ℕ → σ}
(hf : Computable f)
(hg : Computable g)
(hh : Computable₂ h)

Computable fun a => Nat.casesOn (f a) (g a) (h a)


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

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


theorem conjugatesOfSet_subset {s : Set G} {N : Subgroup G} [N.Normal] (h : s ⊆ N) :
    conjugatesOfSet s ⊆ N

{G : Type u_1}
[Group G]
{s : Set G}
{N : Subgroup G}
[N.Normal]
(h : s ⊆ ↑N)


/-- Summing `a^s.card * b^(n-s.card)` over all finite subsets `s` of a fintype of cardinality `n`
gives `(a + b)^n`. The "good" proof involves expanding along all coordinates using the fact that
`x^n` is multilinear, but multilinear maps are only available now over rings, so we give instead
a proof reducing to the usual binomial theorem to have a result over semirings. -/
lemma _root_.Fintype.sum_pow_mul_eq_add_pow (ι : Type*) [Fintype ι] (a b : α) :
    ∑ s : Finset ι, a ^ s.card * b ^ (Fintype.card ι - s.card) = (a + b) ^ Fintype.card ι

{α : Type u_2}
[CommSemiring α]
(ι : Type u_6)
[Fintype ι]
(a b : α)


@[simp]
theorem sInf_empty : sInf (∅ : Set ℝ≥0) = 0


/-- **Uniqueness of the conditional expectation**
If a function is a.e. `m`-measurable, verifies an integrability condition and has same integral
as `f` on all `m`-measurable sets, then it is a.e. equal to `μ[f|hm]`. -/
theorem ae_eq_condexp_of_forall_setIntegral_eq (hm : m ≤ m0) [SigmaFinite (μ.trim hm)]
    {f g : α → F'} (hf : Integrable f μ)
    (hg_int_finite : ∀ s, MeasurableSet[m] s → μ s < ∞ → IntegrableOn g s μ)
    (hg_eq : ∀ s : Set α, MeasurableSet[m] s → μ s < ∞ → ∫ x in s, g x ∂μ = ∫ x in s, f x ∂μ)
    (hgm : AEStronglyMeasurable' m g μ) : g =ᵐ[μ] μ[f|m]

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

(hg_eq : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∫ (x : α) in s, g x ∂μ = ∫ (x : α) in s, f x ∂μ)

(hgm : MeasureTheory.AEStronglyMeasurable' m g μ)


theorem Ideal.pow_right_strictAnti (I : Ideal A) (hI0 : I ≠ ⊥) (hI1 : I ≠ ⊤) :
    StrictAnti (I ^ · : ℕ → Ideal A)

{A : Type u_2}
[CommRing A]
[IsDedekindDomain A]
(I : Ideal A)
(hI0 : I ≠ ⊥)
(hI1 : I ≠ ⊤)


@[simp]
theorem Matrix.toLinAlgEquiv_toMatrixAlgEquiv (f : M₁ →ₗ[R] M₁) :
    Matrix.toLinAlgEquiv v₁ (LinearMap.toMatrixAlgEquiv v₁ f) = f

{R : Type u_1}
[CommSemiring R]
{n : Type u_4}
[Fintype n]
[DecidableEq n]
{M₁ : Type u_5}
[AddCommMonoid M₁]
[Module R M₁]
(v₁ : Basis n R M₁)
(f : M₁ →ₗ[R] M₁)

(Matrix.toLinAlgEquiv v₁) ((LinearMap.toMatrixAlgEquiv v₁) f) = f


theorem toIcoMod_apply_right (a : α) : toIcoMod hp a (a + p) = a

{α : Type u_1}
[LinearOrderedAddCommGroup α]
[hα : Archimedean α]
{p : α}
(hp : 0 < p)
(a : α)


lemma image_preimage_eq_opensRange_inter (U : Y.Opens) : f ''ᵁ f ⁻¹ᵁ U = f.opensRange ⊓ U

[H : AlgebraicGeometry.IsOpenImmersion f]

f.opensFunctor.obj ((TopologicalSpace.Opens.map f.val.base).obj U) = f.opensRange ⊓ U


@[simp]
theorem homEquiv_naturality_left_aux (f : X' ⟶ X) (g : F.obj X ⟶ Y) :
    (adj.homEquiv X' (F.obj X)) (F.map f) ≫ G.map g = f ≫ (adj.homEquiv X Y) g

(adj : CategoryTheory.Adjunction.CoreHomEquiv F G)

CategoryTheory.CategoryStruct.comp ((adj.homEquiv X' (F.obj X)) (F.map f)) (G.map g) =
  CategoryTheory.CategoryStruct.comp f ((adj.homEquiv X Y) g)


theorem Subsingleton.prod (hs : s.Subsingleton) (ht : t.Subsingleton) :
    (s ×ˢ t).Subsingleton

{α : Type u_1}
{β : Type u_2}
{s : Set α}
{t : Set β}
(hs : s.Subsingleton)
(ht : t.Subsingleton)


theorem BijOn.union (h₁ : BijOn f s₁ t₁) (h₂ : BijOn f s₂ t₂) (h : InjOn f (s₁ ∪ s₂)) :
    BijOn f (s₁ ∪ s₂) (t₁ ∪ t₂)

{α : Type u_1}
{β : Type u_2}
{s₁ s₂ : Set α}
{t₁ t₂ : Set β}
{f : α → β}
(h₁ : Set.BijOn f s₁ t₁)
(h₂ : Set.BijOn f s₂ t₂)
(h : Set.InjOn f (s₁ ∪ s₂))


@[simp]
theorem noMaxOrder_iff [LT α] [LT β] : NoMaxOrder (α ⊕ β) ↔ NoMaxOrder α ∧ NoMaxOrder β

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


/-- Like `implies_congr` but provides an additional assumption to the second hypothesis.
This is a non-dependent version of `pi_congr` that allows the domains to be different. -/
private theorem implies_congr' {α α' : Sort u} {β β' : Sort v} (h : α = α') (h' : α' → β = β') :
    (α → β) = (α' → β')


lemma Nonempty.exists_cons_eq {α} {s : Finset α} (hs : s.Nonempty) : ∃ t a ha, cons a t ha = s

{α : Type u_4}
{s : Finset α}
(hs : s.Nonempty)

∃ t a, ∃ (ha : a ∉ t), Finset.cons a t ha = s


/-- Multiplication in the colimit is well-defined in the left argument. -/
@[to_additive "Addition in the colimit is well-defined in the left argument."]
theorem colimitMulAux_eq_of_rel_left {x x' y : Σ j, F.obj j}
    (hxx' : Types.FilteredColimit.Rel (F ⋙ forget MonCat) x x') :
    colimitMulAux.{v, u} F x y = colimitMulAux.{v, u} F x' y

(hxx' : CategoryTheory.Limits.Types.FilteredColimit.Rel (F ⋙ CategoryTheory.forget MonCat) x x')

MonCat.FilteredColimits.colimitMulAux F x y = MonCat.FilteredColimits.colimitMulAux F x' y


@[simp]
theorem comp_apply (f : HeytingHom β γ) (g : HeytingHom α β) (a : α) : f.comp g a = f (g a)

{α : Type u_2}
{β : Type u_3}
{γ : Type u_4}
[HeytingAlgebra α]
[HeytingAlgebra β]
[HeytingAlgebra γ]
(f : HeytingHom β γ)
(g : HeytingHom α β)
(a : α)


@[simp]
theorem coequalizer.cofork_π : (coequalizer.cofork f g).π = coequalizer.π f g

(CategoryTheory.Limits.coequalizer.cofork f g).π = CategoryTheory.Limits.coequalizer.π f g


@[simp]
theorem uliftFunctor_map {X Y : Type u} (f : X ⟶ Y) (x : ULift.{v} X) :
    uliftFunctor.map f x = ULift.up (f x.down)

{X Y : Type u}
(f : X ⟶ Y)
(x : ULift.{v, u} X)

CategoryTheory.uliftFunctor.{v, u}.map f x = { down := f x.down }


nonrec theorem Ideal.Quotient.norm_mk_lt {I : Ideal R} (x : R ⧸ I) {ε : ℝ} (hε : 0 < ε) :
    ∃ r : R, Ideal.Quotient.mk I r = x ∧ ‖r‖ < ‖x‖ + ε

{R : Type u_3}
[SeminormedCommRing R]
{I : Ideal R}
(x : R ⧸ I)
{ε : ℝ}
(hε : 0 < ε)

∃ r, (Ideal.Quotient.mk I) r = x ∧ ‖r‖ < ‖x‖ + ε


theorem sub_mem_ker_iff {x y} : x - y ∈ ker f ↔ f x = f y

{R : Type u}
{S : Type v}
{F : Type u_1}
[Ring R]
[Ring S]
[FunLike F R S]
[rc : RingHomClass F R S]
(f : F)
{x y : R}


theorem pairwise_filterMap (f : β → Option α) {l : List β} :
    Pairwise R (filterMap f l) ↔ Pairwise (fun a a' : β => ∀ b ∈ f a, ∀ b' ∈ f a', R b b') l

{β : Type u_1}
{α : Type u_2}
{R : α → α → Prop}
(f : β → Option α)
{l : List β}

List.Pairwise R (List.filterMap f l) ↔ List.Pairwise (fun a a' => ∀ (b : α), b ∈ f a → ∀ (b' : α), b' ∈ f a' → R b b') l


/-- For a functor `F : C ⥤ D` and an object `d : D`, we obtain a contravariant functor from the
category of structured arrows `op d ⟶ F.op.obj c` to the category of costructured arrows
`F.obj c ⟶ d`.
-/
@[simps]
def toCostructuredArrow' (F : C ⥤ D) (d : D) :
    (StructuredArrow (op d) F.op)ᵒᵖ ⥤ CostructuredArrow F d

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

∀ {X Y : (CategoryTheory.StructuredArrow (Opposite.op d) F.op)ᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.StructuredArrow.toCostructuredArrow' F d).map f =
    CategoryTheory.CostructuredArrow.homMk f.unop.right.unop ⋯


/-- A specific witness of `I.directed` when `P` has joins. -/
theorem sup_mem (hx : x ∈ s) (hy : y ∈ s) : x ⊔ y ∈ s

{P : Type u_1}
[SemilatticeSup P]
{x y : P}
{s : Order.Ideal P}
(hx : x ∈ s)
(hy : y ∈ s)


@[simp]
theorem refl_conj (f : End X) : (Iso.refl X).conj f = f

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


/-- Shrink `α` to a smaller universe preserves module structure. -/
@[simps!]
noncomputable def _root_.Shrink.linearEquiv [Small.{v} α] [AddCommMonoid α] [Module R α] :
    Shrink.{v} α ≃ₗ[R] α

(α : Type u)
(R : Type u_1)
[Semiring R]
[Small.{v, u} α]
[AddCommMonoid α]
[Module R α]

∀ (a : Shrink.{v, u} α), (Shrink.linearEquiv α R) a = (equivShrink α).symm a


@[to_additive]
theorem partialProd_right_inv {G : Type*} [Group G] (f : Fin n → G) (i : Fin n) :
    (partialProd f (Fin.castSucc i))⁻¹ * partialProd f i.succ = f i

{n : ℕ}
{G : Type u_3}
[AddGroup G]
(f : Fin n → G)
(i : Fin n)

-Fin.partialSum f i.castSucc + Fin.partialSum f i.succ = f i


theorem Filter.EventuallyEq.hasDerivWithinAt_iff_of_mem (h₁ : f₁ =ᶠ[𝓝[s] x] f) (hx : x ∈ s) :
    HasDerivWithinAt f₁ f' s x ↔ HasDerivWithinAt f f' s x

{𝕜 : Type u}
[NontriviallyNormedField 𝕜]
{F : Type v}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{f f₁ : 𝕜 → F}
{f' : F}
{x : 𝕜}
{s : Set 𝕜}
(h₁ : f₁ =ᶠ[𝓝[s] x] f)
(hx : x ∈ s)


theorem mk_smoothCoordChange (he : e ∈ a.pretrivializationAtlas)
    (he' : e' ∈ a.pretrivializationAtlas) {b : B} (hb : b ∈ e.baseSet ∩ e'.baseSet) (v : F) :
    (b, a.smoothCoordChange IB he he' b v) = e' ⟨b, e.symm b v⟩

{e e' : Pretrivialization F Bundle.TotalSpace.proj}

(b, (VectorPrebundle.smoothCoordChange IB a he he' b) v) = ↑e' { proj := b, snd := e.symm b v }


/-- If `i` is an `F`-algebra homomorphism from `E` to `K`, then the image of `separableClosure F E`
under the map `i` is contained in `separableClosure F K`. -/
theorem separableClosure.map_le_of_algHom (i : E →ₐ[F] K) :
    (separableClosure F E).map i ≤ separableClosure F K

{F : Type u}
{E : Type v}
[Field F]
[Field E]
[Algebra F E]
{K : Type w}
[Field K]
[Algebra F K]
(i : E →ₐ[F] K)

IntermediateField.map i (separableClosure F E) ≤ separableClosure F K


theorem image_mk_closure : mk '' closure s = closure (mk '' s)

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

SeparationQuotient.mk '' closure s = closure (SeparationQuotient.mk '' s)


theorem supDegree_add_le {f g : R[A]} :
    (f + g).supDegree D ≤ (f.supDegree D) ⊔ (g.supDegree D)

{R : Type u_1}
{A : Type u_3}
{B : Type u_5}
[Semiring R]
[AddZeroClass A]
[SemilatticeSup B]
[OrderBot B]
{D : A → B}
{f g : AddMonoidAlgebra R A}

AddMonoidAlgebra.supDegree D (f + g) ≤ AddMonoidAlgebra.supDegree D f ⊔ AddMonoidAlgebra.supDegree D g


@[simp]
lemma image_subtype_val_Ioi_Iic {a : α} (b : Ioi a) : Subtype.val '' Iic b = Ioc a b

{α : Type u_1}
[Preorder α]
{a : α}
(b : ↑(Set.Ioi a))


@[simp]
theorem fst_star [Star R] [Star A] (x : Unitization R A) : (star x).fst = star x.fst

{R : Type u_1}
{A : Type u_2}
[Star R]
[Star A]
(x : Unitization R A)


@[simp]
theorem fieldRange_val : S.val.fieldRange = S

{K : Type u_1}
{L : Type u_2}
[Field K]
[Field L]
[Algebra K L]
(S : IntermediateField K L)


theorem quotientEquiv_mk (I : Ideal R) (J : Ideal S) (f : R ≃+* S) (hIJ : J = I.map (f : R →+* S))
    (x : R) : quotientEquiv I J f hIJ (Ideal.Quotient.mk I x) = Ideal.Quotient.mk J (f x)

{R : Type u}
[CommRing R]
{S : Type v}
[CommRing S]
(I : Ideal R)
(J : Ideal S)
(f : R ≃+* S)
(hIJ : J = Ideal.map (↑f) I)
(x : R)

(I.quotientEquiv J f hIJ) ((Ideal.Quotient.mk I) x) = (Ideal.Quotient.mk J) (f x)


theorem smul_coe : x • (y : ℍ[R]) = ↑(x * y)


protected theorem OpenEmbedding.locallyCompactSpace [LocallyCompactSpace Y] {f : X → Y}
    (hf : OpenEmbedding f) : LocallyCompactSpace X

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


@[simp, norm_cast] lemma coe_eq_univ : L = (univ : Set α) ↔ L = ⊤

{α : Type u_2}
[Lattice α]
{L : Sublattice α}


/-- A perfection map to a ring of characteristic `p` is a map that is isomorphic
to its perfection. -/
-- @[nolint has_nonempty_instance] -- Porting note(#5171): This linter does not exist yet.
structure PerfectionMap (p : ℕ) [Fact p.Prime] {R : Type u₁} [CommSemiring R] [CharP R p]
    {P : Type u₂} [CommSemiring P] [CharP P p] [PerfectRing P p] (π : P →+* R) : Prop where
  injective : ∀ ⦃x y : P⦄,
    (∀ n, π (((frobeniusEquiv P p).symm)^[n] x) = π (((frobeniusEquiv P p).symm)^[n] y)) → x = y
  surjective : ∀ f : ℕ → R, (∀ n, f (n + 1) ^ p = f n) → ∃ x : P, ∀ n,
    π (((frobeniusEquiv P p).symm)^[n] x) = f n

{p : ℕ}
[Fact (Nat.Prime p)]
{R : Type u₁}
[CommSemiring R]
[CharP R p]
{P : Type u₂}
[CommSemiring P]
[CharP P p]
[PerfectRing P p]
{π : P →+* R}
(self : PerfectionMap p π)
⦃x y : P⦄

(∀ (n : ℕ), π ((⇑(frobeniusEquiv P p).symm)^[n] x) = π ((⇑(frobeniusEquiv P p).symm)^[n] y)) → x = y


theorem adj_of_mem_edges {u v x y : V} (p : G.Walk u v) (h : s(x, y) ∈ p.edges) : G.Adj x y

{V : Type u}
{G : SimpleGraph V}
{u v x y : V}
(p : G.Walk u v)
(h : s(x, y) ∈ p.edges)


/-- Collinear points are coplanar. -/
theorem Collinear.coplanar {s : Set P} (h : Collinear k s) : Coplanar 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 : Collinear k s)


theorem exists_eventuallyEq_const_of_forall_separating [Nonempty β] (p : Set β → Prop)
    [HasCountableSeparatingOn β p univ]
    (h : ∀ U, p U → (∀ᶠ x in l, f x ∈ U) ∨ (∀ᶠ x in l, f x ∉ U)) :
    ∃ a, f =ᶠ[l] const α a

(h : ∀ (U : Set β), p U → (∀ᶠ (x : α) in l, f x ∈ U) ∨ ∀ᶠ (x : α) in l, f x ∉ U)


theorem Metric.exists_isLocalMin_mem_ball [TopologicalSpace β]
    [ConditionallyCompleteLinearOrder β] [OrderTopology β] {f : α → β} {a z : α} {r : ℝ}
    (hf : ContinuousOn f (closedBall a r)) (hz : z ∈ closedBall a r)
    (hf1 : ∀ z' ∈ sphere a r, f z < f z') : ∃ z ∈ ball a r, IsLocalMin f z

(hf : ContinuousOn f (Metric.closedBall a r))

(hf1 : ∀ z' ∈ Metric.sphere a r, f z < f z')


/-- The identity language homomorphism. -/
@[simps]
protected def id (L : Language) : L →ᴸ L

(L : FirstOrder.Language)
(_n : ℕ)
(a : L.Functions _n)

(FirstOrder.Language.LHom.id L).onFunction a = id a


lemma sum_pow (f : ι → α) (n : ℕ) : (∑ a, f a) ^ n = ∑ p : Fin n → ι, ∏ i, f (p i)

{ι : Type u_6}
{α : Type u_8}
[Fintype ι]
[CommSemiring α]
(f : ι → α)
(n : ℕ)

(∑ a : ι, f a) ^ n = ∑ p : Fin n → ι, ∏ i : Fin n, f (p i)


@[to_additive]
theorem smul_finset_card_le : (a • s).card ≤ s.card

{α : Type u_2}
{β : Type u_3}
[DecidableEq β]
[SMul α β]
{s : Finset β}
{a : α}


theorem toNonUnitalSubsemiring_injective :
    Function.Injective (toNonUnitalSubsemiring : NonUnitalSubring R → NonUnitalSubsemiring R)


/-- Given `F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v`, this is the presheaf that is given by
    `YonedaCollection F X` on objects. -/
@[simps]
def yonedaCollectionPresheaf (A : Cᵒᵖ ⥤ Type v) (F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v) :
    Cᵒᵖ ⥤ Type v

(A : CategoryTheory.Functor Cᵒᵖ (Type v))

(F : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v))

∀ {X Y : Cᵒᵖ} (f : X ⟶ Y) (p : CategoryTheory.OverPresheafAux.YonedaCollection F (Opposite.unop X)),
  (CategoryTheory.OverPresheafAux.yonedaCollectionPresheaf A F).map f p =
    CategoryTheory.OverPresheafAux.YonedaCollection.map₂ F f.unop p


theorem mul_right_distrib [Distrib α] (x : Holor α ds₁) (y : Holor α ds₁) (z : Holor α ds₂) :
    (x + y) ⊗ z = x ⊗ z + y ⊗ z

{α : Type}
{ds₁ ds₂ : List ℕ}
[Distrib α]
(x y : Holor α ds₁)
(z : Holor α ds₂)


@[simp] theorem zero_shiftLeft : ∀ n, 0 <<< n = 0


@[simp] theorem loopyOn_base_iff : (loopyOn E).Base B ↔ B = ∅


@[simp]
theorem mk_le_mk {f g : α → β} {hf hg} : mk f hf ≤ mk g hg ↔ f ≤ g

{α : Type u_2}
{β : Type u_3}
[Preorder α]
[Preorder β]
{f g : α → β}
{hf : Monotone f}
{hg : Monotone g}

{ toFun := f, monotone' := hf } ≤ { toFun := g, monotone' := hg } ↔ f ≤ g


@[simp] theorem Matrix.vecMulLinear_transpose [Fintype n] (M : Matrix m n R) :
    Mᵀ.vecMulLinear = M.mulVecLin

{R : Type u_1}
[CommSemiring R]
{m : Type u_4}
{n : Type u_5}
[Fintype n]
(M : Matrix m n R)


lemma gc_smul_ceilDiv (ha : 0 < a) : GaloisConnection (· ⌈/⌉ a) (a • · : β → β)

{α : Type u_2}
{β : Type u_3}
[OrderedAddCommMonoid α]
[OrderedAddCommMonoid β]
[SMulZeroClass α β]
[CeilDiv α β]
{a : α}
(ha : 0 < a)

GaloisConnection (fun x => x ⌈/⌉ a) fun x => a • x


@[to_additive]
theorem mulEquivOfQuotient_monoidOf (x) :
    mulEquivOfQuotient f ((monoidOf S).toMap x) = f.toMap x

{M : Type u_1}
[AddCommMonoid M]
{S : AddSubmonoid M}
{N : Type u_2}
[AddCommMonoid N]
{f : S.LocalizationMap N}
(x : M)

(AddLocalization.addEquivOfQuotient f) ((AddLocalization.addMonoidOf S).toMap x) = f.toMap x


/-- The preimage of a set `s` under a continuous linear equiv `f` has measure
equal to `μ s` times the absolute value of the inverse of the determinant of `f`. -/
@[simp]
theorem addHaar_preimage_continuousLinearEquiv (f : E ≃L[ℝ] E) (s : Set E) :
    μ (f ⁻¹' s) = ENNReal.ofReal |LinearMap.det (f.symm : E →ₗ[ℝ] E)| * μ s

{E : Type u_1}
[NormedAddCommGroup E]
[NormedSpace ℝ E]
[MeasurableSpace E]
[BorelSpace E]
[FiniteDimensional ℝ E]
(μ : MeasureTheory.Measure E)
[μ.IsAddHaarMeasure]
(f : E ≃L[ℝ] E)
(s : Set E)

μ (⇑f ⁻¹' s) = ENNReal.ofReal |LinearMap.det ↑↑f.symm| * μ s


theorem smeval_pow : ∀ (n : ℕ), (p^n).smeval x = (p.smeval x)^n

(R : Type u_1)
[Semiring R]
(p : Polynomial R)
{S : Type u_2}
[NonAssocSemiring S]
[Module R S]
[IsScalarTower R S S]
[SMulCommClass R S S]
[Pow S ℕ]
[NatPowAssoc S]
(x : S)
(n : ℕ)


@[simp]
theorem le_principal_iff {s : Set α} {f : Filter α} : f ≤ 𝓟 s ↔ s ∈ f

f ≤ 𝓟 s ↔ s ∈ f


@[to_additive]
theorem CommGroup.is_simple_iff_isCyclic_and_prime_card [Fintype α] [CommGroup α] :
    IsSimpleGroup α ↔ IsCyclic α ∧ (Fintype.card α).Prime

IsSimpleGroup α ↔ IsCyclic α ∧ Nat.Prime (Fintype.card α)


@[to_additive (attr := simp) card_mul_index]
theorem card_mul_index : Nat.card H * H.index = Nat.card G

{G : Type u_1}
[Group G]
(H : Subgroup G)


theorem Integrable.sup {β} [NormedLatticeAddCommGroup β] {f g : α → β} (hf : Integrable f μ)
    (hg : Integrable g μ) : Integrable (f ⊔ g) μ

{α : Type u_1}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{β : Type u_5}
[NormedLatticeAddCommGroup β]
{f g : α → β}
(hf : MeasureTheory.Integrable f μ)
(hg : MeasureTheory.Integrable g μ)


/-- Suppose `F : Homotopy p q`. Then we have a `Homotopy p.symm q.symm` by reversing the second
argument.
-/
@[simps]
def symm₂ {p q : Path x₀ x₁} (F : p.Homotopy q) : p.symm.Homotopy q.symm

{X : Type u}
[TopologicalSpace X]
{x₀ x₁ : X}
{p q : Path x₀ x₁}
(F : p.Homotopy q)
(x : ↑I × ↑I)


theorem differentiableWithinAt_arcsin_Ici {x : ℝ} :
    DifferentiableWithinAt ℝ arcsin (Ici x) x ↔ x ≠ -1

DifferentiableWithinAt ℝ Real.arcsin (Set.Ici x) x ↔ x ≠ -1


theorem toBlock_mul_eq_mul {m n k : Type*} [Fintype n] (p : m → Prop) (q : k → Prop)
    (A : Matrix m n R) (B : Matrix n k R) :
    (A * B).toBlock p q = A.toBlock p ⊤ * B.toBlock ⊤ q

{R : Type u_10}
[CommRing R]
{m : Type u_14}
{n : Type u_15}
{k : Type u_16}
[Fintype n]
(p : m → Prop)
(q : k → Prop)
(A : Matrix m n R)
(B : Matrix n k R)


@[simp]
theorem lt_succ_iff : a < succ b ↔ a ≤ b

{α : Type u_1}
[Preorder α]
[SuccOrder α]
{a b : α}
[NoMaxOrder α]


theorem exists_aleph {c : Cardinal} : ℵ₀ ≤ c ↔ ∃ o, c = aleph o


theorem tendsto_id' {x y : Filter α} : Tendsto id x y ↔ x ≤ y


/-- The diagram whose colimit defines the values of `plus`. -/
@[simps]
def diagram (X : C) : (J.Cover X)ᵒᵖ ⥤ D

(J : CategoryTheory.GrothendieckTopology C)

[CategoryTheory.Category.{max v u, w} D]

[∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]

(J.diagram P X).obj S = CategoryTheory.Limits.multiequalizer ((Opposite.unop S).index P)


theorem isInt_eq_true [Ring α] : {a b : α} → {z : ℤ} → IsInt a z → IsInt b z → a = b

Mathlib.Meta.NormNum.IsInt a z → Mathlib.Meta.NormNum.IsInt b z → a = b


theorem map_succ (a : Fin (n + 1) → ℕ) :
    map d a = a 0 + (∑ x : Fin n, a x.succ * d ^ (x : ℕ)) * d

(Behrend.map d) a = a 0 + (∑ x : Fin n, a x.succ * d ^ ↑x) * d


@[simp]
theorem mem_inf {S T : IntermediateField F E} {x : E} : x ∈ S ⊓ T ↔ x ∈ S ∧ x ∈ T

{F : Type u_1}
[Field F]
{E : Type u_2}
[Field E]
[Algebra F E]
{S T : IntermediateField F E}
{x : E}


theorem neLocus_comm : f.neLocus g = g.neLocus f

{α : Type u_1}
{N : Type u_3}
[DecidableEq α]
[DecidableEq N]
[Zero N]
(f g : α →₀ N)


/-- An element a divides the sum b + a if and only if a divides b. -/
@[simp]
theorem dvd_add_self_right {a b : α} : a ∣ b + a ↔ a ∣ b


@[simp]
theorem opNorm_mul_apply_le (x : 𝕜') : ‖mul 𝕜 𝕜' x‖ ≤ ‖x‖

(𝕜 : Type u_1)
[NontriviallyNormedField 𝕜]
(𝕜' : Type u_3)
[NonUnitalSeminormedRing 𝕜']
[NormedSpace 𝕜 𝕜']
[IsScalarTower 𝕜 𝕜' 𝕜']
[SMulCommClass 𝕜 𝕜' 𝕜']
(x : 𝕜')

‖(ContinuousLinearMap.mul 𝕜 𝕜') x‖ ≤ ‖x‖


lemma traceForm_eq_sum_weightSpaceOf [IsTriangularizable R L M] (z : L) :
    traceForm R L M =
    ∑ χ ∈ (finite_weightSpaceOf_ne_bot R L M z).toFinset, traceForm R L (weightSpaceOf M χ z)

(R : Type u_1)
(L : Type u_3)
(M : Type u_4)
[CommRing R]
[LieRing L]
[LieAlgebra R L]
[AddCommGroup M]
[Module R M]
[LieRingModule L M]
[LieModule R L M]
[Module.Free R M]
[Module.Finite R M]
[LieAlgebra.IsNilpotent R L]
[IsDomain R]
[IsPrincipalIdealRing R]
[LieModule.IsTriangularizable R L M]
(z : L)

LieModule.traceForm R L M = ∑ χ ∈ ⋯.toFinset, LieModule.traceForm R L ↥↑(LieModule.weightSpaceOf M χ z)


{α : Type u_1}
[LinearOrder α]
{b c : α}


@[simp, norm_cast]
theorem coe_id : ⇑(CentroidHom.id α) = id

(α : Type u_5)
[NonUnitalNonAssocSemiring α]


@[to_additive UniformContinuous.const_zsmul]
theorem UniformContinuous.zpow_const [UniformSpace β] {f : β → α} (hf : UniformContinuous f) :
    ∀ n : ℤ, UniformContinuous fun x => f x ^ n

{α : Type u_1}
{β : Type u_2}
[UniformSpace α]
[AddGroup α]
[UniformAddGroup α]
[UniformSpace β]
{f : β → α}
(hf : UniformContinuous f)
(n : ℤ)


theorem convolution_precompR_apply {g : G → E'' →L[𝕜] E'} (hf : LocallyIntegrable f μ)
    (hcg : HasCompactSupport g) (hg : Continuous g) (x₀ : G) (x : E'') :
    (f ⋆[L.precompR E'', μ] g) x₀ x = (f ⋆[L, μ] fun a => g a x) x₀

(hf : MeasureTheory.LocallyIntegrable f μ)

(MeasureTheory.convolution f g (ContinuousLinearMap.precompR E'' L) μ x₀) x =
  MeasureTheory.convolution f (fun a => (g a) x) L μ x₀


protected theorem Tendsto.if {l₁ : Filter α} {l₂ : Filter β} {f g : α → β} {p : α → Prop}
    [∀ x, Decidable (p x)] (h₀ : Tendsto f (l₁ ⊓ 𝓟 { x | p x }) l₂)
    (h₁ : Tendsto g (l₁ ⊓ 𝓟 { x | ¬p x }) l₂) :
    Tendsto (fun x => if p x then f x else g x) l₁ l₂

(h₀ : Filter.Tendsto f (l₁ ⊓ 𝓟 {x | p x}) l₂)

(h₁ : Filter.Tendsto g (l₁ ⊓ 𝓟 {x | ¬p x}) l₂)

Filter.Tendsto (fun x => if p x then f x else g x) l₁ l₂


/--
Given a submodule `M ⊆ R` and a prime ideal `p` of `S = M⁻¹R`, with `f : R →+* S` the localization
map, then `T = Sₚ` is the localization of `R` at `f⁻¹(p)`.
-/
theorem isLocalization_isLocalization_atPrime_isLocalization (p : Ideal S) [Hp : p.IsPrime]
    [IsLocalization.AtPrime T p] : IsLocalization.AtPrime T (p.comap (algebraMap R S))

{R : Type u_1}
[CommSemiring R]
(M : Submonoid R)
{S : Type u_2}
[CommSemiring S]
[Algebra R S]
(T : Type u_4)
[CommSemiring T]
[Algebra R T]
[Algebra S T]
[IsScalarTower R S T]
[IsLocalization M S]
(p : Ideal S)
[Hp : p.IsPrime]
[IsLocalization.AtPrime T p]

IsLocalization.AtPrime T (Ideal.comap (algebraMap R S) p)


@[to_additive]
theorem MonoidHom.toMulHom_injective [MulOneClass M] [MulOneClass N] :
    Function.Injective (MonoidHom.toMulHom : (M →* N) → M →ₙ* N)

{M : Type u_4}
{N : Type u_5}
[AddZeroClass M]
[AddZeroClass N]


@[simp]
theorem nth_count {n : ℕ} (hpn : p n) : nth p (count p n) = n

{p : ℕ → Prop}
[DecidablePred p]
{n : ℕ}
(hpn : p n)


theorem of_isIso_fac_right {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} {h : X ⟶ Z} [IsIso g]
    [hh : IsIso h] (w : f ≫ g = h) : IsIso f

(w : CategoryTheory.CategoryStruct.comp f g = h)


theorem inter_ae_eq_right_of_ae_eq_univ (h : s =ᵐ[μ] univ) : (s ∩ t : Set α) =ᵐ[μ] t

{α : Type u_1}
{F : Type u_3}
[FunLike F (Set α) ℝ≥0∞]
[MeasureTheory.OuterMeasureClass F α]
{μ : F}
{s t : Set α}
(h : s =ᵐ[μ] Set.univ)


theorem hasCoequalizer_epi_comp [HasCoequalizer f g] {W : C} (h : W ⟶ X) [Epi h] :
    HasCoequalizer (h ≫ f) (h ≫ g)

CategoryTheory.Limits.HasCoequalizer (CategoryTheory.CategoryStruct.comp h f) (CategoryTheory.CategoryStruct.comp h g)


@[simp]
theorem add_eq_left ⦃x y : Tropical R⦄ (h : x ≤ y) : x + y = x

{R : Type u}
[LinearOrder R]
⦃x y : Tropical R⦄
(h : x ≤ y)


@[to_additive] lemma IsMulFreimanHom.superset (hB : B₁ ⊆ B₂) (hf : IsMulFreimanHom n A B₁ f) :
    IsMulFreimanHom n A B₂ f

{α : Type u_2}
{β : Type u_3}
[AddCommMonoid α]
[AddCommMonoid β]
{A : Set α}
{B₁ B₂ : Set β}
{f : α → β}
{n : ℕ}
(hB : B₁ ⊆ B₂)
(hf : IsAddFreimanHom n A B₁ f)


theorem le_or_gt : ∀ a b : α, a ≤ b ∨ a > b


lemma quasiIso_opMap (φ : S₁ ⟶ S₂) [QuasiIso φ] :
    QuasiIso (opMap φ)


theorem nhds_toAdd (x : Multiplicative X) : 𝓝 (toAdd x) = map toAdd (𝓝 x)

{X : Type u}
[TopologicalSpace X]
(x : Multiplicative X)

𝓝 (Multiplicative.toAdd x) = Filter.map (⇑Multiplicative.toAdd) (𝓝 x)


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

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


@[simp, norm_cast]
theorem coe_top : (↑(⊤ : Closeds α) : Set α) = univ


@[simp]
theorem integrable_zero : Integrable (fun _ => (0 : β)) μ

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


@[simp]
theorem coe_det_isEmpty [IsEmpty n] : (det : Matrix n n R → R) = Function.const _ 1

{n : Type u_2}
[DecidableEq n]
[Fintype n]
{R : Type v}
[CommRing R]
[IsEmpty n]

Matrix.det = Function.const (Matrix n n R) 1


theorem Codisjoint.sup_right' (h : Codisjoint a b) : Codisjoint a (c ⊔ b)

{α : Type u_1}
[SemilatticeSup α]
[OrderTop α]
{a b : α}
(c : α)
(h : Codisjoint a b)


@[simp]
lemma realPart_ofReal (r : ℝ) : (ℜ (r : ℂ) : ℂ) = r


theorem mod_mul_right_div_self (m n k : Nat) : m % (n * k) / n = m / n % k


theorem antisymm_iff [IsRefl α r] [IsAntisymm α r] {a b : α} : r a b ∧ r b a ↔ a = b

{α : Type u}
{r : α → α → Prop}
[IsRefl α r]
[IsAntisymm α r]
{a b : α}


theorem ite_cond_eq_false {α : Sort u} {c : Prop} {_ : Decidable c} (a b : α) (h : c = False) : (if c then a else b) = b

∀ {x : Decidable c} (a b : α), c = False → ite c a b = b


@[simp]
lemma image_subtype_val_Ici_Ici {a : α} (b : Ici a) : Subtype.val '' Ici b = Ici b.1

{α : Type u_1}
[Preorder α]
{a : α}
(b : ↑(Set.Ici a))


theorem integral_nonneg_of_ae {f : α → ℝ} (hf : 0 ≤ᵐ[μ] f) : 0 ≤ ∫ a, f a ∂μ

{α : Type u_1}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{f : α → ℝ}
(hf : 0 ≤ᵐ[μ] f)


@[to_additive]
lemma le_stabilizer_smul_right [SMul α β] [SMulCommClass G α β] (a : α) (b : β) :
    stabilizer G b ≤ stabilizer G (a • b)

{G : Type u_1}
{α : Type u_2}
{β : Type u_3}
[Group G]
[MulAction G β]
[SMul α β]
[SMulCommClass G α β]
(a : α)
(b : β)

MulAction.stabilizer G b ≤ MulAction.stabilizer G (a • b)


theorem Specializes.not_disjoint (h : x ⤳ y) : ¬Disjoint (𝓝 x) (𝓝 y)

{X : Type u_1}
[TopologicalSpace X]
{x y : X}
(h : x ⤳ y)


theorem eq_of_not_disjoint {H K : Subgroup G} {a b : G}
    (h : ¬Disjoint (doset a H K) (doset b H K)) : doset a H K = doset b H K

(h : ¬Disjoint (Doset.doset a ↑H ↑K) (Doset.doset b ↑H ↑K))

Doset.doset a ↑H ↑K = Doset.doset b ↑H ↑K


@[simp]
lemma linearDeriv_apply : f.linearDeriv x y = ∑ i, f (Function.update x i (y i))

{R : Type u}
{ι : Type v}
{M₁ : ι → Type w₁}
{M₂ : Type w₂}
[Semiring R]
[(i : ι) → AddCommMonoid (M₁ i)]
[AddCommMonoid M₂]
[(i : ι) → Module R (M₁ i)]
[Module R M₂]
[(i : ι) → TopologicalSpace (M₁ i)]
[TopologicalSpace M₂]
(f : ContinuousMultilinearMap R M₁ M₂)
[ContinuousAdd M₂]
[DecidableEq ι]
[Fintype ι]
(x y : (i : ι) → M₁ i)

(f.linearDeriv x) y = ∑ i : ι, f (Function.update x i (y i))


theorem iInf_mul_right {ι} [Nonempty ι] {f : ι → ℝ≥0∞} {a : ℝ≥0∞}
    (h : a = ∞ → ⨅ i, f i = 0 → ∃ i, f i = 0) : ⨅ i, f i * a = (⨅ i, f i) * a

{f : ι → ℝ≥0∞}

(h : a = ⊤ → ⨅ i, f i = 0 → ∃ i, f i = 0)


@[reassoc (attr := simp)]
theorem tensor_inv_hom_id {V W X Y Z : C} (f : V ≅ W) (g : X ⟶ Y) (h : Y ⟶ Z) :
    (g ⊗ f.inv) ≫ (h ⊗ f.hom) = (g ⊗ 𝟙 W) ≫ (h ⊗ 𝟙 W)

{C : Type u}
[CategoryTheory.Category.{v, u} C]
[CategoryTheory.MonoidalCategory C]
{V W X Y Z : C}
(f : V ≅ W)
(g : X ⟶ Y)
(h : Y ⟶ Z)

CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.tensorHom g f.inv)
    (CategoryTheory.MonoidalCategory.tensorHom h f.hom) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.tensorHom g (CategoryTheory.CategoryStruct.id W))
    (CategoryTheory.MonoidalCategory.tensorHom h (CategoryTheory.CategoryStruct.id W))


@[to_additive]
theorem zpow_comp [Group γ] [TopologicalGroup γ] (f : C(β, γ)) (z : ℤ) (g : C(α, β)) :
    (f ^ z).comp g = f.comp g ^ z

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
[TopologicalSpace α]
[TopologicalSpace β]
[TopologicalSpace γ]
[AddGroup γ]
[TopologicalAddGroup γ]
(f : C(β, γ))
(z : ℤ)
(g : C(α, β))


theorem generateHas_def {C : Set (Set α)} : (generate C).Has = GenerateHas C

(MeasurableSpace.DynkinSystem.generate C).Has = MeasurableSpace.DynkinSystem.GenerateHas C


theorem comap_bot_le_of_injective (hf : Function.Injective f) : comap f ⊥ ≤ I

{R : Type u}
{S : Type v}
{F : Type u_1}
[Semiring R]
[Semiring S]
[FunLike F R S]
[rc : RingHomClass F R S]
(f : F)
{I : Ideal R}
(hf : Function.Injective ⇑f)


/-- Taking the multiequalizer over the multicospan index is equivalent to taking the equalizer over
the two morphisms `∏ᶜ I.left ⇉ ∏ᶜ I.right`. This is the diagram of the latter.
-/
@[simps!]
protected noncomputable def parallelPairDiagram

(I : CategoryTheory.Limits.MulticospanIndex C)

∀ {X Y : CategoryTheory.Limits.WalkingParallelPair} (h : X ⟶ Y),
  I.parallelPairDiagram.map h =
    match X, Y, h with
    | x, .(x), CategoryTheory.Limits.WalkingParallelPairHom.id .(x) =>
      CategoryTheory.CategoryStruct.id
        (match x with
        | CategoryTheory.Limits.WalkingParallelPair.zero => ∏ᶜ I.left
        | CategoryTheory.Limits.WalkingParallelPair.one => ∏ᶜ I.right)
    | .(CategoryTheory.Limits.WalkingParallelPair.zero), .(CategoryTheory.Limits.WalkingParallelPair.one),
      CategoryTheory.Limits.WalkingParallelPairHom.left => I.fstPiMap
    | .(CategoryTheory.Limits.WalkingParallelPair.zero), .(CategoryTheory.Limits.WalkingParallelPair.one),
      CategoryTheory.Limits.WalkingParallelPairHom.right => I.sndPiMap


theorem Ico_filter_coprime_le {a : ℕ} (k n : ℕ) (a_pos : 0 < a) :
    ((Ico k (k + n)).filter (Coprime a)).card ≤ totient a * (n / a + 1)

(Finset.filter a.Coprime (Finset.Ico k (k + n))).card ≤ a.totient * (n / a + 1)


/--
The map taking the product of two fundamental groupoids to the fundamental groupoid of the product
of the two topological spaces. This is in fact an isomorphism (see `prodIso`).
-/
@[simps obj]
def prodToProdTop : πₓ A × πₓ B ⥤ πₓ (TopCat.of (A × B))

(A B : TopCat)
(g : ↑(π.obj A) × ↑(π.obj B))

(FundamentalGroupoidFunctor.prodToProdTop A B).obj g = { as := (g.1.as, g.2.as) }


theorem insertNth_comm (a b : α) (i j : Fin (n + 1)) (h : i ≤ j) :
    ∀ v : Vector α n,
      (v.insertNth a i).insertNth b j.succ = (v.insertNth b j).insertNth a (Fin.castSucc i)

{n : ℕ}
{α : Type u_1}
(a b : α)
(i j : Fin (n + 1))
(h : i ≤ j)
(v : Mathlib.Vector α n)

Mathlib.Vector.insertNth b j.succ (Mathlib.Vector.insertNth a i v) =
  Mathlib.Vector.insertNth a i.castSucc (Mathlib.Vector.insertNth b j v)


@[simp, norm_cast]
theorem intCast_dvd_intCast (a b : ℤ) : (a : ℤ√d) ∣ b ↔ a ∣ b

↑a ∣ ↑b ↔ a ∣ b


@[to_additive]
theorem inv_toGerm (f : α →ₘ[μ] γ) : f⁻¹.toGerm = f.toGerm⁻¹

{α : Type u_1}
{γ : Type u_3}
[MeasurableSpace α]
{μ : MeasureTheory.Measure α}
[TopologicalSpace γ]
[AddGroup γ]
[TopologicalAddGroup γ]
(f : α →ₘ[μ] γ)


theorem inner_.conj_symm (x y : E) : conj (inner_ 𝕜 y x) = inner_ 𝕜 x y

{𝕜 : Type u_1}
[RCLike 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
(x y : E)

(starRingEnd 𝕜) (inner_ 𝕜 y x) = inner_ 𝕜 x y


/--
If there is an `r`-chain starting from `a` and ending at `b`, then `a` and `b` are related by the
reflexive transitive closure of `r`. The converse of `exists_chain_of_relationReflTransGen`.
-/
theorem relationReflTransGen_of_exists_chain (l : List α) (hl₁ : Chain r a l)
    (hl₂ : getLast (a :: l) (cons_ne_nil _ _) = b) : Relation.ReflTransGen r a b

{α : Type u}
{r : α → α → Prop}
{a b : α}
(l : List α)
(hl₁ : List.Chain r a l)
(hl₂ : (a :: l).getLast ⋯ = b)


/-- If `C` is thin and skeletal, then any naturally isomorphic functors to `C` are equal. -/
theorem Functor.eq_of_iso {F₁ F₂ : D ⥤ C} [Quiver.IsThin C] (hC : Skeletal C) (hF : F₁ ≅ F₂) :
    F₁ = F₂

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
{D : Type u₂}
[CategoryTheory.Category.{v₂, u₂} D]
{F₁ F₂ : CategoryTheory.Functor D C}
[Quiver.IsThin C]
(hC : CategoryTheory.Skeletal C)
(hF : F₁ ≅ F₂)


@[simp, norm_cast]
theorem coe_mul (x y : Icc (0 : α) 1) : ↑(x * y) = (x * y : α)

{α : Type u_1}
[OrderedSemiring α]
(x y : ↑(Set.Icc 0 1))


@[gcongr]
theorem union_subset_union_right (s) {t₁ t₂ : Set α} (h : t₁ ⊆ t₂) : s ∪ t₁ ⊆ s ∪ t₂

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

s ∪ t₁ ⊆ s ∪ t₂


theorem lt_succ_self (a : ℕ+) : a < succPNat a


@[simp, mfld_simps]
theorem mfderiv_id : mfderiv I I (@id M) x = ContinuousLinearMap.id 𝕜 (TangentSpace I x)

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

mfderiv I I id x = ContinuousLinearMap.id 𝕜 (TangentSpace I x)


@[to_additive (attr := elab_as_elim)]
theorem induction_on {C : α ⧸ s → Prop} (x : α ⧸ s) (H : ∀ z, C (QuotientGroup.mk z)) : C x

{α : Type u_1}
[AddGroup α]
{s : AddSubgroup α}
{C : α ⧸ s → Prop}
(x : α ⧸ s)
(H : ∀ (z : α), C ↑z)


theorem find?_eq_zoom : ∀ {t : RBNode α} (p := .root), t.find? cut = (t.zoom cut p).1.root?

(p : Batteries.RBNode.Path α := Batteries.RBNode.Path.root)

Batteries.RBNode.find? cut t = (Batteries.RBNode.zoom cut t p).fst.root?


@[simp] theorem mem_bind {f : α → List β} {b} {l : List α} : b ∈ l.bind f ↔ ∃ a, a ∈ l ∧ b ∈ f a

{α : Type u_1}
{β : Type u_2}
{f : α → List β}
{b : β}
{l : List α}


@[simp]
theorem self_trans_symm : e.trans e.symm = refl 𝕜 P

{𝕜 : Type u_1}
{V : Type u_2}
{V₂ : Type u_5}
{P : Type u_10}
{P₂ : Type u_11}
[NormedField 𝕜]
[SeminormedAddCommGroup V]
[NormedSpace 𝕜 V]
[PseudoMetricSpace P]
[NormedAddTorsor V P]
[SeminormedAddCommGroup V₂]
[NormedSpace 𝕜 V₂]
[PseudoMetricSpace P₂]
[NormedAddTorsor V₂ P₂]
(e : P ≃ᵃⁱ[𝕜] P₂)

e.trans e.symm = AffineIsometryEquiv.refl 𝕜 P


@[to_additive]
theorem const_div [Div γ] [MeasurableDiv γ] (h : IdentDistrib f g μ ν) (c : γ) :
    IdentDistrib (fun x => c / f x) (fun x => c / g x) μ ν

(h : ProbabilityTheory.IdentDistrib f g μ ν)

ProbabilityTheory.IdentDistrib (fun x => c / f x) (fun x => c / g x) μ ν


theorem eq_interpolate {f : F[X]} (hvs : Set.InjOn v s) (degree_f_lt : f.degree < s.card) :
    f = interpolate s v fun i => f.eval (v i)

{F : Type u_1}
[Field F]
{ι : Type u_2}
[DecidableEq ι]
{s : Finset ι}
{v : ι → F}
{f : F[X]}
(hvs : Set.InjOn v ↑s)
(degree_f_lt : f.degree < ↑s.card)

f = (Lagrange.interpolate s v) fun i => Polynomial.eval (v i) f


lemma smul_neg_of_neg_of_pos [SMulPosStrictMono α β] (ha : a < 0) (hb : 0 < b) : a • b < 0

{α : Type u_1}
{β : Type u_2}
{a : α}
{b : β}
[Zero α]
[Zero β]
[SMulWithZero α β]
[Preorder α]
[Preorder β]
[SMulPosStrictMono α β]
(ha : a < 0)
(hb : 0 < b)


@[simp]
theorem coe_bracket_of_module (x : L') (m : M) : ⁅x, m⁆ = ⁅(x : L), m⁆

{R : Type u}
{L : Type v}
[CommRing R]
[LieRing L]
[LieAlgebra R L]
(L' : LieSubalgebra R L)
{M : Type w}
[AddCommGroup M]
[LieRingModule L M]
(x : ↥L')
(m : M)


@[to_additive]
theorem pairwise_aedisjoint_of_ac {ν} (h : IsFundamentalDomain G s μ) (hν : ν ≪ μ) :
    Pairwise fun g₁ g₂ : G => AEDisjoint ν (g₁ • s) (g₂ • s)

(h : MeasureTheory.IsAddFundamentalDomain G s μ)

(hν : ν ≪ μ)

Pairwise fun g₁ g₂ => MeasureTheory.AEDisjoint ν (g₁ +ᵥ s) (g₂ +ᵥ s)


lemma primeFactors_mono (hmn : m ∣ n) (hn : n ≠ 0) : primeFactors m ⊆ primeFactors n


theorem isBigO_of_le (hfg : ∀ x, ‖f x‖ ≤ ‖g x‖) : f =O[l] g

{α : Type u_1}
{E : Type u_3}
{F : Type u_4}
[Norm E]
[Norm F]
{f : α → E}
{g : α → F}
(l : Filter α)
(hfg : ∀ (x : α), ‖f x‖ ≤ ‖g x‖)


theorem convex_sInter {S : Set (Set E)} (h : ∀ s ∈ S, Convex 𝕜 s) : Convex 𝕜 (⋂₀ S)

{𝕜 : Type u_1}
{E : Type u_2}
[OrderedSemiring 𝕜]
[AddCommMonoid E]
[SMul 𝕜 E]
{S : Set (Set E)}
(h : ∀ s ∈ S, Convex 𝕜 s)


theorem even_card_of_char_two (hF : ringChar F = 2) : Fintype.card F % 2 = 0

{F : Type u_3}
[Field F]
[Fintype F]
(hF : ringChar F = 2)


@[to_additive]
theorem Filter.Tendsto.smul_const {f : α → M} {l : Filter α} {c : M} (hf : Tendsto f l (𝓝 c))
    (a : X) : Tendsto (fun x => f x • a) l (𝓝 (c • a))

{M : Type u_1}
{X : Type u_2}
{α : Type u_4}
[TopologicalSpace M]
[TopologicalSpace X]
[VAdd M X]
[ContinuousVAdd M X]
{f : α → M}
{l : Filter α}
{c : M}
(hf : Filter.Tendsto f l (𝓝 c))
(a : X)

Filter.Tendsto (fun x => f x +ᵥ a) l (𝓝 (c +ᵥ a))


@[simp]
theorem bind₂_comp_C (f : R →+* MvPolynomial σ S) : (bind₂ f).comp C = f

{σ : Type u_1}
{R : Type u_3}
{S : Type u_4}
[CommSemiring R]
[CommSemiring S]
(f : R →+* MvPolynomial σ S)

(MvPolynomial.bind₂ f).comp MvPolynomial.C = f


theorem objSupIsoProdEqLocus_hom_snd {X : TopCat} (F : X.Sheaf CommRingCat) (U V : Opens X) (x) :
    ((F.objSupIsoProdEqLocus U V).hom x).1.snd = F.1.map (homOfLE le_sup_right).op x

(x : ↑(F.val.obj (Opposite.op (U ⊔ V))))

(↑((F.objSupIsoProdEqLocus U V).hom x)).2 = (F.val.map (CategoryTheory.homOfLE ⋯).op) x


/-- **Uniqueness of left-invariant measures**:
Given two left-invariant measures which are finite on
compacts and inner regular for finite measure sets with respect to compact sets,
they coincide in the following sense: they give the same value to finite measure sets,
up to a multiplicative constant. -/
@[to_additive]
lemma measure_isMulLeftInvariant_eq_smul_of_ne_top [LocallyCompactSpace G]
    (μ' μ : Measure G) [IsHaarMeasure μ] [IsFiniteMeasureOnCompacts μ'] [IsMulLeftInvariant μ']
    [InnerRegularCompactLTTop μ] [InnerRegularCompactLTTop μ'] {s : Set G}
    (hs : μ s ≠ ∞) (h's : μ' s ≠ ∞) : μ' s = haarScalarFactor μ' μ • μ s


@[simp]
theorem liftEquiv_trans :
    (liftEquiv M i p).trans (liftEquiv M g p) = liftEquiv M (g.comp i) p

{K : Type u_1}
{L : Type u_2}
{M : Type u_3}
{N : Type u_4}
[CommRing K]
[CommRing L]
[CommRing M]
[CommRing N]
(i : K →+* L)
(g : L →+* N)
(p : ℕ)
[ExpChar K p]
[ExpChar L p]
[ExpChar M p]
[ExpChar N p]
[PerfectRing M p]
[IsPRadical i p]
[IsPRadical g p]
[IsPRadical (g.comp i) p]

(PerfectRing.liftEquiv M i p).trans (PerfectRing.liftEquiv M g p) = PerfectRing.liftEquiv M (g.comp i) p


@[to_additive]
theorem leftInvEquiv_mul (x : S.leftInv) : (S.leftInvEquiv hS x : M) * x = 1

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


@[to_additive]
theorem hasProd_le (h : ∀ i, f i ≤ g i) (hf : HasProd f a₁) (hg : HasProd g a₂) : a₁ ≤ a₂

{ι : Type u_1}
{α : Type u_3}
[OrderedAddCommMonoid α]
[TopologicalSpace α]
[OrderClosedTopology α]
{f g : ι → α}
{a₁ a₂ : α}
(h : ∀ (i : ι), f i ≤ g i)
(hf : HasSum f a₁)
(hg : HasSum g a₂)


@[simp]
theorem contMDiff_diffeomorph_comp_iff {m} (h : M ≃ₘ^n⟮I, J⟯ N) {f : M' → M} (hm : m ≤ n) :
    ContMDiff I' J m (h ∘ f) ↔ ContMDiff I' I m f

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{E' : Type u_3}
[NormedAddCommGroup E']
[NormedSpace 𝕜 E']
{F : Type u_4}
[NormedAddCommGroup F]
[NormedSpace 𝕜 F]
{H : Type u_5}
[TopologicalSpace H]
{H' : Type u_6}
[TopologicalSpace H']
{G : Type u_7}
[TopologicalSpace G]
{I : ModelWithCorners 𝕜 E H}
{I' : ModelWithCorners 𝕜 E' H'}
{J : ModelWithCorners 𝕜 F G}
{M : Type u_9}
[TopologicalSpace M]
[ChartedSpace H M]
{M' : Type u_10}
[TopologicalSpace M']
[ChartedSpace H' M']
{N : Type u_11}
[TopologicalSpace N]
[ChartedSpace G N]
{n m : ℕ∞}
(h : M ≃ₘ^n⟮I, J⟯ N)
{f : M' → M}
(hm : m ≤ n)

ContMDiff I' J m (⇑h ∘ f) ↔ ContMDiff I' I m f


theorem isSheaf_iff_multifork :
    IsSheaf J P ↔ ∀ (X : C) (S : J.Cover X), Nonempty (IsLimit (S.multifork P))

(J : CategoryTheory.GrothendieckTopology C)

CategoryTheory.Presheaf.IsSheaf J P ↔
  ∀ (X : C) (S : J.Cover X), Nonempty (CategoryTheory.Limits.IsLimit (S.multifork P))


@[simp]
theorem conj_id (e : M ≃ₗ[R] M₂) : e.conj LinearMap.id = LinearMap.id

{R : Type u_1}
{M : Type u_8}
{M₂ : Type u_10}
[CommSemiring R]
[AddCommMonoid M]
[AddCommMonoid M₂]
[Module R M]
[Module R M₂]
(e : M ≃ₗ[R] M₂)


lemma atTop_eq_generate_of_not_bddAbove [LinearOrder α] {s : Set α} (hs : ¬ BddAbove s) :
    (atTop : Filter α) = generate (Ici '' s)

{α : Type u_3}
[LinearOrder α]
{s : Set α}
(hs : ¬BddAbove s)

Filter.atTop = Filter.generate (Set.Ici '' s)


theorem mul_inv_cancel_iff_isUnit {I : FractionalIdeal R₁⁰ K} : I * I⁻¹ = 1 ↔ IsUnit I

(K : Type u_3)
[Field K]
{R₁ : Type u_4}
[CommRing R₁]
[IsDomain R₁]
[Algebra R₁ K]
[IsFractionRing R₁ K]
{I : FractionalIdeal R₁⁰ K}


@[ext]
lemma coyonedaPairingExt {X : C × (C ⥤ Type v₁)} {x y : (coyonedaPairing C).obj X}
    (w : ∀ Y, x.app Y = y.app Y) : x = y

{X : C × CategoryTheory.Functor C (Type v₁)}

{x y : (CategoryTheory.coyonedaPairing C).obj X}


protected theorem isClosed [OrderClosedTopology 𝕜] {A B : Set E} (hAB : IsExposed 𝕜 A B)
    (hA : IsClosed A) : IsClosed B

{𝕜 : Type u_1}
{E : Type u_2}
[TopologicalSpace 𝕜]
[OrderedRing 𝕜]
[AddCommMonoid E]
[TopologicalSpace E]
[Module 𝕜 E]
[OrderClosedTopology 𝕜]
{A B : Set E}
(hAB : IsExposed 𝕜 A B)
(hA : IsClosed A)


theorem exact_iff_exact_coimage_π :
    S.Exact ↔ (ShortComplex.mk S.f (Abelian.coimage.π S.g)
      (Abelian.comp_coimage_π_eq_zero S.zero)).Exact

{C : Type u₁}
[CategoryTheory.Category.{v₁, u₁} C]
[CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C)

S.Exact ↔ (CategoryTheory.ShortComplex.mk S.f (CategoryTheory.Abelian.coimage.π S.g) ⋯).Exact


@[to_additive (attr := simp, nolint simpComm)]
theorem semiconjBy_unop [Mul α] {a x y : αᵐᵒᵖ} :
    SemiconjBy (unop a) (unop y) (unop x) ↔ SemiconjBy a x y

SemiconjBy (MulOpposite.unop a) (MulOpposite.unop y) (MulOpposite.unop x) ↔ SemiconjBy a x y


theorem hε :
    Compatibility.υ (isoN₁) =
      (Γ₂N₁ : (toKaroubiEquivalence _).functor ≅
          (N₁ : SimplicialObject C ⥤ _) ⋙ Preadditive.DoldKan.equivalence.inverse)

AlgebraicTopology.DoldKan.Compatibility.υ CategoryTheory.Idempotents.DoldKan.isoN₁ = AlgebraicTopology.DoldKan.Γ₂N₁


theorem Ioo_inter_Iio : Ioo a b ∩ Iio c = Ioo a (min b c)

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

Set.Ioo a b ∩ Set.Iio c = Set.Ioo a (min b c)


@[simp] lemma mul_div_cancel_left₀ (b : M₀) (ha : a ≠ 0) : a * b / a = b

{M₀ : Type u_1}
[CommMonoidWithZero M₀]
[Div M₀]
[MulDivCancelClass M₀]
{a : M₀}
(b : M₀)
(ha : a ≠ 0)


theorem orderEmbeddingToFun_apply {f : Π₀ i, α i} {i : ι} :
    (@orderEmbeddingToFun ι α _ _ f) i = f i

{ι : Type u_1}
{α : ι → Type u_2}
[(i : ι) → Zero (α i)]
[(i : ι) → LE (α i)]
{f : Π₀ (i : ι), α i}
{i : ι}


lemma smul_inv (g : G) (a : H) : (g • a)⁻¹ = g⁻¹ • a⁻¹

{G : Type u_3}
{H : Type u_4}
[Group G]
[Group H]
[MulAction G H]
[SMulCommClass G H H]
[IsScalarTower G H H]
(g : G)
(a : H)

(g • a)⁻¹ = g⁻¹ • a⁻¹


theorem mul_pf_right (b₁ : R) (b₂) (_ : a * b₃ = c) :
    a * (b₁ ^ b₂ * b₃) = b₁ ^ b₂ * c

{R : Type u_1}
[CommSemiring R]
{a b₃ c : R}
(b₁ : R)
(b₂ : ℕ)

a * b₃ = c → a * (b₁ ^ b₂ * b₃) = b₁ ^ b₂ * c


theorem mem_span_map {x : S} {a : Set R} :
    x ∈ Ideal.span (algebraMap R S '' a) ↔ ∃ y ∈ Ideal.span a, ∃ z : M, x = mk' S y z

{R : Type u_1}
[CommRing R]
(M : Submonoid R)
{S : Type u_2}
[CommRing S]
[Algebra R S]
[IsLocalization M S]
{x : S}
{a : Set R}

x ∈ Ideal.span (⇑(algebraMap R S) '' a) ↔ ∃ y ∈ Ideal.span a, ∃ z, x = IsLocalization.mk' S y z


theorem symmetric_join : Symmetric (Join r)


@[simp]
theorem biproduct.isoProduct_inv {f : J → C} [HasBiproduct f] :
    (biproduct.isoProduct f).inv = biproduct.lift (Pi.π f)

(CategoryTheory.Limits.biproduct.isoProduct f).inv = CategoryTheory.Limits.biproduct.lift (CategoryTheory.Limits.Pi.π f)


/-- Two subalgebras that are equal are also equivalent as algebras.

This is the `Subalgebra` version of `LinearEquiv.ofEq` and `Equiv.Set.ofEq`. -/
@[simps apply]
def equivOfEq (S T : Subalgebra R A) (h : S = T) : S ≃ₐ[R] T

{R : Type u}
{A : Type v}
[CommSemiring R]
[Semiring A]
[Algebra R A]
(S T : Subalgebra R A)
(h : S = T)
(x : ↥S)


theorem prefix_take_le_iff {L : List (List (Option α))} (hm : m < L.length) :
    L.take m <+: L.take n ↔ m ≤ n

{α : Type u_1}
{m n : ℕ}
{L : List (List (Option α))}
(hm : m < L.length)


@[to_additive (attr := simp)]
lemma stabilizer_smul_eq_left [SMul α β] [IsScalarTower G α β] (a : α) (b : β)
    (h : Injective (· • b : α → β)) : stabilizer G (a • b) = stabilizer G a

(h : Function.Injective fun x => x +ᵥ b)

AddAction.stabilizer G (a +ᵥ b) = AddAction.stabilizer G a


theorem exists_lt_of_lt_csSup' {s : Set α} {a : α} (h : a < sSup s) : ∃ b ∈ s, a < b

{α : Type u_1}
[ConditionallyCompleteLinearOrderBot α]
{s : Set α}
{a : α}
(h : a < sSup s)


theorem pred_lt : ∀ {n : Nat}, n ≠ 0 → pred n < n


@[simp]
theorem vadd_re : (x +ᵥ z).re = x + z.re


theorem mul_add_left_right_iff {x y z : R} : IsRelPrime x (x * z + y) ↔ IsRelPrime x y


/--
Define the character module of `M` to be `M →+ ℚ ⧸ ℤ`.
The character module of `M` is an injective module if and only if
 `L ⊗ 𝟙 M` is injective for any linear map `L` in the same universe as `M`.
-/
lemma injective_characterModule_iff_rTensor_preserves_injective_linearMap :
    Module.Injective R (CharacterModule M) ↔
    ∀ ⦃N N' : Type v⦄ [AddCommGroup N] [AddCommGroup N'] [Module R N] [Module R N']
      (L : N →ₗ[R] N'), Function.Injective L → Function.Injective (L.rTensor M)

(R : Type u)
(M : Type v)
[CommRing R]
[AddCommGroup M]
[Module R M]

Module.Injective R (CharacterModule M) ↔
  ∀ ⦃N N' : Type v⦄ [inst : AddCommGroup N] [inst_1 : AddCommGroup N'] [inst_2 : Module R N] [inst_3 : Module R N']
    (L : N →ₗ[R] N'), Function.Injective ⇑L → Function.Injective ⇑(LinearMap.rTensor M L)


theorem sups_subset_left : t₁ ⊆ t₂ → s ⊻ t₁ ⊆ s ⊻ t₂

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

t₁ ⊆ t₂ → s ⊻ t₁ ⊆ s ⊻ t₂


theorem negPart_toSimpleFunc (f : α →₁ₛ[μ] ℝ) :
    toSimpleFunc (negPart f) =ᵐ[μ] (toSimpleFunc f).negPart

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

↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc (MeasureTheory.L1.SimpleFunc.negPart f)) =ᵐ[μ]
  ↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f).negPart


theorem iter_deriv_inv (k : ℕ) (x : 𝕜) :
    deriv^[k] Inv.inv x = (∏ i ∈ Finset.range k, (-1 - i : 𝕜)) * x ^ (-1 - k : ℤ)

{𝕜 : Type u}
[NontriviallyNormedField 𝕜]
(k : ℕ)
(x : 𝕜)

deriv^[k] Inv.inv x = (∏ i ∈ Finset.range k, (-1 - ↑i)) * x ^ (-1 - ↑k)


theorem _root_.MeasureTheory.Memℒp.abs {f : α → E} (hf : Memℒp f p μ) : Memℒp |f| p μ

{α : Type u_1}
{E : Type u_2}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{p : ℝ≥0∞}
[NormedLatticeAddCommGroup E]
{f : α → E}
(hf : MeasureTheory.Memℒp f p μ)


@[simp]
lemma harmonic_zero : harmonic 0 = 0


@[simp] lemma mem_shatterer : s ∈ 𝒜.shatterer ↔ 𝒜.Shatters s

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


@[to_additive]
theorem eq_of_eqOn_denseM {s : Set M} (hs : closure s = ⊤) {f g : M →* N} (h : s.EqOn f g) :
    f = g

{M : Type u_1}
{N : Type u_2}
[MulOneClass M]
[MulOneClass N]
{s : Set M}
(hs : Submonoid.closure s = ⊤)
{f g : M →* N}
(h : Set.EqOn (⇑f) (⇑g) s)


@[simp]
theorem closure_setOf_lt_im (a : ℝ) : closure { z : ℂ | a < z.im } = { z | a ≤ z.im }


/-- The homotopy between morphisms in `ShortComplex C` that is induced by a homotopy
between morphisms in `ShortComplex Cᵒᵖ`. -/
@[simps]
def unop {S₁ S₂ : ShortComplex Cᵒᵖ} {φ₁ φ₂ : S₁ ⟶ S₂}  (h : Homotopy φ₁ φ₂) :
    Homotopy (unopMap φ₁) (unopMap φ₂)

{S₁ S₂ : CategoryTheory.ShortComplex Cᵒᵖ}

{φ₁ φ₂ : S₁ ⟶ S₂}

(h : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂)


theorem exists_finset_nhd_support_subset {U : ι → Set X} (hso : f.IsSubordinate U)
    (ho : ∀ i, IsOpen (U i)) (x : X) :
    ∃ is : Finset ι, ∃ n ∈ 𝓝 x, n ⊆ ⋂ i ∈ is, U i ∧ ∀ z ∈ n, (support (f · z)) ⊆ is

{ι : Type u}
{X : Type v}
[TopologicalSpace X]
{s : Set X}
{f : PartitionOfUnity ι X s}
{U : ι → Set X}
(hso : f.IsSubordinate U)
(ho : ∀ (i : ι), IsOpen (U i))
(x : X)

∃ is, ∃ n ∈ 𝓝 x, n ⊆ ⋂ i ∈ is, U i ∧ ∀ z ∈ n, (Function.support fun x => (f x) z) ⊆ ↑is


@[to_additive (attr := simp)]
lemma antivaryOn_inv_left : AntivaryOn f⁻¹ g s ↔ MonovaryOn f g s

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


@[to_additive]
theorem mem_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
    (hS : DirectedOn (· ≤ ·) S) {x : M} : x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s

(hS : DirectedOn (fun x x_1 => x ≤ x_1) S)


/-- If `f,g` is a kernel pair for some morphism `q`, then it is reflexive. -/
theorem IsKernelPair.isReflexivePair {R : C} {f g : R ⟶ A} {q : A ⟶ B} (h : IsKernelPair q f g) :
    IsReflexivePair f g

{C : Type u}
[CategoryTheory.Category.{v, u} C]
{A B R : C}
{f g : R ⟶ A}
{q : A ⟶ B}
(h : CategoryTheory.IsKernelPair q f g)


theorem SupIndep.subset (ht : t.SupIndep f) (h : s ⊆ t) : s.SupIndep f

{α : Type u_1}
{ι : Type u_3}
[Lattice α]
[OrderBot α]
{s t : Finset ι}
{f : ι → α}
(ht : t.SupIndep f)
(h : s ⊆ t)


theorem Equiv.Perm.decomposeOption_symm_sign {α : Type*} [DecidableEq α] [Fintype α] (e : Perm α) :
    Perm.sign (Equiv.Perm.decomposeOption.symm (none, e)) = Perm.sign e

{α : Type u_1}
[DecidableEq α]
[Fintype α]
(e : Equiv.Perm α)

Equiv.Perm.sign (Equiv.Perm.decomposeOption.symm (none, e)) = Equiv.Perm.sign e


/-- See also `comp_open_symm_mem_uniformity_sets`. -/
theorem comp_symm_mem_uniformity_sets {s : Set (α × α)} (hs : s ∈ 𝓤 α) :
    ∃ t ∈ 𝓤 α, SymmetricRel t ∧ t ○ t ⊆ s

{α : Type ua}
[UniformSpace α]
{s : Set (α × α)}
(hs : s ∈ 𝓤 α)


@[simp]
theorem Matrix.toLinearMap₂_toMatrix₂ (B : M₁ →ₗ[R] M₂ →ₗ[R] N₂) :
    Matrix.toLinearMap₂ b₁ b₂ (LinearMap.toMatrix₂ b₁ b₂ B) = B

{R : Type u_1}
{M₁ : Type u_7}
{M₂ : Type u_8}
{N₂ : Type u_11}
{n : Type u_12}
{m : Type u_13}
[CommSemiring R]
[AddCommMonoid M₁]
[Module R M₁]
[AddCommMonoid M₂]
[Module R M₂]
[AddCommMonoid N₂]
[Module R N₂]
[DecidableEq n]
[Fintype n]
[DecidableEq m]
[Fintype m]
(b₁ : Basis n R M₁)
(b₂ : Basis m R M₂)
(B : M₁ →ₗ[R] M₂ →ₗ[R] N₂)

(Matrix.toLinearMap₂ b₁ b₂) ((LinearMap.toMatrix₂ b₁ b₂) B) = B


lemma numeric_mul_option (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) (h : IsOption y' y) :
    (x * y').Numeric

(ih :
  ∀ (a : Surreal.Multiplication.Args),
    Surreal.Multiplication.ArgsRel a (Surreal.Multiplication.Args.P1 x y) → Surreal.Multiplication.P124 a)


@[simp]
theorem coe_comp (f : M ⟶ N) (g : N ⟶ U) : (f ≫ g : M → U) = g ∘ f

{R : Type u}
[Ring R]
{M N U : ModuleCat R}
(f : M ⟶ N)
(g : N ⟶ U)


@[to_additive (attr := simp)]
theorem le_inv_self_iff : a ≤ a⁻¹ ↔ a ≤ 1

{α : Type u}
[LinearOrderedCommGroup α]
{a : α}

a ≤ a⁻¹ ↔ a ≤ 1


/-- The `G`-set `Gⁿ`, acting on itself by left multiplication. -/
@[simps!]
def diagonal (G : Type u) [Monoid G] (n : ℕ) : Action (Type u) (MonCat.of G)

∀ (x : ↑(MonCat.of G)) (x_1 : Fin n → G) (a : Fin n), (Action.diagonal G n).ρ x x_1 a = (x • x_1) a


theorem toContinuousMultilinearMap_injective :
    Injective (ContinuousAlternatingMap.toContinuousMultilinearMap :
      M [⋀^ι]→L[R] N → ContinuousMultilinearMap R (fun _ : ι => M) N)

{R : Type u_1}
{M : Type u_2}
{N : Type u_4}
{ι : Type u_6}
[Semiring R]
[AddCommMonoid M]
[Module R M]
[TopologicalSpace M]
[AddCommMonoid N]
[Module R N]
[TopologicalSpace N]


/-- `TStructure C` is the type of t-structures on the (pre)triangulated category `C`. -/
structure TStructure where
  /-- the predicate of objects that are `≤ n` for `n : ℤ`. -/
  LE (n : ℤ) : C → Prop
  /-- the predicate of objects that are `≥ n` for `n : ℤ`. -/
  GE (n : ℤ) : C → Prop
  LE_closedUnderIsomorphisms (n : ℤ) : ClosedUnderIsomorphisms (LE n) := by infer_instance
  GE_closedUnderIsomorphisms (n : ℤ) : ClosedUnderIsomorphisms (GE n) := by infer_instance
  LE_shift (n a n' : ℤ) (h : a + n' = n) (X : C) (hX : LE n X) : LE n' (X⟦a⟧)
  GE_shift (n a n' : ℤ) (h : a + n' = n) (X : C) (hX : GE n X) : GE n' (X⟦a⟧)
  zero' ⦃X Y : C⦄ (f : X ⟶ Y) (hX : LE 0 X) (hY : GE 1 Y) : f = 0
  LE_zero_le : LE 0 ≤ LE 1
  GE_one_le : GE 1 ≤ GE 0
  exists_triangle_zero_one (A : C) : ∃ (X Y : C) (_ : LE 0 X) (_ : GE 1 Y)
    (f : X ⟶ A) (g : A ⟶ Y) (h : Y ⟶ X⟦(1 : ℤ)⟧), Triangle.mk f g h ∈ distTriang C

[∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]

(self : CategoryTheory.Triangulated.TStructure C)

self.LE n' ((CategoryTheory.shiftFunctor C a).obj X)


theorem le_maximum_of_mem' (ha : a ∈ l) : (a : WithBot α) ≤ maximum l

{α : Type u_1}
[LinearOrder α]
{l : List α}
{a : α}
(ha : a ∈ l)


/-- If ∠BCD = π, then ∠ABC = ∠ABD. -/
theorem angle_eq_angle_of_angle_eq_pi (p1 : P) {p2 p3 p4 : P} (h : ∠ p2 p3 p4 = π) :
    ∠ p1 p2 p3 = ∠ p1 p2 p4

(h : EuclideanGeometry.angle p2 p3 p4 = π)

EuclideanGeometry.angle p1 p2 p3 = EuclideanGeometry.angle p1 p2 p4


@[simp] theorem set_cons_succ (x : α) (xs : List α) (n : Nat) (a : α) :
  (x :: xs).set (n + 1) a = x :: xs.set n a

{α : Type u_1}
(x : α)
(xs : List α)
(n : Nat)
(a : α)


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

{E : Type u_4}
{F : Type u_5}
[AddGroup E]
[AddGroup F]
{p q : AddGroupSeminorm E}
(f : F →+ E)
(hp : p ≤ q)


lemma EquivLike.pairwise_comp_iff {X : Type*} {Y : Type*} {F} [EquivLike F Y X]
    (f : F) (p : X → X → Prop) : Pairwise (p on f) ↔ Pairwise p

{X : Type u_1}
{Y : Type u_2}
{F : Sort u_3}
[EquivLike F Y X]
(f : F)
(p : X → X → Prop)


theorem CC_comp_zero : ∀ y, (Linear_CC' C hsC ho) ((πs C o) y) = 0

(hsC : Profinite.NobelingProof.contained C (Order.succ o))

(ho : o < Ordinal.type fun x x_1 => x < x_1)

(y : LocallyConstant ↑(Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o) ℤ)

(Profinite.NobelingProof.Linear_CC' C hsC ho) ((Profinite.NobelingProof.πs C o) y) = 0


theorem map_span [RingHomSurjective σ₁₂] (f : F) (s : Set M) :
    (span R s).map f = span R₂ (f '' s)

{R : Type u_1}
{R₂ : Type u_2}
{M : Type u_4}
{M₂ : Type u_5}
[Semiring R]
[AddCommMonoid M]
[Module R M]
[Semiring R₂]
{σ₁₂ : R →+* R₂}
[AddCommMonoid M₂]
[Module R₂ M₂]
{F : Type u_8}
[FunLike F M M₂]
[SemilinearMapClass F σ₁₂ M M₂]
[RingHomSurjective σ₁₂]
(f : F)
(s : Set M)

Submodule.map f (Submodule.span R s) = Submodule.span R₂ (⇑f '' s)


theorem isSheaf_on_punit_iff_isTerminal (F : Presheaf C (TopCat.of PUnit)) :
    F.IsSheaf ↔ Nonempty (IsTerminal <| F.obj <| op ⊥)

(F : TopCat.Presheaf C (TopCat.of PUnit.{u_1 + 1}))

F.IsSheaf ↔ Nonempty (CategoryTheory.Limits.IsTerminal (F.obj (Opposite.op ⊥)))


theorem rfl {p : Set α → Prop} : InnerRegularWRT μ p p

{α : Type u_1}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{p : Set α → Prop}


@[simp]
protected theorem mapL_pow (f : Π i, E i →L[𝕜] E i) (n : ℕ) :
    mapL (f ^ n) = mapL f ^ n

[(i : ι) → SeminormedAddCommGroup (E i)]

PiTensorProduct.mapL (f ^ n) = PiTensorProduct.mapL f ^ n


theorem PairwiseDisjoint.elim (hs : s.PairwiseDisjoint f) {i j : ι} (hi : i ∈ s) (hj : j ∈ s)
    (h : ¬Disjoint (f i) (f j)) : i = j

{α : Type u_1}
{ι : Type u_4}
[PartialOrder α]
[OrderBot α]
{s : Set ι}
{f : ι → α}
(hs : s.PairwiseDisjoint f)
{i j : ι}
(hi : i ∈ s)
(hj : j ∈ s)
(h : ¬Disjoint (f i) (f j))


@[simp]
lemma Φ_ofNat (n : ℕ) : W.Φ (n + 1) =
    X * W.preΨ' (n + 1) ^ 2 * (if Even n then 1 else W.Ψ₂Sq) -
      W.preΨ' (n + 2) * W.preΨ' n * (if Even n then W.Ψ₂Sq else 1)

{R : Type r}
[CommRing R]
(W : WeierstrassCurve R)
(n : ℕ)

W.Φ (↑n + 1) =
  (Polynomial.X * W.preΨ' (n + 1) ^ 2 * if Even n then 1 else W.Ψ₂Sq) -
    W.preΨ' (n + 2) * W.preΨ' n * if Even n then W.Ψ₂Sq else 1


/-- Our function tends to zero at zero faster than any $P(x^{-1})$, $P∈ℝ[X]$, tends to infinity. -/
theorem tendsto_polynomial_inv_mul_zero (p : ℝ[X]) :
    Tendsto (fun x ↦ p.eval x⁻¹ * expNegInvGlue x) (𝓝 0) (𝓝 0)

Filter.Tendsto (fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x) (𝓝 0) (𝓝 0)


lemma mem_iff (hnm : n + 1 = m) (z : Cochain F G n) :
    z ∈ cocycle F G n ↔ δ n m z = 0

(z : CochainComplex.HomComplex.Cochain F G n)

z ∈ CochainComplex.HomComplex.cocycle F G n ↔ CochainComplex.HomComplex.δ n m z = 0


/-- Infinite sums commute with scalar multiplication. Version for scalars living in a
  `DivisionRing`; no summability hypothesis. This could be made to work for a
  `[GroupWithZero γ]` if there was such a thing as `DistribMulActionWithZero`. -/
lemma tsum_const_smul'' {γ : Type*} [DivisionRing γ] [Module γ α] [ContinuousConstSMul γ α]
    [T2Space α] (g : γ) : ∑' (i : β), g • f i = g • ∑' (i : β), f i

{α : Type u_1}
{β : Type u_2}
[TopologicalSpace α]
[AddCommMonoid α]
{f : β → α}
{γ : Type u_5}
[DivisionRing γ]
[Module γ α]
[ContinuousConstSMul γ α]
[T2Space α]
(g : γ)


lemma AntitoneOn.image_Iic_subset (h : AntitoneOn f (Iic b)) : f '' Iic b ⊆ Ici (f b)

{α : Type u_1}
{β : Type u_2}
{f : α → β}
[Preorder α]
[Preorder β]
{b : α}
(h : AntitoneOn f (Set.Iic b))


@[to_additive]
theorem dvd_index_map {f : G →* G'} (hf : f.ker ≤ H) :
    H.index ∣ (H.map f).index

{G : Type u_1}
{G' : Type u_2}
[AddGroup G]
[AddGroup G']
(H : AddSubgroup G)
{f : G →+ G'}
(hf : f.ker ≤ H)


@[simp]
theorem adjointDomainMkCLMExtend_apply (y : T.adjointDomain) (x : T.domain) :
    adjointDomainMkCLMExtend hT y (x : E) = ⟪(y : F), T x⟫

{𝕜 : Type u_1}
{E : Type u_2}
{F : Type u_3}
[RCLike 𝕜]
[NormedAddCommGroup E]
[InnerProductSpace 𝕜 E]
[NormedAddCommGroup F]
[InnerProductSpace 𝕜 F]
{T : E →ₗ.[𝕜] F}
(hT : Dense ↑T.domain)
(y : ↥T.adjointDomain)
(x : ↥T.domain)

(LinearPMap.adjointDomainMkCLMExtend hT y) ↑x = ⟪↑y, ↑T x⟫_𝕜


theorem ext_threefold {g h : (M ⊗[R] N) ⊗[R] P →ₗ[R] Q}
    (H : ∀ x y z, g (x ⊗ₜ y ⊗ₜ z) = h (x ⊗ₜ y ⊗ₜ z)) : g = h

{g h : TensorProduct R (TensorProduct R M N) P →ₗ[R] Q}


lemma leRecOn_succ_left {C : ℕ → Sort*} {n m}
    {next : ∀ {k}, C k → C (k + 1)} (x : C n) (h1 : n ≤ m) (h2 : n + 1 ≤ m) :
    (leRecOn h2 next (next x) : C m) = (leRecOn h1 next x : C m)

{C : ℕ → Sort u_1}
{n m : ℕ}
{next : {k : ℕ} → C k → C (k + 1)}
(x : C n)
(h1 : n ≤ m)
(h2 : n + 1 ≤ m)

Nat.leRecOn h2 (fun {k} => next) (next x) = Nat.leRecOn h1 (fun {k} => next) x


theorem integral_deriv_comp_mul_deriv {f f' g g' : ℝ → ℝ}
    (hf : ∀ x ∈ uIcc a b, HasDerivAt f (f' x) x)
    (hg : ∀ x ∈ uIcc a b, HasDerivAt g (g' (f x)) (f x)) (hf' : ContinuousOn f' (uIcc a b))
    (hg' : Continuous g') : (∫ x in a..b, (g' ∘ f) x * f' x) = (g ∘ f) b - (g ∘ f) a

(hf : ∀ x ∈ [[a, b]], HasDerivAt f (f' x) x)

(hg : ∀ x ∈ [[a, b]], HasDerivAt g (g' (f x)) (f x))

∫ (x : ℝ) in a..b, (g' ∘ f) x * f' x = (g ∘ f) b - (g ∘ f) a


/-- Group homomorphisms preserve division. -/
@[to_additive (attr := simp) "Additive group homomorphisms preserve subtraction."]
theorem map_div [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) :
    ∀ a b, f (a / b) = f a / f b

{G : Type u_7}
{H : Type u_8}
{F : Type u_9}
[FunLike F G H]
[Group G]
[DivisionMonoid H]
[MonoidHomClass F G H]
(f : F)
(a b : G)


lemma LSeriesHasSum.LSeriesSummable {f : ℕ → ℂ} {s a : ℂ}
    (h : LSeriesHasSum f s a) : LSeriesSummable f s


/-- If `w₁ w₂` are words such that `w₁` reduces to `w₂`, then `w₂` is a sublist of `w₁`. -/
@[to_additive "If `w₁ w₂` are words such that `w₁` reduces to `w₂`, then `w₂` is a sublist of
  `w₁`."]
protected theorem sublist : Red L₁ L₂ → L₂ <+ L₁


@[simp]
theorem bmod_sub_cancel (x : Int) (n : Nat) : Int.bmod (x - n) n = Int.bmod x n


@[simp]
theorem isIntegral_algEquiv {A B : Type*} [Ring A] [Ring B] [Algebra R A] [Algebra R B]
    (f : A ≃ₐ[R] B) {x : A} : IsIntegral R (f x) ↔ IsIntegral R x

{R : Type u_1}
[CommRing R]
{A : Type u_5}
{B : Type u_6}
[Ring A]
[Ring B]
[Algebra R A]
[Algebra R B]
(f : A ≃ₐ[R] B)
{x : A}


theorem cauchy_neg : ∀ a, (-a : ℝ).cauchy = -a.cauchy


theorem starConvex_pi {ι : Type*} {E : ι → Type*} [∀ i, AddCommMonoid (E i)] [∀ i, SMul 𝕜 (E i)]
    {x : ∀ i, E i} {s : Set ι} {t : ∀ i, Set (E i)} (ht : ∀ ⦃i⦄, i ∈ s → StarConvex 𝕜 (x i) (t i)) :
    StarConvex 𝕜 x (s.pi t)

(ht : ∀ ⦃i : ι⦄, i ∈ s → StarConvex 𝕜 (x i) (t i))


/-- `NonUnitalSubsemiringClass S R` states that `S` is a type of subsets `s ⊆ R` that
are both an additive submonoid and also a multiplicative subsemigroup. -/
class NonUnitalSubsemiringClass (S : Type*) (R : Type u) [NonUnitalNonAssocSemiring R]
  [SetLike S R] extends AddSubmonoidClass S R : Prop where
  mul_mem : ∀ {s : S} {a b : R}, a ∈ s → b ∈ s → a * b ∈ s

{S : Type u_1}
{R : Type u}
[NonUnitalNonAssocSemiring R]
[SetLike S R]
[self : NonUnitalSubsemiringClass S R]
{s : S}
{a b : R}


theorem mapsTo (h : LeftInvOn f' f s) (hf : SurjOn f s t) :
    MapsTo f' t s

{α : Type u_1}
{β : Type u_2}
{s : Set α}
{t : Set β}
{f : α → β}
{f' : β → α}
(h : Set.LeftInvOn f' f s)
(hf : Set.SurjOn f s t)


@[simp]
theorem id_comp (f : HeytingHom α β) : (HeytingHom.id β).comp f = f

{α : Type u_2}
{β : Type u_3}
[HeytingAlgebra α]
[HeytingAlgebra β]
(f : HeytingHom α β)


@[to_additive (attr := simp)]
theorem coe_pureOneHom : (pureOneHom : α → Filter α) = pure


@[simp]
theorem Path.reverse_reverse [h : HasInvolutiveReverse V] {a b : V} (p : Path a b) :
    p.reverse.reverse = p

{V : Type u_2}
[Quiver V]
[h : Quiver.HasInvolutiveReverse V]
{a b : V}
(p : Quiver.Path a b)


lemma Submodule.finite_ne_bot_of_independent {ι : Type*} {N : ι → Submodule R M}
    (h : CompleteLattice.Independent N) :
    Set.Finite {i | N i ≠ ⊥}

{R : Type u_1}
{M : Type u_2}
[Ring R]
[AddCommGroup M]
[Module R M]
[IsNoetherian R M]
{ι : Type u_4}
{N : ι → Submodule R M}
(h : CompleteLattice.Independent N)


@[to_additive] lemma eq_bot_iff_card : H = ⊥ ↔ Nat.card H = 1

{G : Type u_1}
[Group G]
(H : Subgroup G)


/-- This can't be an instance because of typeclass loops. -/
lemma BoundedLatticeHomClass.toBiheytingHomClass [BooleanAlgebra α] [BooleanAlgebra β]
    [BoundedLatticeHomClass F α β] : BiheytingHomClass F α β

{F : Type u_1}
{α : Type u_2}
{β : Type u_3}
[FunLike F α β]
[BooleanAlgebra α]
[BooleanAlgebra β]
[BoundedLatticeHomClass F α β]


@[simp]
theorem map₂_coe (op : β → γ → δ) (f : α → β) (g : α → γ) :
    map₂ op (f : Germ l β) g = fun x => op (f x) (g x)

{α : Type u_1}
{β : Type u_2}
{γ : Type u_3}
{δ : Type u_4}
{l : Filter α}
(op : β → γ → δ)
(f : α → β)
(g : α → γ)

Filter.Germ.map₂ op ↑f ↑g = ↑fun x => op (f x) (g x)


theorem natAdd_castAdd (p m : Nat) {n : Nat} (i : Fin n) :
    natAdd m (castAdd p i) = cast (Nat.add_assoc ..) (castAdd p (natAdd m i))

Fin.natAdd m (Fin.castAdd p i) = Fin.cast ⋯ (Fin.castAdd p (Fin.natAdd m i))


@[to_additive (attr := simp)]
theorem index_top : (⊤ : Subgroup G).index = 1


/-- `(n, m)` is in the transitive closure of a reflexive relation `~` if `i ~ pred i` and
  `pred i ~ i` for all `i` between `n` and `m`. -/
theorem transGen_of_pred_of_reflexive (r : α → α → Prop) {n m : α} (hr : Reflexive r)
    (h1 : ∀ i ∈ Ioc m n, r i (pred i)) (h2 : ∀ i ∈ Ioc n m, r (pred i) i) : TransGen r n m

(h1 : ∀ i ∈ Set.Ioc m n, r i (Order.pred i))

(h2 : ∀ i ∈ Set.Ioc n m, r (Order.pred i) i)


@[measurability]
protected theorem nnnorm {_ : MeasurableSpace α} {β : Type*} [SeminormedAddCommGroup β] {f : α → β}
    (hf : StronglyMeasurable f) : StronglyMeasurable fun x => ‖f x‖₊

∀ {x : MeasurableSpace α} {β : Type u_5} [inst : SeminormedAddCommGroup β] {f : α → β},
  MeasureTheory.StronglyMeasurable f → MeasureTheory.StronglyMeasurable fun x => ‖f x‖₊


@[fun_prop]
lemma ContinuousOn.sup (hf : ContinuousOn f s) (hg : ContinuousOn g s) :
    ContinuousOn (fun a ↦ f a ⊔ g a) s

{L : Type u_1}
{X : Type u_2}
[TopologicalSpace L]
[TopologicalSpace X]
[Sup L]
[ContinuousSup L]
{f g : X → L}
{s : Set X}
(hf : ContinuousOn f s)
(hg : ContinuousOn g s)


theorem map_filter_eq_foldr (f : α → β) (p : α → Bool) (as : List α) :
    map f (filter p as) = foldr (fun a bs => bif p a then f a :: bs else bs) [] as

{α : Type u_1}
{β : Type u_2}
(f : α → β)
(p : α → Bool)
(as : List α)

List.map f (List.filter p as) = List.foldr (fun a bs => bif p a then f a :: bs else bs) [] as


theorem const_succ_apply {n} (p : Fin (n + 1) → Type u) {τ : Type u} (t : τ)
    (x : p 0) : const p t x = const (vecTail p) t

{n : ℕ}
(p : Fin (n + 1) → Type u)
{τ : Type u}
(t : τ)
(x : p 0)

Function.FromTypes.const p t x = Function.FromTypes.const (Matrix.vecTail p) t


theorem bmod_natAbs_plus_one (x : Int) (w : 1 < x.natAbs) : bmod x (x.natAbs + 1) = - x.sign


theorem cobounded_le_cocompact : cobounded α ≤ cocompact α

Bornology.cobounded α ≤ Filter.cocompact α


@[simp]
lemma toHomeomorph_symm (e : X ≃ᵈ Y) : e.toHomeomorph.symm = e.symm.toHomeomorph

{X : Type u_1}
{Y : Type u_2}
[PseudoEMetricSpace X]
[PseudoEMetricSpace Y]
(e : X ≃ᵈ Y)


theorem irreducible_pow_sup_of_le (hJ : Irreducible J) (n : ℕ) (hn : ↑n ≤ multiplicity J I) :
    J ^ n ⊔ I = J ^ n

{T : Type u_4}
[CommRing T]
[IsDedekindDomain T]
{I J : Ideal T}
(hJ : Irreducible J)
(n : ℕ)
(hn : ↑n ≤ multiplicity J I)


private theorem relations_liftable {G : Type*} [Group G] {f : B → G} (hf : IsLiftable M f)
    (r : FreeGroup B) (hr : r ∈ M.relationsSet) : (FreeGroup.lift f) r = 1

{B : Type u_1}
{M : CoxeterMatrix B}
{G : Type u_5}
[Group G]
{f : B → G}
(hf : M.IsLiftable f)
(r : FreeGroup B)
(hr : r ∈ M.relationsSet)


/-- One subspace is less than or equal to another if and only if all its points are in the second
subspace. -/
theorem le_def' (s1 s2 : AffineSubspace k P) : s1 ≤ s2 ↔ ∀ p ∈ s1, p ∈ s2

{k : Type u_1}
{V : Type u_2}
{P : Type u_3}
[Ring k]
[AddCommGroup V]
[Module k V]
[S : AffineSpace V P]
(s1 s2 : AffineSubspace k P)


lemma mulShift_mulShift (ψ : AddChar R M) (r s : R) :
    mulShift (mulShift ψ r) s = mulShift ψ (r * s)

{R : Type u_1}
{M : Type u_2}
[Ring R]
[CommMonoid M]
(ψ : AddChar R M)
(r s : R)

(ψ.mulShift r).mulShift s = ψ.mulShift (r * s)


@[to_additive]
theorem singleton_mul (a : α) : {a} * s = s.image (a * ·)

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

{a} + s = Finset.image (fun x => a + x) s


/-- The `Prod.GameAdd` relation on well-founded inputs is well-founded.

  In particular, the sum of two well-founded games is well-founded. -/
theorem WellFounded.prod_gameAdd (hα : WellFounded rα) (hβ : WellFounded rβ) :
    WellFounded (Prod.GameAdd rα rβ)

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


@[simp] theorem top_ne_coe : ∞ ≠ (r : ℝ≥0∞)


@[simp]
theorem single_mul (a : α) (b₁ b₂ : β) : single a (b₁ * b₂) = single a b₁ * single a b₂

{α : Type u₁}
{β : Type u₂}
[MulZeroClass β]
(a : α)
(b₁ b₂ : β)

Finsupp.single a (b₁ * b₂) = Finsupp.single a b₁ * Finsupp.single a b₂


theorem coe_get {o : Option α} (h : o.isSome) : ((Option.get _ h : α) : Option α) = o

{α : Type u_1}
{o : Option α}
(h : o.isSome = true)


@[instance]
theorem ordConnected_Ico {a b : α} : OrdConnected (Ico a b)


theorem le.dest {a b : Int} (h : a ≤ b) : ∃ n : Nat, a + n = b


@[simp]
theorem cancel_left (hg : Injective g) : g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

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


theorem cos_antiperiodic : Function.Antiperiodic cos (π : Angle)


theorem hall_cond_of_erase {x : ι} (a : α)
    (ha : ∀ s : Finset ι, s.Nonempty → s ≠ univ → s.card < (s.biUnion t).card)
    (s' : Finset { x' : ι | x' ≠ x }) : s'.card ≤ (s'.biUnion fun x' => (t x').erase a).card

(ha : ∀ (s : Finset ι), s.Nonempty → s ≠ Finset.univ → s.card < (s.biUnion t).card)

s'.card ≤ (s'.biUnion fun x' => (t ↑x').erase a).card


@[simp]
lemma rpow_ne_zero (hx : 0 ≤ x) (hy : y ≠ 0) : x ^ y ≠ 0 ↔ x ≠ 0


/-- The obvious homotopy between a morphism of short complexes and itself. -/
@[simps!]
def refl (φ : S₁ ⟶ S₂) : Homotopy φ φ

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

(CategoryTheory.ShortComplex.Homotopy.refl φ).h₀ = 0


lemma psum_def (n : ℕ) : psum σ R n = ∑ i, X i ^ n

(σ : Type u_1)
(R : Type u_2)
[CommSemiring R]
[Fintype σ]
(n : ℕ)

MvPolynomial.psum σ R n = ∑ i : σ, MvPolynomial.X i ^ n


/-- **Leibniz rule** for the co-Heyting boundary. -/
theorem boundary_inf (a b : α) : ∂ (a ⊓ b) = ∂ a ⊓ b ⊔ a ⊓ ∂ b

{α : Type u_1}
[CoheytingAlgebra α]
(a b : α)


theorem preconnectedSpace_iff_connectedComponent :
    PreconnectedSpace α ↔ ∀ x : α, connectedComponent x = univ

PreconnectedSpace α ↔ ∀ (x : α), connectedComponent x = Set.univ


@[to_additive] lemma le_mulEnergy : s.card * t.card ≤ Eₘ[s, t]

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


@[to_additive]
theorem index_iInf_le {ι : Type*} [Fintype ι] (f : ι → Subgroup G) :
    (⨅ i, f i).index ≤ ∏ i, (f i).index

{G : Type u_1}
[Group G]
{ι : Type u_3}
[Fintype ι]
(f : ι → Subgroup G)


nonrec theorem UniformContinuous.comp [UniformSpace β] [UniformSpace γ] {g : β → γ} {f : α → β}
    (hg : UniformContinuous g) (hf : UniformContinuous f) : UniformContinuous (g ∘ f)

{α : Type ua}
{β : Type ub}
{γ : Type uc}
[UniformSpace α]
[UniformSpace β]
[UniformSpace γ]
{g : β → γ}
{f : α → β}
(hg : UniformContinuous g)
(hf : UniformContinuous f)


theorem tendsto_def {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
    Tendsto f l₁ l₂ ↔ ∀ s ∈ l₂, f ⁻¹' s ∈ l₁

{α : Type u}
{β : Type v}
{f : α → β}
{l₁ : Filter α}
{l₂ : Filter β}

Filter.Tendsto f l₁ l₂ ↔ ∀ s ∈ l₂, f ⁻¹' s ∈ l₁


theorem dist_triangle (x y z : α) : dist x z ≤ dist x y + dist y z

{α : Type u}
[PseudoMetricSpace α]
(x y z : α)


/-- The forgetful functor from `Scheme` to `LocallyRingedSpace`. -/
@[simps!]
def forgetToLocallyRingedSpace : Scheme ⥤ LocallyRingedSpace

∀
  {X Y :
    CategoryTheory.InducedCategory AlgebraicGeometry.LocallyRingedSpace AlgebraicGeometry.Scheme.toLocallyRingedSpace}
  (f : X ⟶ Y), AlgebraicGeometry.Scheme.forgetToLocallyRingedSpace.map f = f


@[simp]
theorem domDomCongr_refl (f : M [⋀^ι]→ₗ[R] N) : f.domDomCongr (Equiv.refl ι) = f

{R : Type u_1}
[Semiring R]
{M : Type u_2}
[AddCommMonoid M]
[Module R M]
{N : Type u_3}
[AddCommMonoid N]
[Module R N]
{ι : Type u_7}
(f : M [⋀^ι]→ₗ[R] N)

AlternatingMap.domDomCongr (Equiv.refl ι) f = f


theorem unzip_zip_right {l₁ : List α} {l₂ : List β} (h : length l₂ ≤ length l₁) :
    (unzip (zip l₁ l₂)).2 = l₂

{α : Type u}
{β : Type u_1}
{l₁ : List α}
{l₂ : List β}
(h : l₂.length ≤ l₁.length)


@[simp]
theorem mem_pi {f : ι →₀ Finset α} {g : ι →₀ α} : g ∈ f.pi ↔ ∀ i, g i ∈ f i

{ι : Type u_1}
{α : Type u_2}
[Zero α]
{f : ι →₀ Finset α}
{g : ι →₀ α}


/-- Negation of the condition `P : Prop` in a `ite` is the same as swapping the branches. -/
@[simp] theorem ite_not (p : Prop) [Decidable p] (x y : α) : ite (¬p) x y = ite p y x

{α : Sort u_1}
(p : Prop)
[Decidable p]
(x y : α)

(if ¬p then x else y) = if p then y else x


@[aesop safe 20 apply (rule_sets := [Measurable])]
theorem AEMeasurable.pow (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) :
    AEMeasurable (fun x => f x ^ g x) μ

{β : Type u_2}
{γ : Type u_3}
{α : Type u_4}
[MeasurableSpace β]
[MeasurableSpace γ]
[Pow β γ]
[MeasurablePow β γ]
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{f : α → β}
{g : α → γ}
(hf : AEMeasurable f μ)
(hg : AEMeasurable g μ)


@[simp]
theorem fst_exp (x : tsze R M) : fst (exp 𝕜 x) = exp 𝕜 x.fst

(𝕜 : Type u_1)
{R : Type u_3}
{M : Type u_4}
[Field 𝕜]
[CharZero 𝕜]
[CommRing R]
[AddCommGroup M]
[Algebra 𝕜 R]
[Module 𝕜 M]
[Module R M]
[Module Rᵐᵒᵖ M]
[IsCentralScalar R M]
[IsScalarTower 𝕜 R M]
[TopologicalSpace R]
[TopologicalSpace M]
[TopologicalRing R]
[TopologicalAddGroup M]
[ContinuousSMul R M]
[ContinuousSMul Rᵐᵒᵖ M]
[T2Space R]
[T2Space M]
(x : tsze R M)

(NormedSpace.exp 𝕜 x).fst = NormedSpace.exp 𝕜 x.fst


/-- Product of a multiset of elements in a submonoid of a `CommMonoid` is in the submonoid. -/
@[to_additive
      "Sum of a multiset of elements in an `AddSubmonoid` of an `AddCommMonoid` is
      in the `AddSubmonoid`."]
theorem multiset_prod_mem {M} [CommMonoid M] (S : Submonoid M) (m : Multiset M)
    (hm : ∀ a ∈ m, a ∈ S) : m.prod ∈ S

{M : Type u_4}
[CommMonoid M]
(S : Submonoid M)
(m : Multiset M)
(hm : ∀ a ∈ m, a ∈ S)


lemma image_symm (e : α ≃ᵐ β) (s : Set β) : e.symm '' s = e ⁻¹' s

{α : Type u_1}
{β : Type u_2}
[MeasurableSpace α]
[MeasurableSpace β]
(e : α ≃ᵐ β)
(s : Set β)


theorem hasFDerivWithinAt_pi :
    HasFDerivWithinAt (fun x i => φ i x) (ContinuousLinearMap.pi φ') s x ↔
      ∀ i, HasFDerivWithinAt (φ i) (φ' i) s x

{𝕜 : Type u_1}
[NontriviallyNormedField 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
{x : E}
{s : Set E}
{ι : Type u_6}
[Fintype ι]
{F' : ι → Type u_7}
[(i : ι) → NormedAddCommGroup (F' i)]
[(i : ι) → NormedSpace 𝕜 (F' i)]
{φ : (i : ι) → E → F' i}
{φ' : (i : ι) → E →L[𝕜] F' i}

HasFDerivWithinAt (fun x i => φ i x) (ContinuousLinearMap.pi φ') s x ↔ ∀ (i : ι), HasFDerivWithinAt (φ i) (φ' i) s x


theorem IsLindelof.countable_of_discrete [DiscreteTopology X] (hs : IsLindelof s) :
    s.Countable

{X : Type u}
[TopologicalSpace X]
{s : Set X}
[DiscreteTopology X]
(hs : IsLindelof s)


theorem head_lt_ord_of_isGood [Inhabited I] {l : Products I} {o : Ordinal}
    (h : l.isGood (π C (ord I · < o))) (hn : l.val ≠ []) : ord I (l.val.head!) < o

{l : Profinite.NobelingProof.Products I}

(h :
  Profinite.NobelingProof.Products.isGood (Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o) l)

Profinite.NobelingProof.ord I (↑l).head! < o


theorem prod_mono_left (t : NonUnitalSubring S) : Monotone fun s : NonUnitalSubring R => s.prod t

{R : Type u}
{S : Type v}
[NonUnitalNonAssocRing R]
[NonUnitalNonAssocRing S]
(t : NonUnitalSubring S)


protected theorem dist_right (x : α) : LipschitzWith 1 (dist x)

{α : Type u}
[PseudoMetricSpace α]
(x : α)


/-- An `𝕆`-graded order is an order `α` equipped with a strictly monotone function
`grade 𝕆 : α → 𝕆` which preserves order covering (`CovBy`). -/
class GradeOrder (𝕆 α : Type*) [Preorder 𝕆] [Preorder α] where
  /-- The grading function. -/
  protected grade : α → 𝕆
  /-- `grade` is strictly monotonic. -/
  grade_strictMono : StrictMono grade
  /-- `grade` preserves `CovBy`. -/
  covBy_grade ⦃a b : α⦄ : a ⋖ b → grade a ⋖ grade b

{𝕆 : Type u_5}
{α : Type u_6}
[Preorder 𝕆]
[Preorder α]
[self : GradeOrder 𝕆 α]
⦃a b : α⦄

a ⋖ b → GradeOrder.grade a ⋖ GradeOrder.grade b


/-- A compact set in an emetric space is separable, i.e., it is the closure of a countable set. -/
theorem countable_closure_of_compact {s : Set γ} (hs : IsCompact s) :
    ∃ t, t ⊆ s ∧ t.Countable ∧ s = closure t

{γ : Type w}
[EMetricSpace γ]
{s : Set γ}
(hs : IsCompact s)


theorem ihom_map_apply {M N P : ModuleCat.{u} R} (f : N ⟶ P) (g : ModuleCat.of R (M ⟶ N)) :
    (ihom M).map f g = g ≫ f

{R : Type u}
[CommRing R]
{M N P : ModuleCat R}
(f : N ⟶ P)
(g : ↑(ModuleCat.of R (M ⟶ N)))

((CategoryTheory.ihom M).map f) g = g ≫ f


lemma BijOn.symm {g : β → α} (h : InvOn f g t s) (hf : BijOn f s t) : BijOn g t s

{α : Type u_1}
{β : Type u_2}
{s : Set α}
{t : Set β}
{f : α → β}
{g : β → α}
(h : Set.InvOn f g t s)
(hf : Set.BijOn f s t)


lemma log_exp (a : A) (ha : IsSelfAdjoint a := by cfc_tac) : log (NormedSpace.exp ℝ a) = a


/-- Angles in a vector space are translation invariant -/
@[simp]
theorem angle_const_add (v : V) (v₁ v₂ v₃ : V) : ∠ (v + v₁) (v + v₂) (v + v₃) = ∠ v₁ v₂ v₃

{V : Type u_1}
[NormedAddCommGroup V]
[InnerProductSpace ℝ V]
(v v₁ v₂ v₃ : V)

EuclideanGeometry.angle (v + v₁) (v + v₂) (v + v₃) = EuclideanGeometry.angle v₁ v₂ v₃


/-- The map `Square C → Square Cᵒᵖ` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ

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


@[fun_prop]
protected theorem ContinuousAt.abs (h : ContinuousAt f a) : ContinuousAt (fun x => |f x|) a

{α : Type u_1}
{G : Type u_2}
[TopologicalSpace G]
[LinearOrderedAddCommGroup G]
[OrderTopology G]
{f : α → G}
[TopologicalSpace α]
{a : α}
(h : ContinuousAt f a)


/-- If a set is disjoint of its translates by infinitely many bounded vectors, then it has measure
zero. This auxiliary lemma proves this assuming additionally that the set is bounded. -/
theorem addHaar_eq_zero_of_disjoint_translates_aux {E : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] [MeasurableSpace E] [BorelSpace E] [FiniteDimensional ℝ E] (μ : Measure E)
    [IsAddHaarMeasure μ] {s : Set E} (u : ℕ → E) (sb : IsBounded s) (hu : IsBounded (range u))
    (hs : Pairwise (Disjoint on fun n => {u n} + s)) (h's : MeasurableSet s) : μ s = 0

(hu : Bornology.IsBounded (Set.range u))


theorem Icc_subset_Ico_union_Icc : Icc a c ⊆ Ico a b ∪ Icc b c

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


@[simp]
protected theorem smul_def {M} [Monoid M] (f : MulAut M) (a : M) : f • a = f a

{M : Type u_4}
[Monoid M]
(f : MulAut M)
(a : M)


/-- An induction principle for closure membership. If `p` holds for `0`, `1`, and all elements
of `s`, and is preserved under addition, negation, and multiplication, then `p` holds for all
elements of the closure of `s`. -/
@[elab_as_elim]
theorem closure_induction {s : Set R} {p : R → Prop} {x} (h : x ∈ closure s) (mem : ∀ x ∈ s, p x)
    (zero : p 0) (add : ∀ x y, p x → p y → p (x + y)) (neg : ∀ x : R, p x → p (-x))
    (mul : ∀ x y, p x → p y → p (x * y)) : p x

(add : ∀ (x y : R), p x → p y → p (x + y))

(mul : ∀ (x y : R), p x → p y → p (x * y))


/-- Lift a `MulHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift an `AddHom` to `Finset` via `image`"]
def imageMulHom : Finset α →ₙ* Finset β

{F : Type u_1}
{α : Type u_2}
{β : Type u_3}
[DecidableEq α]
[DecidableEq β]
[Mul α]
[Mul β]
[FunLike F α β]
[MulHomClass F α β]
(f : F)
(s : Finset α)

(Finset.imageMulHom f) s = Finset.image (⇑f) s


@[simp]
theorem algHom_eval₂_algebraMap {R A B : Type*} [CommSemiring R] [Semiring A] [Semiring B]
    [Algebra R A] [Algebra R B] (p : R[X]) (f : A →ₐ[R] B) (a : A) :
    f (eval₂ (algebraMap R A) a p) = eval₂ (algebraMap R B) (f a) p

{R : Type u_3}
{A : Type u_4}
{B : Type u_5}
[CommSemiring R]
[Semiring A]
[Semiring B]
[Algebra R A]
[Algebra R B]
(p : R[X])
(f : A →ₐ[R] B)
(a : A)

f (Polynomial.eval₂ (algebraMap R A) a p) = Polynomial.eval₂ (algebraMap R B) (f a) p


theorem AlgEquiv.restrictNormal_trans [Normal F E] :
    (χ.trans ω).restrictNormal E = (χ.restrictNormal E).trans (ω.restrictNormal E)

{F : Type u_1}
{K₁ : Type u_3}
{K₂ : Type u_4}
{K₃ : Type u_5}
[Field F]
[Field K₁]
[Field K₂]
[Field K₃]
[Algebra F K₁]
[Algebra F K₂]
[Algebra F K₃]
(χ : K₁ ≃ₐ[F] K₂)
(ω : K₂ ≃ₐ[F] K₃)
(E : Type u_6)
[Field E]
[Algebra F E]
[Algebra E K₁]
[Algebra E K₂]
[Algebra E K₃]
[IsScalarTower F E K₁]
[IsScalarTower F E K₂]
[IsScalarTower F E K₃]
[Normal F E]


theorem sqrt_eq_iff_sq_eq (hx : 0 ≤ x) (hy : 0 ≤ y) : √x = y ↔ y ^ 2 = x


theorem symm_image_target_eq_source : e.symm '' e.target = e.source

{X : Type u_1}
{Y : Type u_3}
[TopologicalSpace X]
[TopologicalSpace Y]
(e : PartialHomeomorph X Y)


@[simp, norm_cast]
theorem coe_zero : ↑(0 : ℝ) = (0 : ℝ*)


@[simp, norm_cast]
theorem coe_bot : ((⊥ : UpperSet α) : Set α) = univ


theorem disconnect_isTotallyDisconnected : S.disconnect.IsTotallyDisconnected

{C : Type u}
[CategoryTheory.Groupoid C]
(S : CategoryTheory.Subgroupoid C)


theorem isOpen_iff_of_mem (h : ∞ ∈ s) :
    IsOpen s ↔ IsClosed ((↑) ⁻¹' s : Set X)ᶜ ∧ IsCompact ((↑) ⁻¹' s : Set X)ᶜ

{X : Type u_1}
[TopologicalSpace X]
{s : Set (OnePoint X)}
(h : OnePoint.infty ∈ s)

IsOpen s ↔ IsClosed (OnePoint.some ⁻¹' s)ᶜ ∧ IsCompact (OnePoint.some ⁻¹' s)ᶜ


{R : Type u_5}
{S : Type u_6}
[Semiring R]
[OrderedSemiring S]
(abv : AbsoluteValue R S)


@[simp, norm_cast]
theorem aemeasurable_coe_nnreal_ennreal_iff {f : α → ℝ≥0} {μ : Measure α} :
    AEMeasurable (fun x => (f x : ℝ≥0∞)) μ ↔ AEMeasurable f μ

{α : Type u_1}
[MeasurableSpace α]
{f : α → ℝ≥0}
{μ : MeasureTheory.Measure α}

AEMeasurable (fun x => ↑(f x)) μ ↔ AEMeasurable f μ


theorem Subpresheaf.le_sheafify : G ≤ G.sheafify J

(J : CategoryTheory.GrothendieckTopology C)

(G : CategoryTheory.GrothendieckTopology.Subpresheaf F)

G ≤ CategoryTheory.GrothendieckTopology.Subpresheaf.sheafify J G


theorem Coprime.symmetric : Symmetric Coprime


theorem add_left (x y z : E) : inner_ 𝕜 (x + y) z = inner_ 𝕜 x z + inner_ 𝕜 y z

{𝕜 : Type u_1}
[RCLike 𝕜]
{E : Type u_2}
[NormedAddCommGroup E]
[NormedSpace 𝕜 E]
[InnerProductSpaceable E]
(x y z : E)


theorem upperCrossingTime_lt_bddAbove (hab : a < b) :
    BddAbove {n | upperCrossingTime a b f N n ω < N}

{Ω : Type u_1}
{a b : ℝ}
{f : ℕ → Ω → ℝ}
{N : ℕ}
{ω : Ω}
(hab : a < b)

BddAbove {n | MeasureTheory.upperCrossingTime a b f N n ω < N}


theorem of_comp (f : A →ₐ[R] A') (hfv : AlgebraicIndependent R (f ∘ x)) :
    AlgebraicIndependent R x

{ι : Type u_1}
{R : Type u_3}
{A : Type u_5}
{A' : Type u_6}
{x : ι → A}
[CommRing R]
[CommRing A]
[CommRing A']
[Algebra R A]
[Algebra R A']
(f : A →ₐ[R] A')
(hfv : AlgebraicIndependent R (⇑f ∘ x))


@[simp]
theorem erase_cons_head (a : α) (s : Multiset α) : (a ::ₘ s).erase a = s

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


theorem pos_of_mem_primeFactorsList {n p : ℕ} (h : p ∈ primeFactorsList n) : 0 < p


theorem prod_mono_right : t₁ ≤ t₂ → s ×ˢ t₁ ≤ s ×ˢ t₂

{α : Type u_1}
{β : Type u_2}
[Preorder α]
[Preorder β]
{s : UpperSet α}
{t₁ t₂ : UpperSet β}

t₁ ≤ t₂ → s ×ˢ t₁ ≤ s ×ˢ t₂


/-- A product of categories indexed by `Option J` identifies to a binary product. -/
@[simps]
def Pi.optionEquivalence (C' : Option J → Type u₁) [∀ i, Category.{v₁} (C' i)] :
    (∀ i, C' i) ≌ C' none × (∀ (j : J), C' (some j))

[(i : Option J) → CategoryTheory.Category.{v₁, u₁} (C' i)]

(CategoryTheory.Pi.optionEquivalence C').counitIso =
  CategoryTheory.Iso.refl
    ((CategoryTheory.Functor.pi' fun i =>
          match i with
          | none => CategoryTheory.Prod.fst (C' none) ((j : J) → C' (some j))
          | some i =>
            (CategoryTheory.Prod.snd (C' none) ((j : J) → C' (some j))).comp
              (CategoryTheory.Pi.eval (fun j => C' (some j)) i)).comp
      ((CategoryTheory.Pi.eval C' none).prod' (CategoryTheory.Functor.pi' fun i => CategoryTheory.Pi.eval C' (some i))))


theorem self_add_star' : a + star a = ↑(2 * a.re)

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


private theorem restrictNonposSeq_lt (n : ℕ) (hn : ¬s ≤[i \ ⋃ k ≤ n, restrictNonposSeq s i k] 0) :
    (1 / (findExistsOneDivLT s (i \ ⋃ k ≤ n, restrictNonposSeq s i k) + 1) : ℝ) <
      s (restrictNonposSeq s i n.succ)

(hn :
  ¬MeasureTheory.VectorMeasure.restrict s
        (i \ ⋃ k, ⋃ (_ : k ≤ n), MeasureTheory.SignedMeasure.restrictNonposSeq s i k) ≤
      MeasureTheory.VectorMeasure.restrict 0
        (i \ ⋃ k, ⋃ (_ : k ≤ n), MeasureTheory.SignedMeasure.restrictNonposSeq s i k))

1 /
    (↑(MeasureTheory.SignedMeasure.findExistsOneDivLT s
          (i \ ⋃ k, ⋃ (_ : k ≤ n), MeasureTheory.SignedMeasure.restrictNonposSeq s i k)) +
      1) <
  ↑s (MeasureTheory.SignedMeasure.restrictNonposSeq s i n.succ)


theorem get_set (a : Array α) (i : Fin a.size) (j : Nat) (hj : j < a.size) (v : α) :
    (a.set i v)[j]'(by simp [*]) = if i = j then v else a[j]

{α : Type u_1}
(a : Array α)
(i : Fin a.size)
(j : Nat)
(hj : j < a.size)
(v : α)

(a.set i v)[j] = if ↑i = j then v else a[j]


theorem map_monic_eq_zero_iff (hp : p.Monic) : p.map f = 0 ↔ ∀ x, f x = 0

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

Polynomial.map f p = 0 ↔ ∀ (x : R), f x = 0


/-- Product of a multiset of elements in a submonoid of a `CommMonoid` is in the submonoid. -/
@[to_additive
      "Sum of a multiset of elements in an `AddSubmonoid` of an `AddCommMonoid` is
      in the `AddSubmonoid`."]
theorem multiset_prod_mem {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (m : Multiset M)
    (hm : ∀ a ∈ m, a ∈ S) : m.prod ∈ S

{B : Type u_3}
{S : B}
{M : Type u_4}
[CommMonoid M]
[SetLike B M]
[SubmonoidClass B M]
(m : Multiset M)
(hm : ∀ a ∈ m, a ∈ S)


theorem withDensityᵥ_toReal {f : α → ℝ≥0∞} (hfm : AEMeasurable f μ) (hf : (∫⁻ x, f x ∂μ) ≠ ∞) :
    (μ.withDensityᵥ fun x => (f x).toReal) =
      @toSignedMeasure α _ (μ.withDensity f) (isFiniteMeasure_withDensity hf)

{α : Type u_1}
{m : MeasurableSpace α}
{μ : MeasureTheory.Measure α}
{f : α → ℝ≥0∞}
(hfm : AEMeasurable f μ)
(hf : ∫⁻ (x : α), f x ∂μ ≠ ⊤)

(μ.withDensityᵥ fun x => (f x).toReal) = (μ.withDensity f).toSignedMeasure


/-- If a category has all products then in particular it has finite products.
-/
theorem hasFiniteProducts_of_hasProducts [HasProducts.{w} C] : HasFiniteProducts C

(C : Type u)
[CategoryTheory.Category.{v, u} C]
[CategoryTheory.Limits.HasProducts C]


/-- Monomials generate the additive monoid of polynomials. -/
theorem addSubmonoid_closure_setOf_eq_monomial :
    AddSubmonoid.closure { p : R[X] | ∃ n a, p = monomial n a } = ⊤

AddSubmonoid.closure {p | ∃ n a, p = (Polynomial.monomial n) a} = ⊤


theorem IsPerfectMatching.even_card [Fintype V] (h : M.IsPerfectMatching) :
    Even (Fintype.card V)

{V : Type u_1}
{G : SimpleGraph V}
{M : G.Subgraph}
[Fintype V]
(h : M.IsPerfectMatching)


@[simp]
theorem toCone_proj (B : Bicone F) (j : J) : Fan.proj B.toCone j = B.π j

CategoryTheory.Limits.Fan.proj B.toCone j = B.π j


@[to_additive]
theorem prod_finset_product_right' (r : Finset (α × γ)) (s : Finset γ) (t : γ → Finset α)
    (h : ∀ p : α × γ, p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2) {f : α → γ → β} :
    ∏ p ∈ r, f p.1 p.2 = ∏ c ∈ s, ∏ a ∈ t c, f a c

(h : ∀ (p : α × γ), p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2)

{f : α → γ → β}

∑ p ∈ r, f p.1 p.2 = ∑ c ∈ s, ∑ a ∈ t c, f a c


theorem injOn_preimage (h : Semiconj f fa fb) {s : Set β} (hb : InjOn fb s)
    (hf : InjOn f (f ⁻¹' s)) : InjOn fa (f ⁻¹' s)

{α : Type u_1}
{β : Type u_2}
{fa : α → α}
{fb : β → β}
{f : α → β}
(h : Function.Semiconj f fa fb)
{s : Set β}
(hb : Set.InjOn fb s)
(hf : Set.InjOn f (f ⁻¹' s))


theorem Perm.product_left (l : List α) {t₁ t₂ : List β} (p : t₁ ~ t₂) :
    product l t₁ ~ product l t₂

{α : Type u_1}
{β : Type u_2}
(l : List α)
{t₁ t₂ : List β}
(p : t₁.Perm t₂)


theorem tfae_of_forall (b : Prop) (l : List Prop) (h : ∀ a ∈ l, a ↔ b) : TFAE l

(b : Prop)
(l : List Prop)
(h : ∀ (a : Prop), a ∈ l → (a ↔ b))


/-- An algebra of sets is closed by intersection. -/
theorem inter_mem (h𝒜 : IsSetAlgebra 𝒜) (s_mem : s ∈ 𝒜) (t_mem : t ∈ 𝒜) :
    s ∩ t ∈ 𝒜

{α : Type u_1}
{𝒜 : Set (Set α)}
{s t : Set α}
(h𝒜 : MeasureTheory.IsSetAlgebra 𝒜)
(s_mem : s ∈ 𝒜)
(t_mem : t ∈ 𝒜)


theorem disjoint_ker {f : F} {p : Submodule R M} :
    Disjoint p (ker f) ↔ ∀ x ∈ p, f x = 0 → x = 0

{R : Type u_1}
{R₂ : Type u_3}
{M : Type u_6}
{M₂ : Type u_8}
[Semiring R]
[Semiring R₂]
[AddCommMonoid M]
[AddCommMonoid M₂]
[Module R M]
[Module R₂ M₂]
{τ₁₂ : R →+* R₂}
{F : Type u_12}
[FunLike F M M₂]
[SemilinearMapClass F τ₁₂ M M₂]
{f : F}
{p : Submodule R M}

Disjoint p (LinearMap.ker f) ↔ ∀ x ∈ p, f x = 0 → x = 0


@[simp]
theorem map_bijective {f : α → γ} {g : β → δ} :
    Bijective (Sum.map f g) ↔ Bijective f ∧ Bijective g

{α : Type u}
{β : Type v}
{γ : Type u_1}
{δ : Type u_2}
{f : α → γ}
{g : β → δ}

Function.Bijective (Sum.map f g) ↔ Function.Bijective f ∧ Function.Bijective g


/-- The image of a totally bounded set under a uniformly continuous map is totally bounded. -/
theorem TotallyBounded.image [UniformSpace β] {f : α → β} {s : Set α} (hs : TotallyBounded s)
    (hf : UniformContinuous f) : TotallyBounded (f '' s)

{α : Type u}
{β : Type v}
[uniformSpace : UniformSpace α]
[UniformSpace β]
{f : α → β}
{s : Set α}
(hs : TotallyBounded s)
(hf : UniformContinuous f)


theorem repr_add (a b) : repr (a + b) = repr a + repr b


/-- The `ShortComplex` in `C` associated to a short complex in `Cᵒᵖ`. -/
@[simps]
def unop (S : ShortComplex Cᵒᵖ) : ShortComplex C


theorem preimage_frontier (h : X ≃ₜ Y) (s : Set Y) : h ⁻¹' frontier s = frontier (h ⁻¹' s)

{X : Type u_1}
{Y : Type u_2}
[TopologicalSpace X]
[TopologicalSpace Y]
(h : X ≃ₜ Y)
(s : Set Y)


@[to_additive (attr := simp)]
theorem prod_replicate (n : ℕ) (a : α) : (replicate n a).prod = a ^ n

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


lemma zero_mem_preCantorSet (n : ℕ) : 0 ∈ preCantorSet n