l3lab/ntp-mathlib huggingface dataset:
/-- The five lemma. -/
theorem isIso_of_epi_of_isIso_of_isIso_of_mono (h₀ : Epi (app' φ 0)) (h₁ : IsIso (app' φ 1))
    (h₂ : IsIso (app' φ 3)) (h₃ : Mono (app' φ 4)) : IsIso (app' φ 2) := by
  dsimp at h₀ h₁ h₂ h₃
  have : Mono (app' φ 2) := by
    apply mono_of_epi_of_mono_of_mono (δlastFunctor.map φ) (R₁.exact_iff_δlast.1 hR₁).1
      (R₂.exact_iff_δlast.1 hR₂).1 <;> dsimp <;> infer_instance
  have : Epi (app' φ 2) := by
    apply epi_of_epi_of_epi_of_mono (δ₀Functor.map φ) (R₁.exact_iff_δ₀.1 hR₁).2
      (R₂.exact_iff_δ₀.1 hR₂).2 <;> dsimp <;> 

Proof state:
case h₃
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
R₁ R₂ : ComposableArrows C 4
hR₁ : ComposableArrows.Exact R₁
hR₂ : ComposableArrows.Exact R₂
φ : R₁ ⟶ R₂
h₀ : Epi (φ.app 0)
h₁ : IsIso (φ.app 1)
h₂ : IsIso (φ.app { val := 3, isLt := (_ : 3 < 4 + 1) })
h₃ : Mono (φ.app { val := 4, isLt := (_ : 4 < 4 + 1) })
this : Mono (app' φ 2)
⊢ Mono (φ.app { val := 3 + 1, isLt := (_ : Nat.succ 3 < Nat.succ (3 + 1)) })

Next tactic:
infer_instance
/-- The five lemma. -/
theorem isIso_of_epi_of_isIso_of_isIso_of_mono (h₀ : Epi (app' φ 0)) (h₁ : IsIso (app' φ 1))
    (h₂ : IsIso (app' φ 3)) (h₃ : Mono (app' φ 4)) : IsIso (app' φ 2) := by
  dsimp at h₀ h₁ h₂ h₃
  have : Mono (app' φ 2) := by
    apply mono_of_epi_of_mono_of_mono (δlastFunctor.map φ) (R₁.exact_iff_δlast.1 hR₁).1
      (R₂.exact_iff_δlast.1 hR₂).1 <;> dsimp <;> infer_instance
  have : Epi (app' φ 2) := by
    apply epi_of_epi_of_epi_of_mono (δ₀Functor.map φ) (R₁.exact_iff_δ₀.1 hR₁).2
      (R₂.exact_iff_δ₀.1 hR₂).2 <;> dsimp <;> infer_instance
  

Proof state:
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
R₁ R₂ : ComposableArrows C 4
hR₁ : ComposableArrows.Exact R₁
hR₂ : ComposableArrows.Exact R₂
φ : R₁ ⟶ R₂
h₀ : Epi (φ.app 0)
h₁ : IsIso (φ.app 1)
h₂ : IsIso (φ.app { val := 3, isLt := (_ : 3 < 4 + 1) })
h₃ : Mono (φ.app { val := 4, isLt := (_ : 4 < 4 + 1) })
this✝ : Mono (app' φ 2)
this : Epi (app' φ 2)
⊢ IsIso (app' φ 2)

Next tactic:
apply isIso_of_mono_of_epi
instance : AddGroupWithOne (α × β) :=
  { Prod.instAddMonoidWithOne, Prod.instAddGroup with
    intCast := fun n => (n, n)
    intCast_ofNat := fun _ => by 

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : AddGroupWithOne α
inst✝ : AddGroupWithOne β
src✝¹ : AddMonoidWithOne (α × β) := instAddMonoidWithOne
src✝ : AddGroup (α × β) := instAddGroup
x✝ : ℕ
⊢ IntCast.intCast ↑x✝ = ↑x✝

Next tactic:
simp
instance : AddGroupWithOne (α × β) :=
  { Prod.instAddMonoidWithOne, Prod.instAddGroup with
    intCast := fun n => (n, n)
    intCast_ofNat := fun _ => by simp; 

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : AddGroupWithOne α
inst✝ : AddGroupWithOne β
src✝¹ : AddMonoidWithOne (α × β) := instAddMonoidWithOne
src✝ : AddGroup (α × β) := instAddGroup
x✝ : ℕ
⊢ (↑x✝, ↑x✝) = ↑x✝

Next tactic:
rfl
instance : AddGroupWithOne (α × β) :=
  { Prod.instAddMonoidWithOne, Prod.instAddGroup with
    intCast := fun n => (n, n)
    intCast_ofNat := fun _ => by simp; rfl
    intCast_negSucc := fun _ => by 

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : AddGroupWithOne α
inst✝ : AddGroupWithOne β
src✝¹ : AddMonoidWithOne (α × β) := instAddMonoidWithOne
src✝ : AddGroup (α × β) := instAddGroup
x✝ : ℕ
⊢ IntCast.intCast (Int.negSucc x✝) = -↑(x✝ + 1)

Next tactic:
simp
instance : AddGroupWithOne (α × β) :=
  { Prod.instAddMonoidWithOne, Prod.instAddGroup with
    intCast := fun n => (n, n)
    intCast_ofNat := fun _ => by simp; rfl
    intCast_negSucc := fun _ => by simp; 

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : AddGroupWithOne α
inst✝ : AddGroupWithOne β
src✝¹ : AddMonoidWithOne (α × β) := instAddMonoidWithOne
src✝ : AddGroup (α × β) := instAddGroup
x✝ : ℕ
⊢ (-1 + -↑x✝, -1 + -↑x✝) = -1 + -↑x✝

Next tactic:
rfl
/-- The braided structure on a full subcategory inherited by the braided structure on `C`.
-/
instance fullBraidedSubcategory : BraidedCategory (FullSubcategory P) :=
  braidedCategoryOfFaithful (fullMonoidalSubcategoryInclusion P)
    (fun X Y =>
      ⟨(β_ X.1 Y.1).hom, (β_ X.1 Y.1).inv, (β_ X.1 Y.1).hom_inv_id, (β_ X.1 Y.1).inv_hom_id⟩)
    fun X Y => by 

Proof state:
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
X Y : FullSubcategory P
⊢ LaxMonoidalFunctor.μ (fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor X Y ≫
      (fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor.toFunctor.map
        ((fun X Y => Iso.mk (β_ X.obj Y.obj).hom (β_ X.obj Y.obj).inv) X Y).hom =
    (β_ ((fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor.toFunctor.obj X)
          ((fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor.toFunctor.obj Y)).hom ≫
      LaxMonoidalFunctor.μ (fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor Y X

Next tactic:
aesop_cat
/-- The forgetful braided functor from a full braided subcategory into the original category
("forgetting" the condition).
-/
@[simps!]
def fullBraidedSubcategoryInclusion : BraidedFunctor (FullSubcategory P) C where
  toMonoidalFunctor := fullMonoidalSubcategoryInclusion P
  braided X Y := by 

Proof state:
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor.toFunctor.map (β_ X Y).hom =
    inv (LaxMonoidalFunctor.μ (fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor X Y) ≫
      (β_ ((fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor.toFunctor.obj X)
            ((fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor.toFunctor.obj Y)).hom ≫
        LaxMonoidalFunctor.μ (fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor Y X

Next tactic:
rw [IsIso.eq_inv_comp]
/-- The forgetful braided functor from a full braided subcategory into the original category
("forgetting" the condition).
-/
@[simps!]
def fullBraidedSubcategoryInclusion : BraidedFunctor (FullSubcategory P) C where
  toMonoidalFunctor := fullMonoidalSubcategoryInclusion P
  braided X Y := by rw [IsIso.eq_inv_comp]; 

Proof state:
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
X Y : FullSubcategory P
⊢ LaxMonoidalFunctor.μ (fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor X Y ≫
      (fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor.toFunctor.map (β_ X Y).hom =
    (β_ ((fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor.toFunctor.obj X)
          ((fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor.toFunctor.obj Y)).hom ≫
      LaxMonoidalFunctor.μ (fullMonoidalSubcategoryInclusion P).toLaxMonoidalFunctor Y X

Next tactic:
aesop_cat
/-- An implication of predicates `P → P'` induces a braided functor between full braided
subcategories. -/
@[simps!]
def fullBraidedSubcategory.map (h : ∀ ⦃X⦄, P X → P' X) :
    BraidedFunctor (FullSubcategory P) (FullSubcategory P') where
  toMonoidalFunctor := fullMonoidalSubcategory.map h
  braided X Y := by 

Proof state:
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
h : ∀ ⦃X : C⦄, P X → P' X
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategory.map h).toLaxMonoidalFunctor.toFunctor.map (β_ X Y).hom =
    inv (LaxMonoidalFunctor.μ (fullMonoidalSubcategory.map h).toLaxMonoidalFunctor X Y) ≫
      (β_ ((fullMonoidalSubcategory.map h).toLaxMonoidalFunctor.toFunctor.obj X)
            ((fullMonoidalSubcategory.map h).toLaxMonoidalFunctor.toFunctor.obj Y)).hom ≫
        LaxMonoidalFunctor.μ (fullMonoidalSubcategory.map h).toLaxMonoidalFunctor Y X

Next tactic:
rw [IsIso.eq_inv_comp]
/-- An implication of predicates `P → P'` induces a braided functor between full braided
subcategories. -/
@[simps!]
def fullBraidedSubcategory.map (h : ∀ ⦃X⦄, P X → P' X) :
    BraidedFunctor (FullSubcategory P) (FullSubcategory P') where
  toMonoidalFunctor := fullMonoidalSubcategory.map h
  braided X Y := by rw [IsIso.eq_inv_comp]; 

Proof state:
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
h : ∀ ⦃X : C⦄, P X → P' X
X Y : FullSubcategory P
⊢ LaxMonoidalFunctor.μ (fullMonoidalSubcategory.map h).toLaxMonoidalFunctor X Y ≫
      (fullMonoidalSubcategory.map h).toLaxMonoidalFunctor.toFunctor.map (β_ X Y).hom =
    (β_ ((fullMonoidalSubcategory.map h).toLaxMonoidalFunctor.toFunctor.obj X)
          ((fullMonoidalSubcategory.map h).toLaxMonoidalFunctor.toFunctor.obj Y)).hom ≫
      LaxMonoidalFunctor.μ (fullMonoidalSubcategory.map h).toLaxMonoidalFunctor Y X

Next tactic:
aesop_cat
instance fullMonoidalClosedSubcategory : MonoidalClosed (FullSubcategory P) where
  closed X :=
  { isAdj :=
    { right :=
        FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.1) fun Y => prop_ihom X.2 Y.2
      adj :=
        Adjunction.mkOfUnitCounit
        { unit :=
          { app := fun Y => (ihom.coev X.1).app Y.1
            naturality := fun Y Z f => ihom.coev_naturality X.1 f }
          counit :=
          { app := fun Y => (ihom.ev X.1).app Y.1
            naturality := fun Y Z f => ihom.ev_naturality X.1 f }
          left_triangle := by 

Proof state:
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
P : C → Prop
inst✝³ : MonoidalPredicate P
P' : C → Prop
inst✝² : MonoidalPredicate P'
inst✝¹ : MonoidalClosed C
inst✝ : ClosedPredicate P
X : FullSubcategory P
⊢ CategoryTheory.whiskerRight (NatTrans.mk fun Y => (ihom.coev X.obj).app Y.obj) (tensorLeft X) ≫
      (Functor.associator (tensorLeft X)
            (FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.obj)
              (_ : ∀ (Y : FullSubcategory P), P ((ihom X.obj).obj ((fullSubcategoryInclusion P).obj Y))))
            (tensorLeft X)).hom ≫
        CategoryTheory.whiskerLeft (tensorLeft X) (NatTrans.mk fun Y => (ihom.ev X.obj).app Y.obj) =
    NatTrans.id (𝟭 (FullSubcategory P) ⋙ tensorLeft X)

Next tactic:
ext Y
instance fullMonoidalClosedSubcategory : MonoidalClosed (FullSubcategory P) where
  closed X :=
  { isAdj :=
    { right :=
        FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.1) fun Y => prop_ihom X.2 Y.2
      adj :=
        Adjunction.mkOfUnitCounit
        { unit :=
          { app := fun Y => (ihom.coev X.1).app Y.1
            naturality := fun Y Z f => ihom.coev_naturality X.1 f }
          counit :=
          { app := fun Y => (ihom.ev X.1).app Y.1
            naturality := fun Y Z f => ihom.ev_naturality X.1 f }
          left_triangle := by ext Y; 

Proof state:
case w.h
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
P : C → Prop
inst✝³ : MonoidalPredicate P
P' : C → Prop
inst✝² : MonoidalPredicate P'
inst✝¹ : MonoidalClosed C
inst✝ : ClosedPredicate P
X Y : FullSubcategory P
⊢ (CategoryTheory.whiskerRight (NatTrans.mk fun Y => (ihom.coev X.obj).app Y.obj) (tensorLeft X) ≫
          (Functor.associator (tensorLeft X)
                (FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.obj)
                  (_ : ∀ (Y : FullSubcategory P), P ((ihom X.obj).obj ((fullSubcategoryInclusion P).obj Y))))
                (tensorLeft X)).hom ≫
            CategoryTheory.whiskerLeft (tensorLeft X) (NatTrans.mk fun Y => (ihom.ev X.obj).app Y.obj)).app
      Y =
    (NatTrans.id (𝟭 (FullSubcategory P) ⋙ tensorLeft X)).app Y

Next tactic:
simp [FullSubcategory.comp_def, FullSubcategory.id_def]
instance fullMonoidalClosedSubcategory : MonoidalClosed (FullSubcategory P) where
  closed X :=
  { isAdj :=
    { right :=
        FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.1) fun Y => prop_ihom X.2 Y.2
      adj :=
        Adjunction.mkOfUnitCounit
        { unit :=
          { app := fun Y => (ihom.coev X.1).app Y.1
            naturality := fun Y Z f => ihom.coev_naturality X.1 f }
          counit :=
          { app := fun Y => (ihom.ev X.1).app Y.1
            naturality := fun Y Z f => ihom.ev_naturality X.1 f }
          left_triangle := by ext Y; simp [FullSubcategory.comp_def, FullSubcategory.id_def]
          right_triangle := by 

Proof state:
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
P : C → Prop
inst✝³ : MonoidalPredicate P
P' : C → Prop
inst✝² : MonoidalPredicate P'
inst✝¹ : MonoidalClosed C
inst✝ : ClosedPredicate P
X : FullSubcategory P
⊢ CategoryTheory.whiskerLeft
        (FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.obj)
          (_ : ∀ (Y : FullSubcategory P), P ((ihom X.obj).obj ((fullSubcategoryInclusion P).obj Y))))
        (NatTrans.mk fun Y => (ihom.coev X.obj).app Y.obj) ≫
      (Functor.associator
            (FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.obj)
              (_ : ∀ (Y : FullSubcategory P), P ((ihom X.obj).obj ((fullSubcategoryInclusion P).obj Y))))
            (tensorLeft X)
            (FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.obj)
              (_ : ∀ (Y : FullSubcategory P), P ((ihom X.obj).obj ((fullSubcategoryInclusion P).obj Y))))).inv ≫
        CategoryTheory.whiskerRight (NatTrans.mk fun Y => (ihom.ev X.obj).app Y.obj)
          (FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.obj)
            (_ : ∀ (Y : FullSubcategory P), P ((ihom X.obj).obj ((fullSubcategoryInclusion P).obj Y)))) =
    NatTrans.id
      (FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.obj)
          (_ : ∀ (Y : FullSubcategory P), P ((ihom X.obj).obj ((fullSubcategoryInclusion P).obj Y))) ⋙
        𝟭 (FullSubcategory P))

Next tactic:
ext Y
instance fullMonoidalClosedSubcategory : MonoidalClosed (FullSubcategory P) where
  closed X :=
  { isAdj :=
    { right :=
        FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.1) fun Y => prop_ihom X.2 Y.2
      adj :=
        Adjunction.mkOfUnitCounit
        { unit :=
          { app := fun Y => (ihom.coev X.1).app Y.1
            naturality := fun Y Z f => ihom.coev_naturality X.1 f }
          counit :=
          { app := fun Y => (ihom.ev X.1).app Y.1
            naturality := fun Y Z f => ihom.ev_naturality X.1 f }
          left_triangle := by ext Y; simp [FullSubcategory.comp_def, FullSubcategory.id_def]
          right_triangle := by ext Y; 

Proof state:
case w.h
C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
P : C → Prop
inst✝³ : MonoidalPredicate P
P' : C → Prop
inst✝² : MonoidalPredicate P'
inst✝¹ : MonoidalClosed C
inst✝ : ClosedPredicate P
X Y : FullSubcategory P
⊢ (CategoryTheory.whiskerLeft
            (FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.obj)
              (_ : ∀ (Y : FullSubcategory P), P ((ihom X.obj).obj ((fullSubcategoryInclusion P).obj Y))))
            (NatTrans.mk fun Y => (ihom.coev X.obj).app Y.obj) ≫
          (Functor.associator
                (FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.obj)
                  (_ : ∀ (Y : FullSubcategory P), P ((ihom X.obj).obj ((fullSubcategoryInclusion P).obj Y))))
                (tensorLeft X)
                (FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.obj)
                  (_ : ∀ (Y : FullSubcategory P), P ((ihom X.obj).obj ((fullSubcategoryInclusion P).obj Y))))).inv ≫
            CategoryTheory.whiskerRight (NatTrans.mk fun Y => (ihom.ev X.obj).app Y.obj)
              (FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.obj)
                (_ : ∀ (Y : FullSubcategory P), P ((ihom X.obj).obj ((fullSubcategoryInclusion P).obj Y))))).app
      Y =
    (NatTrans.id
          (FullSubcategory.lift P (fullSubcategoryInclusion P ⋙ ihom X.obj)
              (_ : ∀ (Y : FullSubcategory P), P ((ihom X.obj).obj ((fullSubcategoryInclusion P).obj Y))) ⋙
            𝟭 (FullSubcategory P))).app
      Y

Next tactic:
simp [FullSubcategory.comp_def, FullSubcategory.id_def]
/-- Obtain a measure by giving a countably additive function that sends `∅` to `0`. -/
def ofMeasurable (m : ∀ s : Set α, MeasurableSet s → ℝ≥0∞) (m0 : m ∅ MeasurableSet.empty = 0)
    (mU :
      ∀ ⦃f : ℕ → Set α⦄ (h : ∀ i, MeasurableSet (f i)),
        Pairwise (Disjoint on f) → m (⋃ i, f i) (MeasurableSet.iUnion h) = ∑' i, m (f i) (h i)) :
    Measure α :=
  { inducedOuterMeasure m _ m0 with
    m_iUnion := fun f hf hd =>
      show inducedOuterMeasure m _ m0 (iUnion f) = ∑' i, inducedOuterMeasure m _ m0 (f i) by
        

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
m : (s : Set α) → MeasurableSet s → ℝ≥0∞
m0 : m ∅ (_ : MeasurableSet ∅) = 0
mU :
  ∀ ⦃f : ℕ → Set α⦄ (h : ∀ (i : ℕ), MeasurableSet (f i)),
    Pairwise (Disjoint on f) →
      m (⋃ i, f i) (_ : MeasurableSet (⋃ b, f b)) = ∑' (i : ℕ), m (f i) (_ : MeasurableSet (f i))
src✝ : OuterMeasure α := inducedOuterMeasure m (_ : MeasurableSet ∅) m0
f : ℕ → Set α
hf : ∀ (i : ℕ), MeasurableSet (f i)
hd : Pairwise (Disjoint on f)
⊢ ↑(inducedOuterMeasure m (_ : MeasurableSet ∅) m0) (iUnion f) =
    ∑' (i : ℕ), ↑(inducedOuterMeasure m (_ : MeasurableSet ∅) m0) (f i)

Next tactic:
rw [inducedOuterMeasure_eq m0 mU, mU hf hd]
/-- Obtain a measure by giving a countably additive function that sends `∅` to `0`. -/
def ofMeasurable (m : ∀ s : Set α, MeasurableSet s → ℝ≥0∞) (m0 : m ∅ MeasurableSet.empty = 0)
    (mU :
      ∀ ⦃f : ℕ → Set α⦄ (h : ∀ i, MeasurableSet (f i)),
        Pairwise (Disjoint on f) → m (⋃ i, f i) (MeasurableSet.iUnion h) = ∑' i, m (f i) (h i)) :
    Measure α :=
  { inducedOuterMeasure m _ m0 with
    m_iUnion := fun f hf hd =>
      show inducedOuterMeasure m _ m0 (iUnion f) = ∑' i, inducedOuterMeasure m _ m0 (f i) by
        rw [inducedOuterMeasure_eq m0 mU, mU hf hd]
        

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
m : (s : Set α) → MeasurableSet s → ℝ≥0∞
m0 : m ∅ (_ : MeasurableSet ∅) = 0
mU :
  ∀ ⦃f : ℕ → Set α⦄ (h : ∀ (i : ℕ), MeasurableSet (f i)),
    Pairwise (Disjoint on f) →
      m (⋃ i, f i) (_ : MeasurableSet (⋃ b, f b)) = ∑' (i : ℕ), m (f i) (_ : MeasurableSet (f i))
src✝ : OuterMeasure α := inducedOuterMeasure m (_ : MeasurableSet ∅) m0
f : ℕ → Set α
hf : ∀ (i : ℕ), MeasurableSet (f i)
hd : Pairwise (Disjoint on f)
⊢ ∑' (i : ℕ), m (f i) (_ : MeasurableSet (f i)) = ∑' (i : ℕ), ↑(inducedOuterMeasure m (_ : MeasurableSet ∅) m0) (f i)

Next tactic:
congr
/-- Obtain a measure by giving a countably additive function that sends `∅` to `0`. -/
def ofMeasurable (m : ∀ s : Set α, MeasurableSet s → ℝ≥0∞) (m0 : m ∅ MeasurableSet.empty = 0)
    (mU :
      ∀ ⦃f : ℕ → Set α⦄ (h : ∀ i, MeasurableSet (f i)),
        Pairwise (Disjoint on f) → m (⋃ i, f i) (MeasurableSet.iUnion h) = ∑' i, m (f i) (h i)) :
    Measure α :=
  { inducedOuterMeasure m _ m0 with
    m_iUnion := fun f hf hd =>
      show inducedOuterMeasure m _ m0 (iUnion f) = ∑' i, inducedOuterMeasure m _ m0 (f i) by
        rw [inducedOuterMeasure_eq m0 mU, mU hf hd]
        congr; 

Proof state:
case e_f
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
m : (s : Set α) → MeasurableSet s → ℝ≥0∞
m0 : m ∅ (_ : MeasurableSet ∅) = 0
mU :
  ∀ ⦃f : ℕ → Set α⦄ (h : ∀ (i : ℕ), MeasurableSet (f i)),
    Pairwise (Disjoint on f) →
      m (⋃ i, f i) (_ : MeasurableSet (⋃ b, f b)) = ∑' (i : ℕ), m (f i) (_ : MeasurableSet (f i))
src✝ : OuterMeasure α := inducedOuterMeasure m (_ : MeasurableSet ∅) m0
f : ℕ → Set α
hf : ∀ (i : ℕ), MeasurableSet (f i)
hd : Pairwise (Disjoint on f)
⊢ (fun i => m (f i) (_ : MeasurableSet (f i))) = fun i => ↑(inducedOuterMeasure m (_ : MeasurableSet ∅) m0) (f i)

Next tactic:
funext n
/-- Obtain a measure by giving a countably additive function that sends `∅` to `0`. -/
def ofMeasurable (m : ∀ s : Set α, MeasurableSet s → ℝ≥0∞) (m0 : m ∅ MeasurableSet.empty = 0)
    (mU :
      ∀ ⦃f : ℕ → Set α⦄ (h : ∀ i, MeasurableSet (f i)),
        Pairwise (Disjoint on f) → m (⋃ i, f i) (MeasurableSet.iUnion h) = ∑' i, m (f i) (h i)) :
    Measure α :=
  { inducedOuterMeasure m _ m0 with
    m_iUnion := fun f hf hd =>
      show inducedOuterMeasure m _ m0 (iUnion f) = ∑' i, inducedOuterMeasure m _ m0 (f i) by
        rw [inducedOuterMeasure_eq m0 mU, mU hf hd]
        congr; funext n; 

Proof state:
case e_f.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
m : (s : Set α) → MeasurableSet s → ℝ≥0∞
m0 : m ∅ (_ : MeasurableSet ∅) = 0
mU :
  ∀ ⦃f : ℕ → Set α⦄ (h : ∀ (i : ℕ), MeasurableSet (f i)),
    Pairwise (Disjoint on f) →
      m (⋃ i, f i) (_ : MeasurableSet (⋃ b, f b)) = ∑' (i : ℕ), m (f i) (_ : MeasurableSet (f i))
src✝ : OuterMeasure α := inducedOuterMeasure m (_ : MeasurableSet ∅) m0
f : ℕ → Set α
hf : ∀ (i : ℕ), MeasurableSet (f i)
hd : Pairwise (Disjoint on f)
n : ℕ
⊢ m (f n) (_ : MeasurableSet (f n)) = ↑(inducedOuterMeasure m (_ : MeasurableSet ∅) m0) (f n)

Next tactic:
rw [inducedOuterMeasure_eq m0 mU]
/-- Obtain a measure by giving a countably additive function that sends `∅` to `0`. -/
def ofMeasurable (m : ∀ s : Set α, MeasurableSet s → ℝ≥0∞) (m0 : m ∅ MeasurableSet.empty = 0)
    (mU :
      ∀ ⦃f : ℕ → Set α⦄ (h : ∀ i, MeasurableSet (f i)),
        Pairwise (Disjoint on f) → m (⋃ i, f i) (MeasurableSet.iUnion h) = ∑' i, m (f i) (h i)) :
    Measure α :=
  { inducedOuterMeasure m _ m0 with
    m_iUnion := fun f hf hd =>
      show inducedOuterMeasure m _ m0 (iUnion f) = ∑' i, inducedOuterMeasure m _ m0 (f i) by
        rw [inducedOuterMeasure_eq m0 mU, mU hf hd]
        congr; funext n; rw [inducedOuterMeasure_eq m0 mU]
    trimmed :=
      show (inducedOuterMeasure m _ m0).trim = inducedOuterMeasure m _ m0 by
        

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
m : (s : Set α) → MeasurableSet s → ℝ≥0∞
m0 : m ∅ (_ : MeasurableSet ∅) = 0
mU :
  ∀ ⦃f : ℕ → Set α⦄ (h : ∀ (i : ℕ), MeasurableSet (f i)),
    Pairwise (Disjoint on f) →
      m (⋃ i, f i) (_ : MeasurableSet (⋃ b, f b)) = ∑' (i : ℕ), m (f i) (_ : MeasurableSet (f i))
src✝ : OuterMeasure α := inducedOuterMeasure m (_ : MeasurableSet ∅) m0
⊢ OuterMeasure.trim (inducedOuterMeasure m (_ : MeasurableSet ∅) m0) = inducedOuterMeasure m (_ : MeasurableSet ∅) m0

Next tactic:
unfold OuterMeasure.trim
/-- Obtain a measure by giving a countably additive function that sends `∅` to `0`. -/
def ofMeasurable (m : ∀ s : Set α, MeasurableSet s → ℝ≥0∞) (m0 : m ∅ MeasurableSet.empty = 0)
    (mU :
      ∀ ⦃f : ℕ → Set α⦄ (h : ∀ i, MeasurableSet (f i)),
        Pairwise (Disjoint on f) → m (⋃ i, f i) (MeasurableSet.iUnion h) = ∑' i, m (f i) (h i)) :
    Measure α :=
  { inducedOuterMeasure m _ m0 with
    m_iUnion := fun f hf hd =>
      show inducedOuterMeasure m _ m0 (iUnion f) = ∑' i, inducedOuterMeasure m _ m0 (f i) by
        rw [inducedOuterMeasure_eq m0 mU, mU hf hd]
        congr; funext n; rw [inducedOuterMeasure_eq m0 mU]
    trimmed :=
      show (inducedOuterMeasure m _ m0).trim = inducedOuterMeasure m _ m0 by
        unfold OuterMeasure.trim
        

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
m : (s : Set α) → MeasurableSet s → ℝ≥0∞
m0 : m ∅ (_ : MeasurableSet ∅) = 0
mU :
  ∀ ⦃f : ℕ → Set α⦄ (h : ∀ (i : ℕ), MeasurableSet (f i)),
    Pairwise (Disjoint on f) →
      m (⋃ i, f i) (_ : MeasurableSet (⋃ b, f b)) = ∑' (i : ℕ), m (f i) (_ : MeasurableSet (f i))
src✝ : OuterMeasure α := inducedOuterMeasure m (_ : MeasurableSet ∅) m0
⊢ inducedOuterMeasure (fun s x => ↑(inducedOuterMeasure m (_ : MeasurableSet ∅) m0) s) (_ : MeasurableSet ∅)
      (_ : ↑(inducedOuterMeasure m (_ : MeasurableSet ∅) m0) ∅ = 0) =
    inducedOuterMeasure m (_ : MeasurableSet ∅) m0

Next tactic:
congr