α : Type u_1
inst✝² : OrderedRing α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
n✝ n : ℕ
⊢ Disjoint (box (n + 1)) (Icc (-↑n) ↑n)

α : Type u_1
inst✝² : OrderedRing α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
n✝ n : ℕ
⊢ Disjoint (Icc (-↑n.succ) ↑n.succ \ Icc (-↑n) ↑n) (Icc (-↑n) ↑n)


n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
n : ℤ
⊢ 0 ^ n = if n = 0 then 1 else 0

case pos
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
n : ℤ
h : n = 0
⊢ 0 ^ n = 1

case neg
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
n : ℤ
h : ¬n = 0
⊢ 0 ^ n = 0


p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
inst✝ : Finite α
hpα : ¬p ∣ Nat.card α
this : Finite α
⊢ Nonempty ↑(fixedPoints G α)

p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
inst✝ : Finite α
hpα : ¬p ∣ Nat.card α
this : Finite α
⊢ Nat.card ↑(fixedPoints G α) ≠ 0

rw [← Finite.card_pos_iff, pos_iff_ne_zero]

p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
inst✝ this : Finite α
hpα : Nat.card ↑(fixedPoints G α) = 0
⊢ p ∣ Nat.card α

p : ℕ
G : Type u_1
inst✝² : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
α : Type u_2
inst✝¹ : MulAction G α
inst✝ this : Finite α
hpα : Nat.card ↑(fixedPoints G α) = 0
⊢ Nat.card α ≡ Nat.card ↑(fixedPoints G α) [MOD p]


α : Type u
m : OuterMeasure α
s s₁ s₂ : Set α
⊢ m.IsCaratheodory s₁ → m.IsCaratheodory s₁ᶜ

simp [IsCaratheodory, diff_eq, add_comm]


ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M'✝ : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁹ : Semiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M'✝
inst✝⁶ : AddCommMonoid M''
inst✝⁵ : Module R M
inst✝⁴ : Module R M'✝
inst✝³ : Module R M''
a b : R
x y : M
R' : Type u_8
M' : Type u_9
inst✝² : Semiring R'
inst✝¹ : AddCommMonoid M'
inst✝ : Module R' M'
hv : LinearIndependent R v
i : ZeroHom R R'
j : M →+ M'
hi : Surjective ⇑i
hj : ∀ (m : M), j m = 0 → m = 0
hc : ∀ (r : R) (m : M), j (r • m) = i r • j m
⊢ LinearIndependent R' (⇑j ∘ v)

case intro
ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M'✝ : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁹ : Semiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M'✝
inst✝⁶ : AddCommMonoid M''
inst✝⁵ : Module R M
inst✝⁴ : Module R M'✝
inst✝³ : Module R M''
a b : R
x y : M
R' : Type u_8
M' : Type u_9
inst✝² : Semiring R'
inst✝¹ : AddCommMonoid M'
inst✝ : Module R' M'
hv : LinearIndependent R v
i : ZeroHom R R'
j : M →+ M'
hi : Surjective ⇑i
hj : ∀ (m : M), j m = 0 → m = 0
hc : ∀ (r : R) (m : M), j (r • m) = i r • j m
i' : R' → R
hi' : Function.RightInverse i' ⇑i
⊢ LinearIndependent R' (⇑j ∘ v)

case intro.refine_1
ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M'✝ : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁹ : Semiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M'✝
inst✝⁶ : AddCommMonoid M''
inst✝⁵ : Module R M
inst✝⁴ : Module R M'✝
inst✝³ : Module R M''
a b : R
x y : M
R' : Type u_8
M' : Type u_9
inst✝² : Semiring R'
inst✝¹ : AddCommMonoid M'
inst✝ : Module R' M'
hv : LinearIndependent R v
i : ZeroHom R R'
j : M →+ M'
hi : Surjective ⇑i
hj : ∀ (m : M), j m = 0 → m = 0
hc : ∀ (r : R) (m : M), j (r • m) = i r • j m
i' : R' → R
hi' : Function.RightInverse i' ⇑i
x✝ : R'
h : i' x✝ = 0
⊢ x✝ = 0

case intro.refine_2
ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M'✝ : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁹ : Semiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M'✝
inst✝⁶ : AddCommMonoid M''
inst✝⁵ : Module R M
inst✝⁴ : Module R M'✝
inst✝³ : Module R M''
a b : R
x y : M
R' : Type u_8
M' : Type u_9
inst✝² : Semiring R'
inst✝¹ : AddCommMonoid M'
inst✝ : Module R' M'
hv : LinearIndependent R v
i : ZeroHom R R'
j : M →+ M'
hi : Surjective ⇑i
hj : ∀ (m : M), j m = 0 → m = 0
hc : ∀ (r : R) (m : M), j (r • m) = i r • j m
i' : R' → R
hi' : Function.RightInverse i' ⇑i
r : R'
m : M
⊢ j (i' r • m) = r • j m

refine hv.map_of_injective_injective i' j (fun _ h ↦ ?_) hj fun r m ↦ ?_


C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
⊢ ∀ {X Y : D} (f : X ⟶ Y),
    (𝟭 D).map f ≫ ((fun X => (asIso ((reflectorAdjunction i).counit.app X)).symm) Y).hom =
      ((fun X => (asIso ((reflectorAdjunction i).counit.app X)).symm) X).hom ≫
        (i.toEssImage ⋙ i.essImageInclusion ⋙ reflector i).map f

C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X Y : D
f : X ⟶ Y
⊢ (𝟭 D).map f ≫ ((fun X => (asIso ((reflectorAdjunction i).counit.app X)).symm) Y).hom =
    ((fun X => (asIso ((reflectorAdjunction i).counit.app X)).symm) X).hom ≫
      (i.toEssImage ⋙ i.essImageInclusion ⋙ reflector i).map f

C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X Y : D
f : X ⟶ Y
⊢ f ≫ inv ((reflectorAdjunction i).counit.app Y) =
    inv ((reflectorAdjunction i).counit.app X) ≫ (reflector i).map (i.map f)

C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X Y : D
f : X ⟶ Y
⊢ (reflectorAdjunction i).counit.app X ≫ f = (reflector i).map (i.map f) ≫ (reflectorAdjunction i).counit.app Y

rw [IsIso.comp_inv_eq, Category.assoc, IsIso.eq_inv_comp]

exact ((reflectorAdjunction i).counit.naturality f).symm

C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
⊢ ∀ {X Y : i.EssImageSubcategory} (f : X ⟶ Y),
    ((i.essImageInclusion ⋙ reflector i) ⋙ i.toEssImage).map f ≫ (equivEssImageOfReflective_counitIso_app Y).hom =
      (equivEssImageOfReflective_counitIso_app X).hom ≫ (𝟭 i.EssImageSubcategory).map f

C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X Y : i.EssImageSubcategory
f : X ⟶ Y
⊢ ((i.essImageInclusion ⋙ reflector i) ⋙ i.toEssImage).map f ≫ (equivEssImageOfReflective_counitIso_app Y).hom =
    (equivEssImageOfReflective_counitIso_app X).hom ≫ (𝟭 i.EssImageSubcategory).map f

case a
C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X Y : i.EssImageSubcategory
f : X ⟶ Y
⊢ i.essImageInclusion.map
      (((i.essImageInclusion ⋙ reflector i) ⋙ i.toEssImage).map f ≫ (equivEssImageOfReflective_counitIso_app Y).hom) =
    i.essImageInclusion.map ((equivEssImageOfReflective_counitIso_app X).hom ≫ (𝟭 i.EssImageSubcategory).map f)

case a
C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X Y : i.EssImageSubcategory
f : X ⟶ Y
h :
  (reflectorAdjunction i).unit.app X.obj ≫ (reflector i ⋙ i).map f =
    (𝟭 C).map f ≫ (reflectorAdjunction i).unit.app Y.obj
⊢ i.essImageInclusion.map
      (((i.essImageInclusion ⋙ reflector i) ⋙ i.toEssImage).map f ≫ (equivEssImageOfReflective_counitIso_app Y).hom) =
    i.essImageInclusion.map ((equivEssImageOfReflective_counitIso_app X).hom ≫ (𝟭 i.EssImageSubcategory).map f)

have h := ((reflectorAdjunction i).unit.naturality f).symm

case a
C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X Y : i.EssImageSubcategory
f : X ⟶ Y
h : (reflectorAdjunction i).unit.app X.obj ≫ (reflector i ⋙ i).map f = f ≫ (reflectorAdjunction i).unit.app Y.obj
⊢ i.essImageInclusion.map
      (((i.essImageInclusion ⋙ reflector i) ⋙ i.toEssImage).map f ≫ (equivEssImageOfReflective_counitIso_app Y).hom) =
    i.essImageInclusion.map ((equivEssImageOfReflective_counitIso_app X).hom ≫ (𝟭 i.EssImageSubcategory).map f)

erw [Functor.map_comp, Functor.map_comp,
          equivEssImageOfReflective_map_counitIso_app_hom,
          equivEssImageOfReflective_map_counitIso_app_hom,
          IsIso.comp_inv_eq, assoc, ← h, IsIso.inv_hom_id_assoc, Functor.comp_map]

C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X : D
⊢ i.toEssImage.map ((NatIso.ofComponents (fun X => (asIso ((reflectorAdjunction i).counit.app X)).symm) ⋯).hom.app X) ≫
      (NatIso.ofComponents equivEssImageOfReflective_counitIso_app ⋯).hom.app (i.toEssImage.obj X) =
    𝟙 (i.toEssImage.obj X)

case a
C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X : D
⊢ i.essImageInclusion.map
      (i.toEssImage.map
          ((NatIso.ofComponents (fun X => (asIso ((reflectorAdjunction i).counit.app X)).symm) ⋯).hom.app X) ≫
        (NatIso.ofComponents equivEssImageOfReflective_counitIso_app ⋯).hom.app (i.toEssImage.obj X)) =
    i.essImageInclusion.map (𝟙 (i.toEssImage.obj X))

case a
C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X : D
⊢ i.essImageInclusion.map
        (i.toEssImage.map
          ((NatIso.ofComponents (fun X => (asIso ((reflectorAdjunction i).counit.app X)).symm) ⋯).hom.app X)) ≫
      inv ((reflectorAdjunction i).unit.app ((𝟭 i.EssImageSubcategory).obj (i.toEssImage.obj X)).obj) =
    i.essImageInclusion.map (𝟙 (i.toEssImage.obj X))


J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : C
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B objs arrows
⊢ (∀ (j : J), g1 ≫ π arrows j = g2 ≫ π arrows j) → g1 ≫ base arrows = g2 ≫ base arrows → g1 = g2

J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : C
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B objs arrows
h1 : ∀ (j : J), g1 ≫ π arrows j = g2 ≫ π arrows j
h2 : g1 ≫ base arrows = g2 ≫ base arrows
⊢ g1 = g2

case w
J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : C
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B objs arrows
h1 : ∀ (j : J), g1 ≫ π arrows j = g2 ≫ π arrows j
h2 : g1 ≫ base arrows = g2 ≫ base arrows
⊢ ∀ (j : WidePullbackShape J),
    g1 ≫ limit.π (WidePullbackShape.wideCospan B objs arrows) j =
      g2 ≫ limit.π (WidePullbackShape.wideCospan B objs arrows) j

case w.none
J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : C
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B objs arrows
h1 : ∀ (j : J), g1 ≫ π arrows j = g2 ≫ π arrows j
h2 : g1 ≫ base arrows = g2 ≫ base arrows
⊢ g1 ≫ limit.π (WidePullbackShape.wideCospan B objs arrows) none =
    g2 ≫ limit.π (WidePullbackShape.wideCospan B objs arrows) none

case w.some
J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : C
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B objs arrows
h1 : ∀ (j : J), g1 ≫ π arrows j = g2 ≫ π arrows j
h2 : g1 ≫ base arrows = g2 ≫ base arrows
val✝ : J
⊢ g1 ≫ limit.π (WidePullbackShape.wideCospan B objs arrows) (some val✝) =
    g2 ≫ limit.π (WidePullbackShape.wideCospan B objs arrows) (some val✝)


K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
⊢ weightSpaceOf M (χ x) x ≠ ⊥

K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
this : ⨅ x, weightSpaceOf M (χ x) x ≠ ⊥
⊢ weightSpaceOf M (χ x) x ≠ ⊥

have : ⨅ x, weightSpaceOf M (χ x) x ≠ ⊥ := χ.weightSpace_ne_bot

K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
this : weightSpaceOf M (χ x) x = ⊥
⊢ ⨅ x, weightSpaceOf M (χ x) x = ⊥

K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : Weight R L M
x : L
this : weightSpaceOf M (χ x) x = ⊥
⊢ ⨅ x, weightSpaceOf M (χ x) x ≤ ⊥


α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
b : β
⊢ ⇑e ⁻¹' Iio b = Iio (e.symm b)

case h
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
b : β
x : α
⊢ x ∈ ⇑e ⁻¹' Iio b ↔ x ∈ Iio (e.symm b)


R : Type u_1
V : Type u_2
inst✝⁷ : Field R
inst✝⁶ : AddCommGroup V
inst✝⁵ : TopologicalSpace R
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalRing R
inst✝² : TopologicalAddGroup V
inst✝¹ : Module R V
inst✝ : SeparatingDual R V
x : V
hx : x ≠ 0
⊢ ∃ f, f x = 1

case intro
R : Type u_1
V : Type u_2
inst✝⁷ : Field R
inst✝⁶ : AddCommGroup V
inst✝⁵ : TopologicalSpace R
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalRing R
inst✝² : TopologicalAddGroup V
inst✝¹ : Module R V
inst✝ : SeparatingDual R V
x : V
hx : x ≠ 0
f : V →L[R] R
hf : f x ≠ 0
⊢ ∃ f, f x = 1

rcases exists_ne_zero (R := R) hx with ⟨f, hf⟩


α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
⊢ M.Basis I I ↔ M.Indep I

α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
⊢ M.Indep I → (∀ (J : Set α), M.Indep J → I ⊆ J → J ⊆ I → I = J) ∧ I ⊆ M.E

rw [basis_iff', and_iff_right rfl.subset, and_assoc, and_iff_left_iff_imp]

exact fun hi ↦ ⟨fun _ _ ↦ subset_antisymm, hi.subset_ground⟩


α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
f : Filter α
H : ∀ {q : α → Prop}, (∀ᶠ (x : α) in f, q x) → ∃ x, p x ∧ q x
hp : ∀ᶠ (x : α) in f, ¬(fun x => p x) x
⊢ False

simpa only [and_not_self_iff, exists_false] using H hp


ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
⊢ (e.symm.trans e'.toPartialEquiv).target = (e.baseSet ∩ e'.baseSet) ×ˢ univ

rw [← PartialEquiv.symm_source, symm_trans_symm, symm_trans_source_eq, inter_comm]


p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℚ
n : ℕ
⊢ wittStructureRat p Φ n =
    C (1 / ↑p ^ n) *
      ((bind₁ fun b => (rename fun i => (b, i)) (W_ ℚ n)) Φ -
        ∑ i ∈ Finset.range n, C (↑p ^ i) * wittStructureRat p Φ i ^ p ^ (n - i))

p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℚ
n : ℕ
⊢ wittStructureRat p Φ n = C (1 / ↑p ^ n) * (wittStructureRat p Φ n * C (↑p ^ n))

calc
    wittStructureRat p Φ n = C (1 / (p : ℚ) ^ n) * (wittStructureRat p Φ n * C ((p : ℚ) ^ n)) := ?_
    _ = _ := by rw [wittStructureRat_rec_aux]

case h
p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℚ
n : ℕ
⊢ ↑p ^ n ≠ 0

rw [mul_left_comm, ← C_mul, div_mul_cancel₀, C_1, mul_one]

exact pow_ne_zero _ (Nat.cast_ne_zero.2 hp.1.ne_zero)


ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : OrderedCommMonoid M
b : M
h : ∀ x ∈ [b], 1 < x
x✝ : [b] ≠ []
⊢ 1 < [b].prod

ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : OrderedCommMonoid M
a b : M
l : List M
hl₁ : ∀ x ∈ a :: b :: l, 1 < x
x✝ : a :: b :: l ≠ []
⊢ 1 < (a :: b :: l).prod

ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : OrderedCommMonoid M
a b : M
l : List M
x✝ : a :: b :: l ≠ []
hl₁ : 1 < a ∧ 1 < b ∧ ∀ a ∈ l, 1 < a
⊢ 1 < (a :: b :: l).prod

simp only [forall_eq_or_imp, List.mem_cons] at hl₁

ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : OrderedCommMonoid M
a b : M
l : List M
x✝ : a :: b :: l ≠ []
hl₁ : 1 < a ∧ 1 < b ∧ ∀ a ∈ l, 1 < a
⊢ 1 < a * (b :: l).prod

ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : OrderedCommMonoid M
a b : M
l : List M
x✝ : a :: b :: l ≠ []
hl₁ : 1 < a ∧ 1 < b ∧ ∀ a ∈ l, 1 < a
⊢ 1 ≤ (b :: l).prod

ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : OrderedCommMonoid M
a b : M
l : List M
x✝ : a :: b :: l ≠ []
hl₁ : 1 < a ∧ 1 < b ∧ ∀ a ∈ l, 1 < a
⊢ ∀ x ∈ b :: l, 1 < x

apply le_of_lt ((b :: l).one_lt_prod_of_one_lt _ (l.cons_ne_nil b))

ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : OrderedCommMonoid M
a b : M
l : List M
x✝ : a :: b :: l ≠ []
hl₁ : 1 < a ∧ 1 < b ∧ ∀ a ∈ l, 1 < a
x : M
hx : x ∈ b :: l
⊢ 1 < x

case head
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : OrderedCommMonoid M
a b : M
l : List M
x✝ : a :: b :: l ≠ []
hl₁ : 1 < a ∧ 1 < b ∧ ∀ a ∈ l, 1 < a
⊢ 1 < b

case tail
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : OrderedCommMonoid M
a b : M
l : List M
x✝ : a :: b :: l ≠ []
hl₁ : 1 < a ∧ 1 < b ∧ ∀ a ∈ l, 1 < a
x : M
a✝ : Mem x l
⊢ 1 < x


α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
U V : Set (α × α)
hU : SymmetricRel U
hV : SymmetricRel V
⊢ SymmetricRel (U ∩ V)

rw [SymmetricRel, preimage_inter, hU.eq, hV.eq]


a b m n : ℕ+
cop : m.Coprime n
am : a ∣ m
bn : b ∣ n
⊢ a = (a * b).gcd m

a b m n : ℕ+
cop : m.Coprime n
am : a.gcd m = a
bn : b ∣ n
⊢ a = (a * b).gcd m

a b m n : ℕ+
cop : m.Coprime n
am : a.gcd m = a
bn : b ∣ n
⊢ a.gcd m = (a * b).gcd m

a b m n : ℕ+
cop : m.Coprime n
am : a.gcd m = a
bn : b ∣ n
⊢ (a * b).gcd m = a.gcd m

a b m n : ℕ+
cop : m.Coprime n
am : a.gcd m = a
bn : b ∣ n
⊢ b.Coprime m

apply Coprime.coprime_dvd_left bn cop.symm


R : Type u
inst✝⁶ : CommSemiring R
A : Type u
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
B✝ : Type u
inst✝³ : CommRing B✝
inst✝² : Algebra R B✝
I✝ : Ideal B✝
B : Type u
inst✝¹ : CommRing B
_RB : Algebra R B
inst✝ : FormallySmooth R A
I : Ideal B
hI : IsNilpotent I
g : A →ₐ[R] B ⧸ I
⊢ ∃ f, (Ideal.Quotient.mkₐ R I).comp f = g

R : Type u
inst✝⁶ : CommSemiring R
A : Type u
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
B✝ : Type u
inst✝³ : CommRing B✝
inst✝² : Algebra R B✝
I✝ : Ideal B✝
B : Type u
inst✝¹ : CommRing B
_RB : Algebra R B
inst✝ : FormallySmooth R A
I : Ideal B
hI : IsNilpotent I
⊢ ∀ (g : A →ₐ[R] B ⧸ I), ∃ f, (Ideal.Quotient.mkₐ R I).comp f = g

R : Type u
inst✝⁶ : CommSemiring R
A : Type u
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
B✝ : Type u
inst✝³ : CommRing B✝
inst✝² : Algebra R B✝
I✝ : Ideal B✝
B : Type u
inst✝¹ : CommRing B
_RB : Algebra R B
inst✝ : FormallySmooth R A
I : Ideal B
hI : IsNilpotent I
⊢ Function.Surjective (Ideal.Quotient.mkₐ R I).comp

change Function.Surjective (Ideal.Quotient.mkₐ R I).comp

R : Type u
inst✝⁶ : CommSemiring R
A : Type u
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
B✝ : Type u
inst✝³ : CommRing B✝
inst✝² : Algebra R B✝
I✝ : Ideal B✝
B : Type u
inst✝¹ : CommRing B
inst✝ : FormallySmooth R A
I : Ideal B
hI : IsNilpotent I
⊢ ∀ [_RB : Algebra R B], Function.Surjective (Ideal.Quotient.mkₐ R I).comp

case h₁
R : Type u
inst✝⁶ : CommSemiring R
A : Type u
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
B✝ : Type u
inst✝³ : CommRing B✝
inst✝² : Algebra R B✝
I✝ : Ideal B✝
B : Type u
inst✝¹ : CommRing B
inst✝ : FormallySmooth R A
I : Ideal B
hI : IsNilpotent I
⊢ ∀ ⦃S : Type u⦄ [inst : CommRing S] (I : Ideal S),
    I ^ 2 = ⊥ → ∀ [_RB : Algebra R S], Function.Surjective (Ideal.Quotient.mkₐ R I).comp

case h₂
R : Type u
inst✝⁶ : CommSemiring R
A : Type u
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
B✝ : Type u
inst✝³ : CommRing B✝
inst✝² : Algebra R B✝
I✝ : Ideal B✝
B : Type u
inst✝¹ : CommRing B
inst✝ : FormallySmooth R A
I : Ideal B
hI : IsNilpotent I
⊢ ∀ ⦃S : Type u⦄ [inst : CommRing S] (I J : Ideal S),
    I ≤ J →
      (∀ [_RB : Algebra R S], Function.Surjective (Ideal.Quotient.mkₐ R I).comp) →
        (∀ [_RB : Algebra R (S ⧸ I)],
            Function.Surjective (Ideal.Quotient.mkₐ R (Ideal.map (Ideal.Quotient.mk I) J)).comp) →
          ∀ [_RB : Algebra R S], Function.Surjective (Ideal.Quotient.mkₐ R J).comp

apply Ideal.IsNilpotent.induction_on (R := B) I hI


α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝³ : MeasurableSpace α
inst✝² : (a : δ) → MeasurableSpace (π a)
inst✝¹ : MeasurableSpace γ
p : δ → Prop
inst✝ : DecidablePred p
⊢ Measurable ⇑(piEquivPiSubtypeProd p π).symm

α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝³ : MeasurableSpace α
inst✝² : (a : δ) → MeasurableSpace (π a)
inst✝¹ : MeasurableSpace γ
p : δ → Prop
inst✝ : DecidablePred p
j : δ
⊢ Measurable fun x => (piEquivPiSubtypeProd p π).symm x j

case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝³ : MeasurableSpace α
inst✝² : (a : δ) → MeasurableSpace (π a)
inst✝¹ : MeasurableSpace γ
p : δ → Prop
inst✝ : DecidablePred p
j : δ
hj : p j
⊢ Measurable fun x => (piEquivPiSubtypeProd p π).symm x j

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝³ : MeasurableSpace α
inst✝² : (a : δ) → MeasurableSpace (π a)
inst✝¹ : MeasurableSpace γ
p : δ → Prop
inst✝ : DecidablePred p
j : δ
hj : ¬p j
⊢ Measurable fun x => (piEquivPiSubtypeProd p π).symm x j


μ : Measure ℝ
inst✝ : IsProbabilityMeasure μ
x : ℝ
⊢ ENNReal.ofReal (↑(cdf μ) x) = μ (Iic x)

μ : Measure ℝ
inst✝ : IsProbabilityMeasure μ
x : ℝ
this : IsFiniteMeasure ((Measure.dirac ()).prod μ)
⊢ ENNReal.ofReal (↑(cdf μ) x) = μ (Iic x)

have := IsProbabilityMeasure.toIsFiniteMeasure (Measure.prod (Measure.dirac ()) μ)

μ : Measure ℝ
inst✝ : IsProbabilityMeasure μ
x : ℝ
this : IsFiniteMeasure ((Measure.dirac ()).prod μ)
h :
  ∫⁻ (a : Unit), ENNReal.ofReal (↑(condCDF ((Measure.dirac ()).prod μ) a) x) ∂((Measure.dirac ()).prod μ).fst =
    ((Measure.dirac ()).prod μ) (univ ×ˢ Iic x)
⊢ ENNReal.ofReal (↑(cdf μ) x) = μ (Iic x)

have h := lintegral_condCDF ((Measure.dirac Unit.unit).prod μ) x

simpa only [MeasureTheory.Measure.fst_prod, Measure.prod_prod, measure_univ, one_mul,
    lintegral_dirac] using h


α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : ι → Set α
t : Set β
⊢ image2 f (⋃ i, s i) t = ⋃ i, image2 f (s i) t

simp only [← image_prod, iUnion_prod_const, image_iUnion]


α : Type u_1
β : Type u_2
inst✝³ : MulOneClass α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
⊢ a < a * b ↔ a * 1 < a * b


α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
M : Type u_5
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l : List (α → M)
hl : ∀ f ∈ l, StronglyMeasurable f
⊢ StronglyMeasurable fun x => (List.map (fun f => f x) l).prod

simpa only [← Pi.list_prod_apply] using l.stronglyMeasurable_prod' hl


K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
⊢ Bornology.IsBounded (convexBodySum K B)

K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hx : x ∈ convexBodySum K B
y : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hy : y ∈ convexBodySum K B
⊢ dist x y ≤ B + B

refine Metric.isBounded_iff.mpr ⟨B + B, fun x hx y hy => ?_⟩

case refine_1
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hx : x ∈ convexBodySum K B
y : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hy : y ∈ convexBodySum K B
⊢ ‖x‖ ≤ B

case refine_2
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hx : x ∈ convexBodySum K B
y : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hy : y ∈ convexBodySum K B
⊢ ‖y‖ ≤ B

refine le_trans (norm_sub_le x y) (add_le_add ?_ ?_)


F : Type u_1
R : Type u_2
A : Type u_3
B : Type u_4
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
S : Subalgebra R A
x : A
⊢ star x ∈ star S ↔ x ∈ S


ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
K : HomologicalComplex V c
p₂ p₃ : ι
h : p₃ = p₂
p₁ : ι
⊢ K.d p₁ p₂ ≫ (K.XIsoOfEq h).inv = K.d p₁ p₃

ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
K : HomologicalComplex V c
p₃ p₁ : ι
⊢ K.d p₁ p₃ ≫ (K.XIsoOfEq ⋯).inv = K.d p₁ p₃


α : Type u_1
β : Type u_2
m✝ m : OuterMeasure α
s₁ s₂ : Set α
h : s₁ ⊆ s₂
⊢ m s₁ ≤ m s₂


ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
x✝ : DecidablePred p
h : ∀ i ∈ s, p i
f : (i : α) → p i → β
g : (i : α) → ¬p i → β
⊢ (∏ i ∈ s, if hi : p i then f i hi else g i hi) = ∏ i : { x // x ∈ s }, f ↑i ⋯

refine prod_bij' (fun x hx => ⟨x, hx⟩) (fun x _ ↦ x) ?_ ?_ ?_ ?_ ?_ <;> aesop


R : Type u
inst✝⁴ : OrderedCommRing R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : Algebra ℝ R
inst✝ : OrderedSMul ℝ R
A₀ A₁ B₀ B₁ : R
T : IsCHSHTuple A₀ A₁ B₀ B₁
⊢ A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁ ≤ 2

R : Type u
inst✝⁴ : OrderedCommRing R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : Algebra ℝ R
inst✝ : OrderedSMul ℝ R
A₀ A₁ B₀ B₁ : R
T : IsCHSHTuple A₀ A₁ B₀ B₁
P : R := 2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁
⊢ A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁ ≤ 2

let P := 2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁

R : Type u
inst✝⁴ : OrderedCommRing R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : Algebra ℝ R
inst✝ : OrderedSMul ℝ R
A₀ A₁ B₀ B₁ : R
T : IsCHSHTuple A₀ A₁ B₀ B₁
P : R := 2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁
i₁ : 0 ≤ P
⊢ A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁ ≤ 2

have i₁ : 0 ≤ P := by
    have idem : P * P = 4 * P := CHSH_id T.A₀_inv T.A₁_inv T.B₀_inv T.B₁_inv
    have idem' : P = (1 / 4 : ℝ) • (P * P) := by
      have h : 4 * P = (4 : ℝ) • P := by simp [Algebra.smul_def]
      rw [idem, h, ← mul_smul]
      norm_num
    have sa : star P = P := by
      dsimp [P]
      simp only [star_add, star_sub, star_mul, star_ofNat, star_one, T.A₀_sa, T.A₁_sa, T.B₀_sa,
        T.B₁_sa, mul_comm B₀, mul_comm B₁]
    simpa only [← idem', sa]
      using smul_nonneg (by norm_num : (0 : ℝ) ≤ 1 / 4) (star_mul_self_nonneg P)

case a
R : Type u
inst✝⁴ : OrderedCommRing R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : Algebra ℝ R
inst✝ : OrderedSMul ℝ R
A₀ A₁ B₀ B₁ : R
T : IsCHSHTuple A₀ A₁ B₀ B₁
P : R := 2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁
i₁ : 0 ≤ P
⊢ 0 ≤ 2 - (A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁)

simpa only [sub_add_eq_sub_sub, ← sub_add] using i₁


G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
⊢ orderOf 1 = 1

rw [orderOf, ← minimalPeriod_id (x := (1 : G)), ← one_mul_eq_id]


K : Type u_1
inst✝¹ : Field K
t : ℕ
inst✝ : Invertible ↑t
⊢ ¬ringChar K ∣ t

K : Type u_1
inst✝¹ : Field K
t : ℕ
inst✝ : Invertible ↑t
⊢ ↑t ≠ 0


ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
h : α ≃ᵢ β
x : β
r : ℝ≥0∞
⊢ ⇑h ⁻¹' EMetric.closedBall x r = EMetric.closedBall (h.symm x) r

rw [← h.isometry.preimage_emetric_closedBall (h.symm x) r, h.apply_symm_apply]


α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f₁ f₂ : α → E'
g₁ g₂ : α → F'
h₁ : f₁ =o[l] g₁
h₂ : f₂ =o[l] g₂
⊢ (fun x => f₁ x + f₂ x) =o[l] fun x => ‖g₁ x‖ + ‖g₂ x‖

refine (h₁.trans_le fun x => ?_).add (h₂.trans_le ?_) <;> simp [abs_of_nonneg, add_nonneg]


R : Type u
S : Type v
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
P : Generators R S
R' : Type u'
S' : Type v'
inst✝⁷ : CommRing R'
inst✝⁶ : CommRing S'
inst✝⁵ : Algebra R' S'
P' : Generators R' S'
inst✝⁴ : Algebra R R'
inst✝³ : Algebra S S'
inst✝² : Algebra R S'
inst✝¹ : IsScalarTower R R' S'
inst✝ : IsScalarTower R S S'
f : P.Hom P'
i : P.vars
j : P'.vars
⊢ (P'.cotangentSpaceBasis.repr ((CotangentSpace.map f) (P.cotangentSpaceBasis i))) j =
    (aeval P'.val) ((pderiv j) (f.val i))

simp only [cotangentSpaceBasis_apply, map_tmul, _root_.map_one, Hom.toAlgHom_X,
    cotangentSpaceBasis_repr_one_tmul]


α : Type u_1
inst✝ : Group α
s t : Subgroup α
ι : Type u_2
f : ι → Subgroup α
⊢ ∀ (a₁ a₂ : α),
    (fun q i => quotientMapOfLE ⋯ q) (Quotient.mk'' a₁) = (fun q i => quotientMapOfLE ⋯ q) (Quotient.mk'' a₂) →
      Quotient.mk'' a₁ = Quotient.mk'' a₂

simp_rw [funext_iff, quotientMapOfLE_apply_mk, eq', mem_iInf, imp_self, forall_const]


R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m : M
x : A × ↥(CliffordAlgebra.even.lift.S f)
⊢ ((CliffordAlgebra.even.lift.fFold f) m) (((CliffordAlgebra.even.lift.fFold f) m) x) = Q m • x

case mk.mk
R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m : M
a : A
g : M →ₗ[R] A
hg : g ∈ CliffordAlgebra.even.lift.S f
⊢ ((CliffordAlgebra.even.lift.fFold f) m) (((CliffordAlgebra.even.lift.fFold f) m) (a, ⟨g, hg⟩)) = Q m • (a, ⟨g, hg⟩)

case mk.mk.a
R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m : M
a : A
g : M →ₗ[R] A
hg : g ∈ CliffordAlgebra.even.lift.S f
⊢ (((CliffordAlgebra.even.lift.fFold f) m) (((CliffordAlgebra.even.lift.fFold f) m) (a, ⟨g, hg⟩))).1 =
    (Q m • (a, ⟨g, hg⟩)).1

case mk.mk.a.a
R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m : M
a : A
g : M →ₗ[R] A
hg : g ∈ CliffordAlgebra.even.lift.S f
⊢ ↑(((CliffordAlgebra.even.lift.fFold f) m) (((CliffordAlgebra.even.lift.fFold f) m) (a, ⟨g, hg⟩))).2 =
    ↑(Q m • (a, ⟨g, hg⟩)).2


m k : ℕ+
⊢ ↑(m.mod k) ≤ ↑m ∧ ↑(m.mod k) ≤ ↑k

change (mod m k : ℕ) ≤ (m : ℕ) ∧ (mod m k : ℕ) ≤ (k : ℕ)

m k : ℕ+
⊢ (if ↑m % ↑k = 0 then ↑k else ↑m % ↑k) ≤ ↑m ∧ (if ↑m % ↑k = 0 then ↑k else ↑m % ↑k) ≤ ↑k

case pos
m k : ℕ+
h : ↑m % ↑k = 0
⊢ ↑k ≤ ↑m ∧ ↑k ≤ ↑k

case neg
m k : ℕ+
h : ¬↑m % ↑k = 0
⊢ ↑m % ↑k ≤ ↑m ∧ ↑m % ↑k ≤ ↑k


α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∈ S → s ⊆ S → a ∉ s → C s → C (insert a s)
⊢ C S

α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∈ S → s ⊆ S → a ∉ s → C s → C (insert a s)
⊢ ∀ {a : α} {s : Set α}, a ∉ s → s.Finite → (fun s => s ⊆ S → C s) s → (fun s => s ⊆ S → C s) (insert a s)

refine @Set.Finite.induction_on α (fun s => s ⊆ S → C s) S h (fun _ => H0) ?_ Subset.rfl

α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∈ S → s ⊆ S → a ∉ s → C s → C (insert a s)
a : α
s : Set α
has : a ∉ s
a✝ : s.Finite
hCs : s ⊆ S → C s
haS : insert a s ⊆ S
⊢ C (insert a s)

α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
S : Set α
h : S.Finite
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, a ∈ S → s ⊆ S → a ∉ s → C s → C (insert a s)
a : α
s : Set α
has : a ∉ s
a✝ : s.Finite
hCs : s ⊆ S → C s
haS : a ∈ S ∧ s ⊆ S
⊢ C (insert a s)


Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : IsProbabilityMeasure μ
ι : Type u_2
β : Type u_3
inst✝² : LinearOrder ι
mβ : MeasurableSpace β
inst✝¹ : NormedAddCommGroup β
inst✝ : BorelSpace β
f : ι → Ω → β
i j : ι
s : ι → Set Ω
hsm : ∀ (n : ι), MeasurableSet (s n)
hs : iIndepSet s μ
hij : i < j
⊢ μ[(s j).indicator fun x => 1|↑(filtrationOfSet hsm) i] =ᶠ[ae μ] fun x => (μ (s j)).toReal

Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : IsProbabilityMeasure μ
ι : Type u_2
β : Type u_3
inst✝² : LinearOrder ι
mβ : MeasurableSpace β
inst✝¹ : NormedAddCommGroup β
inst✝ : BorelSpace β
f : ι → Ω → β
i j : ι
s : ι → Set Ω
hsm : ∀ (n : ι), MeasurableSet (s n)
hs : iIndepSet s μ
hij : i < j
⊢ μ[(s j).indicator fun x => 1|↑(Filtration.natural (fun i => (s i).indicator fun x => 1) ⋯) i] =ᶠ[ae μ] fun x =>
    (μ (s j)).toReal

rw [Filtration.filtrationOfSet_eq_natural (β := ℝ) hsm]

Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : IsProbabilityMeasure μ
ι : Type u_2
β : Type u_3
inst✝² : LinearOrder ι
mβ : MeasurableSpace β
inst✝¹ : NormedAddCommGroup β
inst✝ : BorelSpace β
f : ι → Ω → β
i j : ι
s : ι → Set Ω
hsm : ∀ (n : ι), MeasurableSet (s n)
hs : iIndepSet s μ
hij : i < j
⊢ (fun x => ∫ (x : Ω), (s j).indicator (fun _ω => 1) x ∂μ) =ᶠ[ae μ] fun x => (μ (s j)).toReal

refine (iIndepFun.condexp_natural_ae_eq_of_lt _ hs.iIndepFun_indicator hij).trans ?_

Ω : Type u_1
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : IsProbabilityMeasure μ
ι : Type u_2
β : Type u_3
inst✝² : LinearOrder ι
mβ : MeasurableSpace β
inst✝¹ : NormedAddCommGroup β
inst✝ : BorelSpace β
f : ι → Ω → β
i j : ι
s : ι → Set Ω
hsm : ∀ (n : ι), MeasurableSet (s n)
hs : iIndepSet s μ
hij : i < j
⊢ (fun x => (μ (s j)).toReal) =ᶠ[ae μ] fun x => (μ (s j)).toReal

simp only [integral_indicator_const _ (hsm _), Algebra.id.smul_eq_mul, mul_one]


C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
X Y : C
F G : C ⥤ D
H I : D ⥤ E
α : F ≅ G
β : H ≅ I
⊢ F ⋙ H ≅ G ⋙ I

case refine_1
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
X Y : C
F G : C ⥤ D
H I : D ⥤ E
α : F ≅ G
β : H ≅ I
⊢ (α.hom ◫ β.hom) ≫ α.inv ◫ β.inv = 𝟙 (F ⋙ H)

case refine_2
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
X Y : C
F G : C ⥤ D
H I : D ⥤ E
α : F ≅ G
β : H ≅ I
⊢ (α.inv ◫ β.inv) ≫ α.hom ◫ β.hom = 𝟙 (G ⋙ I)

refine ⟨α.hom ◫ β.hom, α.inv ◫ β.inv, ?_, ?_⟩

case refine_2.w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
X Y : C
F G : C ⥤ D
H I : D ⥤ E
α : F ≅ G
β : H ≅ I
x✝ : C
⊢ ((α.inv ◫ β.inv) ≫ α.hom ◫ β.hom).app x✝ = (𝟙 (G ⋙ I)).app x✝

case refine_2.w.h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
X Y : C
F G : C ⥤ D
H I : D ⥤ E
α : F ≅ G
β : H ≅ I
x✝ : C
⊢ ((α.inv ≫ α.hom) ◫ (β.inv ≫ β.hom)).app x✝ = (𝟙 (G ⋙ I)).app x✝


p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝⁸ : Fact (1 ≤ p)
inst✝⁷ : Fintype ι
inst✝⁶ : Semiring 𝕜
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝³ : (i : ι) → Module 𝕜 (α i)
inst✝² : (i : ι) → Module 𝕜 (β✝ i)
c : 𝕜
β : Type u_5
inst✝¹ : SeminormedAddCommGroup β
inst✝ : Nonempty ι
b : β
⊢ ‖(WithLp.equiv p (ι → β)).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖₊

case inl
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝⁸ : Fintype ι
inst✝⁷ : Semiring 𝕜
inst✝⁶ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝⁴ : (i : ι) → Module 𝕜 (α i)
inst✝³ : (i : ι) → Module 𝕜 (β✝ i)
c : 𝕜
β : Type u_5
inst✝² : SeminormedAddCommGroup β
inst✝¹ : Nonempty ι
b : β
inst✝ : Fact (1 ≤ ⊤)
⊢ ‖(WithLp.equiv ⊤ (ι → β)).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ (1 / ⊤).toReal * ‖b‖₊

case inr
p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝⁸ : Fact (1 ≤ p)
inst✝⁷ : Fintype ι
inst✝⁶ : Semiring 𝕜
inst✝⁵ : (i : ι) → SeminormedAddCommGroup (α i)
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (β✝ i)
inst✝³ : (i : ι) → Module 𝕜 (α i)
inst✝² : (i : ι) → Module 𝕜 (β✝ i)
c : 𝕜
β : Type u_5
inst✝¹ : SeminormedAddCommGroup β
inst✝ : Nonempty ι
b : β
hp : ¬p = ⊤
⊢ ‖(WithLp.equiv p (ι → β)).symm (Function.const ι b)‖₊ = ↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖₊


M✝ : Type u_1
inst✝² : Monoid M✝
s✝ : Set M✝
A : Type u_2
inst✝¹ : AddMonoid A
t : Set A
M : Type u_3
inst✝ : CommMonoid M
s : Set M
hs : IsSubmonoid s
m : Multiset M
⊢ (∀ a ∈ m, a ∈ s) → m.prod ∈ s

M✝ : Type u_1
inst✝² : Monoid M✝
s✝ : Set M✝
A : Type u_2
inst✝¹ : AddMonoid A
t : Set A
M : Type u_3
inst✝ : CommMonoid M
s : Set M
hs : IsSubmonoid s
m : Multiset M
l : List M
hl : ∀ a ∈ ⟦l⟧, a ∈ s
⊢ Multiset.prod ⟦l⟧ ∈ s

refine Quotient.inductionOn m fun l hl => ?_

M✝ : Type u_1
inst✝² : Monoid M✝
s✝ : Set M✝
A : Type u_2
inst✝¹ : AddMonoid A
t : Set A
M : Type u_3
inst✝ : CommMonoid M
s : Set M
hs : IsSubmonoid s
m : Multiset M
l : List M
hl : ∀ a ∈ ⟦l⟧, a ∈ s
⊢ l.prod ∈ s


α : Type u_1
s✝¹ t✝ : Finset α
n✝ : ?m.21109
s✝ t : Finset α
n : ℕ
s : Finset α
⊢ powersetCard n s = filter (fun x => x.card = n) s.powerset

case a
α : Type u_1
s✝¹ t✝ : Finset α
n✝ : ?m.21109
s✝ t : Finset α
n : ℕ
s a✝ : Finset α
⊢ a✝ ∈ powersetCard n s ↔ a✝ ∈ filter (fun x => x.card = n) s.powerset


α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
l : List (Sigma β)
⊢ kerase a (kerase a' l) = kerase a' (kerase a l)

case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
l : List (Sigma β)
h : a = a'
⊢ kerase a (kerase a' l) = kerase a' (kerase a l)

case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
l : List (Sigma β)
h : ¬a = a'
⊢ kerase a (kerase a' l) = kerase a' (kerase a l)

case neg.nil
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
h : ¬a = a'
⊢ kerase a (kerase a' []) = kerase a' (kerase a [])

case neg.cons
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
h : ¬a = a'
x : Sigma β
xs : List (Sigma β)
tail_ih✝ : kerase a (kerase a' xs) = kerase a' (kerase a xs)
⊢ kerase a (kerase a' (x :: xs)) = kerase a' (kerase a (x :: xs))


α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
x y z : Multiset α
h : z ≤ y
⊢ x + y = x ∪ z ↔ y = z ∧ x.Disjoint y

simpa only [and_comm] using add_eq_union_left_of_le h


β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
f : β → C
inst✝ : HasCoproduct f
c : Cofan f
⊢ IsIso (Sigma.desc c.inj) ↔ Nonempty (IsColimit c)

β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
f : β → C
inst✝ : HasCoproduct f
c : Cofan f
x✝ : Nonempty (IsColimit c)
hc : IsColimit c
⊢ IsIso (Sigma.desc c.inj)

refine ⟨fun h ↦ ⟨isColimitOfIsIsoSigmaDesc c⟩, fun ⟨hc⟩ ↦ ?_⟩

β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
f : β → C
inst✝ : HasCoproduct f
c : Cofan f
x✝ : Nonempty (IsColimit c)
hc : IsColimit c
this : IsIso (((coproductIsCoproduct f).coconePointUniqueUpToIso hc).hom ≫ hc.desc c)
⊢ IsIso (Sigma.desc c.inj)

have : IsIso (((coproductIsCoproduct f).coconePointUniqueUpToIso hc).hom ≫ hc.desc c) := by
    simp; infer_instance

case h.e'_5.h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
f : β → C
inst✝ : HasCoproduct f
c : Cofan f
x✝ : Nonempty (IsColimit c)
hc : IsColimit c
this : IsIso (((coproductIsCoproduct f).coconePointUniqueUpToIso hc).hom ≫ hc.desc c)
e_3✝ : ∐ f = (mk (∐ f) (Sigma.ι f)).pt
⊢ Sigma.desc c.inj = ((coproductIsCoproduct f).coconePointUniqueUpToIso hc).hom ≫ hc.desc c

case h.e'_5.h.h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
f : β → C
inst✝ : HasCoproduct f
c : Cofan f
x✝ : Nonempty (IsColimit c)
hc : IsColimit c
this : IsIso (((coproductIsCoproduct f).coconePointUniqueUpToIso hc).hom ≫ hc.desc c)
e_3✝ : ∐ f = (mk (∐ f) (Sigma.ι f)).pt
b✝ : β
⊢ Sigma.ι f b✝ ≫ Sigma.desc c.inj =
    Sigma.ι f b✝ ≫ ((coproductIsCoproduct f).coconePointUniqueUpToIso hc).hom ≫ hc.desc c

case h.e'_5.h.h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
f : β → C
inst✝ : HasCoproduct f
c : Cofan f
x✝ : Nonempty (IsColimit c)
hc : IsColimit c
this : IsIso (((coproductIsCoproduct f).coconePointUniqueUpToIso hc).hom ≫ hc.desc c)
e_3✝ : ∐ f = (mk (∐ f) (Sigma.ι f)).pt
b✝ : β
⊢ c.inj b✝ = c.ι.app { as := b✝ }

simp only [colimit.ι_desc, mk_pt, mk_ι_app, IsColimit.coconePointUniqueUpToIso,
    coproductIsCoproduct, colimit.cocone_x, Functor.mapIso_hom, IsColimit.uniqueUpToIso_hom,
    Cocones.forget_map, IsColimit.descCoconeMorphism_hom, IsColimit.ofIsoColimit_desc,
    Cocones.ext_inv_hom, Iso.refl_inv, colimit.isColimit_desc, Category.id_comp,
    IsColimit.desc_self, Category.comp_id]


F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hs : s.Nonempty
⊢ ∑ j ∈ s, Lagrange.basis s v j = 1

case refine_1
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hs : s.Nonempty
⊢ (s.sup fun b => (Lagrange.basis s v b).degree) < ↑s.card

case refine_2
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hs : s.Nonempty
⊢ degree 1 < ↑s.card

case refine_3
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hvs : Set.InjOn v ↑s
hs : s.Nonempty
⊢ ∀ i ∈ s, eval (v i) (∑ j ∈ s, Lagrange.basis s v j) = eval (v i) 1

refine eq_of_degrees_lt_of_eval_index_eq s hvs (lt_of_le_of_lt (degree_sum_le _ _) ?_) ?_ ?_


α : Type u_1
inst✝ : DecidableEq α
s : Multiset α
l₁ l₂ : List α
⊢ (↑l₁).ndinter ↑l₂ = ↑(l₁ ∩ l₂)

α : Type u_1
inst✝ : DecidableEq α
s : Multiset α
l₁ l₂ : List α
⊢ List.filter (fun b => elem b l₂) l₁ ~ l₁ ∩ l₂

simp only [ndinter, mem_coe, filter_coe, coe_eq_coe, ← elem_eq_mem]


α : Type u
β : Type v
f : α → β
⊢ toFreeSemigroup.comp (map f) = (FreeSemigroup.map f).comp toFreeSemigroup

case h
α : Type u
β : Type v
f : α → β
⊢ ⇑(toFreeSemigroup.comp (map f)) ∘ of = ⇑((FreeSemigroup.map f).comp toFreeSemigroup) ∘ of


α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
U : Finset α
hU : U ∈ P.parts
V : Finset α
𝒜 : Finset (Finset α)
s : Finset α
h𝒜 : 𝒜 ⊆ (chunk hP G ε hU).parts
hs : s ∈ 𝒜
⊢ ↑𝒜.card * ↑s.card * (↑m / (↑m + 1)) ≤ ↑(𝒜.sup id).card

α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
U : Finset α
hU : U ∈ P.parts
V : Finset α
𝒜 : Finset (Finset α)
s : Finset α
h𝒜 : 𝒜 ⊆ (chunk hP G ε hU).parts
hs : s ∈ 𝒜
⊢ ↑𝒜.card * ↑m * ↑s.card ≤ ↑(𝒜.sup id).card * (↑m + 1)

rw [mul_div_assoc', div_le_iff coe_m_add_one_pos, mul_right_comm]

case refine_1
α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
U : Finset α
hU : U ∈ P.parts
V : Finset α
𝒜 : Finset (Finset α)
s : Finset α
h𝒜 : 𝒜 ⊆ (chunk hP G ε hU).parts
hs : s ∈ 𝒜
⊢ ↑𝒜.card * ↑m ≤ ↑(𝒜.sup id).card

case refine_2
α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
U : Finset α
hU : U ∈ P.parts
V : Finset α
𝒜 : Finset (Finset α)
s : Finset α
h𝒜 : 𝒜 ⊆ (chunk hP G ε hU).parts
hs : s ∈ 𝒜
⊢ ↑s.card ≤ ↑m + 1

refine mul_le_mul ?_ ?_ (cast_nonneg _) (cast_nonneg _)


M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Set M
x✝¹ : { x // x ∈ ↑(closure s) }
x : M
hx : x ∈ ↑(closure s)
x✝ : ⟨x, hx⟩ ∈ ⊤
⊢ ⟨x, hx⟩ ∈ closure (Subtype.val ⁻¹' s)

case refine_1
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Set M
x✝¹ : { x // x ∈ ↑(closure s) }
x : M
hx : x ∈ ↑(closure s)
x✝ : ⟨x, hx⟩ ∈ ⊤
⊢ (fun y hy => ⟨y, hy⟩ ∈ closure (Subtype.val ⁻¹' s)) 1 ⋯

case refine_2
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Set M
x✝¹ : { x // x ∈ ↑(closure s) }
x : M
hx : x ∈ ↑(closure s)
x✝ : ⟨x, hx⟩ ∈ ⊤
g₁ : M
g₂ : g₁ ∈ closure s
hg₁ : M
hg₂ : hg₁ ∈ closure s
⊢ (fun y hy => ⟨y, hy⟩ ∈ closure (Subtype.val ⁻¹' s)) g₁ g₂ →
    (fun y hy => ⟨y, hy⟩ ∈ closure (Subtype.val ⁻¹' s)) hg₁ hg₂ →
      (fun y hy => ⟨y, hy⟩ ∈ closure (Subtype.val ⁻¹' s)) (g₁ * hg₁) ⋯

refine closure_induction' (p := fun y hy ↦ ⟨y, hy⟩ ∈ closure (((↑) : closure s → M) ⁻¹' s))
        (fun g hg => subset_closure hg) ?_ (fun g₁ g₂ hg₁ hg₂ => ?_) hx


α : Type u_1
G G' : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
ε : ℝ
s t u : Finset α
inst✝ : DecidableEq α
hst : Disjoint s t
hsu : Disjoint s u
htu : Disjoint t u
x₁ x₂ y₁ y₂ z₁ z₂ : α
h : {x₁, y₁, z₁} = {x₂, y₂, z₂}
hx₁ : x₁ ∈ s
hx₂ : x₂ ∈ s
hy₁ : y₁ ∈ t
hy₂ : y₂ ∈ t
hz₁ : z₁ ∈ u
hz₂ : z₂ ∈ u
⊢ (x₁, y₁, z₁) = (x₂, y₂, z₂)

α : Type u_1
G G' : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
ε : ℝ
s t u : Finset α
inst✝ : DecidableEq α
hst : Disjoint s t
hsu : Disjoint s u
htu : Disjoint t u
x₁ x₂ y₁ y₂ z₁ z₂ : α
hx₁ : x₁ ∈ s
hx₂ : x₂ ∈ s
hy₁ : y₁ ∈ t
hy₂ : y₂ ∈ t
hz₁ : z₁ ∈ u
hz₂ : z₂ ∈ u
h :
  ((x₁ = x₂ ∨ x₁ = y₂ ∨ x₁ = z₂) ∧ (y₁ = x₂ ∨ y₁ = y₂ ∨ y₁ = z₂) ∧ (z₁ = x₂ ∨ z₁ = y₂ ∨ z₁ = z₂)) ∧
    (x₂ = x₁ ∨ x₂ = y₁ ∨ x₂ = z₁) ∧ (y₂ = x₁ ∨ y₂ = y₁ ∨ y₂ = z₁) ∧ (z₂ = x₁ ∨ z₂ = y₁ ∨ z₂ = z₁)
⊢ (x₁, y₁, z₁) = (x₂, y₂, z₂)

simp only [Finset.Subset.antisymm_iff, subset_iff, mem_insert, mem_singleton, forall_eq_or_imp,
    forall_eq] at h

α : Type u_1
G G' : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
ε : ℝ
s t u : Finset α
inst✝ : DecidableEq α
hst : ∀ ⦃a : α⦄, a ∈ s → a ∉ t
hsu : ∀ ⦃a : α⦄, a ∈ s → a ∉ u
htu : ∀ ⦃a : α⦄, a ∈ t → a ∉ u
x₁ x₂ y₁ y₂ z₁ z₂ : α
hx₁ : x₁ ∈ s
hx₂ : x₂ ∈ s
hy₁ : y₁ ∈ t
hy₂ : y₂ ∈ t
hz₁ : z₁ ∈ u
hz₂ : z₂ ∈ u
h :
  ((x₁ = x₂ ∨ x₁ = y₂ ∨ x₁ = z₂) ∧ (y₁ = x₂ ∨ y₁ = y₂ ∨ y₁ = z₂) ∧ (z₁ = x₂ ∨ z₁ = y₂ ∨ z₁ = z₂)) ∧
    (x₂ = x₁ ∨ x₂ = y₁ ∨ x₂ = z₁) ∧ (y₂ = x₁ ∨ y₂ = y₁ ∨ y₂ = z₁) ∧ (z₂ = x₁ ∨ z₂ = y₁ ∨ z₂ = z₁)
⊢ (x₁, y₁, z₁) = (x₂, y₂, z₂)

α : Type u_1
G G' : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
ε : ℝ
s t u : Finset α
inst✝ : DecidableEq α
hst : ∀ ⦃a : α⦄, a ∈ s → a ∉ t
hsu : ∀ ⦃a : α⦄, a ∈ s → a ∉ u
htu : ∀ ⦃a : α⦄, a ∈ t → a ∉ u
x₁ x₂ y₁ y₂ z₁ z₂ : α
hx₁ : x₁ ∈ s
hx₂ : x₂ ∈ s
hy₁ : y₁ ∈ t
hy₂ : y₂ ∈ t
hz₁ : z₁ ∈ u
hz₂ : z₂ ∈ u
h :
  ((x₁ = x₂ ∨ x₁ = y₂ ∨ x₁ = z₂) ∧ (y₁ = x₂ ∨ y₁ = y₂ ∨ y₁ = z₂) ∧ (z₁ = x₂ ∨ z₁ = y₂ ∨ z₁ = z₂)) ∧
    (x₂ = x₁ ∨ x₂ = y₁ ∨ x₂ = z₁) ∧ (y₂ = x₁ ∨ y₂ = y₁ ∨ y₂ = z₁) ∧ (z₂ = x₁ ∨ z₂ = y₁ ∨ z₂ = z₁)
⊢ x₁ = x₂ ∧ y₁ = y₂ ∧ z₁ = z₂

α : Type u_1
G G' : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
ε : ℝ
s t u : Finset α
inst✝ : DecidableEq α
hst : ∀ ⦃a : α⦄, a ∈ s → a ∉ t
hsu : ∀ ⦃a : α⦄, a ∈ s → a ∉ u
htu : ∀ ⦃a : α⦄, a ∈ t → a ∉ u
x₁ x₂ y₁ y₂ z₁ z₂ : α
hx₁ : x₁ ∈ s
hx₂ : x₂ ∈ s
hy₁ : y₁ ∈ t
hy₂ : y₂ ∈ t
hz₁ : z₁ ∈ u
hz₂ : z₂ ∈ u
h :
  (x₁ = x₂ ∨ x₁ = y₂ ∨ x₁ = z₂) ∧
    (y₁ = y₂ ∨ y₁ = x₂ ∨ y₁ = z₂) ∧
      (z₁ = z₂ ∨ z₁ = x₂ ∨ z₁ = y₂) ∧
        (x₂ = x₁ ∨ x₂ = y₁ ∨ x₂ = z₁) ∧ (y₂ = x₁ ∨ y₂ = y₁ ∨ y₂ = z₁) ∧ (z₂ = x₁ ∨ z₂ = y₁ ∨ z₂ = z₁)
⊢ x₁ = x₂ ∧ y₁ = y₂ ∧ z₁ = z₂

simp only [and_assoc, @or_left_comm _ (y₁ = y₂), @or_comm _ (z₁ = z₂),
    @or_left_comm _ (z₁ = z₂)] at h


α : Type u_1
inst✝⁵ : Mul α
inst✝⁴ : PartialOrder α
inst✝³ : DecidableEq α
inst✝² : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝¹ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
inst✝ : LocallyFiniteOrder α
a b c d : α
⊢ ↑(Icc a b * Ico c d) ⊆ ↑(Ico (a * c) (b * d))

simpa using Set.Icc_mul_Ico_subset' _ _ _ _


C : Type u
inst✝¹ : Groupoid C
S : Subgroupoid C
D : Type u_1
inst✝ : Groupoid D
φ : C ⥤ D
hφ : Function.Injective φ.obj
d : D
⊢ d ∈ (im φ hφ).objs ↔ ∃ c, φ.obj c = d

simp only [im, mem_map_objs_iff, mem_top_objs, true_and]


s : Finset ℕ
m n✝ p n k : ℕ
n0 : 0 < n
i : ℕ
e : k = 2 * i + 3
ih : ∀ (m : ℕ), Prime m → m ∣ n → k ≤ m
⊢ n.MinSqFacProp (n.minSqFacAux k)

s : Finset ℕ
m n✝ p n k : ℕ
n0 : 0 < n
i : ℕ
e : k = 2 * i + 3
ih : ∀ (m : ℕ), Prime m → m ∣ n → k ≤ m
⊢ n.MinSqFacProp
    (if h : n < k * k then none
    else
      let_fun this := ⋯;
      if k ∣ n then
        let n' := n / k;
        let_fun this := ⋯;
        if k ∣ n' then some k else n'.minSqFacAux (k + 2)
      else n.minSqFacAux (k + 2))

case pos
s : Finset ℕ
m n✝ p n k : ℕ
n0 : 0 < n
i : ℕ
e : k = 2 * i + 3
ih : ∀ (m : ℕ), Prime m → m ∣ n → k ≤ m
h : n < k * k
⊢ n.MinSqFacProp none

case neg
s : Finset ℕ
m n✝ p n k : ℕ
n0 : 0 < n
i : ℕ
e : k = 2 * i + 3
ih : ∀ (m : ℕ), Prime m → m ∣ n → k ≤ m
h : ¬n < k * k
⊢ n.MinSqFacProp (if k ∣ n then if k ∣ n / k then some k else (n / k).minSqFacAux (k + 2) else n.minSqFacAux (k + 2))

by_cases h : n < k * k <;> simp only [h, ↓reduceDIte]

case neg
s : Finset ℕ
m n✝ p n k : ℕ
n0 : 0 < n
i : ℕ
e : k = 2 * i + 3
ih : ∀ (m : ℕ), Prime m → m ∣ n → k ≤ m
h : ¬n < k * k
k2 : 2 ≤ k
⊢ n.MinSqFacProp (if k ∣ n then if k ∣ n / k then some k else (n / k).minSqFacAux (k + 2) else n.minSqFacAux (k + 2))

case neg
s : Finset ℕ
m n✝ p n k : ℕ
n0 : 0 < n
i : ℕ
e : k = 2 * i + 3
ih : ∀ (m : ℕ), Prime m → m ∣ n → k ≤ m
h : ¬n < k * k
k2 : 2 ≤ k
k0 : 0 < k
⊢ n.MinSqFacProp (if k ∣ n then if k ∣ n / k then some k else (n / k).minSqFacAux (k + 2) else n.minSqFacAux (k + 2))

have k0 : 0 < k := lt_of_lt_of_le (by decide) k2

case neg
s : Finset ℕ
m n✝ p n k : ℕ
n0 : 0 < n
i : ℕ
e : k = 2 * i + 3
ih : ∀ (m : ℕ), Prime m → m ∣ n → k ≤ m
h : ¬n < k * k
k2 : 2 ≤ k
k0 : 0 < k
IH : ∀ (n' : ℕ), n' ∣ n → ¬k ∣ n' → n'.MinSqFacProp (n'.minSqFacAux (k + 2))
⊢ n.MinSqFacProp (if k ∣ n then if k ∣ n / k then some k else (n / k).minSqFacAux (k + 2) else n.minSqFacAux (k + 2))

case neg
s : Finset ℕ
m n✝ p n k : ℕ
n0 : 0 < n
i : ℕ
e : k = 2 * i + 3
ih : ∀ (m : ℕ), Prime m → m ∣ n → k ≤ m
h : ¬n < k * k
k2 : 2 ≤ k
k0 : 0 < k
IH : ∀ (n' : ℕ), n' ∣ n → ¬k ∣ n' → n'.MinSqFacProp (n'.minSqFacAux (k + 2))
pk : k ∣ n → Prime k
⊢ n.MinSqFacProp (if k ∣ n then if k ∣ n / k then some k else (n / k).minSqFacAux (k + 2) else n.minSqFacAux (k + 2))

have pk : k ∣ n → Prime k := by
    refine fun dk => prime_def_minFac.2 ⟨k2, le_antisymm (minFac_le k0) ?_⟩
    exact ih _ (minFac_prime (ne_of_gt k2)) (dvd_trans (minFac_dvd _) dk)

case pos
s : Finset ℕ
m n✝ p n k : ℕ
n0 : 0 < n
i : ℕ
e : k = 2 * i + 3
ih : ∀ (m : ℕ), Prime m → m ∣ n → k ≤ m
h : ¬n < k * k
k2 : 2 ≤ k
k0 : 0 < k
IH : ∀ (n' : ℕ), n' ∣ n → ¬k ∣ n' → n'.MinSqFacProp (n'.minSqFacAux (k + 2))
pk : k ∣ n → Prime k
dk : k ∣ n
dkk : k ∣ n / k
⊢ n.MinSqFacProp (some k)

case neg
s : Finset ℕ
m n✝ p n k : ℕ
n0 : 0 < n
i : ℕ
e : k = 2 * i + 3
ih : ∀ (m : ℕ), Prime m → m ∣ n → k ≤ m
h : ¬n < k * k
k2 : 2 ≤ k
k0 : 0 < k
IH : ∀ (n' : ℕ), n' ∣ n → ¬k ∣ n' → n'.MinSqFacProp (n'.minSqFacAux (k + 2))
pk : k ∣ n → Prime k
dk : k ∣ n
dkk : ¬k ∣ n / k
⊢ n.MinSqFacProp ((n / k).minSqFacAux (k + 2))

case neg
s : Finset ℕ
m n✝ p n k : ℕ
n0 : 0 < n
i : ℕ
e : k = 2 * i + 3
ih : ∀ (m : ℕ), Prime m → m ∣ n → k ≤ m
h : ¬n < k * k
k2 : 2 ≤ k
k0 : 0 < k
IH : ∀ (n' : ℕ), n' ∣ n → ¬k ∣ n' → n'.MinSqFacProp (n'.minSqFacAux (k + 2))
pk : k ∣ n → Prime k
dk : ¬k ∣ n
⊢ n.MinSqFacProp (n.minSqFacAux (k + 2))


α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
⊢ UniformContinuous fun f => (ofFun 𝔖) (UniformFun.toFun f)

α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
⊢ ∀ i ∈ 𝔖,
    ∀ i_2 ∈ 𝓤 β,
      ∃ i_4 ∈ 𝓤 β,
        ∀ ⦃x : (α →ᵤ β) × (α →ᵤ β)⦄,
          x ∈ UniformFun.gen α β i_4 →
            ((ofFun 𝔖) (UniformFun.toFun x.1), (ofFun 𝔖) (UniformFun.toFun x.2)) ∈ UniformOnFun.gen 𝔖 i i_2

simp only [UniformContinuous, UniformOnFun.uniformity_eq, tendsto_iInf, tendsto_principal,
    (UniformFun.hasBasis_uniformity _ _).eventually_iff]

exact fun _ _ U hU ↦ ⟨U, hU, fun f hf x _ ↦ hf x⟩


ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝¹³ : CommSemiring R
inst✝¹² : AddCommMonoid M
inst✝¹¹ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝¹⁰ : CommRing R₂
inst✝⁹ : AddCommGroup M₂
inst✝⁸ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝⁵ : Fintype ι'
inst✝⁴ : Finite κ
inst✝³ : Fintype ι
inst✝² : Fintype κ'
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq ι'
⊢ c.toMatrix ⇑c' * (toMatrix b' c') f * b'.toMatrix ⇑b = (toMatrix b c) f

case intro
ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝¹³ : CommSemiring R
inst✝¹² : AddCommMonoid M
inst✝¹¹ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝¹⁰ : CommRing R₂
inst✝⁹ : AddCommGroup M₂
inst✝⁸ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝⁵ : Fintype ι'
inst✝⁴ : Finite κ
inst✝³ : Fintype ι
inst✝² : Fintype κ'
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq ι'
val✝ : Fintype κ
⊢ c.toMatrix ⇑c' * (toMatrix b' c') f * b'.toMatrix ⇑b = (toMatrix b c) f


I : Type u
inst✝⁵ : DecidableEq I
i : I
R : Type v
inst✝⁴ : CommSemiring R
A : I → Type w
inst✝³ : (i : I) → Semiring (A i)
inst✝² : (i : I) → Algebra R (A i)
B : Type w'
inst✝¹ : Semiring B
inst✝ : Algebra R B
maps✝ maps : {i : I} → A i →ₐ[R] B
x y : FreeTensorAlgebra R A
r : rel R A x y
⊢ ((TensorAlgebra.lift R) (toModule R I B fun x => maps.toLinearMap)) x =
    ((TensorAlgebra.lift R) (toModule R I B fun x => maps.toLinearMap)) y

cases r with
          | id => simp
          | prod => simp

I : Type u
inst✝⁵ : DecidableEq I
i : I
R : Type v
inst✝⁴ : CommSemiring R
A : I → Type w
inst✝³ : (i : I) → Semiring (A i)
inst✝² : (i : I) → Algebra R (A i)
B : Type w'
inst✝¹ : Semiring B
inst✝ : Algebra R B
maps π : {i : I} → A i →ₐ[R] B
⊢ (fun π i => π ∘ₐ ι R A i)
      ((fun maps => (liftAlgHom R) ⟨(TensorAlgebra.lift R) (toModule R I B fun x => maps.toLinearMap), ⋯⟩) π) =
    π

case h.H
I : Type u
inst✝⁵ : DecidableEq I
i✝ : I
R : Type v
inst✝⁴ : CommSemiring R
A : I → Type w
inst✝³ : (i : I) → Semiring (A i)
inst✝² : (i : I) → Algebra R (A i)
B : Type w'
inst✝¹ : Semiring B
inst✝ : Algebra R B
maps π : {i : I} → A i →ₐ[R] B
i : I
aᵢ : A i
⊢ ((fun π i => π ∘ₐ ι R A i)
        ((fun maps => (liftAlgHom R) ⟨(TensorAlgebra.lift R) (toModule R I B fun x => maps.toLinearMap), ⋯⟩) π) i)
      aᵢ =
    π aᵢ

I : Type u
inst✝⁵ : DecidableEq I
i : I
R : Type v
inst✝⁴ : CommSemiring R
A : I → Type w
inst✝³ : (i : I) → Semiring (A i)
inst✝² : (i : I) → Algebra R (A i)
B : Type w'
inst✝¹ : Semiring B
inst✝ : Algebra R B
maps✝ : {i : I} → A i →ₐ[R] B
maps : FreeProduct R A →ₐ[R] B
⊢ (fun maps => (liftAlgHom R) ⟨(TensorAlgebra.lift R) (toModule R I B fun x => maps.toLinearMap), ⋯⟩)
      ((fun π i => π ∘ₐ ι R A i) maps) =
    maps

case w.w.H.h
I : Type u
inst✝⁵ : DecidableEq I
i✝ : I
R : Type v
inst✝⁴ : CommSemiring R
A : I → Type w
inst✝³ : (i : I) → Semiring (A i)
inst✝² : (i : I) → Algebra R (A i)
B : Type w'
inst✝¹ : Semiring B
inst✝ : Algebra R B
maps✝ : {i : I} → A i →ₐ[R] B
maps : FreeProduct R A →ₐ[R] B
i : I
a : A i
⊢ ((((fun maps => (liftAlgHom R) ⟨(TensorAlgebra.lift R) (toModule R I B fun x => maps.toLinearMap), ⋯⟩)
                ((fun π i => π ∘ₐ ι R A i) maps) ∘ₐ
              RingQuot.mkAlgHom R (rel R A)).toLinearMap ∘ₗ
          TensorAlgebra.ι R) ∘ₗ
        DirectSum.lof R I A i)
      a =
    (((maps ∘ₐ RingQuot.mkAlgHom R (rel R A)).toLinearMap ∘ₗ TensorAlgebra.ι R) ∘ₗ DirectSum.lof R I A i) a


α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
ι : Type u_2
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
⊢ μ.withDensity (∑' (n : ι), f n) = sum fun n => μ.withDensity (f n)

case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
ι : Type u_2
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
s : Set α
hs : MeasurableSet s
⊢ (μ.withDensity (∑' (n : ι), f n)) s = (sum fun n => μ.withDensity (f n)) s

case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
ι : Type u_2
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (a : α) in s, tsum (fun n => f n) a ∂μ = ∑' (i : ι), ∫⁻ (a : α) in s, f i a ∂μ

simp_rw [sum_apply _ hs, withDensity_apply _ hs]

case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
ι : Type u_2
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (x : α) in s, tsum (fun n => f n) x ∂μ = ∑' (i : ι), ∫⁻ (x : α) in s, f i x ∂μ

change ∫⁻ x in s, (∑' n, f n) x ∂μ = ∑' i, ∫⁻ x, f i x ∂μ.restrict s

case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
ι : Type u_2
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (x : α) in s, tsum (fun n => f n) x ∂μ = ∫⁻ (a : α) in s, ∑' (i : ι), f i a ∂μ

rw [← lintegral_tsum fun i => (h i).aemeasurable]

exact lintegral_congr fun x => tsum_apply (Pi.summable.2 fun _ => ENNReal.summable)


R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
h : p.degrees.Disjoint q.degrees
⊢ (p + q).degrees = p.degrees ∪ q.degrees

case a
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
h : p.degrees.Disjoint q.degrees
⊢ (p + q).degrees ≤ p.degrees ∪ q.degrees

case a
R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : MvPolynomial σ R
inst✝ : DecidableEq σ
p q : MvPolynomial σ R
h : p.degrees.Disjoint q.degrees
⊢ p.degrees ∪ q.degrees ≤ (p + q).degrees


X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : PseudoEMetricSpace X
inst✝¹ : PseudoEMetricSpace Y
inst✝ : PseudoEMetricSpace Z
C : ℝ≥0
f : X → Y
s : Set X
⊢ HolderOnWith C 1 f s ↔ LipschitzOnWith C f s

simp only [HolderOnWith, LipschitzOnWith, NNReal.coe_one, ENNReal.rpow_one]


f : ZFSet → ZFSet
H : PSet.Definable 1 f
x y : ZFSet
h : y ∈ x
z : ZFSet
⊢ Class.ToSet (fun x_1 => ↑(map f x) (x_1.pair z)) ↑y ↔ z = f y

f : ZFSet → ZFSet
H : PSet.Definable 1 f
x y : ZFSet
h : y ∈ x
z : ZFSet
⊢ (∃ z_1 ∈ x, z_1.pair (f z_1) = y.pair z) ↔ z = f y

rw [Class.toSet_of_ZFSet, Class.coe_apply, mem_map]

exact
      ⟨fun ⟨w, _, pr⟩ => by
        let ⟨wy, fw⟩ := ZFSet.pair_injective pr
        rw [← fw, wy], fun e => by
        subst e
        exact ⟨_, h, rfl⟩⟩


α : Type u_1
inst✝ : ConditionallyCompleteLattice α
f : ℕ → α
h : BddAbove (Set.range f)
⊢ ⨆ n, (partialSups f) n = ⨆ n, f n

case refine_1
α : Type u_1
inst✝ : ConditionallyCompleteLattice α
f : ℕ → α
h : BddAbove (Set.range f)
n : ℕ
⊢ (partialSups f) n ≤ ⨆ n, f n

case refine_2
α : Type u_1
inst✝ : ConditionallyCompleteLattice α
f : ℕ → α
h : BddAbove (Set.range f)
⊢ BddAbove (Set.range fun n => (partialSups f) n)

refine (ciSup_le fun n => ?_).antisymm (ciSup_mono ?_ <| le_partialSups f)


α : Type u_1
β : Type u_2
f : α → β
E I s : Set α
M : Matroid α
N : Matroid β
⊢ M.map id ⋯ = M


C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.15006, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
X Y : C
φ : W.RightFraction₂ X Y
inst✝ : W.HasLeftCalculusOfFractions
⊢ ∃ ψ, φ.f ≫ ψ.s = φ.s ≫ ψ.f ∧ φ.f' ≫ ψ.s = φ.s ≫ ψ.f'

case intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.15006, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
X Y : C
φ : W.RightFraction₂ X Y
inst✝ : W.HasLeftCalculusOfFractions
ψ₁ : W.LeftFraction X Y
hψ₁ : φ.fst.f ≫ ψ₁.s = φ.fst.s ≫ ψ₁.f
⊢ ∃ ψ, φ.f ≫ ψ.s = φ.s ≫ ψ.f ∧ φ.f' ≫ ψ.s = φ.s ≫ ψ.f'

obtain ⟨ψ₁, hψ₁⟩ := φ.fst.exists_leftFraction

case intro.intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.15006, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
X Y : C
φ : W.RightFraction₂ X Y
inst✝ : W.HasLeftCalculusOfFractions
ψ₁ : W.LeftFraction X Y
hψ₁ : φ.fst.f ≫ ψ₁.s = φ.fst.s ≫ ψ₁.f
ψ₂ : W.LeftFraction X Y
hψ₂ : φ.snd.f ≫ ψ₂.s = φ.snd.s ≫ ψ₂.f
⊢ ∃ ψ, φ.f ≫ ψ.s = φ.s ≫ ψ.f ∧ φ.f' ≫ ψ.s = φ.s ≫ ψ.f'

obtain ⟨ψ₂, hψ₂⟩ := φ.snd.exists_leftFraction

case intro.intro.intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.15006, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
X Y : C
φ : W.RightFraction₂ X Y
inst✝ : W.HasLeftCalculusOfFractions
ψ₁ : W.LeftFraction X Y
hψ₁ : φ.fst.f ≫ ψ₁.s = φ.fst.s ≫ ψ₁.f
ψ₂ : W.LeftFraction X Y
hψ₂ : φ.snd.f ≫ ψ₂.s = φ.snd.s ≫ ψ₂.f
α : W.LeftFraction ψ₁.Y' ψ₂.Y'
hα : (RightFraction.mk ψ₁.s ⋯ ψ₂.s).f ≫ α.s = (RightFraction.mk ψ₁.s ⋯ ψ₂.s).s ≫ α.f
⊢ ∃ ψ, φ.f ≫ ψ.s = φ.s ≫ ψ.f ∧ φ.f' ≫ ψ.s = φ.s ≫ ψ.f'

obtain ⟨α, hα⟩ := (RightFraction.mk _ ψ₁.hs ψ₂.s).exists_leftFraction

case intro.intro.intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.15006, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
X Y : C
φ : W.RightFraction₂ X Y
inst✝ : W.HasLeftCalculusOfFractions
ψ₁ : W.LeftFraction X Y
hψ₁ : φ.f ≫ ψ₁.s = φ.s ≫ ψ₁.f
ψ₂ : W.LeftFraction X Y
hψ₂ : φ.f' ≫ ψ₂.s = φ.s ≫ ψ₂.f
α : W.LeftFraction ψ₁.Y' ψ₂.Y'
hα : ψ₂.s ≫ α.s = ψ₁.s ≫ α.f
⊢ ∃ ψ, φ.f ≫ ψ.s = φ.s ≫ ψ.f ∧ φ.f' ≫ ψ.s = φ.s ≫ ψ.f'

case intro.intro.intro.refine_1
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.15006, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
X Y : C
φ : W.RightFraction₂ X Y
inst✝ : W.HasLeftCalculusOfFractions
ψ₁ : W.LeftFraction X Y
hψ₁ : φ.f ≫ ψ₁.s = φ.s ≫ ψ₁.f
ψ₂ : W.LeftFraction X Y
hψ₂ : φ.f' ≫ ψ₂.s = φ.s ≫ ψ₂.f
α : W.LeftFraction ψ₁.Y' ψ₂.Y'
hα : ψ₂.s ≫ α.s = ψ₁.s ≫ α.f
⊢ φ.f ≫ (LeftFraction₂.mk (ψ₁.f ≫ α.f) (ψ₂.f ≫ α.s) (ψ₂.s ≫ α.s) ⋯).s =
    φ.s ≫ (LeftFraction₂.mk (ψ₁.f ≫ α.f) (ψ₂.f ≫ α.s) (ψ₂.s ≫ α.s) ⋯).f

case intro.intro.intro.refine_2
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.15006, u_2} D
L : C ⥤ D
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
X Y : C
φ : W.RightFraction₂ X Y
inst✝ : W.HasLeftCalculusOfFractions
ψ₁ : W.LeftFraction X Y
hψ₁ : φ.f ≫ ψ₁.s = φ.s ≫ ψ₁.f
ψ₂ : W.LeftFraction X Y
hψ₂ : φ.f' ≫ ψ₂.s = φ.s ≫ ψ₂.f
α : W.LeftFraction ψ₁.Y' ψ₂.Y'
hα : ψ₂.s ≫ α.s = ψ₁.s ≫ α.f
⊢ φ.f' ≫ (LeftFraction₂.mk (ψ₁.f ≫ α.f) (ψ₂.f ≫ α.s) (ψ₂.s ≫ α.s) ⋯).s =
    φ.s ≫ (LeftFraction₂.mk (ψ₁.f ≫ α.f) (ψ₂.f ≫ α.s) (ψ₂.s ≫ α.s) ⋯).f'

refine ⟨LeftFraction₂.mk (ψ₁.f ≫ α.f) (ψ₂.f ≫ α.s) (ψ₂.s ≫ α.s)
      (W.comp_mem _ _ ψ₂.hs α.hs), ?_, ?_⟩


n : ℕ
hn : n ≠ 0
x : ℝ≥0∞
⊢ (x ^ n) ^ (↑n)⁻¹ = x

rw [← rpow_natCast, ← rpow_mul, mul_inv_cancel (by positivity), rpow_one]


𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
b : E × F → G
u : Set (E × F)
h : IsBoundedBilinearMap 𝕜 b
p : E × F
⊢ HasStrictFDerivAt b (h.deriv p) p

𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
b : E × F → G
u : Set (E × F)
h : IsBoundedBilinearMap 𝕜 b
p : E × F
⊢ (fun p_1 => b p_1.1 - b p_1.2 - (h.deriv p) (p_1.1 - p_1.2)) =o[𝓝 (p, p)] fun p => p.1 - p.2

𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
b : E × F → G
u : Set (E × F)
h : IsBoundedBilinearMap 𝕜 b
p : E × F
⊢ ((fun p_1 => b p_1.1 - b p_1.2 - (h.deriv p) (p_1.1 - p_1.2)) ∘ fun x => (p, p) + x) =o[𝓝 0]
    ((fun p => p.1 - p.2) ∘ fun x => (p, p) + x)

simp only [← map_add_left_nhds_zero (p, p), isLittleO_map]

𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
b : E × F → G
u : Set (E × F)
h : IsBoundedBilinearMap 𝕜 b
p : E × F
T : Type (max u_3 u_2) := (E × F) × E × F
⊢ ((fun p_1 => b p_1.1 - b p_1.2 - (h.deriv p) (p_1.1 - p_1.2)) ∘ fun x => (p, p) + x) =o[𝓝 0]
    ((fun p => p.1 - p.2) ∘ fun x => (p, p) + x)


α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ✝ : Type u_5
E : Type u_6
inst✝⁸ : MeasurableSpace α
inst✝⁷ : MeasurableSpace α'
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace β'
inst✝⁴ : MeasurableSpace γ✝
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ✝
inst✝³ : NormedAddCommGroup E
γ : Type u_7
inst✝² : TopologicalSpace γ
inst✝¹ : SFinite μ
inst✝ : SFinite ν
f : β × α → γ
hf : AEStronglyMeasurable f (ν.prod μ)
⊢ AEStronglyMeasurable (fun z => f z.swap) (μ.prod ν)

α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ✝ : Type u_5
E : Type u_6
inst✝⁸ : MeasurableSpace α
inst✝⁷ : MeasurableSpace α'
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace β'
inst✝⁴ : MeasurableSpace γ✝
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ✝
inst✝³ : NormedAddCommGroup E
γ : Type u_7
inst✝² : TopologicalSpace γ
inst✝¹ : SFinite μ
inst✝ : SFinite ν
f : β × α → γ
hf : AEStronglyMeasurable f (map Prod.swap (μ.prod ν))
⊢ AEStronglyMeasurable (fun z => f z.swap) (μ.prod ν)


α✝ : Sort u_1
β✝ : Sort u_2
α β : Sort u_3
h : α = β
⊢ Bijective h.mpr

case refl
α✝ : Sort u_1
β : Sort u_2
α : Sort u_3
⊢ Bijective ⋯.mpr


α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
p : PMF α
b : β
⊢ map (Function.const α b) p = pure b

simp only [map, Function.comp, bind_const, Function.const]


ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π : Prepartition I
⊢ ∃ π', π'.iUnion = ↑I \ π.iUnion

case intro
ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π : Prepartition I
s : Finset (ι × ℝ)
hs : π ⊓ splitMany I s = (splitMany I s).filter fun J => ↑J ⊆ π.iUnion
⊢ ∃ π', π'.iUnion = ↑I \ π.iUnion

rcases π.eventually_splitMany_inf_eq_filter.exists with ⟨s, hs⟩

case h
ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π : Prepartition I
s : Finset (ι × ℝ)
hs : π ⊓ splitMany I s = (splitMany I s).filter fun J => ↑J ⊆ π.iUnion
⊢ ((splitMany I s).filter fun J => ¬↑J ⊆ π.iUnion).iUnion = ↑I \ π.iUnion

use (splitMany I s).filter fun J => ¬(J : Set (ι → ℝ)) ⊆ π.iUnion


F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝⁵ : Monoid β
inst✝⁴ : Monoid γ
inst✝³ : FunLike F β γ
M : ι → Type u_6
inst✝² : (i : ι) → Monoid (M i)
inst✝¹ : Finite ι
inst✝ : DecidableEq ι
f g : ((i : ι) → M i) →* γ
h : ∀ (i : ι) (x : M i), f (Pi.mulSingle i x) = g (Pi.mulSingle i x)
⊢ f = g

case intro
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝⁵ : Monoid β
inst✝⁴ : Monoid γ
inst✝³ : FunLike F β γ
M : ι → Type u_6
inst✝² : (i : ι) → Monoid (M i)
inst✝¹ : Finite ι
inst✝ : DecidableEq ι
f g : ((i : ι) → M i) →* γ
h : ∀ (i : ι) (x : M i), f (Pi.mulSingle i x) = g (Pi.mulSingle i x)
val✝ : Fintype ι
⊢ f = g

case intro.h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝⁵ : Monoid β
inst✝⁴ : Monoid γ
inst✝³ : FunLike F β γ
M : ι → Type u_6
inst✝² : (i : ι) → Monoid (M i)
inst✝¹ : Finite ι
inst✝ : DecidableEq ι
f g : ((i : ι) → M i) →* γ
h : ∀ (i : ι) (x : M i), f (Pi.mulSingle i x) = g (Pi.mulSingle i x)
val✝ : Fintype ι
x : (i : ι) → M i
⊢ f x = g x

case intro.h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝⁵ : Monoid β
inst✝⁴ : Monoid γ
inst✝³ : FunLike F β γ
M : ι → Type u_6
inst✝² : (i : ι) → Monoid (M i)
inst✝¹ : Finite ι
inst✝ : DecidableEq ι
f g : ((i : ι) → M i) →* γ
h : ∀ (i : ι) (x : M i), f (Pi.mulSingle i x) = g (Pi.mulSingle i x)
val✝ : Fintype ι
x : (i : ι) → M i
⊢ univ.noncommProd (fun i => f (Pi.mulSingle i (x i))) ⋯ = univ.noncommProd (fun i => g (Pi.mulSingle i (x i))) ⋯

rw [← noncommProd_mul_single x, univ.map_noncommProd, univ.map_noncommProd]

case intro.h.e_f.h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝⁵ : Monoid β
inst✝⁴ : Monoid γ
inst✝³ : FunLike F β γ
M : ι → Type u_6
inst✝² : (i : ι) → Monoid (M i)
inst✝¹ : Finite ι
inst✝ : DecidableEq ι
f g : ((i : ι) → M i) →* γ
h : ∀ (i : ι) (x : M i), f (Pi.mulSingle i x) = g (Pi.mulSingle i x)
val✝ : Fintype ι
x : (i : ι) → M i
i : ι
⊢ f (Pi.mulSingle i (x i)) = g (Pi.mulSingle i (x i))


ι : Type u_1
α : Type u_2
β : Type u_3
l : Filter α
s t : Set α
ht : t.Finite
⊢ cofinite ⊓ 𝓟 (s \ t) = cofinite ⊓ 𝓟 s

rw [diff_eq, ← inf_principal, ← inf_assoc, inf_right_comm, ht.cofinite_inf_principal_compl]


R : Type u
M : Type v
inst✝⁴ : DivisionSemiring R
inst✝³ : AddCommGroup M
inst✝² : Module Rᵐᵒᵖ M
inst✝¹ : Module R M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
⊢ 0⁻¹ = 0

rw [← inl_zero, TrivSqZeroExt.inv_inl, inv_zero]


n : ℕ
α β γ : TypeVec.{u} n
F : TypeVec.{u} n → Type v
inst✝¹ : MvFunctor F
P : α ⟹ TypeVec.repeat n Prop
R : α ⊗ α ⟹ TypeVec.repeat n Prop
inst✝ : LawfulMvFunctor F
x y : F α
⊢ ∀ (u : F fun i => { p // (fun i x y => ofRepeat (R i (prod.mk i x y))) i p.1 p.2 }),
    (fun i t => (↑t).1) <$$> u = x ∧ (fun i t => (↑t).2) <$$> u = y ↔
      (prod.fst ⊚ subtypeVal R) <$$> toSubtype' R <$$> u = x ∧ (prod.snd ⊚ subtypeVal R) <$$> toSubtype' R <$$> u = y

n : ℕ
α β γ : TypeVec.{u} n
F : TypeVec.{u} n → Type v
inst✝¹ : MvFunctor F
P : α ⟹ TypeVec.repeat n Prop
R : α ⊗ α ⟹ TypeVec.repeat n Prop
inst✝ : LawfulMvFunctor F
x y : F α
⊢ ∀ (u : F fun i => { p // ofRepeat (R i (prod.mk i p.1 p.2)) }),
    (fun i t => (↑t).1) <$$> u = x ∧ (fun i t => (↑t).2) <$$> u = y ↔
      (prod.fst ⊚ fun i x => prod.mk i (↑x).1 (↑x).2) <$$> u = x ∧
        (prod.snd ⊚ fun i x => prod.mk i (↑x).1 (↑x).2) <$$> u = y

simp only [map_map, comp_assoc, subtypeVal_toSubtype']

simp (config := { unfoldPartialApp := true }) [comp]


C : Type u
inst✝ : Category.{v, u} C
A F : Cᵒᵖ ⥤ Type v
η : F ⟶ A
X Y : C
f : X ⟶ Y
s : yoneda.obj X ⟶ A
t : yoneda.obj Y ⟶ A
hst : yoneda.map f ≫ t = s
u : F.obj (op Y)
h : MakesOverArrow η t u
⊢ η.app (op X) (F.map f.op u) = yonedaEquiv s

rw [elementwise_of% η.naturality, h.app, yonedaEquiv_naturality, hst]


R : Type u_1
inst✝³ : Semiring R
r : R
p : R[X]
S : Type u_2
inst✝² : AddCommMonoid S
inst✝¹ : Pow S ℕ
inst✝ : MulActionWithZero R S
x : S
n : ℕ
⊢ ((monomial n) r).smeval x = r • x ^ n

simp only [smeval_eq_sum, smul_pow, zero_smul, sum_monomial_index]


α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ toIocMod hp a (b - c) = toIocMod hp (a + c) b - c

simp_rw [toIocMod, toIocDiv_sub_eq_toIocDiv_add, sub_right_comm]


α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ rdropWhile p (l ++ [x]) = if p x = true then rdropWhile p l else l ++ [x]

α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ (match p x with
      | true => dropWhile p l.reverse
      | false => x :: l.reverse).reverse =
    if p x = true then (dropWhile p l.reverse).reverse else l ++ [x]

simp only [rdropWhile, dropWhile, reverse_append, reverse_singleton, singleton_append]


K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
e : Free.ChooseBasisIndex ℤ (𝓞 K) ≃ Free.ChooseBasisIndex ℤ ↥↑↑I
⊢ |(integralBasis K).det ⇑((basisOfFractionalIdeal K I).reindex e.symm)| = FractionalIdeal.absNorm ↑I

K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
e : Free.ChooseBasisIndex ℤ (𝓞 K) ≃ Free.ChooseBasisIndex ℤ ↥↑↑I
⊢ |(integralBasis K).det ⇑((basisOfFractionalIdeal K I).reindex e.symm)| =
    |(Basis.localizationLocalization ℚ ℤ⁰ K (RingOfIntegers.basis K)).det
        (Subtype.val ∘ ⇑((fractionalIdealBasis K ↑I).reindex e.symm))|

rw [← FractionalIdeal.abs_det_basis_change (RingOfIntegers.basis K) I.1
    ((fractionalIdealBasis K I.1).reindex e.symm)]

case e_a.h.e_6.h
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
e : Free.ChooseBasisIndex ℤ (𝓞 K) ≃ Free.ChooseBasisIndex ℤ ↥↑↑I
⊢ ⇑((basisOfFractionalIdeal K I).reindex e.symm) = Subtype.val ∘ ⇑((fractionalIdealBasis K ↑I).reindex e.symm)

case e_a.h.e_6.h.h
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
e : Free.ChooseBasisIndex ℤ (𝓞 K) ≃ Free.ChooseBasisIndex ℤ ↥↑↑I
x✝ : Free.ChooseBasisIndex ℤ (𝓞 K)
⊢ ((basisOfFractionalIdeal K I).reindex e.symm) x✝ = (Subtype.val ∘ ⇑((fractionalIdealBasis K ↑I).reindex e.symm)) x✝

simpa using basisOfFractionalIdeal_apply K I _


R : Type u_1
p : ℕ
hp : Nat.Prime p
⊢ ω p = 1

rw [← pow_one p, cardDistinctFactors_apply_prime_pow hp one_ne_zero]


α : Type u
n : ℕ
f g : Fin n → α
h : ofFn f = ofFn g
⊢ HEq f g

α : Type u
n : ℕ
f g : Fin n → α
h : ⟨n, f⟩ = ⟨n, g⟩
⊢ HEq f g

case refl
α : Type u
n : ℕ
f : Fin n → α
⊢ HEq f f


α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ ↑(upperClosure (s * t)) = ↑(upperClosure s * upperClosure t)

rw [UpperSet.coe_mul, mul_upperClosure, upperClosure_mul, UpperSet.upperClosure]


ι : Type u_1
ι' : Type u_2
R : Type u_3
K : Type u_4
A : Type u_5
A' : Type u_6
A'' : Type u_7
V : Type u
V' : Type u_8
x : ι → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a b : R
hx : AlgebraicIndependent R x
⊢ hx.mvPolynomialOptionEquivPolynomialAdjoin (X none) = Polynomial.X

rw [AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin_apply, aeval_X, Option.elim,
    Polynomial.map_X]


𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 (fun i => Ei i.castSucc) (Ei (last n) →L[𝕜] G)
m : (i : Fin n.succ) → Ei i
⊢ ‖f‖ * ((∏ i : Fin n, ‖init m i‖) * ‖m (last n)‖) = ‖f‖ * ∏ i : Fin n.succ, ‖m i‖

𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 (fun i => Ei i.castSucc) (Ei (last n) →L[𝕜] G)
m : (i : Fin n.succ) → Ei i
⊢ ‖f‖ * ((∏ i : Fin n, ‖init m i‖) * ‖m (last n)‖) = ‖f‖ * ((∏ i : Fin n, ‖m i.castSucc‖) * ‖m (last n)‖)


Fq F : Type
inst✝² : Field Fq
inst✝¹ : Field F
inst✝ : DecidableEq (RatFunc Fq)
k : Fq
hk : k ≠ 0
⊢ inftyValuationDef Fq (RatFunc.C k) = ↑(Multiplicative.ofAdd 0)

Fq F : Type
inst✝² : Field Fq
inst✝¹ : Field F
inst✝ : DecidableEq (RatFunc Fq)
k : Fq
hk : k ≠ 0
hCk : RatFunc.C k ≠ 0
⊢ inftyValuationDef Fq (RatFunc.C k) = ↑(Multiplicative.ofAdd 0)

have hCk : RatFunc.C k ≠ 0 := (map_ne_zero _).mpr hk

rw [inftyValuationDef, if_neg hCk, RatFunc.intDegree_C]


V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
v : V₁
⊢ ‖0 v‖ ≤ ‖v‖


C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasZeroMorphisms C
X Y : C
P : Subobject Y
h : P.Factors 0
⊢ P.factorThru 0 h = 0


R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝¹ : OrthogonalIdempotents e
inst✝ : Fintype I
he✝ : CompleteOrthogonalIdempotents e
h : ∀ x ∈ RingHom.ker f, IsNilpotent x
he : ∀ (i : I), IsIdempotentElem (e i)
he' : ∀ (i : I), IsMulCentral (e i)
he'' : CompleteOrthogonalIdempotents (⇑f ∘ e)
⊢ CompleteOrthogonalIdempotents e

case intro.intro
R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝¹ : OrthogonalIdempotents e
inst✝ : Fintype I
he✝ : CompleteOrthogonalIdempotents e
h : ∀ x ∈ RingHom.ker f, IsNilpotent x
he : ∀ (i : I), IsIdempotentElem (e i)
he' : ∀ (i : I), IsMulCentral (e i)
he'' : CompleteOrthogonalIdempotents (⇑f ∘ e)
e' : I → R
h₁ : CompleteOrthogonalIdempotents e'
h₂ : ⇑f ∘ e' = ⇑f ∘ e
⊢ CompleteOrthogonalIdempotents e

obtain ⟨e', h₁, h₂⟩ := lift_of_isNilpotent_ker f h he'' (fun _ ↦ ⟨_, rfl⟩)

case intro.intro
R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝¹ : OrthogonalIdempotents e
inst✝ : Fintype I
he✝ : CompleteOrthogonalIdempotents e
h : ∀ x ∈ RingHom.ker f, IsNilpotent x
he : ∀ (i : I), IsIdempotentElem (e i)
he' : ∀ (i : I), IsMulCentral (e i)
he'' : CompleteOrthogonalIdempotents (⇑f ∘ e)
h₁ : CompleteOrthogonalIdempotents e
h₂ : ⇑f ∘ e = ⇑f ∘ e
⊢ CompleteOrthogonalIdempotents e

obtain rfl : e = e' := by
    ext i
    refine eq_of_isNilpotent_sub_of_isIdempotentElem_of_commute
      (he _) (h₁.idem _) (h _ ?_) ((he' i).comm _)
    simpa [RingHom.mem_ker, sub_eq_zero] using congr_fun h₂.symm i


α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : MetricSpace E
f : ℕ → α → E
g : α → E
hfg : TendstoInMeasure μ f atTop g
n : ℕ
⊢ ∃ N, ∀ m_1 ≥ N, μ {x | 2⁻¹ ^ n ≤ dist (f m_1 x) (g x)} ≤ 2⁻¹ ^ n

α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : MetricSpace E
f : ℕ → α → E
g : α → E
n : ℕ
hfg : Tendsto (fun i => μ {x | 2⁻¹ ^ n ≤ dist (f i x) (g x)}) atTop (𝓝 0)
⊢ ∃ N, ∀ m_1 ≥ N, μ {x | 2⁻¹ ^ n ≤ dist (f m_1 x) (g x)} ≤ 2⁻¹ ^ n

specialize hfg ((2⁻¹ : ℝ) ^ n) (by simp only [Real.rpow_natCast, inv_pos, zero_lt_two, pow_pos])

α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : MetricSpace E
f : ℕ → α → E
g : α → E
n : ℕ
hfg : ∀ ε > 0, ∃ N, ∀ n_1 ≥ N, μ {x | 2⁻¹ ^ n ≤ dist (f n_1 x) (g x)} ≤ ε
⊢ ∃ N, ∀ m_1 ≥ N, μ {x | 2⁻¹ ^ n ≤ dist (f m_1 x) (g x)} ≤ 2⁻¹ ^ n

exact hfg ((2 : ℝ≥0∞)⁻¹ ^ n) (pos_iff_ne_zero.mpr fun h_zero => by simpa using pow_eq_zero h_zero)


R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Ring R
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ⇑f
n : ℕ
⊢ Disjoint (f.tailing i n) (OrderDual.ofDual ((f.tunnel i) (n + 1)))

R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Ring R
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ⇑f
n : ℕ
⊢ f.tailing i n ⊓ OrderDual.ofDual ((f.tunnel i) (n + 1)) = ⊥

R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Ring R
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ⇑f
n : ℕ
⊢ Submodule.map (f.tunnelAux (f.tunnel' i n)) (Submodule.snd R M N) ⊓
      Submodule.map (f.tunnelAux (f.tunnel' i n)) (Submodule.fst R M N) =
    ⊥

erw [Submodule.map_inf_eq_map_inf_comap,
    Submodule.comap_map_eq_of_injective (tunnelAux_injective _ i _), inf_comm,
    Submodule.fst_inf_snd, Submodule.map_bot]


α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
H : a / b = c / d
⊢ a = b ↔ c = d


R : Type u_1
inst✝⁴ : AddCommGroupWithOne R
inst✝³ : PartialOrder R
inst✝² : CovariantClass R R (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : ZeroLEOneClass R
inst✝ : NeZero 1
⊢ Monotone Int.cast

R : Type u_1
inst✝⁴ : AddCommGroupWithOne R
inst✝³ : PartialOrder R
inst✝² : CovariantClass R R (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : ZeroLEOneClass R
inst✝ : NeZero 1
m n : ℤ
h : m ≤ n
⊢ ↑m ≤ ↑n

R : Type u_1
inst✝⁴ : AddCommGroupWithOne R
inst✝³ : PartialOrder R
inst✝² : CovariantClass R R (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : ZeroLEOneClass R
inst✝ : NeZero 1
m n : ℤ
h : 0 ≤ n - m
⊢ ↑m ≤ ↑n

case intro
R : Type u_1
inst✝⁴ : AddCommGroupWithOne R
inst✝³ : PartialOrder R
inst✝² : CovariantClass R R (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : ZeroLEOneClass R
inst✝ : NeZero 1
m n : ℤ
k : ℕ
hk : ↑k = n - m
⊢ ↑m ≤ ↑n

case intro
R : Type u_1
inst✝⁴ : AddCommGroupWithOne R
inst✝³ : PartialOrder R
inst✝² : CovariantClass R R (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : ZeroLEOneClass R
inst✝ : NeZero 1
m n : ℤ
k : ℕ
hk : ↑k = n - m
⊢ 0 ≤ ↑k

rw [← sub_nonneg, ← cast_sub, ← hk, cast_natCast]


R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
s : ↥S
p : LocalizedModule S M
x✝² x✝¹ : M × ↥S
a : M
b : ↥S
a' : M
b' : ↥S
x✝ : (a, b) ≈ (a', b')
c : ↥S
eq1 : c • (a', b').2 • (a, b).1 = c • (a, b).2 • (a', b').1
⊢ c • ((a', b').2 * s) • (a, b).1 = c • ((a, b).2 * s) • (a', b').1

rw [mul_smul, mul_smul, smul_comm _ s, smul_comm _ s, eq1, smul_comm _ s,
        smul_comm _ s]

R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
s : ↥S
x y : LocalizedModule S M
⊢ (fun p => p.liftOn (fun p => mk p.1 (p.2 * s)) ⋯) (x + y) =
    (fun p => p.liftOn (fun p => mk p.1 (p.2 * s)) ⋯) x + (fun p => p.liftOn (fun p => mk p.1 (p.2 * s)) ⋯) y

R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
s : ↥S
x y : LocalizedModule S M
⊢ ∀ (m m' : M) (s_1 s' : ↥S),
    (fun p => p.liftOn (fun p => mk p.1 (p.2 * s)) ⋯) (mk m s_1 + mk m' s') =
      (fun p => p.liftOn (fun p => mk p.1 (p.2 * s)) ⋯) (mk m s_1) +
        (fun p => p.liftOn (fun p => mk p.1 (p.2 * s)) ⋯) (mk m' s')

R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
s : ↥S
x y : LocalizedModule S M
m₁ m₂ : M
t₁ t₂ : ↥S
⊢ (fun p => p.liftOn (fun p => mk p.1 (p.2 * s)) ⋯) (mk m₁ t₁ + mk m₂ t₂) =
    (fun p => p.liftOn (fun p => mk p.1 (p.2 * s)) ⋯) (mk m₁ t₁) +
      (fun p => p.liftOn (fun p => mk p.1 (p.2 * s)) ⋯) (mk m₂ t₂)

simp_rw [mk_add_mk, LocalizedModule.liftOn_mk, mk_add_mk, mul_smul, mul_comm _ s, mul_assoc,
      smul_comm _ s, ← smul_add, mul_left_comm s t₁ t₂, mk_cancel_common_left s]

R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
s : ↥S
r : R
x : LocalizedModule S M
⊢ { toFun := fun p => p.liftOn (fun p => mk p.1 (p.2 * s)) ⋯, map_add' := ⋯ }.toFun (r • x) =
    (RingHom.id R) r • { toFun := fun p => p.liftOn (fun p => mk p.1 (p.2 * s)) ⋯, map_add' := ⋯ }.toFun x

R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
s : ↥S
r : R
x : LocalizedModule S M
x✝¹ : M
x✝ : ↥S
⊢ { toFun := fun p => p.liftOn (fun p => mk p.1 (p.2 * s)) ⋯, map_add' := ⋯ }.toFun (r • mk x✝¹ x✝) =
    (RingHom.id R) r • { toFun := fun p => p.liftOn (fun p => mk p.1 (p.2 * s)) ⋯, map_add' := ⋯ }.toFun (mk x✝¹ x✝)

R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
s : ↥S
r : R
x : LocalizedModule S M
x✝¹ : M
x✝ : ↥S
⊢ (r • mk x✝¹ x✝).liftOn (fun p => mk p.1 (p.2 * s)) ⋯ =
    (RingHom.id R) r • (mk x✝¹ x✝).liftOn (fun p => mk p.1 (p.2 * s)) ⋯

R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
s : ↥S
r : R
x : LocalizedModule S M
x✝¹ : M
x✝ : ↥S
⊢ (mk ((IsLocalization.sec S (↑(algebraMap R (Localization S)).toMonoidWithZeroHom r)).1 • (x✝¹, x✝).1)
          ((IsLocalization.sec S (↑(algebraMap R (Localization S)).toMonoidWithZeroHom r)).2 * (x✝¹, x✝).2)).liftOn
      (fun p => mk p.1 (p.2 * s)) ⋯ =
    r • (mk x✝¹ x✝).liftOn (fun p => mk p.1 (p.2 * s)) ⋯

change liftOn (mk _ _) _ _ = r • (liftOn (mk _ _) _ _)

R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
s : ↥S
r : R
x : LocalizedModule S M
x✝¹ : M
x✝ : ↥S
⊢ { toFun := (↑↑(algebraMap R (Localization S))).toFun, map_zero' := ⋯ } r • mk x✝¹ (x✝ * s) = r • mk x✝¹ (x✝ * s)

simp_rw [liftOn_mk, mul_assoc, ← smul_def]


C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ (fun i j k => t' 𝒰 f g i j k) i j k ≫
      pullback.snd ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) j k)
        ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) j i) =
    pullback.fst ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) i j)
        ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) i k) ≫
      (fun i j => t 𝒰 f g i j) i j

case h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ ((fun i j k => t' 𝒰 f g i j k) i j k ≫
        pullback.snd ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) j k)
          ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) j i)) ≫
      pullback.fst (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) =
    (pullback.fst ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) i j)
          ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) i k) ≫
        (fun i j => t 𝒰 f g i j) i j) ≫
      pullback.fst (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i)

case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ ((fun i j k => t' 𝒰 f g i j k) i j k ≫
        pullback.snd ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) j k)
          ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) j i)) ≫
      pullback.snd (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) =
    (pullback.fst ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) i j)
          ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) i k) ≫
        (fun i j => t 𝒰 f g i j) i j) ≫
      pullback.snd (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i)

case h₀.h₀
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ (((fun i j k => t' 𝒰 f g i j k) i j k ≫
          pullback.snd ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) j k)
            ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) j i)) ≫
        pullback.fst (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i)) ≫
      pullback.fst (𝒰.map j ≫ f) g =
    ((pullback.fst ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) i j)
            ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) i k) ≫
          (fun i j => t 𝒰 f g i j) i j) ≫
        pullback.fst (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i)) ≫
      pullback.fst (𝒰.map j ≫ f) g

case h₀.h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ (((fun i j k => t' 𝒰 f g i j k) i j k ≫
          pullback.snd ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) j k)
            ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) j i)) ≫
        pullback.fst (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i)) ≫
      pullback.snd (𝒰.map j ≫ f) g =
    ((pullback.fst ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) i j)
            ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) i k) ≫
          (fun i j => t 𝒰 f g i j) i j) ≫
        pullback.fst (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i)) ≫
      pullback.snd (𝒰.map j ≫ f) g

case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ ((fun i j k => t' 𝒰 f g i j k) i j k ≫
        pullback.snd ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) j k)
          ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) j i)) ≫
      pullback.snd (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) =
    (pullback.fst ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) i j)
          ((fun i j => pullback.fst (pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) (𝒰.map j)) i k) ≫
        (fun i j => t 𝒰 f g i j) i j) ≫
      pullback.snd (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i)

all_goals
      simp only [t'_snd_fst_fst, t'_snd_fst_snd, t'_snd_snd, t_fst_fst, t_fst_snd, t_snd,
        Category.assoc]


n : ℕ
i a b : Fin (n + 1)
hab : a ≤ b
H : {i, a, b}.card ≤ n
⊢ Λ[n, i] _[1]

case range
n : ℕ
i a b : Fin (n + 1)
hab : a ≤ b
H : {i, a, b}.card ≤ n
⊢ Set.range ⇑(asOrderHom (standardSimplex.edge n a b hab)) ∪ {i} ≠ Set.univ

refine ⟨standardSimplex.edge n a b hab, ?range⟩

case range =>
    suffices ∃ x, ¬i = x ∧ ¬a = x ∧ ¬b = x by
      simpa only [unop_op, SimplexCategory.len_mk, asOrderHom, SimplexCategory.Hom.toOrderHom_mk,
        Set.union_singleton, ne_eq, ← Set.univ_subset_iff, Set.subset_def, Set.mem_univ,
        Set.mem_insert_iff, @eq_comm _ _ i, Set.mem_range, forall_true_left, not_forall, not_or,
        not_exists, Fin.forall_fin_two]
    contrapose! H
    replace H : univ ⊆ {i, a, b} :=
      fun x _ ↦ by simpa [or_iff_not_imp_left, eq_comm] using H x
    replace H := card_le_card H
    rwa [card_fin] at H


G : Type u_1
inst✝¹ : Group G
ι : Type u_2
hdec : DecidableEq ι
hfin : Fintype ι
H : ι → Type u_3
inst✝ : (i : ι) → Group (H i)
ϕ : (i : ι) → H i →* G
f g : (i : ι) → H i
hcomm : Pairwise fun i j => ∀ (x : H i) (y : H j), Commute ((ϕ i) x) ((ϕ j) y)
hind : CompleteLattice.Independent fun i => (ϕ i).range
hinj : ∀ (i : ι), Function.Injective ⇑(ϕ i)
⊢ Function.Injective ⇑(noncommPiCoprod ϕ hcomm)

classical
    apply (MonoidHom.ker_eq_bot_iff _).mp
    rw [eq_bot_iff]
    intro f heq1
    have : ∀ i, i ∈ Finset.univ → ϕ i (f i) = 1 :=
      Subgroup.eq_one_of_noncommProd_eq_one_of_independent _ _ (fun _ _ _ _ h => hcomm h _ _)
        _ hind (by simp) heq1
    ext i
    apply hinj
    simp [this i (Finset.mem_univ i)]


𝕜 : Type u
inst✝⁵ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
E : Type w
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s✝ t : Set 𝕜
L L₁ L₂ : Filter 𝕜
inst✝ : SeparableSpace 𝕜
f : 𝕜 → F
s : Set 𝕜
⊢ IsSeparable (range (derivWithin f s))

case intro.intro.intro
𝕜 : Type u
inst✝⁵ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
E : Type w
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s✝ t✝ : Set 𝕜
L L₁ L₂ : Filter 𝕜
inst✝ : SeparableSpace 𝕜
f : 𝕜 → F
s t : Set 𝕜
ts : t ⊆ s
t_count : t.Countable
ht : s ⊆ closure t
⊢ IsSeparable (range (derivWithin f s))

obtain ⟨t, ts, t_count, ht⟩ : ∃ t, t ⊆ s ∧ Set.Countable t ∧ s ⊆ closure t :=
    (IsSeparable.of_separableSpace s).exists_countable_dense_subset

case intro.intro.intro
𝕜 : Type u
inst✝⁵ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
E : Type w
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s✝ t✝ : Set 𝕜
L L₁ L₂ : Filter 𝕜
inst✝ : SeparableSpace 𝕜
f : 𝕜 → F
s t : Set 𝕜
ts : t ⊆ s
t_count : t.Countable
ht : s ⊆ closure t
this : s ⊆ closure (s ∩ t)
⊢ IsSeparable (range (derivWithin f s))

have : s ⊆ closure (s ∩ t) := by rwa [inter_eq_self_of_subset_right ts]

𝕜 : Type u
inst✝⁵ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
E : Type w
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s✝ t✝ : Set 𝕜
L L₁ L₂ : Filter 𝕜
inst✝ : SeparableSpace 𝕜
f : 𝕜 → F
s t : Set 𝕜
ts : t ⊆ s
t_count : t.Countable
ht : s ⊆ closure t
this : s ⊆ closure (s ∩ t)
⊢ IsSeparable (closure ↑(Submodule.span 𝕜 (f '' t)))

apply IsSeparable.mono _ (range_derivWithin_subset_closure_span_image f this)

exact (Countable.image t_count f).isSeparable.span.closure


X : Scheme
𝒰 : X.OpenCover
x y z : 𝒰.J
⊢ 𝒰.gluedCoverT' x y z ≫
      pullback.snd (pullback.fst (𝒰.map y) (𝒰.map z)) (pullback.fst (𝒰.map y) (𝒰.map x)) ≫
        pullback.snd (𝒰.map y) (𝒰.map x) =
    pullback.fst (pullback.fst (𝒰.map x) (𝒰.map y)) (pullback.fst (𝒰.map x) (𝒰.map z)) ≫
      pullback.fst (𝒰.map x) (𝒰.map y)

X : Scheme
𝒰 : X.OpenCover
x y z : 𝒰.J
⊢ ((pullbackRightPullbackFstIso (𝒰.map x) (𝒰.map z) (pullback.fst (𝒰.map x) (𝒰.map y))).hom ≫
        (pullback.map (pullback.fst (𝒰.map x) (𝒰.map y) ≫ 𝒰.map x) (𝒰.map z)
              (pullback.fst (𝒰.map y) (𝒰.map x) ≫ 𝒰.map y) (𝒰.map z) (pullbackSymmetry (𝒰.map x) (𝒰.map y)).hom
              (𝟙 (𝒰.obj z)) (𝟙 X) ⋯ ⋯ ≫
            (pullbackRightPullbackFstIso (𝒰.map y) (𝒰.map z) (pullback.fst (𝒰.map y) (𝒰.map x))).inv) ≫
          (pullbackSymmetry (pullback.fst (𝒰.map y) (𝒰.map x)) (pullback.fst (𝒰.map y) (𝒰.map z))).hom) ≫
      pullback.snd (pullback.fst (𝒰.map y) (𝒰.map z)) (pullback.fst (𝒰.map y) (𝒰.map x)) ≫
        pullback.snd (𝒰.map y) (𝒰.map x) =
    pullback.fst (pullback.fst (𝒰.map x) (𝒰.map y)) (pullback.fst (𝒰.map x) (𝒰.map z)) ≫
      pullback.fst (𝒰.map x) (𝒰.map y)


⊢ 2 • ↑π = 0