[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t : Set α
s : ℕ → Set (NullMeasurableSpace α)
hs : ∀ (i : ℕ), (fun s => ∃ t, MeasurableSet t ∧ s =ᵐ[μ] t) (s i)
⊢ (fun s => ∃ t, MeasurableSet t ∧ s =ᵐ[μ] t) (⋃ (i : ℕ), s i)
[PROOFSTEP]
choose t htm hts using hs
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t✝ : Set α
s : ℕ → Set (NullMeasurableSpace α)
t : ℕ → Set α
htm : ∀ (i : ℕ), MeasurableSet (t i)
hts : ∀ (i : ℕ), s i =ᵐ[μ] t i
⊢ ∃ t, MeasurableSet t ∧ ⋃ (i : ℕ), s i =ᵐ[μ] t
[PROOFSTEP]
exact ⟨⋃ i, t i, MeasurableSet.iUnion htm, EventuallyEq.countable_iUnion hts⟩
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t : Set α
s : Set (Set α)
hs : Set.Countable s
h : ∀ (t : Set α), t ∈ s → NullMeasurableSet t
⊢ NullMeasurableSet (⋃₀ s)
[PROOFSTEP]
rw [sUnion_eq_biUnion]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t : Set α
s : Set (Set α)
hs : Set.Countable s
h : ∀ (t : Set α), t ∈ s → NullMeasurableSet t
⊢ NullMeasurableSet (⋃ (i : Set α) (_ : i ∈ s), i)
[PROOFSTEP]
exact MeasurableSet.biUnion hs h
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
h : NullMeasurableSet s
⊢ ∃ t x, MeasurableSet t ∧ t =ᵐ[μ] s
[PROOFSTEP]
rcases h with ⟨t, htm, hst⟩
[GOAL]
case intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᵐ[μ] t
⊢ ∃ t x, MeasurableSet t ∧ t =ᵐ[μ] s
[PROOFSTEP]
refine' ⟨t ∪ toMeasurable μ (s \ t), _, htm.union (measurableSet_toMeasurable _ _), _⟩
[GOAL]
case intro.intro.refine'_1
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᵐ[μ] t
⊢ t ∪ toMeasurable μ (s \ t) ⊇ s
[PROOFSTEP]
exact diff_subset_iff.1 (subset_toMeasurable _ _)
[GOAL]
case intro.intro.refine'_2
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᵐ[μ] t
⊢ t ∪ toMeasurable μ (s \ t) =ᵐ[μ] s
[PROOFSTEP]
have : toMeasurable μ (s \ t) =ᵐ[μ] (∅ : Set α) := by simp [ae_le_set.1 hst.le]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᵐ[μ] t
⊢ toMeasurable μ (s \ t) =ᵐ[μ] ∅
[PROOFSTEP]
simp [ae_le_set.1 hst.le]
[GOAL]
case intro.intro.refine'_2
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ t : Set α
htm : MeasurableSet t
hst : s =ᵐ[μ] t
this : toMeasurable μ (s \ t) =ᵐ[μ] ∅
⊢ t ∪ toMeasurable μ (s \ t) =ᵐ[μ] s
[PROOFSTEP]
simpa only [union_empty] using hst.symm.union this
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
h : NullMeasurableSet s
⊢ toMeasurable μ s =ᵐ[μ] s
[PROOFSTEP]
rw [toMeasurable_def, dif_pos]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
h : NullMeasurableSet s
⊢ Exists.choose ?hc =ᵐ[μ] s
case hc
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
h : NullMeasurableSet s
⊢ ∃ t x, MeasurableSet t ∧ t =ᵐ[μ] s
[PROOFSTEP]
exact (exists_measurable_superset_ae_eq h).choose_spec.snd.2
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t : Set α
inst✝ : Countable ι
s : ι → Set α
h : ∀ (i : ι), NullMeasurableSet (s i)
hd : Pairwise (AEDisjoint μ on s)
⊢ ∃ t, (∀ (i : ι), t i ⊆ s i) ∧ (∀ (i : ι), s i =ᵐ[μ] t i) ∧ (∀ (i : ι), MeasurableSet (t i)) ∧ Pairwise (Disjoint on t)
[PROOFSTEP]
choose t ht_sub htm ht_eq using fun i => exists_measurable_subset_ae_eq (h i)
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
h : ∀ (i : ι), NullMeasurableSet (s i)
hd : Pairwise (AEDisjoint μ on s)
t : ι → Set α
ht_sub : ∀ (i : ι), t i ⊆ s i
htm : ∀ (i : ι), MeasurableSet (t i)
ht_eq : ∀ (i : ι), t i =ᵐ[μ] s i
⊢ ∃ t, (∀ (i : ι), t i ⊆ s i) ∧ (∀ (i : ι), s i =ᵐ[μ] t i) ∧ (∀ (i : ι), MeasurableSet (t i)) ∧ Pairwise (Disjoint on t)
[PROOFSTEP]
rcases exists_null_pairwise_disjoint_diff hd with ⟨u, hum, hu₀, hud⟩
[GOAL]
case intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
h : ∀ (i : ι), NullMeasurableSet (s i)
hd : Pairwise (AEDisjoint μ on s)
t : ι → Set α
ht_sub : ∀ (i : ι), t i ⊆ s i
htm : ∀ (i : ι), MeasurableSet (t i)
ht_eq : ∀ (i : ι), t i =ᵐ[μ] s i
u : ι → Set α
hum : ∀ (i : ι), MeasurableSet (u i)
hu₀ : ∀ (i : ι), ↑↑μ (u i) = 0
hud : Pairwise (Disjoint on fun i => s i \ u i)
⊢ ∃ t, (∀ (i : ι), t i ⊆ s i) ∧ (∀ (i : ι), s i =ᵐ[μ] t i) ∧ (∀ (i : ι), MeasurableSet (t i)) ∧ Pairwise (Disjoint on t)
[PROOFSTEP]
exact
  ⟨fun i => t i \ u i, fun i => (diff_subset _ _).trans (ht_sub _), fun i =>
    (ht_eq _).symm.trans (diff_null_ae_eq_self (hu₀ i)).symm, fun i => (htm i).diff (hum i),
    hud.mono fun i j h => h.mono (diff_subset_diff_left (ht_sub i)) (diff_subset_diff_left (ht_sub j))⟩
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0✝ : MeasurableSpace α
μ✝ : Measure α
s t : Set α
m0 : MeasurableSpace α
μ : Measure α
inst✝ : Countable ι
f : ι → Set α
hn : Pairwise (Disjoint on f)
h : ∀ (i : ι), MeasurableSet (f i)
⊢ ↑↑μ (⋃ (i : ι), f i) = ∑' (i : ι), ↑↑μ (f i)
[PROOFSTEP]
rw [measure_eq_extend (MeasurableSet.iUnion h), extend_iUnion MeasurableSet.empty _ MeasurableSet.iUnion _ hn h]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0✝ : MeasurableSpace α
μ✝ : Measure α
s t : Set α
m0 : MeasurableSpace α
μ : Measure α
inst✝ : Countable ι
f : ι → Set α
hn : Pairwise (Disjoint on f)
h : ∀ (i : ι), MeasurableSet (f i)
⊢ ∑' (i : ι), extend (fun t _ht => ↑↑μ t) (f i) = ∑' (i : ι), ↑↑μ (f i)
[PROOFSTEP]
simp [measure_eq_extend, h]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0✝ : MeasurableSpace α
μ✝ : Measure α
s t : Set α
m0 : MeasurableSpace α
μ : Measure α
inst✝ : Countable ι
f : ι → Set α
hn : Pairwise (Disjoint on f)
h : ∀ (i : ι), MeasurableSet (f i)
⊢ ↑↑μ ∅ = 0
[PROOFSTEP]
exact μ.empty
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0✝ : MeasurableSpace α
μ✝ : Measure α
s t : Set α
m0 : MeasurableSpace α
μ : Measure α
inst✝ : Countable ι
f : ι → Set α
hn : Pairwise (Disjoint on f)
h : ∀ (i : ι), MeasurableSet (f i)
⊢ ∀ ⦃f : ℕ → Set α⦄,
    (∀ (i : ℕ), MeasurableSet (f i)) → Pairwise (Disjoint on f) → ↑↑μ (⋃ (i : ℕ), f i) = ∑' (i : ℕ), ↑↑μ (f i)
[PROOFSTEP]
exact μ.m_iUnion
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝ : Countable ι
f : ι → Set α
hd : Pairwise (AEDisjoint μ on f)
h : ∀ (i : ι), NullMeasurableSet (f i)
⊢ ↑↑μ (⋃ (i : ι), f i) = ∑' (i : ι), ↑↑μ (f i)
[PROOFSTEP]
rcases exists_subordinate_pairwise_disjoint h hd with ⟨t, _ht_sub, ht_eq, htm, htd⟩
[GOAL]
case intro.intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ : Set α
inst✝ : Countable ι
f : ι → Set α
hd : Pairwise (AEDisjoint μ on f)
h : ∀ (i : ι), NullMeasurableSet (f i)
t : ι → Set α
_ht_sub : ∀ (i : ι), t i ⊆ f i
ht_eq : ∀ (i : ι), f i =ᵐ[μ] t i
htm : ∀ (i : ι), MeasurableSet (t i)
htd : Pairwise (Disjoint on t)
⊢ ↑↑μ (⋃ (i : ι), f i) = ∑' (i : ι), ↑↑μ (f i)
[PROOFSTEP]
calc
  μ (⋃ i, f i) = μ (⋃ i, t i) := measure_congr (EventuallyEq.countable_iUnion ht_eq)
  _ = ∑' i, μ (t i) := (measure_iUnion htd htm)
  _ = ∑' i, μ (f i) := tsum_congr fun i => measure_congr (ht_eq _).symm
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hs : NullMeasurableSet s
ht : NullMeasurableSet t
hd : AEDisjoint μ s t
⊢ ↑↑μ (s ∪ t) = ↑↑μ s + ↑↑μ t
[PROOFSTEP]
rw [union_eq_iUnion, measure_iUnion₀, tsum_fintype, Fintype.sum_bool, cond, cond]
[GOAL]
case hd
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hs : NullMeasurableSet s
ht : NullMeasurableSet t
hd : AEDisjoint μ s t
⊢ Pairwise (AEDisjoint μ on fun b => bif b then s else t)
case h
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hs : NullMeasurableSet s
ht : NullMeasurableSet t
hd : AEDisjoint μ s t
⊢ ∀ (i : Bool), NullMeasurableSet (bif i then s else t)
[PROOFSTEP]
exacts [(pairwise_on_bool AEDisjoint.symmetric).2 hd, fun b => Bool.casesOn b ht hs]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t
⊢ ↑↑μ (s ∩ t) + ↑↑μ (s \ t) = ↑↑μ s
[PROOFSTEP]
refine' le_antisymm _ _
[GOAL]
case refine'_1
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t
⊢ ↑↑μ (s ∩ t) + ↑↑μ (s \ t) ≤ ↑↑μ s
[PROOFSTEP]
rcases exists_measurable_superset μ s with ⟨s', hsub, hs'm, hs'⟩
[GOAL]
case refine'_1.intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t
s' : Set α
hsub : s ⊆ s'
hs'm : MeasurableSet s'
hs' : ↑↑μ s' = ↑↑μ s
⊢ ↑↑μ (s ∩ t) + ↑↑μ (s \ t) ≤ ↑↑μ s
[PROOFSTEP]
replace hs'm : NullMeasurableSet s' μ := hs'm.nullMeasurableSet
[GOAL]
case refine'_1.intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t
s' : Set α
hsub : s ⊆ s'
hs' : ↑↑μ s' = ↑↑μ s
hs'm : NullMeasurableSet s'
⊢ ↑↑μ (s ∩ t) + ↑↑μ (s \ t) ≤ ↑↑μ s
[PROOFSTEP]
calc
  μ (s ∩ t) + μ (s \ t) ≤ μ (s' ∩ t) + μ (s' \ t) :=
    add_le_add (measure_mono <| inter_subset_inter_left _ hsub) (measure_mono <| diff_subset_diff_left hsub)
  _ = μ (s' ∩ t ∪ s' \ t) :=
    (measure_union₀_aux (hs'm.inter ht) (hs'm.diff ht) <| (@disjoint_inf_sdiff _ s' t _).aedisjoint).symm
  _ = μ s' := (congr_arg μ (inter_union_diff _ _))
  _ = μ s := hs'
[GOAL]
case refine'_2
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t
⊢ ↑↑μ s ≤ ↑↑μ (s ∩ t) + ↑↑μ (s \ t)
[PROOFSTEP]
calc
  μ s = μ (s ∩ t ∪ s \ t) := by rw [inter_union_diff]
  _ ≤ μ (s ∩ t) + μ (s \ t) := measure_union_le _ _
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t
⊢ ↑↑μ s = ↑↑μ (s ∩ t ∪ s \ t)
[PROOFSTEP]
rw [inter_union_diff]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
ht : NullMeasurableSet t
⊢ ↑↑μ (s ∪ t) + ↑↑μ (s ∩ t) = ↑↑μ s + ↑↑μ t
[PROOFSTEP]
rw [← measure_inter_add_diff₀ (s ∪ t) ht, union_inter_cancel_right, union_diff_right, ← measure_inter_add_diff₀ s ht,
  add_comm, ← add_assoc, add_right_comm]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ : Set α
hs : NullMeasurableSet s
t : Set α
⊢ ↑↑μ (s ∪ t) + ↑↑μ (s ∩ t) = ↑↑μ s + ↑↑μ t
[PROOFSTEP]
rw [union_comm, inter_comm, measure_union_add_inter₀ t hs, add_comm]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
ht : NullMeasurableSet t
hd : AEDisjoint μ s t
⊢ ↑↑μ (s ∪ t) = ↑↑μ s + ↑↑μ t
[PROOFSTEP]
rw [← measure_union_add_inter₀ s ht, hd, add_zero]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hs : NullMeasurableSet s
hd : AEDisjoint μ s t
⊢ ↑↑μ (s ∪ t) = ↑↑μ s + ↑↑μ t
[PROOFSTEP]
rw [union_comm, measure_union₀ hs (AEDisjoint.symm hd), add_comm]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t s : Set α
hs : NullMeasurableSet s
⊢ ↑↑μ s + ↑↑μ sᶜ = ↑↑μ univ
[PROOFSTEP]
rw [← measure_union₀' hs aedisjoint_compl_right, union_compl_self]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t : Set α
inst✝ : MeasurableSingletonClass (NullMeasurableSpace α)
s : Finset α
⊢ NullMeasurableSet ↑s
[PROOFSTEP]
apply Finset.measurableSet
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
μ : Measure α
g : α → β
hf : NullMeasurable f
hg : f =ᵐ[μ] g
s : Set β
hs : MeasurableSet s
x : α
hx : f x = g x
⊢ x ∈ f ⁻¹' s ↔ x ∈ g ⁻¹' s
[PROOFSTEP]
rw [mem_preimage, mem_preimage, hx]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ✝ : Measure α
s t : Set α
x✝ : MeasurableSpace α
μ : Measure α
⊢ OuterMeasure.trim ↑μ = ↑μ
[PROOFSTEP]
refine' le_antisymm (fun s => _) (@OuterMeasure.le_trim (NullMeasurableSpace α μ) _ _)
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
x✝ : MeasurableSpace α
μ : Measure α
s : Set (NullMeasurableSpace α)
⊢ ↑(OuterMeasure.trim ↑μ) s ≤ ↑↑μ s
[PROOFSTEP]
rw [@OuterMeasure.trim_eq_iInf (NullMeasurableSpace α μ) _]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
x✝ : MeasurableSpace α
μ : Measure α
s : Set (NullMeasurableSpace α)
⊢ ⨅ (t : Set (NullMeasurableSpace α)) (_ : s ⊆ t) (_ : MeasurableSet t), ↑↑μ t ≤ ↑↑μ s
[PROOFSTEP]
have : ∀ s, μ.toOuterMeasure s = μ s := by simp only [forall_const]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
x✝ : MeasurableSpace α
μ : Measure α
s : Set (NullMeasurableSpace α)
⊢ ∀ (s : Set α), ↑↑μ s = ↑↑μ s
[PROOFSTEP]
simp only [forall_const]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
x✝ : MeasurableSpace α
μ : Measure α
s : Set (NullMeasurableSpace α)
this : ∀ (s : Set α), ↑↑μ s = ↑↑μ s
⊢ ⨅ (t : Set (NullMeasurableSpace α)) (_ : s ⊆ t) (_ : MeasurableSet t), ↑↑μ t ≤ ↑↑μ s
[PROOFSTEP]
rw [this, measure_eq_iInf]
[GOAL]
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
x✝ : MeasurableSpace α
μ : Measure α
s : Set (NullMeasurableSpace α)
this : ∀ (s : Set α), ↑↑μ s = ↑↑μ s
⊢ ⨅ (t : Set (NullMeasurableSpace α)) (_ : s ⊆ t) (_ : MeasurableSet t), ↑↑μ t ≤
    ⨅ (t : Set α) (_ : s ⊆ t) (_ : MeasurableSet t), ↑↑μ t
[PROOFSTEP]
apply iInf₂_mono
[GOAL]
case h
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ✝ : Measure α
s✝ t : Set α
x✝ : MeasurableSpace α
μ : Measure α
s : Set (NullMeasurableSpace α)
this : ∀ (s : Set α), ↑↑μ s = ↑↑μ s
⊢ ∀ (i : Set (NullMeasurableSpace α)), s ⊆ i → ⨅ (_ : MeasurableSet i), ↑↑μ i ≤ ⨅ (_ : MeasurableSet i), ↑↑μ i
[PROOFSTEP]
exact fun t _ht => iInf_mono' fun h => ⟨MeasurableSet.nullMeasurableSet h, le_rfl⟩


[GOAL]
α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : BoundedOrder α
inst✝¹ : IsSimpleOrder α
inst✝ : DecidableEq α
⊢ Finset.univ = {⊤, ⊥}
[PROOFSTEP]
change Finset.map _ (Finset.univ : Finset Bool) = _
[GOAL]
α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : BoundedOrder α
inst✝¹ : IsSimpleOrder α
inst✝ : DecidableEq α
⊢ Finset.map { toFun := ↑IsSimpleOrder.equivBool.symm, inj' := (_ : Function.Injective ↑IsSimpleOrder.equivBool.symm) }
      Finset.univ =
    {⊤, ⊥}
[PROOFSTEP]
rw [Fintype.univ_bool]
[GOAL]
α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : BoundedOrder α
inst✝¹ : IsSimpleOrder α
inst✝ : DecidableEq α
⊢ Finset.map { toFun := ↑IsSimpleOrder.equivBool.symm, inj' := (_ : Function.Injective ↑IsSimpleOrder.equivBool.symm) }
      {true, false} =
    {⊤, ⊥}
[PROOFSTEP]
simp only [Finset.map_insert, Function.Embedding.coeFn_mk, Finset.map_singleton]
[GOAL]
α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : BoundedOrder α
inst✝¹ : IsSimpleOrder α
inst✝ : DecidableEq α
⊢ {↑IsSimpleOrder.equivBool.symm true, ↑IsSimpleOrder.equivBool.symm false} = {⊤, ⊥}
[PROOFSTEP]
rfl
[GOAL]
α : Type u_1
β : Type u_2
a : Bool
⊢ a = ⊥ ∨ a = ⊤
[PROOFSTEP]
rw [← Finset.mem_singleton, Or.comm, ← Finset.mem_insert, top_eq_true, bot_eq_false, ← Fintype.univ_bool]
[GOAL]
α : Type u_1
β : Type u_2
a : Bool
⊢ a ∈ Finset.univ
[PROOFSTEP]
apply Finset.mem_univ
[GOAL]
α : Type u_1
β : Type u_2
inst✝² : PartialOrder α
inst✝¹ : OrderTop α
inst✝ : Finite α
⊢ IsCoatomic α
[PROOFSTEP]
refine' IsCoatomic.mk fun b => or_iff_not_imp_left.2 fun ht => _
[GOAL]
α : Type u_1
β : Type u_2
inst✝² : PartialOrder α
inst✝¹ : OrderTop α
inst✝ : Finite α
b : α
ht : ¬b = ⊤
⊢ ∃ a, IsCoatom a ∧ b ≤ a
[PROOFSTEP]
obtain ⟨c, hc, hmax⟩ := Set.Finite.exists_maximal_wrt id {x : α | b ≤ x ∧ x ≠ ⊤} (Set.toFinite _) ⟨b, le_rfl, ht⟩
[GOAL]
case intro.intro
α : Type u_1
β : Type u_2
inst✝² : PartialOrder α
inst✝¹ : OrderTop α
inst✝ : Finite α
b : α
ht : ¬b = ⊤
c : α
hc : c ∈ {x | b ≤ x ∧ x ≠ ⊤}
hmax : ∀ (a' : α), a' ∈ {x | b ≤ x ∧ x ≠ ⊤} → id c ≤ id a' → id c = id a'
⊢ ∃ a, IsCoatom a ∧ b ≤ a
[PROOFSTEP]
refine' ⟨c, ⟨hc.2, fun y hcy => _⟩, hc.1⟩
[GOAL]
case intro.intro
α : Type u_1
β : Type u_2
inst✝² : PartialOrder α
inst✝¹ : OrderTop α
inst✝ : Finite α
b : α
ht : ¬b = ⊤
c : α
hc : c ∈ {x | b ≤ x ∧ x ≠ ⊤}
hmax : ∀ (a' : α), a' ∈ {x | b ≤ x ∧ x ≠ ⊤} → id c ≤ id a' → id c = id a'
y : α
hcy : c < y
⊢ y = ⊤
[PROOFSTEP]
by_contra hyt
[GOAL]
case intro.intro
α : Type u_1
β : Type u_2
inst✝² : PartialOrder α
inst✝¹ : OrderTop α
inst✝ : Finite α
b : α
ht : ¬b = ⊤
c : α
hc : c ∈ {x | b ≤ x ∧ x ≠ ⊤}
hmax : ∀ (a' : α), a' ∈ {x | b ≤ x ∧ x ≠ ⊤} → id c ≤ id a' → id c = id a'
y : α
hcy : c < y
hyt : ¬y = ⊤
⊢ False
[PROOFSTEP]
obtain rfl : c = y := hmax y ⟨hc.1.trans hcy.le, hyt⟩ hcy.le
[GOAL]
case intro.intro
α : Type u_1
β : Type u_2
inst✝² : PartialOrder α
inst✝¹ : OrderTop α
inst✝ : Finite α
b : α
ht : ¬b = ⊤
c : α
hc : c ∈ {x | b ≤ x ∧ x ≠ ⊤}
hmax : ∀ (a' : α), a' ∈ {x | b ≤ x ∧ x ≠ ⊤} → id c ≤ id a' → id c = id a'
hcy : c < c
hyt : ¬c = ⊤
⊢ False
[PROOFSTEP]
exact (lt_self_iff_false _).mp hcy


[GOAL]
J : Type w
X✝ Y✝ Z✝ : WidePullbackShape J
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ X✝ ⟶ Z✝
[PROOFSTEP]
cases f
[GOAL]
case id
J : Type w
X✝ Z✝ : WidePullbackShape J
g : X✝ ⟶ Z✝
⊢ X✝ ⟶ Z✝
case term J : Type w Z✝ : WidePullbackShape J j✝ : J g : none ⟶ Z✝ ⊢ some j✝ ⟶ Z✝
[PROOFSTEP]
exact g
[GOAL]
case term
J : Type w
Z✝ : WidePullbackShape J
j✝ : J
g : none ⟶ Z✝
⊢ some j✝ ⟶ Z✝
[PROOFSTEP]
cases g
[GOAL]
case term.id
J : Type w
j✝ : J
⊢ some j✝ ⟶ none
[PROOFSTEP]
apply Hom.term _
[GOAL]
J : Type w
x✝¹ x✝ : WidePullbackShape J
⊢ Subsingleton (x✝¹ ⟶ x✝)
[PROOFSTEP]
constructor
[GOAL]
case allEq
J : Type w
x✝¹ x✝ : WidePullbackShape J
⊢ ∀ (a b : x✝¹ ⟶ x✝), a = b
[PROOFSTEP]
intro a b
[GOAL]
case allEq
J : Type w
x✝¹ x✝ : WidePullbackShape J
a b : x✝¹ ⟶ x✝
⊢ a = b
[PROOFSTEP]
casesm*WidePullbackShape _, (_ : WidePullbackShape _) ⟶ (_ : WidePullbackShape _)
[GOAL]
case allEq.none.none.id.id
J : Type w
⊢ Hom.id none = Hom.id none
case allEq.some.none.term.term
J : Type w
val✝ : J
⊢ Hom.term val✝ = Hom.term val✝
case allEq.some.some.id.id J : Type w val✝ : J ⊢ Hom.id (some val✝) = Hom.id (some val✝)
[PROOFSTEP]
rfl
[GOAL]
case allEq.some.none.term.term
J : Type w
val✝ : J
⊢ Hom.term val✝ = Hom.term val✝
case allEq.some.some.id.id J : Type w val✝ : J ⊢ Hom.id (some val✝) = Hom.id (some val✝)
[PROOFSTEP]
rfl
[GOAL]
case allEq.some.some.id.id
J : Type w
val✝ : J
⊢ Hom.id (some val✝) = Hom.id (some val✝)
[PROOFSTEP]
rfl
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
X✝ Y✝ : WidePullbackShape J
f : X✝ ⟶ Y✝
⊢ (fun j => Option.casesOn j B objs) X✝ ⟶ (fun j => Option.casesOn j B objs) Y✝
[PROOFSTEP]
cases' f with _ j
[GOAL]
case id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
X✝ : WidePullbackShape J
⊢ (fun j => Option.casesOn j B objs) X✝ ⟶ (fun j => Option.casesOn j B objs) X✝
[PROOFSTEP]
apply 𝟙 _
[GOAL]
case term
J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → objs j ⟶ B
j : J
⊢ (fun j => Option.casesOn j B objs) (some j) ⟶ (fun j => Option.casesOn j B objs) none
[PROOFSTEP]
exact arrows j
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
j : WidePullbackShape J
⊢ F.obj j = (wideCospan (F.obj none) (fun j => F.obj (some j)) fun j => F.map (Hom.term j)).obj j
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f✝ : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f✝
j j' : WidePullbackShape J
f : j ⟶ j'
⊢ ((Functor.const (WidePullbackShape J)).obj X).map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        j' =
    (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        j ≫
      F.map f
[PROOFSTEP]
cases j
[GOAL]
case none
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f✝ : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f✝
j' : WidePullbackShape J
f : none ⟶ j'
⊢ ((Functor.const (WidePullbackShape J)).obj X).map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        j' =
    (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        none ≫
      F.map f
[PROOFSTEP]
cases j'
[GOAL]
case some
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f✝ : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f✝
j' : WidePullbackShape J
val✝ : J
f : some val✝ ⟶ j'
⊢ ((Functor.const (WidePullbackShape J)).obj X).map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        j' =
    (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        (some val✝) ≫
      F.map f
[PROOFSTEP]
cases j'
[GOAL]
case none.none
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f✝ : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f✝
f : none ⟶ none
⊢ ((Functor.const (WidePullbackShape J)).obj X).map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        none =
    (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        none ≫
      F.map f
[PROOFSTEP]
cases f
[GOAL]
case none.some
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f✝ : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f✝
val✝ : J
f : none ⟶ some val✝
⊢ ((Functor.const (WidePullbackShape J)).obj X).map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        (some val✝) =
    (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        none ≫
      F.map f
[PROOFSTEP]
cases f
[GOAL]
case some.none
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f✝ : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f✝
val✝ : J
f : some val✝ ⟶ none
⊢ ((Functor.const (WidePullbackShape J)).obj X).map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        none =
    (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        (some val✝) ≫
      F.map f
[PROOFSTEP]
cases f
[GOAL]
case some.some
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f✝ : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f✝
val✝¹ val✝ : J
f : some val✝¹ ⟶ some val✝
⊢ ((Functor.const (WidePullbackShape J)).obj X).map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        (some val✝) =
    (fun j =>
          match j with
          | none => f✝
          | some j => π j)
        (some val✝¹) ≫
      F.map f
[PROOFSTEP]
cases f
[GOAL]
case none.none.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f
⊢ ((Functor.const (WidePullbackShape J)).obj X).map (Hom.id none) ≫
      (fun j =>
          match j with
          | none => f
          | some j => π j)
        none =
    (fun j =>
          match j with
          | none => f
          | some j => π j)
        none ≫
      F.map (Hom.id none)
[PROOFSTEP]
refine id _
[GOAL]
case some.none.term
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f
val✝ : J
⊢ ((Functor.const (WidePullbackShape J)).obj X).map (Hom.term val✝) ≫
      (fun j =>
          match j with
          | none => f
          | some j => π j)
        none =
    (fun j =>
          match j with
          | none => f
          | some j => π j)
        (some val✝) ≫
      F.map (Hom.term val✝)
[PROOFSTEP]
refine id _
[GOAL]
case some.some.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f
val✝ : J
⊢ ((Functor.const (WidePullbackShape J)).obj X).map (Hom.id (some val✝)) ≫
      (fun j =>
          match j with
          | none => f
          | some j => π j)
        (some val✝) =
    (fun j =>
          match j with
          | none => f
          | some j => π j)
        (some val✝) ≫
      F.map (Hom.id (some val✝))
[PROOFSTEP]
refine id _
[GOAL]
case none.none.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f
⊢ ((Functor.const (WidePullbackShape J)).obj X).map (Hom.id none) ≫
      (fun j =>
          match j with
          | none => f
          | some j => π j)
        none =
    (fun j =>
          match j with
          | none => f
          | some j => π j)
        none ≫
      F.map (Hom.id none)
[PROOFSTEP]
dsimp
[GOAL]
case some.none.term
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f
val✝ : J
⊢ ((Functor.const (WidePullbackShape J)).obj X).map (Hom.term val✝) ≫
      (fun j =>
          match j with
          | none => f
          | some j => π j)
        none =
    (fun j =>
          match j with
          | none => f
          | some j => π j)
        (some val✝) ≫
      F.map (Hom.term val✝)
[PROOFSTEP]
dsimp
[GOAL]
case some.some.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f
val✝ : J
⊢ ((Functor.const (WidePullbackShape J)).obj X).map (Hom.id (some val✝)) ≫
      (fun j =>
          match j with
          | none => f
          | some j => π j)
        (some val✝) =
    (fun j =>
          match j with
          | none => f
          | some j => π j)
        (some val✝) ≫
      F.map (Hom.id (some val✝))
[PROOFSTEP]
dsimp
[GOAL]
case none.none.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f
⊢ 𝟙 X ≫ f = f ≫ F.map (𝟙 none)
[PROOFSTEP]
simp [w]
[GOAL]
case some.none.term
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f
val✝ : J
⊢ 𝟙 X ≫ f = π val✝ ≫ F.map (Hom.term val✝)
[PROOFSTEP]
simp [w]
[GOAL]
case some.some.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePullbackShape J ⥤ C
X : C
f : X ⟶ F.obj none
π : (j : J) → X ⟶ F.obj (some j)
w : ∀ (j : J), π j ≫ F.map (Hom.term j) = f
val✝ : J
⊢ 𝟙 X ≫ π val✝ = π val✝ ≫ F.map (𝟙 (some val✝))
[PROOFSTEP]
simp [w]
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
J' : Type w'
h : J ≃ J'
j : WidePullbackShape J
⊢ (𝟭 (WidePullbackShape J)).obj j ≅
    ((wideCospan none (fun j => some (↑h j)) fun j => Hom.term (↑h j)) ⋙
          wideCospan none (fun j => some (Equiv.invFun h j)) fun j => Hom.term (Equiv.invFun h j)).obj
      j
[PROOFSTEP]
aesop_cat_nonterminal
[GOAL]
case none
J : Type w
C : Type u
inst : Category.{v, u} C
J' : Type w'
h : J ≃ J'
⊢ none ≅ none
case some J : Type w C : Type u inst : Category.{v, u} C J' : Type w' h : J ≃ J' val✝ : J ⊢ some val✝ ≅ some val✝
[PROOFSTEP]
repeat rfl
[GOAL]
case none
J : Type w
C : Type u
inst : Category.{v, u} C
J' : Type w'
h : J ≃ J'
⊢ none ≅ none
case some J : Type w C : Type u inst : Category.{v, u} C J' : Type w' h : J ≃ J' val✝ : J ⊢ some val✝ ≅ some val✝
[PROOFSTEP]
rfl
[GOAL]
case some
J : Type w
C : Type u
inst : Category.{v, u} C
J' : Type w'
h : J ≃ J'
val✝ : J
⊢ some val✝ ≅ some val✝
[PROOFSTEP]
rfl
[GOAL]

[PROOFSTEP]
rfl
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
J' : Type w'
h : J ≃ J'
X✝ Y✝ : WidePullbackShape J
f : X✝ ⟶ Y✝
⊢ (𝟭 (WidePullbackShape J)).map f ≫
      ((fun j =>
            id
              (Option.casesOn j (id (Iso.refl none)) fun val =>
                Eq.mpr
                  (_ :
                    (some val ≅
                        Option.rec none (fun val => some (↑h.symm val))
                          (Option.rec none (fun val => some (↑h val)) (some val))) =
                      (some val ≅ some val))
                  (Iso.refl (some val))))
          Y✝).hom =
    ((fun j =>
            id
              (Option.casesOn j (id (Iso.refl none)) fun val =>
                Eq.mpr
                  (_ :
                    (some val ≅
                        Option.rec none (fun val => some (↑h.symm val))
                          (Option.rec none (fun val => some (↑h val)) (some val))) =
                      (some val ≅ some val))
                  (Iso.refl (some val))))
          X✝).hom ≫
      ((wideCospan none (fun j => some (↑h j)) fun j => Hom.term (↑h j)) ⋙
            wideCospan none (fun j => some (Equiv.invFun h j)) fun j => Hom.term (Equiv.invFun h j)).map
        f
[PROOFSTEP]
simp only [eq_iff_true_of_subsingleton]
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
J' : Type w'
h : J ≃ J'
j : WidePullbackShape J'
⊢ ((wideCospan none (fun j => some (Equiv.invFun h j)) fun j => Hom.term (Equiv.invFun h j)) ⋙
          wideCospan none (fun j => some (↑h j)) fun j => Hom.term (↑h j)).obj
      j ≅
    (𝟭 (WidePullbackShape J')).obj j
[PROOFSTEP]
aesop_cat_nonterminal
[GOAL]
case none
J : Type w
C : Type u
inst : Category.{v, u} C
J' : Type w'
h : J ≃ J'
⊢ none ≅ none
case some J : Type w C : Type u inst : Category.{v, u} C J' : Type w' h : J ≃ J' val✝ : J' ⊢ some val✝ ≅ some val✝
[PROOFSTEP]
repeat rfl
[GOAL]
case none
J : Type w
C : Type u
inst : Category.{v, u} C
J' : Type w'
h : J ≃ J'
⊢ none ≅ none
case some J : Type w C : Type u inst : Category.{v, u} C J' : Type w' h : J ≃ J' val✝ : J' ⊢ some val✝ ≅ some val✝
[PROOFSTEP]
rfl
[GOAL]
case some
J : Type w
C : Type u
inst : Category.{v, u} C
J' : Type w'
h : J ≃ J'
val✝ : J'
⊢ some val✝ ≅ some val✝
[PROOFSTEP]
rfl
[GOAL]

[PROOFSTEP]
rfl
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
J' : Type w'
h : J ≃ J'
X✝ Y✝ : WidePullbackShape J'
f : X✝ ⟶ Y✝
⊢ ((wideCospan none (fun j => some (Equiv.invFun h j)) fun j => Hom.term (Equiv.invFun h j)) ⋙
            wideCospan none (fun j => some (↑h j)) fun j => Hom.term (↑h j)).map
        f ≫
      ((fun j =>
            id
              (Option.casesOn j (id (Iso.refl none)) fun val =>
                Eq.mpr
                  (_ :
                    (Option.rec none (fun val => some (↑h val))
                          (Option.rec none (fun val => some (↑h.symm val)) (some val)) ≅
                        some val) =
                      (some val ≅ some val))
                  (Iso.refl (some val))))
          Y✝).hom =
    ((fun j =>
            id
              (Option.casesOn j (id (Iso.refl none)) fun val =>
                Eq.mpr
                  (_ :
                    (Option.rec none (fun val => some (↑h val))
                          (Option.rec none (fun val => some (↑h.symm val)) (some val)) ≅
                        some val) =
                      (some val ≅ some val))
                  (Iso.refl (some val))))
          X✝).hom ≫
      (𝟭 (WidePullbackShape J')).map f
[PROOFSTEP]
simp only [eq_iff_true_of_subsingleton]
[GOAL]
J : Type w
X✝ Y✝ Z✝ : WidePushoutShape J
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ X✝ ⟶ Z✝
[PROOFSTEP]
cases f
[GOAL]
case id
J : Type w
X✝ Z✝ : WidePushoutShape J
g : X✝ ⟶ Z✝
⊢ X✝ ⟶ Z✝
case init J : Type w Z✝ : WidePushoutShape J j✝ : J g : some j✝ ⟶ Z✝ ⊢ none ⟶ Z✝
[PROOFSTEP]
exact g
[GOAL]
case init
J : Type w
Z✝ : WidePushoutShape J
j✝ : J
g : some j✝ ⟶ Z✝
⊢ none ⟶ Z✝
[PROOFSTEP]
cases g
[GOAL]
case init.id
J : Type w
j✝ : J
⊢ none ⟶ some j✝
[PROOFSTEP]
apply Hom.init _
[GOAL]
J : Type w
x✝¹ x✝ : WidePushoutShape J
⊢ Subsingleton (x✝¹ ⟶ x✝)
[PROOFSTEP]
constructor
[GOAL]
case allEq
J : Type w
x✝¹ x✝ : WidePushoutShape J
⊢ ∀ (a b : x✝¹ ⟶ x✝), a = b
[PROOFSTEP]
intro a b
[GOAL]
case allEq
J : Type w
x✝¹ x✝ : WidePushoutShape J
a b : x✝¹ ⟶ x✝
⊢ a = b
[PROOFSTEP]
casesm*WidePushoutShape _, (_ : WidePushoutShape _) ⟶ (_ : WidePushoutShape _)
[GOAL]
case allEq.none.none.id.id
J : Type w
⊢ Hom.id none = Hom.id none
case allEq.none.some.init.init
J : Type w
val✝ : J
⊢ Hom.init val✝ = Hom.init val✝
case allEq.some.some.id.id J : Type w val✝ : J ⊢ Hom.id (some val✝) = Hom.id (some val✝)
[PROOFSTEP]
repeat rfl
[GOAL]
case allEq.none.none.id.id
J : Type w
⊢ Hom.id none = Hom.id none
case allEq.none.some.init.init
J : Type w
val✝ : J
⊢ Hom.init val✝ = Hom.init val✝
case allEq.some.some.id.id J : Type w val✝ : J ⊢ Hom.id (some val✝) = Hom.id (some val✝)
[PROOFSTEP]
rfl
[GOAL]
case allEq.none.some.init.init
J : Type w
val✝ : J
⊢ Hom.init val✝ = Hom.init val✝
case allEq.some.some.id.id J : Type w val✝ : J ⊢ Hom.id (some val✝) = Hom.id (some val✝)
[PROOFSTEP]
rfl
[GOAL]
case allEq.some.some.id.id
J : Type w
val✝ : J
⊢ Hom.id (some val✝) = Hom.id (some val✝)
[PROOFSTEP]
rfl
[GOAL]

[PROOFSTEP]
rfl
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
X✝ Y✝ : WidePushoutShape J
f : X✝ ⟶ Y✝
⊢ (fun j => Option.casesOn j B objs) X✝ ⟶ (fun j => Option.casesOn j B objs) Y✝
[PROOFSTEP]
cases' f with _ j
[GOAL]
case id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
X✝ : WidePushoutShape J
⊢ (fun j => Option.casesOn j B objs) X✝ ⟶ (fun j => Option.casesOn j B objs) X✝
[PROOFSTEP]
apply 𝟙 _
[GOAL]
case init
J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
j : J
⊢ (fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) (some j)
[PROOFSTEP]
exact arrows j
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
X✝ Y✝ Z✝ : WidePushoutShape J
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun j => Option.casesOn j B objs,
          map := fun {X Y} f =>
            Hom.casesOn (motive := fun a a_1 t =>
              X = a → Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
              f
              (fun X_1 h =>
                Eq.ndrec (motive := fun X_2 =>
                  Y = X_2 →
                    HEq f (Hom.id X_2) → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                  (fun h =>
                    Eq.ndrec (motive := fun {Y} =>
                      (f : X ⟶ Y) →
                        HEq f (Hom.id X) →
                          ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                      (fun f h => (_ : Hom.id X = f) ▸ 𝟙 ((fun j => Option.casesOn j B objs) X)) (_ : X = Y) f)
                  h)
              (fun j h =>
                Eq.ndrec (motive := fun {X} =>
                  (f : X ⟶ Y) →
                    Y = some j →
                      HEq f (Hom.init j) →
                        ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                  (fun f h =>
                    Eq.ndrec (motive := fun {Y} =>
                      (f : none ⟶ Y) →
                        HEq f (Hom.init j) →
                          ((fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) Y))
                      (fun f h => (_ : Hom.init j = f) ▸ arrows j) (_ : some j = Y) f)
                  (_ : none = X) f)
              (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
      (f ≫ g) =
    { obj := fun j => Option.casesOn j B objs,
            map := fun {X Y} f =>
              Hom.casesOn (motive := fun a a_1 t =>
                X = a →
                  Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                f
                (fun X_1 h =>
                  Eq.ndrec (motive := fun X_2 =>
                    Y = X_2 →
                      HEq f (Hom.id X_2) →
                        ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : X ⟶ Y) →
                          HEq f (Hom.id X) →
                            ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.id X = f) ▸ 𝟙 ((fun j => Option.casesOn j B objs) X)) (_ : X = Y) f)
                    h)
                (fun j h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = some j →
                        HEq f (Hom.init j) →
                          ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : none ⟶ Y) →
                          HEq f (Hom.init j) →
                            ((fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.init j = f) ▸ arrows j) (_ : some j = Y) f)
                    (_ : none = X) f)
                (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
        f ≫
      { obj := fun j => Option.casesOn j B objs,
            map := fun {X Y} f =>
              Hom.casesOn (motive := fun a a_1 t =>
                X = a →
                  Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                f
                (fun X_1 h =>
                  Eq.ndrec (motive := fun X_2 =>
                    Y = X_2 →
                      HEq f (Hom.id X_2) →
                        ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : X ⟶ Y) →
                          HEq f (Hom.id X) →
                            ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.id X = f) ▸ 𝟙 ((fun j => Option.casesOn j B objs) X)) (_ : X = Y) f)
                    h)
                (fun j h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = some j →
                        HEq f (Hom.init j) →
                          ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : none ⟶ Y) →
                          HEq f (Hom.init j) →
                            ((fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.init j = f) ▸ arrows j) (_ : some j = Y) f)
                    (_ : none = X) f)
                (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
        g
[PROOFSTEP]
cases f
[GOAL]
case id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
X✝ Z✝ : WidePushoutShape J
g : X✝ ⟶ Z✝
⊢ { obj := fun j => Option.casesOn j B objs,
          map := fun {X Y} f =>
            Hom.casesOn (motive := fun a a_1 t =>
              X = a → Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
              f
              (fun X_1 h =>
                Eq.ndrec (motive := fun X_2 =>
                  Y = X_2 →
                    HEq f (Hom.id X_2) → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                  (fun h =>
                    Eq.ndrec (motive := fun {Y} =>
                      (f : X ⟶ Y) →
                        HEq f (Hom.id X) →
                          ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                      (fun f h => (_ : Hom.id X = f) ▸ 𝟙 ((fun j => Option.casesOn j B objs) X)) (_ : X = Y) f)
                  h)
              (fun j h =>
                Eq.ndrec (motive := fun {X} =>
                  (f : X ⟶ Y) →
                    Y = some j →
                      HEq f (Hom.init j) →
                        ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                  (fun f h =>
                    Eq.ndrec (motive := fun {Y} =>
                      (f : none ⟶ Y) →
                        HEq f (Hom.init j) →
                          ((fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) Y))
                      (fun f h => (_ : Hom.init j = f) ▸ arrows j) (_ : some j = Y) f)
                  (_ : none = X) f)
              (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
      (Hom.id X✝ ≫ g) =
    { obj := fun j => Option.casesOn j B objs,
            map := fun {X Y} f =>
              Hom.casesOn (motive := fun a a_1 t =>
                X = a →
                  Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                f
                (fun X_1 h =>
                  Eq.ndrec (motive := fun X_2 =>
                    Y = X_2 →
                      HEq f (Hom.id X_2) →
                        ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : X ⟶ Y) →
                          HEq f (Hom.id X) →
                            ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.id X = f) ▸ 𝟙 ((fun j => Option.casesOn j B objs) X)) (_ : X = Y) f)
                    h)
                (fun j h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = some j →
                        HEq f (Hom.init j) →
                          ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : none ⟶ Y) →
                          HEq f (Hom.init j) →
                            ((fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.init j = f) ▸ arrows j) (_ : some j = Y) f)
                    (_ : none = X) f)
                (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
        (Hom.id X✝) ≫
      { obj := fun j => Option.casesOn j B objs,
            map := fun {X Y} f =>
              Hom.casesOn (motive := fun a a_1 t =>
                X = a →
                  Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                f
                (fun X_1 h =>
                  Eq.ndrec (motive := fun X_2 =>
                    Y = X_2 →
                      HEq f (Hom.id X_2) →
                        ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : X ⟶ Y) →
                          HEq f (Hom.id X) →
                            ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.id X = f) ▸ 𝟙 ((fun j => Option.casesOn j B objs) X)) (_ : X = Y) f)
                    h)
                (fun j h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = some j →
                        HEq f (Hom.init j) →
                          ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : none ⟶ Y) →
                          HEq f (Hom.init j) →
                            ((fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.init j = f) ▸ arrows j) (_ : some j = Y) f)
                    (_ : none = X) f)
                (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
        g
[PROOFSTEP]
simp only [Eq.ndrec, hom_id, eq_rec_constant, Category.id_comp]
[GOAL]
case id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
X✝ Z✝ : WidePushoutShape J
g : X✝ ⟶ Z✝
⊢ Hom.rec (motive := fun a a_1 t =>
      X✝ = a →
        Z✝ = a_1 → HEq (𝟙 X✝ ≫ g) t → (Option.rec B (fun val => objs val) X✝ ⟶ Option.rec B (fun val => objs val) Z✝))
      (fun X h =>
        Eq.rec (motive := fun x x_1 =>
          Z✝ = x →
            HEq (𝟙 X✝ ≫ g) (𝟙 x) → (Option.rec B (fun val => objs val) X✝ ⟶ Option.rec B (fun val => objs val) Z✝))
          (fun h =>
            Eq.rec (motive := fun x x_1 =>
              (f : X✝ ⟶ x) →
                HEq f (𝟙 X✝) → (Option.rec B (fun val => objs val) X✝ ⟶ Option.rec B (fun val => objs val) x))
              (fun f h => 𝟙 (Option.rec B (fun val => objs val) X✝)) (_ : X✝ = Z✝) (𝟙 X✝ ≫ g))
          h)
      (fun j h =>
        Eq.rec (motive := fun x x_1 =>
          (f : x ⟶ Z✝) →
            Z✝ = some j →
              HEq f (Hom.init j) → (Option.rec B (fun val => objs val) x ⟶ Option.rec B (fun val => objs val) Z✝))
          (fun f h =>
            Eq.rec (motive := fun x x_1 =>
              (f : none ⟶ x) → HEq f (Hom.init j) → (B ⟶ Option.rec B (fun val => objs val) x)) (fun f h => arrows j)
              (_ : some j = Z✝) f)
          (_ : none = X✝) (𝟙 X✝ ≫ g))
      (𝟙 X✝ ≫ g) (_ : X✝ = X✝) (_ : Z✝ = Z✝) (_ : HEq (Hom.id X✝ ≫ g) (Hom.id X✝ ≫ g)) =
    Hom.rec (motive := fun a a_1 t =>
      X✝ = a → Z✝ = a_1 → HEq g t → (Option.rec B (fun val => objs val) X✝ ⟶ Option.rec B (fun val => objs val) Z✝))
      (fun X h =>
        Eq.rec (motive := fun x x_1 =>
          Z✝ = x → HEq g (𝟙 x) → (Option.rec B (fun val => objs val) X✝ ⟶ Option.rec B (fun val => objs val) Z✝))
          (fun h =>
            Eq.rec (motive := fun x x_1 =>
              (f : X✝ ⟶ x) →
                HEq f (𝟙 X✝) → (Option.rec B (fun val => objs val) X✝ ⟶ Option.rec B (fun val => objs val) x))
              (fun f h => 𝟙 (Option.rec B (fun val => objs val) X✝)) (_ : X✝ = Z✝) g)
          h)
      (fun j h =>
        Eq.rec (motive := fun x x_1 =>
          (f : x ⟶ Z✝) →
            Z✝ = some j →
              HEq f (Hom.init j) → (Option.rec B (fun val => objs val) x ⟶ Option.rec B (fun val => objs val) Z✝))
          (fun f h =>
            Eq.rec (motive := fun x x_1 =>
              (f : none ⟶ x) → HEq f (Hom.init j) → (B ⟶ Option.rec B (fun val => objs val) x)) (fun f h => arrows j)
              (_ : some j = Z✝) f)
          (_ : none = X✝) g)
      g (_ : X✝ = X✝) (_ : Z✝ = Z✝) (_ : HEq g g)
[PROOFSTEP]
congr
[GOAL]
case init
J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
Z✝ : WidePushoutShape J
j✝ : J
g : some j✝ ⟶ Z✝
⊢ { obj := fun j => Option.casesOn j B objs,
          map := fun {X Y} f =>
            Hom.casesOn (motive := fun a a_1 t =>
              X = a → Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
              f
              (fun X_1 h =>
                Eq.ndrec (motive := fun X_2 =>
                  Y = X_2 →
                    HEq f (Hom.id X_2) → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                  (fun h =>
                    Eq.ndrec (motive := fun {Y} =>
                      (f : X ⟶ Y) →
                        HEq f (Hom.id X) →
                          ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                      (fun f h => (_ : Hom.id X = f) ▸ 𝟙 ((fun j => Option.casesOn j B objs) X)) (_ : X = Y) f)
                  h)
              (fun j h =>
                Eq.ndrec (motive := fun {X} =>
                  (f : X ⟶ Y) →
                    Y = some j →
                      HEq f (Hom.init j) →
                        ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                  (fun f h =>
                    Eq.ndrec (motive := fun {Y} =>
                      (f : none ⟶ Y) →
                        HEq f (Hom.init j) →
                          ((fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) Y))
                      (fun f h => (_ : Hom.init j = f) ▸ arrows j) (_ : some j = Y) f)
                  (_ : none = X) f)
              (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
      (Hom.init j✝ ≫ g) =
    { obj := fun j => Option.casesOn j B objs,
            map := fun {X Y} f =>
              Hom.casesOn (motive := fun a a_1 t =>
                X = a →
                  Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                f
                (fun X_1 h =>
                  Eq.ndrec (motive := fun X_2 =>
                    Y = X_2 →
                      HEq f (Hom.id X_2) →
                        ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : X ⟶ Y) →
                          HEq f (Hom.id X) →
                            ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.id X = f) ▸ 𝟙 ((fun j => Option.casesOn j B objs) X)) (_ : X = Y) f)
                    h)
                (fun j h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = some j →
                        HEq f (Hom.init j) →
                          ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : none ⟶ Y) →
                          HEq f (Hom.init j) →
                            ((fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.init j = f) ▸ arrows j) (_ : some j = Y) f)
                    (_ : none = X) f)
                (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
        (Hom.init j✝) ≫
      { obj := fun j => Option.casesOn j B objs,
            map := fun {X Y} f =>
              Hom.casesOn (motive := fun a a_1 t =>
                X = a →
                  Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                f
                (fun X_1 h =>
                  Eq.ndrec (motive := fun X_2 =>
                    Y = X_2 →
                      HEq f (Hom.id X_2) →
                        ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : X ⟶ Y) →
                          HEq f (Hom.id X) →
                            ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.id X = f) ▸ 𝟙 ((fun j => Option.casesOn j B objs) X)) (_ : X = Y) f)
                    h)
                (fun j h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = some j →
                        HEq f (Hom.init j) →
                          ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : none ⟶ Y) →
                          HEq f (Hom.init j) →
                            ((fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.init j = f) ▸ arrows j) (_ : some j = Y) f)
                    (_ : none = X) f)
                (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
        g
[PROOFSTEP]
cases g
[GOAL]
case init.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
j✝ : J
⊢ { obj := fun j => Option.casesOn j B objs,
          map := fun {X Y} f =>
            Hom.casesOn (motive := fun a a_1 t =>
              X = a → Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
              f
              (fun X_1 h =>
                Eq.ndrec (motive := fun X_2 =>
                  Y = X_2 →
                    HEq f (Hom.id X_2) → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                  (fun h =>
                    Eq.ndrec (motive := fun {Y} =>
                      (f : X ⟶ Y) →
                        HEq f (Hom.id X) →
                          ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                      (fun f h => (_ : Hom.id X = f) ▸ 𝟙 ((fun j => Option.casesOn j B objs) X)) (_ : X = Y) f)
                  h)
              (fun j h =>
                Eq.ndrec (motive := fun {X} =>
                  (f : X ⟶ Y) →
                    Y = some j →
                      HEq f (Hom.init j) →
                        ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                  (fun f h =>
                    Eq.ndrec (motive := fun {Y} =>
                      (f : none ⟶ Y) →
                        HEq f (Hom.init j) →
                          ((fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) Y))
                      (fun f h => (_ : Hom.init j = f) ▸ arrows j) (_ : some j = Y) f)
                  (_ : none = X) f)
              (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
      (Hom.init j✝ ≫ Hom.id (some j✝)) =
    { obj := fun j => Option.casesOn j B objs,
            map := fun {X Y} f =>
              Hom.casesOn (motive := fun a a_1 t =>
                X = a →
                  Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                f
                (fun X_1 h =>
                  Eq.ndrec (motive := fun X_2 =>
                    Y = X_2 →
                      HEq f (Hom.id X_2) →
                        ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : X ⟶ Y) →
                          HEq f (Hom.id X) →
                            ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.id X = f) ▸ 𝟙 ((fun j => Option.casesOn j B objs) X)) (_ : X = Y) f)
                    h)
                (fun j h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = some j →
                        HEq f (Hom.init j) →
                          ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : none ⟶ Y) →
                          HEq f (Hom.init j) →
                            ((fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.init j = f) ▸ arrows j) (_ : some j = Y) f)
                    (_ : none = X) f)
                (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
        (Hom.init j✝) ≫
      { obj := fun j => Option.casesOn j B objs,
            map := fun {X Y} f =>
              Hom.casesOn (motive := fun a a_1 t =>
                X = a →
                  Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                f
                (fun X_1 h =>
                  Eq.ndrec (motive := fun X_2 =>
                    Y = X_2 →
                      HEq f (Hom.id X_2) →
                        ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : X ⟶ Y) →
                          HEq f (Hom.id X) →
                            ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.id X = f) ▸ 𝟙 ((fun j => Option.casesOn j B objs) X)) (_ : X = Y) f)
                    h)
                (fun j h =>
                  Eq.ndrec (motive := fun {X} =>
                    (f : X ⟶ Y) →
                      Y = some j →
                        HEq f (Hom.init j) →
                          ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
                    (fun f h =>
                      Eq.ndrec (motive := fun {Y} =>
                        (f : none ⟶ Y) →
                          HEq f (Hom.init j) →
                            ((fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) Y))
                        (fun f h => (_ : Hom.init j = f) ▸ arrows j) (_ : some j = Y) f)
                    (_ : none = X) f)
                (_ : X = X) (_ : Y = Y) (_ : HEq f f) }.map
        (Hom.id (some j✝))
[PROOFSTEP]
simp only [Eq.ndrec, hom_id, eq_rec_constant, Category.comp_id]
[GOAL]
case init.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
j✝ : J
⊢ Hom.rec (motive := fun a a_1 t => none = a → some j✝ = a_1 → HEq (Hom.init j✝ ≫ 𝟙 (some j✝)) t → (B ⟶ objs j✝))
      (fun X h =>
        Eq.rec (motive := fun x x_1 => some j✝ = x → HEq (Hom.init j✝ ≫ 𝟙 (some j✝)) (𝟙 x) → (B ⟶ objs j✝))
          (fun h =>
            Eq.rec (motive := fun x x_1 => (f : none ⟶ x) → HEq f (𝟙 none) → (B ⟶ Option.rec B (fun val => objs val) x))
              (fun f h => 𝟙 B) (_ : none = some j✝) (Hom.init j✝ ≫ 𝟙 (some j✝)))
          h)
      (fun j h h =>
        Eq.rec (motive := fun x x_1 => (f : none ⟶ x) → HEq f (Hom.init j) → (B ⟶ Option.rec B (fun val => objs val) x))
          (fun f h => arrows j) (_ : some j = some j✝) (Hom.init j✝ ≫ 𝟙 (some j✝)))
      (Hom.init j✝ ≫ 𝟙 (some j✝)) (_ : none = none) (_ : some j✝ = some j✝)
      (_ : HEq (Hom.init j✝ ≫ Hom.id (some j✝)) (Hom.init j✝ ≫ Hom.id (some j✝))) =
    arrows j✝
[PROOFSTEP]
congr
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
j : WidePushoutShape J
⊢ F.obj j = (wideSpan (F.obj none) (fun j => F.obj (some j)) fun j => F.map (Hom.init j)).obj j
[PROOFSTEP]
cases j
[GOAL]
case none
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
⊢ F.obj none = (wideSpan (F.obj none) (fun j => F.obj (some j)) fun j => F.map (Hom.init j)).obj none
case some
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
val✝ : J
⊢ F.obj (some val✝) = (wideSpan (F.obj none) (fun j => F.obj (some j)) fun j => F.map (Hom.init j)).obj (some val✝)
[PROOFSTEP]
repeat rfl
[GOAL]
case none
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
⊢ F.obj none = (wideSpan (F.obj none) (fun j => F.obj (some j)) fun j => F.map (Hom.init j)).obj none
case some
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
val✝ : J
⊢ F.obj (some val✝) = (wideSpan (F.obj none) (fun j => F.obj (some j)) fun j => F.map (Hom.init j)).obj (some val✝)
[PROOFSTEP]
rfl
[GOAL]
case some
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
val✝ : J
⊢ F.obj (some val✝) = (wideSpan (F.obj none) (fun j => F.obj (some j)) fun j => F.map (Hom.init j)).obj (some val✝)
[PROOFSTEP]
rfl
[GOAL]

[PROOFSTEP]
rfl
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f✝ : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f✝
j j' : WidePushoutShape J
f : j ⟶ j'
⊢ F.map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        j' =
    (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        j ≫
      ((Functor.const (WidePushoutShape J)).obj X).map f
[PROOFSTEP]
cases j
[GOAL]
case none
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f✝ : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f✝
j' : WidePushoutShape J
f : none ⟶ j'
⊢ F.map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        j' =
    (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        none ≫
      ((Functor.const (WidePushoutShape J)).obj X).map f
[PROOFSTEP]
cases j'
[GOAL]
case some
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f✝ : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f✝
j' : WidePushoutShape J
val✝ : J
f : some val✝ ⟶ j'
⊢ F.map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        j' =
    (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        (some val✝) ≫
      ((Functor.const (WidePushoutShape J)).obj X).map f
[PROOFSTEP]
cases j'
[GOAL]
case none.none
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f✝ : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f✝
f : none ⟶ none
⊢ F.map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        none =
    (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        none ≫
      ((Functor.const (WidePushoutShape J)).obj X).map f
[PROOFSTEP]
cases f
[GOAL]
case none.some
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f✝ : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f✝
val✝ : J
f : none ⟶ some val✝
⊢ F.map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        (some val✝) =
    (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        none ≫
      ((Functor.const (WidePushoutShape J)).obj X).map f
[PROOFSTEP]
cases f
[GOAL]
case some.none
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f✝ : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f✝
val✝ : J
f : some val✝ ⟶ none
⊢ F.map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        none =
    (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        (some val✝) ≫
      ((Functor.const (WidePushoutShape J)).obj X).map f
[PROOFSTEP]
cases f
[GOAL]
case some.some
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f✝ : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f✝
val✝¹ val✝ : J
f : some val✝¹ ⟶ some val✝
⊢ F.map f ≫
      (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        (some val✝) =
    (fun j =>
          match j with
          | none => f✝
          | some j => ι j)
        (some val✝¹) ≫
      ((Functor.const (WidePushoutShape J)).obj X).map f
[PROOFSTEP]
cases f
[GOAL]
case none.none.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f
⊢ F.map (Hom.id none) ≫
      (fun j =>
          match j with
          | none => f
          | some j => ι j)
        none =
    (fun j =>
          match j with
          | none => f
          | some j => ι j)
        none ≫
      ((Functor.const (WidePushoutShape J)).obj X).map (Hom.id none)
[PROOFSTEP]
refine id _
[GOAL]
case none.some.init
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f
val✝ : J
⊢ F.map (Hom.init val✝) ≫
      (fun j =>
          match j with
          | none => f
          | some j => ι j)
        (some val✝) =
    (fun j =>
          match j with
          | none => f
          | some j => ι j)
        none ≫
      ((Functor.const (WidePushoutShape J)).obj X).map (Hom.init val✝)
[PROOFSTEP]
refine id _
[GOAL]
case some.some.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f
val✝ : J
⊢ F.map (Hom.id (some val✝)) ≫
      (fun j =>
          match j with
          | none => f
          | some j => ι j)
        (some val✝) =
    (fun j =>
          match j with
          | none => f
          | some j => ι j)
        (some val✝) ≫
      ((Functor.const (WidePushoutShape J)).obj X).map (Hom.id (some val✝))
[PROOFSTEP]
refine id _
[GOAL]
case none.none.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f
⊢ F.map (Hom.id none) ≫
      (fun j =>
          match j with
          | none => f
          | some j => ι j)
        none =
    (fun j =>
          match j with
          | none => f
          | some j => ι j)
        none ≫
      ((Functor.const (WidePushoutShape J)).obj X).map (Hom.id none)
[PROOFSTEP]
dsimp
[GOAL]
case none.some.init
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f
val✝ : J
⊢ F.map (Hom.init val✝) ≫
      (fun j =>
          match j with
          | none => f
          | some j => ι j)
        (some val✝) =
    (fun j =>
          match j with
          | none => f
          | some j => ι j)
        none ≫
      ((Functor.const (WidePushoutShape J)).obj X).map (Hom.init val✝)
[PROOFSTEP]
dsimp
[GOAL]
case some.some.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f
val✝ : J
⊢ F.map (Hom.id (some val✝)) ≫
      (fun j =>
          match j with
          | none => f
          | some j => ι j)
        (some val✝) =
    (fun j =>
          match j with
          | none => f
          | some j => ι j)
        (some val✝) ≫
      ((Functor.const (WidePushoutShape J)).obj X).map (Hom.id (some val✝))
[PROOFSTEP]
dsimp
[GOAL]
case none.none.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f
⊢ F.map (𝟙 none) ≫ f = f ≫ 𝟙 X
[PROOFSTEP]
simp [w]
[GOAL]
case none.some.init
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f
val✝ : J
⊢ F.map (Hom.init val✝) ≫ ι val✝ = f ≫ 𝟙 X
[PROOFSTEP]
simp [w]
[GOAL]
case some.some.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
F : WidePushoutShape J ⥤ C
X : C
f : F.obj none ⟶ X
ι : (j : J) → F.obj (some j) ⟶ X
w : ∀ (j : J), F.map (Hom.init j) ≫ ι j = f
val✝ : J
⊢ F.map (𝟙 (some val✝)) ≫ ι val✝ = ι val✝ ≫ 𝟙 X
[PROOFSTEP]
simp [w]
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
J' : Type w'
h : J ≃ J'
j : WidePushoutShape J
⊢ (𝟭 (WidePushoutShape J)).obj j ≅
    ((wideSpan none (fun j => some (↑h j)) fun j => Hom.init (↑h j)) ⋙
          wideSpan none (fun j => some (Equiv.invFun h j)) fun j => Hom.init (Equiv.invFun h j)).obj
      j
[PROOFSTEP]
aesop_cat_nonterminal
[GOAL]
case none
J : Type w
C : Type u
inst : Category.{v, u} C
J' : Type w'
h : J ≃ J'
⊢ none ≅ none
case some J : Type w C : Type u inst : Category.{v, u} C J' : Type w' h : J ≃ J' val✝ : J ⊢ some val✝ ≅ some val✝
[PROOFSTEP]
repeat rfl
[GOAL]
case none
J : Type w
C : Type u
inst : Category.{v, u} C
J' : Type w'
h : J ≃ J'
⊢ none ≅ none
case some J : Type w C : Type u inst : Category.{v, u} C J' : Type w' h : J ≃ J' val✝ : J ⊢ some val✝ ≅ some val✝
[PROOFSTEP]
rfl
[GOAL]
case some
J : Type w
C : Type u
inst : Category.{v, u} C
J' : Type w'
h : J ≃ J'
val✝ : J
⊢ some val✝ ≅ some val✝
[PROOFSTEP]
rfl
[GOAL]

[PROOFSTEP]
rfl
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
J' : Type w'
h : J ≃ J'
X✝ Y✝ : WidePushoutShape J
f : X✝ ⟶ Y✝
⊢ (𝟭 (WidePushoutShape J)).map f ≫
      ((fun j =>
            id
              (Option.casesOn j (id (Iso.refl none)) fun val =>
                Eq.mpr
                  (_ :
                    (some val ≅
                        Option.rec none (fun val => some (↑h.symm val))
                          (Option.rec none (fun val => some (↑h val)) (some val))) =
                      (some val ≅ some val))
                  (Iso.refl (some val))))
          Y✝).hom =
    ((fun j =>
            id
              (Option.casesOn j (id (Iso.refl none)) fun val =>
                Eq.mpr
                  (_ :
                    (some val ≅
                        Option.rec none (fun val => some (↑h.symm val))
                          (Option.rec none (fun val => some (↑h val)) (some val))) =
                      (some val ≅ some val))
                  (Iso.refl (some val))))
          X✝).hom ≫
      ((wideSpan none (fun j => some (↑h j)) fun j => Hom.init (↑h j)) ⋙
            wideSpan none (fun j => some (Equiv.invFun h j)) fun j => Hom.init (Equiv.invFun h j)).map
        f
[PROOFSTEP]
simp only [eq_iff_true_of_subsingleton]
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
J' : Type w'
h : J ≃ J'
j : WidePushoutShape J'
⊢ ((wideSpan none (fun j => some (Equiv.invFun h j)) fun j => Hom.init (Equiv.invFun h j)) ⋙
          wideSpan none (fun j => some (↑h j)) fun j => Hom.init (↑h j)).obj
      j ≅
    (𝟭 (WidePushoutShape J')).obj j
[PROOFSTEP]
aesop_cat_nonterminal
[GOAL]
case none
J : Type w
C : Type u
inst : Category.{v, u} C
J' : Type w'
h : J ≃ J'
⊢ none ≅ none
case some J : Type w C : Type u inst : Category.{v, u} C J' : Type w' h : J ≃ J' val✝ : J' ⊢ some val✝ ≅ some val✝
[PROOFSTEP]
repeat rfl
[GOAL]
case none
J : Type w
C : Type u
inst : Category.{v, u} C
J' : Type w'
h : J ≃ J'
⊢ none ≅ none
case some J : Type w C : Type u inst : Category.{v, u} C J' : Type w' h : J ≃ J' val✝ : J' ⊢ some val✝ ≅ some val✝
[PROOFSTEP]
rfl
[GOAL]
case some
J : Type w
C : Type u
inst : Category.{v, u} C
J' : Type w'
h : J ≃ J'
val✝ : J'
⊢ some val✝ ≅ some val✝
[PROOFSTEP]
rfl
[GOAL]

[PROOFSTEP]
rfl
[GOAL]
J : Type w
C : Type u
inst✝ : Category.{v, u} C
J' : Type w'
h : J ≃ J'
X✝ Y✝ : WidePushoutShape J'
f : X✝ ⟶ Y✝
⊢ ((wideSpan none (fun j => some (Equiv.invFun h j)) fun j => Hom.init (Equiv.invFun h j)) ⋙
            wideSpan none (fun j => some (↑h j)) fun j => Hom.init (↑h j)).map
        f ≫
      ((fun j =>
            id
              (Option.casesOn j (id (Iso.refl none)) fun val =>
                Eq.mpr
                  (_ :
                    (Option.rec none (fun val => some (↑h val))
                          (Option.rec none (fun val => some (↑h.symm val)) (some val)) ≅
                        some val) =
                      (some val ≅ some val))
                  (Iso.refl (some val))))
          Y✝).hom =
    ((fun j =>
            id
              (Option.casesOn j (id (Iso.refl none)) fun val =>
                Eq.mpr
                  (_ :
                    (Option.rec none (fun val => some (↑h val))
                          (Option.rec none (fun val => some (↑h.symm val)) (some val)) ≅
                        some val) =
                      (some val ≅ some val))
                  (Iso.refl (some val))))
          X✝).hom ≫
      (𝟭 (WidePushoutShape J')).map f
[PROOFSTEP]
simp only [eq_iff_true_of_subsingleton]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
j : J
⊢ π arrows j ≫ arrows j = base arrows
[PROOFSTEP]
apply limit.w (WidePullbackShape.wideCospan _ _ _) (WidePullbackShape.Hom.term j)
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
j : J
⊢ lift f fs w ≫ π arrows j = fs j
[PROOFSTEP]
simp only [limit.lift_π, WidePullbackShape.mkCone_pt, WidePullbackShape.mkCone_π_app]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
⊢ lift f fs w ≫ base arrows = f
[PROOFSTEP]
simp only [limit.lift_π, WidePullbackShape.mkCone_pt, WidePullbackShape.mkCone_π_app]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
⊢ (∀ (j : J), g ≫ π arrows j = fs j) → g ≫ base arrows = f → g = lift f fs w
[PROOFSTEP]
intro h1 h2
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g ≫ π arrows j = fs j
h2 : g ≫ base arrows = f
⊢ g = lift f fs w
[PROOFSTEP]
apply (limit.isLimit (WidePullbackShape.wideCospan B objs arrows)).uniq (WidePullbackShape.mkCone f fs <| w)
[GOAL]
case x
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g ≫ π arrows j = fs j
h2 : g ≫ base arrows = f
⊢ ∀ (j : WidePullbackShape J),
    g ≫ NatTrans.app (limit.cone (WidePullbackShape.wideCospan B objs arrows)).π j =
      NatTrans.app (WidePullbackShape.mkCone f fs w).π j
[PROOFSTEP]
rintro (_ | _)
[GOAL]
case x.none
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g ≫ π arrows j = fs j
h2 : g ≫ base arrows = f
⊢ g ≫ NatTrans.app (limit.cone (WidePullbackShape.wideCospan B objs arrows)).π none =
    NatTrans.app (WidePullbackShape.mkCone f fs w).π none
[PROOFSTEP]
apply h2
[GOAL]
case x.some
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g ≫ π arrows j = fs j
h2 : g ≫ base arrows = f
val✝ : J
⊢ g ≫ NatTrans.app (limit.cone (WidePullbackShape.wideCospan B objs arrows)).π (some val✝) =
    NatTrans.app (WidePullbackShape.mkCone f fs w).π (some val✝)
[PROOFSTEP]
apply h1
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type ?u.192408
inst✝¹ : Category.{v₂, ?u.192408} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
⊢ ∀ (j : J), (fun j => g ≫ π arrows j) j ≫ arrows j = g ≫ base arrows
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
⊢ g = lift (g ≫ base arrows) (fun j => g ≫ π arrows j) (_ : ∀ (j : J), (g ≫ π arrows j) ≫ arrows j = g ≫ base arrows)
[PROOFSTEP]
apply eq_lift_of_comp_eq
[GOAL]
case a
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
⊢ ∀ (j : J), g ≫ π arrows j = g ≫ π arrows j
case a
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
⊢ g ≫ base arrows = g ≫ base arrows
[PROOFSTEP]
aesop_cat
[GOAL]
case a
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
⊢ g ≫ base arrows = g ≫ base arrows
[PROOFSTEP]
rfl
  -- Porting note: quite a few missing refl's in aesop_cat now
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B (fun j => objs j) arrows
⊢ (∀ (j : J), g1 ≫ π arrows j = g2 ≫ π arrows j) → g1 ≫ base arrows = g2 ≫ base arrows → g1 = g2
[PROOFSTEP]
intro h1 h2
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g1 ≫ π arrows j = g2 ≫ π arrows j
h2 : g1 ≫ base arrows = g2 ≫ base arrows
⊢ g1 = g2
[PROOFSTEP]
apply limit.hom_ext
[GOAL]
case w
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B (fun j => objs j) 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 (fun j => objs j) arrows) j =
      g2 ≫ limit.π (WidePullbackShape.wideCospan B (fun j => objs j) arrows) j
[PROOFSTEP]
rintro (_ | _)
[GOAL]
case w.none
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g1 ≫ π arrows j = g2 ≫ π arrows j
h2 : g1 ≫ base arrows = g2 ≫ base arrows
⊢ g1 ≫ limit.π (WidePullbackShape.wideCospan B (fun j => objs j) arrows) none =
    g2 ≫ limit.π (WidePullbackShape.wideCospan B (fun j => objs j) arrows) none
[PROOFSTEP]
apply h2
[GOAL]
case w.some
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g1 g2 : X ⟶ widePullback B (fun j => objs j) arrows
h1 : ∀ (j : J), g1 ≫ π arrows j = g2 ≫ π arrows j
h2 : g1 ≫ base arrows = g2 ≫ base arrows
val✝ : J
⊢ g1 ≫ limit.π (WidePullbackShape.wideCospan B (fun j => objs j) arrows) (some val✝) =
    g2 ≫ limit.π (WidePullbackShape.wideCospan B (fun j => objs j) arrows) (some val✝)
[PROOFSTEP]
apply h1
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
j : J
⊢ arrows j ≫ ι arrows j = head arrows
[PROOFSTEP]
apply colimit.w (WidePushoutShape.wideSpan _ _ _) (WidePushoutShape.Hom.init j)
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
j : J
⊢ ι arrows j ≫ desc f fs w = fs j
[PROOFSTEP]
simp only [colimit.ι_desc, WidePushoutShape.mkCocone_pt, WidePushoutShape.mkCocone_ι_app]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
⊢ head arrows ≫ desc f fs w = f
[PROOFSTEP]
simp only [colimit.ι_desc, WidePushoutShape.mkCocone_pt, WidePushoutShape.mkCocone_ι_app]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
⊢ (∀ (j : J), ι arrows j ≫ g = fs j) → head arrows ≫ g = f → g = desc f fs w
[PROOFSTEP]
intro h1 h2
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
h1 : ∀ (j : J), ι arrows j ≫ g = fs j
h2 : head arrows ≫ g = f
⊢ g = desc f fs w
[PROOFSTEP]
apply (colimit.isColimit (WidePushoutShape.wideSpan B objs arrows)).uniq (WidePushoutShape.mkCocone f fs <| w)
[GOAL]
case x
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
h1 : ∀ (j : J), ι arrows j ≫ g = fs j
h2 : head arrows ≫ g = f
⊢ ∀ (j : WidePushoutShape J),
    NatTrans.app (colimit.cocone (WidePushoutShape.wideSpan B objs arrows)).ι j ≫ g =
      NatTrans.app (WidePushoutShape.mkCocone f fs w).ι j
[PROOFSTEP]
rintro (_ | _)
[GOAL]
case x.none
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
h1 : ∀ (j : J), ι arrows j ≫ g = fs j
h2 : head arrows ≫ g = f
⊢ NatTrans.app (colimit.cocone (WidePushoutShape.wideSpan B objs arrows)).ι none ≫ g =
    NatTrans.app (WidePushoutShape.mkCocone f fs w).ι none
[PROOFSTEP]
apply h2
[GOAL]
case x.some
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
h1 : ∀ (j : J), ι arrows j ≫ g = fs j
h2 : head arrows ≫ g = f
val✝ : J
⊢ NatTrans.app (colimit.cocone (WidePushoutShape.wideSpan B objs arrows)).ι (some val✝) ≫ g =
    NatTrans.app (WidePushoutShape.mkCocone f fs w).ι (some val✝)
[PROOFSTEP]
apply h1
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type ?u.203710
inst✝¹ : Category.{v₂, ?u.203710} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
j : J
⊢ arrows j ≫ (fun j => ι arrows j ≫ g) j = head arrows ≫ g
[PROOFSTEP]
rw [← Category.assoc]
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type ?u.203710
inst✝¹ : Category.{v₂, ?u.203710} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
j : J
⊢ (arrows j ≫ ι arrows j) ≫ g = head arrows ≫ g
[PROOFSTEP]
simp
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
⊢ g =
    desc (head arrows ≫ g) (fun j => ι arrows j ≫ g)
      (_ : ∀ (j : J), arrows j ≫ (fun j => ι arrows j ≫ g) j = head arrows ≫ g)
[PROOFSTEP]
apply eq_desc_of_comp_eq
[GOAL]
case a
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
⊢ ∀ (j : J), ι arrows j ≫ g = ι arrows j ≫ g
case a
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
⊢ head arrows ≫ g = head arrows ≫ g
[PROOFSTEP]
aesop_cat
[GOAL]
case a
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B (fun j => objs j) arrows ⟶ X
⊢ head arrows ≫ g = head arrows ≫ g
[PROOFSTEP]
rfl
  -- Porting note: another missing rfl
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g1 g2 : widePushout B (fun j => objs j) arrows ⟶ X
⊢ (∀ (j : J), ι arrows j ≫ g1 = ι arrows j ≫ g2) → head arrows ≫ g1 = head arrows ≫ g2 → g1 = g2
[PROOFSTEP]
intro h1 h2
[GOAL]
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g1 g2 : widePushout B (fun j => objs j) arrows ⟶ X
h1 : ∀ (j : J), ι arrows j ≫ g1 = ι arrows j ≫ g2
h2 : head arrows ≫ g1 = head arrows ≫ g2
⊢ g1 = g2
[PROOFSTEP]
apply colimit.hom_ext
[GOAL]
case w
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g1 g2 : widePushout B (fun j => objs j) arrows ⟶ X
h1 : ∀ (j : J), ι arrows j ≫ g1 = ι arrows j ≫ g2
h2 : head arrows ≫ g1 = head arrows ≫ g2
⊢ ∀ (j : WidePushoutShape J),
    colimit.ι (WidePushoutShape.wideSpan B (fun j => objs j) arrows) j ≫ g1 =
      colimit.ι (WidePushoutShape.wideSpan B (fun j => objs j) arrows) j ≫ g2
[PROOFSTEP]
rintro (_ | _)
[GOAL]
case w.none
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g1 g2 : widePushout B (fun j => objs j) arrows ⟶ X
h1 : ∀ (j : J), ι arrows j ≫ g1 = ι arrows j ≫ g2
h2 : head arrows ≫ g1 = head arrows ≫ g2
⊢ colimit.ι (WidePushoutShape.wideSpan B (fun j => objs j) arrows) none ≫ g1 =
    colimit.ι (WidePushoutShape.wideSpan B (fun j => objs j) arrows) none ≫ g2
[PROOFSTEP]
apply h2
[GOAL]
case w.some
J : Type w
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{v₂, u_1} D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g1 g2 : widePushout B (fun j => objs j) arrows ⟶ X
h1 : ∀ (j : J), ι arrows j ≫ g1 = ι arrows j ≫ g2
h2 : head arrows ≫ g1 = head arrows ≫ g2
val✝ : J
⊢ colimit.ι (WidePushoutShape.wideSpan B (fun j => objs j) arrows) (some val✝) ≫ g1 =
    colimit.ι (WidePushoutShape.wideSpan B (fun j => objs j) arrows) (some val✝) ≫ g2
[PROOFSTEP]
apply h1