[GOAL]
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝¹ : One M
inst✝ : One N
f : OneHom M N
g : N → M
h₁ : Function.LeftInverse g ↑f
⊢ g 1 = 1
[PROOFSTEP]
rw [← f.map_one, h₁]
[GOAL]
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝¹ : Mul M
inst✝ : Mul N
f : M →ₙ* N
g : N → M
h₁ : Function.LeftInverse g ↑f
h₂ : Function.RightInverse g ↑f
x y : N
⊢ g (x * y) = g (↑f (g x) * ↑f (g y))
[PROOFSTEP]
rw [h₂ x, h₂ y]
[GOAL]
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝¹ : Mul M
inst✝ : Mul N
f : M →ₙ* N
g : N → M
h₁ : Function.LeftInverse g ↑f
h₂ : Function.RightInverse g ↑f
x y : N
⊢ g (↑f (g x) * ↑f (g y)) = g (↑f (g x * g y))
[PROOFSTEP]
rw [f.map_mul]
[GOAL]
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulEquivClass F M N
src✝ : MulHomClass F M N := instMulHomClass F
e : F
⊢ ↑e 1 * ↑e (EquivLike.inv e 1) = ↑e (EquivLike.inv e 1)
[PROOFSTEP]
rw [← map_mul, one_mul]
[GOAL]
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝² : MulZeroClass α
inst✝¹ : MulZeroClass β
inst✝ : MulEquivClass F α β
e : F
⊢ ↑e 0 = ↑e 0 * ↑e (EquivLike.inv e 0)
[PROOFSTEP]
rw [← map_mul, zero_mul]
[GOAL]
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝² : MulZeroClass α
inst✝¹ : MulZeroClass β
inst✝ : MulEquivClass F α β
e : F
⊢ ↑e 0 * ↑e (EquivLike.inv e 0) = 0
[PROOFSTEP]
simp
  -- See note [lower instance priority]
[GOAL]
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝¹ : Mul M
inst✝ : Mul N
f g : M ≃* N
h₁ : (fun f => f.toFun) f = (fun f => f.toFun) g
h₂ : (fun f => f.invFun) f = (fun f => f.invFun) g
⊢ f = g
[PROOFSTEP]
cases f
[GOAL]
case mk
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝¹ : Mul M
inst✝ : Mul N
g : M ≃* N
toEquiv✝ : M ≃ N
map_mul'✝ : ∀ (x y : M), Equiv.toFun toEquiv✝ (x * y) = Equiv.toFun toEquiv✝ x * Equiv.toFun toEquiv✝ y
h₁ : (fun f => f.toFun) { toEquiv := toEquiv✝, map_mul' := map_mul'✝ } = (fun f => f.toFun) g
h₂ : (fun f => f.invFun) { toEquiv := toEquiv✝, map_mul' := map_mul'✝ } = (fun f => f.invFun) g
⊢ { toEquiv := toEquiv✝, map_mul' := map_mul'✝ } = g
[PROOFSTEP]
cases g
[GOAL]
case mk.mk
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝¹ : Mul M
inst✝ : Mul N
toEquiv✝¹ : M ≃ N
map_mul'✝¹ : ∀ (x y : M), Equiv.toFun toEquiv✝¹ (x * y) = Equiv.toFun toEquiv✝¹ x * Equiv.toFun toEquiv✝¹ y
toEquiv✝ : M ≃ N
map_mul'✝ : ∀ (x y : M), Equiv.toFun toEquiv✝ (x * y) = Equiv.toFun toEquiv✝ x * Equiv.toFun toEquiv✝ y
h₁ :
  (fun f => f.toFun) { toEquiv := toEquiv✝¹, map_mul' := map_mul'✝¹ } =
    (fun f => f.toFun) { toEquiv := toEquiv✝, map_mul' := map_mul'✝ }
h₂ :
  (fun f => f.invFun) { toEquiv := toEquiv✝¹, map_mul' := map_mul'✝¹ } =
    (fun f => f.invFun) { toEquiv := toEquiv✝, map_mul' := map_mul'✝ }
⊢ { toEquiv := toEquiv✝¹, map_mul' := map_mul'✝¹ } = { toEquiv := toEquiv✝, map_mul' := map_mul'✝ }
[PROOFSTEP]
congr
[GOAL]
case mk.mk.e_toEquiv
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝¹ : Mul M
inst✝ : Mul N
toEquiv✝¹ : M ≃ N
map_mul'✝¹ : ∀ (x y : M), Equiv.toFun toEquiv✝¹ (x * y) = Equiv.toFun toEquiv✝¹ x * Equiv.toFun toEquiv✝¹ y
toEquiv✝ : M ≃ N
map_mul'✝ : ∀ (x y : M), Equiv.toFun toEquiv✝ (x * y) = Equiv.toFun toEquiv✝ x * Equiv.toFun toEquiv✝ y
h₁ :
  (fun f => f.toFun) { toEquiv := toEquiv✝¹, map_mul' := map_mul'✝¹ } =
    (fun f => f.toFun) { toEquiv := toEquiv✝, map_mul' := map_mul'✝ }
h₂ :
  (fun f => f.invFun) { toEquiv := toEquiv✝¹, map_mul' := map_mul'✝¹ } =
    (fun f => f.invFun) { toEquiv := toEquiv✝, map_mul' := map_mul'✝ }
⊢ toEquiv✝¹ = toEquiv✝
[PROOFSTEP]
apply Equiv.coe_fn_injective h₁
[GOAL]
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝³ : Mul M
inst✝² : Mul N
inst✝¹ : Mul P
inst✝ : Mul Q
h1 : M ≃* N
h2 : N ≃* P
src✝ : M ≃ P := h1.trans h2.toEquiv
x y : M
⊢ ↑h2 (↑h1 (x * y)) = ↑h2 (↑h1 x) * ↑h2 (↑h1 y)
[PROOFSTEP]
rw [h1.map_mul, h2.map_mul]
[GOAL]
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M✝ : Type u_6
N✝ : Type u_7
P✝ : Type u_8
Q✝ : Type u_9
G : Type u_10
H : Type u_11
inst✝⁵ : Mul M✝
inst✝⁴ : Mul N✝
inst✝³ : Mul P✝
inst✝² : Mul Q✝
M : Type u_12
N : Type u_13
P : Type u_14
Q : Type u_15
inst✝¹ : Mul P
inst✝ : Mul Q
f : M ≃ N
g : P ≃* Q
h : M → P
⊢ (fun k m => ↑(symm g) (k (↑f m))) ((fun h n => ↑g (h (↑f.symm n))) h) = h
[PROOFSTEP]
ext
[GOAL]
case h
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M✝ : Type u_6
N✝ : Type u_7
P✝ : Type u_8
Q✝ : Type u_9
G : Type u_10
H : Type u_11
inst✝⁵ : Mul M✝
inst✝⁴ : Mul N✝
inst✝³ : Mul P✝
inst✝² : Mul Q✝
M : Type u_12
N : Type u_13
P : Type u_14
Q : Type u_15
inst✝¹ : Mul P
inst✝ : Mul Q
f : M ≃ N
g : P ≃* Q
h : M → P
x✝ : M
⊢ (fun k m => ↑(symm g) (k (↑f m))) ((fun h n => ↑g (h (↑f.symm n))) h) x✝ = h x✝
[PROOFSTEP]
simp
[GOAL]
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M✝ : Type u_6
N✝ : Type u_7
P✝ : Type u_8
Q✝ : Type u_9
G : Type u_10
H : Type u_11
inst✝⁵ : Mul M✝
inst✝⁴ : Mul N✝
inst✝³ : Mul P✝
inst✝² : Mul Q✝
M : Type u_12
N : Type u_13
P : Type u_14
Q : Type u_15
inst✝¹ : Mul P
inst✝ : Mul Q
f : M ≃ N
g : P ≃* Q
k : N → Q
⊢ (fun h n => ↑g (h (↑f.symm n))) ((fun k m => ↑(symm g) (k (↑f m))) k) = k
[PROOFSTEP]
ext
[GOAL]
case h
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M✝ : Type u_6
N✝ : Type u_7
P✝ : Type u_8
Q✝ : Type u_9
G : Type u_10
H : Type u_11
inst✝⁵ : Mul M✝
inst✝⁴ : Mul N✝
inst✝³ : Mul P✝
inst✝² : Mul Q✝
M : Type u_12
N : Type u_13
P : Type u_14
Q : Type u_15
inst✝¹ : Mul P
inst✝ : Mul Q
f : M ≃ N
g : P ≃* Q
k : N → Q
x✝ : N
⊢ (fun h n => ↑g (h (↑f.symm n))) ((fun k m => ↑(symm g) (k (↑f m))) k) x✝ = k x✝
[PROOFSTEP]
simp
[GOAL]
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M✝ : Type u_6
N✝ : Type u_7
P✝ : Type u_8
Q✝ : Type u_9
G : Type u_10
H : Type u_11
inst✝⁵ : Mul M✝
inst✝⁴ : Mul N✝
inst✝³ : Mul P✝
inst✝² : Mul Q✝
M : Type u_12
N : Type u_13
P : Type u_14
Q : Type u_15
inst✝¹ : Mul P
inst✝ : Mul Q
f : M ≃ N
g : P ≃* Q
h k : M → P
⊢ Equiv.toFun
      { toFun := fun h n => ↑g (h (↑f.symm n)), invFun := fun k m => ↑(symm g) (k (↑f m)),
        left_inv := (_ : ∀ (h : M → P), (fun k m => ↑(symm g) (k (↑f m))) ((fun h n => ↑g (h (↑f.symm n))) h) = h),
        right_inv := (_ : ∀ (k : N → Q), (fun h n => ↑g (h (↑f.symm n))) ((fun k m => ↑(symm g) (k (↑f m))) k) = k) }
      (h * k) =
    Equiv.toFun
        { toFun := fun h n => ↑g (h (↑f.symm n)), invFun := fun k m => ↑(symm g) (k (↑f m)),
          left_inv := (_ : ∀ (h : M → P), (fun k m => ↑(symm g) (k (↑f m))) ((fun h n => ↑g (h (↑f.symm n))) h) = h),
          right_inv := (_ : ∀ (k : N → Q), (fun h n => ↑g (h (↑f.symm n))) ((fun k m => ↑(symm g) (k (↑f m))) k) = k) }
        h *
      Equiv.toFun
        { toFun := fun h n => ↑g (h (↑f.symm n)), invFun := fun k m => ↑(symm g) (k (↑f m)),
          left_inv := (_ : ∀ (h : M → P), (fun k m => ↑(symm g) (k (↑f m))) ((fun h n => ↑g (h (↑f.symm n))) h) = h),
          right_inv := (_ : ∀ (k : N → Q), (fun h n => ↑g (h (↑f.symm n))) ((fun k m => ↑(symm g) (k (↑f m))) k) = k) }
        k
[PROOFSTEP]
ext
[GOAL]
case h
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M✝ : Type u_6
N✝ : Type u_7
P✝ : Type u_8
Q✝ : Type u_9
G : Type u_10
H : Type u_11
inst✝⁵ : Mul M✝
inst✝⁴ : Mul N✝
inst✝³ : Mul P✝
inst✝² : Mul Q✝
M : Type u_12
N : Type u_13
P : Type u_14
Q : Type u_15
inst✝¹ : Mul P
inst✝ : Mul Q
f : M ≃ N
g : P ≃* Q
h k : M → P
x✝ : N
⊢ Equiv.toFun
      { toFun := fun h n => ↑g (h (↑f.symm n)), invFun := fun k m => ↑(symm g) (k (↑f m)),
        left_inv := (_ : ∀ (h : M → P), (fun k m => ↑(symm g) (k (↑f m))) ((fun h n => ↑g (h (↑f.symm n))) h) = h),
        right_inv := (_ : ∀ (k : N → Q), (fun h n => ↑g (h (↑f.symm n))) ((fun k m => ↑(symm g) (k (↑f m))) k) = k) }
      (h * k) x✝ =
    (Equiv.toFun
          { toFun := fun h n => ↑g (h (↑f.symm n)), invFun := fun k m => ↑(symm g) (k (↑f m)),
            left_inv := (_ : ∀ (h : M → P), (fun k m => ↑(symm g) (k (↑f m))) ((fun h n => ↑g (h (↑f.symm n))) h) = h),
            right_inv :=
              (_ : ∀ (k : N → Q), (fun h n => ↑g (h (↑f.symm n))) ((fun k m => ↑(symm g) (k (↑f m))) k) = k) }
          h *
        Equiv.toFun
          { toFun := fun h n => ↑g (h (↑f.symm n)), invFun := fun k m => ↑(symm g) (k (↑f m)),
            left_inv := (_ : ∀ (h : M → P), (fun k m => ↑(symm g) (k (↑f m))) ((fun h n => ↑g (h (↑f.symm n))) h) = h),
            right_inv :=
              (_ : ∀ (k : N → Q), (fun h n => ↑g (h (↑f.symm n))) ((fun k m => ↑(symm g) (k (↑f m))) k) = k) }
          k)
      x✝
[PROOFSTEP]
simp
[GOAL]
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M✝ : Type u_6
N✝ : Type u_7
P✝ : Type u_8
Q✝ : Type u_9
G : Type u_10
H : Type u_11
inst✝⁷ : Mul M✝
inst✝⁶ : Mul N✝
inst✝⁵ : Mul P✝
inst✝⁴ : Mul Q✝
M : Type ?u.66798
N : Type ?u.66801
P : Type ?u.66804
Q : Type ?u.66807
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommMonoid P
inst✝ : CommMonoid Q
f : M ≃* N
g : P ≃* Q
h : M →* P
⊢ (fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f)))
      ((fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f)))) h) =
    h
[PROOFSTEP]
ext
[GOAL]
case h
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M✝ : Type u_6
N✝ : Type u_7
P✝ : Type u_8
Q✝ : Type u_9
G : Type u_10
H : Type u_11
inst✝⁷ : Mul M✝
inst✝⁶ : Mul N✝
inst✝⁵ : Mul P✝
inst✝⁴ : Mul Q✝
M : Type ?u.66798
N : Type ?u.66801
P : Type ?u.66804
Q : Type ?u.66807
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommMonoid P
inst✝ : CommMonoid Q
f : M ≃* N
g : P ≃* Q
h : M →* P
x✝ : M
⊢ ↑((fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f)))
          ((fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f)))) h))
      x✝ =
    ↑h x✝
[PROOFSTEP]
simp
[GOAL]
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M✝ : Type u_6
N✝ : Type u_7
P✝ : Type u_8
Q✝ : Type u_9
G : Type u_10
H : Type u_11
inst✝⁷ : Mul M✝
inst✝⁶ : Mul N✝
inst✝⁵ : Mul P✝
inst✝⁴ : Mul Q✝
M : Type ?u.66798
N : Type ?u.66801
P : Type ?u.66804
Q : Type ?u.66807
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommMonoid P
inst✝ : CommMonoid Q
f : M ≃* N
g : P ≃* Q
k : N →* Q
⊢ (fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f))))
      ((fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f))) k) =
    k
[PROOFSTEP]
ext
[GOAL]
case h
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M✝ : Type u_6
N✝ : Type u_7
P✝ : Type u_8
Q✝ : Type u_9
G : Type u_10
H : Type u_11
inst✝⁷ : Mul M✝
inst✝⁶ : Mul N✝
inst✝⁵ : Mul P✝
inst✝⁴ : Mul Q✝
M : Type ?u.66798
N : Type ?u.66801
P : Type ?u.66804
Q : Type ?u.66807
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommMonoid P
inst✝ : CommMonoid Q
f : M ≃* N
g : P ≃* Q
k : N →* Q
x✝ : N
⊢ ↑((fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f))))
          ((fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f))) k))
      x✝ =
    ↑k x✝
[PROOFSTEP]
simp
[GOAL]
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M✝ : Type u_6
N✝ : Type u_7
P✝ : Type u_8
Q✝ : Type u_9
G : Type u_10
H : Type u_11
inst✝⁷ : Mul M✝
inst✝⁶ : Mul N✝
inst✝⁵ : Mul P✝
inst✝⁴ : Mul Q✝
M : Type ?u.66798
N : Type ?u.66801
P : Type ?u.66804
Q : Type ?u.66807
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommMonoid P
inst✝ : CommMonoid Q
f : M ≃* N
g : P ≃* Q
h k : M →* P
⊢ Equiv.toFun
      { toFun := fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f))),
        invFun := fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f)),
        left_inv :=
          (_ :
            ∀ (h : M →* P),
              (fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f)))
                  ((fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f)))) h) =
                h),
        right_inv :=
          (_ :
            ∀ (k : N →* Q),
              (fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f))))
                  ((fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f))) k) =
                k) }
      (h * k) =
    Equiv.toFun
        { toFun := fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f))),
          invFun := fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f)),
          left_inv :=
            (_ :
              ∀ (h : M →* P),
                (fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f)))
                    ((fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f)))) h) =
                  h),
          right_inv :=
            (_ :
              ∀ (k : N →* Q),
                (fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f))))
                    ((fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f))) k) =
                  k) }
        h *
      Equiv.toFun
        { toFun := fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f))),
          invFun := fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f)),
          left_inv :=
            (_ :
              ∀ (h : M →* P),
                (fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f)))
                    ((fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f)))) h) =
                  h),
          right_inv :=
            (_ :
              ∀ (k : N →* Q),
                (fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f))))
                    ((fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f))) k) =
                  k) }
        k
[PROOFSTEP]
ext
[GOAL]
case h
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M✝ : Type u_6
N✝ : Type u_7
P✝ : Type u_8
Q✝ : Type u_9
G : Type u_10
H : Type u_11
inst✝⁷ : Mul M✝
inst✝⁶ : Mul N✝
inst✝⁵ : Mul P✝
inst✝⁴ : Mul Q✝
M : Type ?u.66798
N : Type ?u.66801
P : Type ?u.66804
Q : Type ?u.66807
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommMonoid P
inst✝ : CommMonoid Q
f : M ≃* N
g : P ≃* Q
h k : M →* P
x✝ : N
⊢ ↑(Equiv.toFun
          { toFun := fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f))),
            invFun := fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f)),
            left_inv :=
              (_ :
                ∀ (h : M →* P),
                  (fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f)))
                      ((fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f)))) h) =
                    h),
            right_inv :=
              (_ :
                ∀ (k : N →* Q),
                  (fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f))))
                      ((fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f))) k) =
                    k) }
          (h * k))
      x✝ =
    ↑(Equiv.toFun
            { toFun := fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f))),
              invFun := fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f)),
              left_inv :=
                (_ :
                  ∀ (h : M →* P),
                    (fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f)))
                        ((fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f)))) h) =
                      h),
              right_inv :=
                (_ :
                  ∀ (k : N →* Q),
                    (fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f))))
                        ((fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f))) k) =
                      k) }
            h *
          Equiv.toFun
            { toFun := fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f))),
              invFun := fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f)),
              left_inv :=
                (_ :
                  ∀ (h : M →* P),
                    (fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f)))
                        ((fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f)))) h) =
                      h),
              right_inv :=
                (_ :
                  ∀ (k : N →* Q),
                    (fun h => MonoidHom.comp (toMonoidHom g) (MonoidHom.comp h (toMonoidHom (symm f))))
                        ((fun k => MonoidHom.comp (toMonoidHom (symm g)) (MonoidHom.comp k (toMonoidHom f))) k) =
                      k) }
            k)
      x✝
[PROOFSTEP]
simp


[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
⊢ pullbackFst F = pullback.snd
[PROOFSTEP]
convert
  (eq_whisker pullback.condition Limits.prod.fst : (_ : constructEqualizer F ⟶ F.obj WalkingParallelPair.zero) = _)
[GOAL]
case h.e'_2
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
⊢ pullbackFst F =
    (pullback.fst ≫ prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.left)) ≫ prod.fst
[PROOFSTEP]
simp
[GOAL]
case h.e'_3
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
⊢ pullback.snd =
    (pullback.snd ≫ prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.right)) ≫ prod.fst
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
⊢ pullbackFst F ≫ F.map WalkingParallelPairHom.left = pullbackFst F ≫ F.map WalkingParallelPairHom.right
[PROOFSTEP]
conv_rhs => rw [pullbackFst_eq_pullback_snd]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
| pullbackFst F ≫ F.map WalkingParallelPairHom.right
[PROOFSTEP]
rw [pullbackFst_eq_pullback_snd]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
| pullbackFst F ≫ F.map WalkingParallelPairHom.right
[PROOFSTEP]
rw [pullbackFst_eq_pullback_snd]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
| pullbackFst F ≫ F.map WalkingParallelPairHom.right
[PROOFSTEP]
rw [pullbackFst_eq_pullback_snd]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
⊢ pullbackFst F ≫ F.map WalkingParallelPairHom.left = pullback.snd ≫ F.map WalkingParallelPairHom.right
[PROOFSTEP]
convert
  (eq_whisker pullback.condition Limits.prod.snd : (_ : constructEqualizer F ⟶ F.obj WalkingParallelPair.one) = _) using
  1
[GOAL]
case h.e'_2
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
⊢ pullbackFst F ≫ F.map WalkingParallelPairHom.left =
    (pullback.fst ≫ prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.left)) ≫ prod.snd
[PROOFSTEP]
simp
[GOAL]
case h.e'_3
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
⊢ pullback.snd ≫ F.map WalkingParallelPairHom.right =
    (pullback.snd ≫ prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.right)) ≫ prod.snd
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
⊢ (s : Cone F) → s.pt ⟶ (equalizerCone F).pt
[PROOFSTEP]
intro c
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
c : Cone F
⊢ c.pt ⟶ (equalizerCone F).pt
[PROOFSTEP]
apply pullback.lift (c.π.app _) (c.π.app _)
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
c : Cone F
⊢ NatTrans.app c.π WalkingParallelPair.zero ≫
      prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.left) =
    NatTrans.app c.π WalkingParallelPair.zero ≫
      prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.right)
[PROOFSTEP]
ext
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
c : Cone F
⊢ (NatTrans.app c.π WalkingParallelPair.zero ≫
        prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.left)) ≫
      prod.fst =
    (NatTrans.app c.π WalkingParallelPair.zero ≫
        prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.right)) ≫
      prod.fst
[PROOFSTEP]
simp
[GOAL]
case h₂
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
c : Cone F
⊢ (NatTrans.app c.π WalkingParallelPair.zero ≫
        prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.left)) ≫
      prod.snd =
    (NatTrans.app c.π WalkingParallelPair.zero ≫
        prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.right)) ≫
      prod.snd
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
⊢ ∀ (s : Cone F) (j : WalkingParallelPair),
    pullback.lift (NatTrans.app s.π WalkingParallelPair.zero) (NatTrans.app s.π WalkingParallelPair.zero)
          (_ :
            NatTrans.app s.π WalkingParallelPair.zero ≫
                prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.left) =
              NatTrans.app s.π WalkingParallelPair.zero ≫
                prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.right)) ≫
        NatTrans.app (equalizerCone F).π j =
      NatTrans.app s.π j
[PROOFSTEP]
rintro c (_ | _)
[GOAL]
case zero
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
c : Cone F
⊢ pullback.lift (NatTrans.app c.π WalkingParallelPair.zero) (NatTrans.app c.π WalkingParallelPair.zero)
        (_ :
          NatTrans.app c.π WalkingParallelPair.zero ≫
              prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.left) =
            NatTrans.app c.π WalkingParallelPair.zero ≫
              prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.right)) ≫
      NatTrans.app (equalizerCone F).π WalkingParallelPair.zero =
    NatTrans.app c.π WalkingParallelPair.zero
[PROOFSTEP]
simp
[GOAL]
case one
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
c : Cone F
⊢ pullback.lift (NatTrans.app c.π WalkingParallelPair.zero) (NatTrans.app c.π WalkingParallelPair.zero)
        (_ :
          NatTrans.app c.π WalkingParallelPair.zero ≫
              prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.left) =
            NatTrans.app c.π WalkingParallelPair.zero ≫
              prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.right)) ≫
      NatTrans.app (equalizerCone F).π WalkingParallelPair.one =
    NatTrans.app c.π WalkingParallelPair.one
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
⊢ ∀ (s : Cone F) (m : s.pt ⟶ (equalizerCone F).pt),
    (∀ (j : WalkingParallelPair), m ≫ NatTrans.app (equalizerCone F).π j = NatTrans.app s.π j) →
      m =
        pullback.lift (NatTrans.app s.π WalkingParallelPair.zero) (NatTrans.app s.π WalkingParallelPair.zero)
          (_ :
            NatTrans.app s.π WalkingParallelPair.zero ≫
                prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.left) =
              NatTrans.app s.π WalkingParallelPair.zero ≫
                prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.right))
[PROOFSTEP]
intro c _ J
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
c : Cone F
m✝ : c.pt ⟶ (equalizerCone F).pt
J : ∀ (j : WalkingParallelPair), m✝ ≫ NatTrans.app (equalizerCone F).π j = NatTrans.app c.π j
⊢ m✝ =
    pullback.lift (NatTrans.app c.π WalkingParallelPair.zero) (NatTrans.app c.π WalkingParallelPair.zero)
      (_ :
        NatTrans.app c.π WalkingParallelPair.zero ≫
            prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.left) =
          NatTrans.app c.π WalkingParallelPair.zero ≫
            prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.right))
[PROOFSTEP]
have J0 := J WalkingParallelPair.zero
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
c : Cone F
m✝ : c.pt ⟶ (equalizerCone F).pt
J : ∀ (j : WalkingParallelPair), m✝ ≫ NatTrans.app (equalizerCone F).π j = NatTrans.app c.π j
J0 : m✝ ≫ NatTrans.app (equalizerCone F).π WalkingParallelPair.zero = NatTrans.app c.π WalkingParallelPair.zero
⊢ m✝ =
    pullback.lift (NatTrans.app c.π WalkingParallelPair.zero) (NatTrans.app c.π WalkingParallelPair.zero)
      (_ :
        NatTrans.app c.π WalkingParallelPair.zero ≫
            prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.left) =
          NatTrans.app c.π WalkingParallelPair.zero ≫
            prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.right))
[PROOFSTEP]
simp at J0
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
c : Cone F
m✝ : c.pt ⟶ (equalizerCone F).pt
J : ∀ (j : WalkingParallelPair), m✝ ≫ NatTrans.app (equalizerCone F).π j = NatTrans.app c.π j
J0 : m✝ ≫ pullbackFst F = NatTrans.app c.π WalkingParallelPair.zero
⊢ m✝ =
    pullback.lift (NatTrans.app c.π WalkingParallelPair.zero) (NatTrans.app c.π WalkingParallelPair.zero)
      (_ :
        NatTrans.app c.π WalkingParallelPair.zero ≫
            prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.left) =
          NatTrans.app c.π WalkingParallelPair.zero ≫
            prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.right))
[PROOFSTEP]
apply pullback.hom_ext
[GOAL]
case h₀
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
c : Cone F
m✝ : c.pt ⟶ (equalizerCone F).pt
J : ∀ (j : WalkingParallelPair), m✝ ≫ NatTrans.app (equalizerCone F).π j = NatTrans.app c.π j
J0 : m✝ ≫ pullbackFst F = NatTrans.app c.π WalkingParallelPair.zero
⊢ m✝ ≫ pullback.fst =
    pullback.lift (NatTrans.app c.π WalkingParallelPair.zero) (NatTrans.app c.π WalkingParallelPair.zero)
        (_ :
          NatTrans.app c.π WalkingParallelPair.zero ≫
              prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.left) =
            NatTrans.app c.π WalkingParallelPair.zero ≫
              prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.right)) ≫
      pullback.fst
[PROOFSTEP]
rwa [limit.lift_π]
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryProducts C
inst✝ : HasPullbacks C
F : WalkingParallelPair ⥤ C
c : Cone F
m✝ : c.pt ⟶ (equalizerCone F).pt
J : ∀ (j : WalkingParallelPair), m✝ ≫ NatTrans.app (equalizerCone F).π j = NatTrans.app c.π j
J0 : m✝ ≫ pullbackFst F = NatTrans.app c.π WalkingParallelPair.zero
⊢ m✝ ≫ pullback.snd =
    pullback.lift (NatTrans.app c.π WalkingParallelPair.zero) (NatTrans.app c.π WalkingParallelPair.zero)
        (_ :
          NatTrans.app c.π WalkingParallelPair.zero ≫
              prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.left) =
            NatTrans.app c.π WalkingParallelPair.zero ≫
              prod.lift (𝟙 (F.obj WalkingParallelPair.zero)) (F.map WalkingParallelPairHom.right)) ≫
      pullback.snd
[PROOFSTEP]
erw [limit.lift_π, ← J0, pullbackFst_eq_pullback_snd]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
c : Cone (K ⋙ G)
⊢ c.pt ⟶ (G.mapCone (equalizerCone K)).pt
[PROOFSTEP]
refine' pullback.lift ?_ ?_ ?_ ≫ (PreservesPullback.iso _ _ _).inv
[GOAL]
case refine'_1
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
c : Cone (K ⋙ G)
⊢ c.pt ⟶ G.obj (K.obj WalkingParallelPair.zero)
[PROOFSTEP]
exact c.π.app WalkingParallelPair.zero
[GOAL]
case refine'_2
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
c : Cone (K ⋙ G)
⊢ c.pt ⟶ G.obj (K.obj WalkingParallelPair.zero)
[PROOFSTEP]
exact c.π.app WalkingParallelPair.zero
[GOAL]
case refine'_3
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
c : Cone (K ⋙ G)
⊢ NatTrans.app c.π WalkingParallelPair.zero ≫
      G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left)) =
    NatTrans.app c.π WalkingParallelPair.zero ≫
      G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))
[PROOFSTEP]
apply (mapIsLimitOfPreservesOfIsLimit G _ _ (prodIsProd _ _)).hom_ext
[GOAL]
case refine'_3
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
c : Cone (K ⋙ G)
⊢ ∀ (j : Discrete WalkingPair),
    (NatTrans.app c.π WalkingParallelPair.zero ≫
          G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left))) ≫
        NatTrans.app (BinaryFan.mk (G.map prod.fst) (G.map prod.snd)).π j =
      (NatTrans.app c.π WalkingParallelPair.zero ≫
          G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))) ≫
        NatTrans.app (BinaryFan.mk (G.map prod.fst) (G.map prod.snd)).π j
[PROOFSTEP]
rintro (_ | _)
[GOAL]
case refine'_3.mk.left
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
c : Cone (K ⋙ G)
⊢ (NatTrans.app c.π WalkingParallelPair.zero ≫
        G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left))) ≫
      NatTrans.app (BinaryFan.mk (G.map prod.fst) (G.map prod.snd)).π { as := WalkingPair.left } =
    (NatTrans.app c.π WalkingParallelPair.zero ≫
        G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))) ≫
      NatTrans.app (BinaryFan.mk (G.map prod.fst) (G.map prod.snd)).π { as := WalkingPair.left }
[PROOFSTEP]
simp only [Category.assoc, ← G.map_comp, prod.lift_fst, BinaryFan.π_app_left, BinaryFan.mk_fst]
[GOAL]
case refine'_3.mk.right
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
c : Cone (K ⋙ G)
⊢ (NatTrans.app c.π WalkingParallelPair.zero ≫
        G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left))) ≫
      NatTrans.app (BinaryFan.mk (G.map prod.fst) (G.map prod.snd)).π { as := WalkingPair.right } =
    (NatTrans.app c.π WalkingParallelPair.zero ≫
        G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))) ≫
      NatTrans.app (BinaryFan.mk (G.map prod.fst) (G.map prod.snd)).π { as := WalkingPair.right }
[PROOFSTEP]
simp only [BinaryFan.π_app_right, BinaryFan.mk_snd, Category.assoc, ← G.map_comp, prod.lift_snd]
[GOAL]
case refine'_3.mk.right
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
c : Cone (K ⋙ G)
⊢ NatTrans.app c.π WalkingParallelPair.zero ≫ G.map (K.map WalkingParallelPairHom.left) =
    NatTrans.app c.π WalkingParallelPair.zero ≫ G.map (K.map WalkingParallelPairHom.right)
[PROOFSTEP]
exact (c.π.naturality WalkingParallelPairHom.left).symm.trans (c.π.naturality WalkingParallelPairHom.right)
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
c : Cone (K ⋙ G)
j : WalkingParallelPair
⊢ (fun c =>
          pullback.lift (NatTrans.app c.π WalkingParallelPair.zero) (NatTrans.app c.π WalkingParallelPair.zero)
              (_ :
                NatTrans.app c.π WalkingParallelPair.zero ≫
                    G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left)) =
                  NatTrans.app c.π WalkingParallelPair.zero ≫
                    G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))) ≫
            (PreservesPullback.iso G
                (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left))
                (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))).inv)
        c ≫
      NatTrans.app (G.mapCone (equalizerCone K)).π j =
    NatTrans.app c.π j
[PROOFSTEP]
rcases j with (_ | _)
[GOAL]
case zero
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
c : Cone (K ⋙ G)
⊢ (fun c =>
          pullback.lift (NatTrans.app c.π WalkingParallelPair.zero) (NatTrans.app c.π WalkingParallelPair.zero)
              (_ :
                NatTrans.app c.π WalkingParallelPair.zero ≫
                    G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left)) =
                  NatTrans.app c.π WalkingParallelPair.zero ≫
                    G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))) ≫
            (PreservesPullback.iso G
                (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left))
                (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))).inv)
        c ≫
      NatTrans.app (G.mapCone (equalizerCone K)).π WalkingParallelPair.zero =
    NatTrans.app c.π WalkingParallelPair.zero
[PROOFSTEP]
simp only [Category.comp_id, PreservesPullback.iso_inv_fst, Cone.ofFork_π, G.map_comp,
  PreservesPullback.iso_inv_fst_assoc, Functor.mapCone_π_app, eqToHom_refl, Category.assoc, Fork.ofι_π_app,
  pullback.lift_fst, pullback.lift_fst_assoc]
[GOAL]
case one
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
c : Cone (K ⋙ G)
⊢ (fun c =>
          pullback.lift (NatTrans.app c.π WalkingParallelPair.zero) (NatTrans.app c.π WalkingParallelPair.zero)
              (_ :
                NatTrans.app c.π WalkingParallelPair.zero ≫
                    G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left)) =
                  NatTrans.app c.π WalkingParallelPair.zero ≫
                    G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))) ≫
            (PreservesPullback.iso G
                (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left))
                (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))).inv)
        c ≫
      NatTrans.app (G.mapCone (equalizerCone K)).π WalkingParallelPair.one =
    NatTrans.app c.π WalkingParallelPair.one
[PROOFSTEP]
simp only [Category.comp_id, PreservesPullback.iso_inv_fst, Cone.ofFork_π, G.map_comp,
  PreservesPullback.iso_inv_fst_assoc, Functor.mapCone_π_app, eqToHom_refl, Category.assoc, Fork.ofι_π_app,
  pullback.lift_fst, pullback.lift_fst_assoc]
[GOAL]
case one
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
c : Cone (K ⋙ G)
⊢ NatTrans.app c.π WalkingParallelPair.zero ≫ G.map (K.map WalkingParallelPairHom.left) =
    NatTrans.app c.π WalkingParallelPair.one
[PROOFSTEP]
exact (c.π.naturality WalkingParallelPairHom.left).symm.trans (Category.id_comp _)
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
s : Cone (K ⋙ G)
m : s.pt ⟶ (G.mapCone (equalizerCone K)).pt
h : ∀ (j : WalkingParallelPair), m ≫ NatTrans.app (G.mapCone (equalizerCone K)).π j = NatTrans.app s.π j
⊢ m =
    (fun c =>
        pullback.lift (NatTrans.app c.π WalkingParallelPair.zero) (NatTrans.app c.π WalkingParallelPair.zero)
            (_ :
              NatTrans.app c.π WalkingParallelPair.zero ≫
                  G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left)) =
                NatTrans.app c.π WalkingParallelPair.zero ≫
                  G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))) ≫
          (PreservesPullback.iso G (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left))
              (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))).inv)
      s
[PROOFSTEP]
rw [Iso.eq_comp_inv]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
s : Cone (K ⋙ G)
m : s.pt ⟶ (G.mapCone (equalizerCone K)).pt
h : ∀ (j : WalkingParallelPair), m ≫ NatTrans.app (G.mapCone (equalizerCone K)).π j = NatTrans.app s.π j
⊢ m ≫
      (PreservesPullback.iso G (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left))
          (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))).hom =
    pullback.lift (NatTrans.app s.π WalkingParallelPair.zero) (NatTrans.app s.π WalkingParallelPair.zero)
      (_ :
        NatTrans.app s.π WalkingParallelPair.zero ≫
            G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left)) =
          NatTrans.app s.π WalkingParallelPair.zero ≫
            G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right)))
[PROOFSTEP]
have := h WalkingParallelPair.zero
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
s : Cone (K ⋙ G)
m : s.pt ⟶ (G.mapCone (equalizerCone K)).pt
h : ∀ (j : WalkingParallelPair), m ≫ NatTrans.app (G.mapCone (equalizerCone K)).π j = NatTrans.app s.π j
this :
  m ≫ NatTrans.app (G.mapCone (equalizerCone K)).π WalkingParallelPair.zero = NatTrans.app s.π WalkingParallelPair.zero
⊢ m ≫
      (PreservesPullback.iso G (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left))
          (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))).hom =
    pullback.lift (NatTrans.app s.π WalkingParallelPair.zero) (NatTrans.app s.π WalkingParallelPair.zero)
      (_ :
        NatTrans.app s.π WalkingParallelPair.zero ≫
            G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left)) =
          NatTrans.app s.π WalkingParallelPair.zero ≫
            G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right)))
[PROOFSTEP]
dsimp [equalizerCone] at this
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
s : Cone (K ⋙ G)
m : s.pt ⟶ (G.mapCone (equalizerCone K)).pt
h : ∀ (j : WalkingParallelPair), m ≫ NatTrans.app (G.mapCone (equalizerCone K)).π j = NatTrans.app s.π j
this : m ≫ G.map (pullbackFst K ≫ 𝟙 (K.obj WalkingParallelPair.zero)) = NatTrans.app s.π WalkingParallelPair.zero
⊢ m ≫
      (PreservesPullback.iso G (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left))
          (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))).hom =
    pullback.lift (NatTrans.app s.π WalkingParallelPair.zero) (NatTrans.app s.π WalkingParallelPair.zero)
      (_ :
        NatTrans.app s.π WalkingParallelPair.zero ≫
            G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left)) =
          NatTrans.app s.π WalkingParallelPair.zero ≫
            G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right)))
[PROOFSTEP]
ext
[GOAL]
case h₀
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
s : Cone (K ⋙ G)
m : s.pt ⟶ (G.mapCone (equalizerCone K)).pt
h : ∀ (j : WalkingParallelPair), m ≫ NatTrans.app (G.mapCone (equalizerCone K)).π j = NatTrans.app s.π j
this : m ≫ G.map (pullbackFst K ≫ 𝟙 (K.obj WalkingParallelPair.zero)) = NatTrans.app s.π WalkingParallelPair.zero
⊢ (m ≫
        (PreservesPullback.iso G (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left))
            (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))).hom) ≫
      pullback.fst =
    pullback.lift (NatTrans.app s.π WalkingParallelPair.zero) (NatTrans.app s.π WalkingParallelPair.zero)
        (_ :
          NatTrans.app s.π WalkingParallelPair.zero ≫
              G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left)) =
            NatTrans.app s.π WalkingParallelPair.zero ≫
              G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))) ≫
      pullback.fst
[PROOFSTEP]
simp only [PreservesPullback.iso_hom_snd, Category.assoc, PreservesPullback.iso_hom_fst, pullback.lift_fst,
  pullback.lift_snd, Category.comp_id, ← pullbackFst_eq_pullback_snd, ← this]
[GOAL]
case h₁
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryProducts C
inst✝² : HasPullbacks C
inst✝¹ : PreservesLimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesLimitsOfShape WalkingCospan G
K : WalkingParallelPair ⥤ C
s : Cone (K ⋙ G)
m : s.pt ⟶ (G.mapCone (equalizerCone K)).pt
h : ∀ (j : WalkingParallelPair), m ≫ NatTrans.app (G.mapCone (equalizerCone K)).π j = NatTrans.app s.π j
this : m ≫ G.map (pullbackFst K ≫ 𝟙 (K.obj WalkingParallelPair.zero)) = NatTrans.app s.π WalkingParallelPair.zero
⊢ (m ≫
        (PreservesPullback.iso G (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left))
            (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))).hom) ≫
      pullback.snd =
    pullback.lift (NatTrans.app s.π WalkingParallelPair.zero) (NatTrans.app s.π WalkingParallelPair.zero)
        (_ :
          NatTrans.app s.π WalkingParallelPair.zero ≫
              G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.left)) =
            NatTrans.app s.π WalkingParallelPair.zero ≫
              G.map (prod.lift (𝟙 (K.obj WalkingParallelPair.zero)) (K.map WalkingParallelPairHom.right))) ≫
      pullback.snd
[PROOFSTEP]
simp only [PreservesPullback.iso_hom_snd, Category.assoc, PreservesPullback.iso_hom_fst, pullback.lift_fst,
  pullback.lift_snd, Category.comp_id, ← pullbackFst_eq_pullback_snd, ← this]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
⊢ pushoutInl F = pushout.inr
[PROOFSTEP]
convert (whisker_eq Limits.coprod.inl pushout.condition : (_ : F.obj _ ⟶ constructCoequalizer _) = _)
[GOAL]
case h.e'_2
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
⊢ pushoutInl F =
    coprod.inl ≫ coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫ pushout.inl
[PROOFSTEP]
simp
[GOAL]
case h.e'_3
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
⊢ pushout.inr =
    coprod.inl ≫ coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫ pushout.inr
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
⊢ F.map WalkingParallelPairHom.left ≫ pushoutInl F = F.map WalkingParallelPairHom.right ≫ pushoutInl F
[PROOFSTEP]
conv_rhs => rw [pushoutInl_eq_pushout_inr]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
| F.map WalkingParallelPairHom.right ≫ pushoutInl F
[PROOFSTEP]
rw [pushoutInl_eq_pushout_inr]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
| F.map WalkingParallelPairHom.right ≫ pushoutInl F
[PROOFSTEP]
rw [pushoutInl_eq_pushout_inr]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
| F.map WalkingParallelPairHom.right ≫ pushoutInl F
[PROOFSTEP]
rw [pushoutInl_eq_pushout_inr]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
⊢ F.map WalkingParallelPairHom.left ≫ pushoutInl F = F.map WalkingParallelPairHom.right ≫ pushout.inr
[PROOFSTEP]
convert (whisker_eq Limits.coprod.inr pushout.condition : (_ : F.obj _ ⟶ constructCoequalizer _) = _) using 1
[GOAL]
case h.e'_2
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
⊢ F.map WalkingParallelPairHom.left ≫ pushoutInl F =
    coprod.inr ≫ coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫ pushout.inl
[PROOFSTEP]
simp
[GOAL]
case h.e'_3
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
⊢ F.map WalkingParallelPairHom.right ≫ pushout.inr =
    coprod.inr ≫ coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫ pushout.inr
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
⊢ (s : Cocone F) → (coequalizerCocone F).pt ⟶ s.pt
[PROOFSTEP]
intro c
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
c : Cocone F
⊢ (coequalizerCocone F).pt ⟶ c.pt
[PROOFSTEP]
apply pushout.desc (c.ι.app _) (c.ι.app _)
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
c : Cocone F
⊢ coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫
      NatTrans.app c.ι WalkingParallelPair.one =
    coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫
      NatTrans.app c.ι WalkingParallelPair.one
[PROOFSTEP]
ext
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
c : Cocone F
⊢ coprod.inl ≫
      coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫
        NatTrans.app c.ι WalkingParallelPair.one =
    coprod.inl ≫
      coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫
        NatTrans.app c.ι WalkingParallelPair.one
[PROOFSTEP]
simp
[GOAL]
case h₂
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
c : Cocone F
⊢ coprod.inr ≫
      coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫
        NatTrans.app c.ι WalkingParallelPair.one =
    coprod.inr ≫
      coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫
        NatTrans.app c.ι WalkingParallelPair.one
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
⊢ ∀ (s : Cocone F) (j : WalkingParallelPair),
    NatTrans.app (coequalizerCocone F).ι j ≫
        pushout.desc (NatTrans.app s.ι WalkingParallelPair.one) (NatTrans.app s.ι WalkingParallelPair.one)
          (_ :
            coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫
                NatTrans.app s.ι WalkingParallelPair.one =
              coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫
                NatTrans.app s.ι WalkingParallelPair.one) =
      NatTrans.app s.ι j
[PROOFSTEP]
rintro c (_ | _)
[GOAL]
case zero
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
c : Cocone F
⊢ NatTrans.app (coequalizerCocone F).ι WalkingParallelPair.zero ≫
      pushout.desc (NatTrans.app c.ι WalkingParallelPair.one) (NatTrans.app c.ι WalkingParallelPair.one)
        (_ :
          coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫
              NatTrans.app c.ι WalkingParallelPair.one =
            coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫
              NatTrans.app c.ι WalkingParallelPair.one) =
    NatTrans.app c.ι WalkingParallelPair.zero
[PROOFSTEP]
simp
[GOAL]
case one
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
c : Cocone F
⊢ NatTrans.app (coequalizerCocone F).ι WalkingParallelPair.one ≫
      pushout.desc (NatTrans.app c.ι WalkingParallelPair.one) (NatTrans.app c.ι WalkingParallelPair.one)
        (_ :
          coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫
              NatTrans.app c.ι WalkingParallelPair.one =
            coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫
              NatTrans.app c.ι WalkingParallelPair.one) =
    NatTrans.app c.ι WalkingParallelPair.one
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
⊢ ∀ (s : Cocone F) (m : (coequalizerCocone F).pt ⟶ s.pt),
    (∀ (j : WalkingParallelPair), NatTrans.app (coequalizerCocone F).ι j ≫ m = NatTrans.app s.ι j) →
      m =
        pushout.desc (NatTrans.app s.ι WalkingParallelPair.one) (NatTrans.app s.ι WalkingParallelPair.one)
          (_ :
            coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫
                NatTrans.app s.ι WalkingParallelPair.one =
              coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫
                NatTrans.app s.ι WalkingParallelPair.one)
[PROOFSTEP]
intro c m J
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
c : Cocone F
m : (coequalizerCocone F).pt ⟶ c.pt
J : ∀ (j : WalkingParallelPair), NatTrans.app (coequalizerCocone F).ι j ≫ m = NatTrans.app c.ι j
⊢ m =
    pushout.desc (NatTrans.app c.ι WalkingParallelPair.one) (NatTrans.app c.ι WalkingParallelPair.one)
      (_ :
        coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫
            NatTrans.app c.ι WalkingParallelPair.one =
          coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫
            NatTrans.app c.ι WalkingParallelPair.one)
[PROOFSTEP]
have J1 : pushoutInl F ≫ m = c.ι.app WalkingParallelPair.one := by simpa using J WalkingParallelPair.one
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
c : Cocone F
m : (coequalizerCocone F).pt ⟶ c.pt
J : ∀ (j : WalkingParallelPair), NatTrans.app (coequalizerCocone F).ι j ≫ m = NatTrans.app c.ι j
⊢ pushoutInl F ≫ m = NatTrans.app c.ι WalkingParallelPair.one
[PROOFSTEP]
simpa using J WalkingParallelPair.one
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
c : Cocone F
m : (coequalizerCocone F).pt ⟶ c.pt
J : ∀ (j : WalkingParallelPair), NatTrans.app (coequalizerCocone F).ι j ≫ m = NatTrans.app c.ι j
J1 : pushoutInl F ≫ m = NatTrans.app c.ι WalkingParallelPair.one
⊢ m =
    pushout.desc (NatTrans.app c.ι WalkingParallelPair.one) (NatTrans.app c.ι WalkingParallelPair.one)
      (_ :
        coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫
            NatTrans.app c.ι WalkingParallelPair.one =
          coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫
            NatTrans.app c.ι WalkingParallelPair.one)
[PROOFSTEP]
apply pushout.hom_ext
[GOAL]
case h₀
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
c : Cocone F
m : (coequalizerCocone F).pt ⟶ c.pt
J : ∀ (j : WalkingParallelPair), NatTrans.app (coequalizerCocone F).ι j ≫ m = NatTrans.app c.ι j
J1 : pushoutInl F ≫ m = NatTrans.app c.ι WalkingParallelPair.one
⊢ pushout.inl ≫ m =
    pushout.inl ≫
      pushout.desc (NatTrans.app c.ι WalkingParallelPair.one) (NatTrans.app c.ι WalkingParallelPair.one)
        (_ :
          coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫
              NatTrans.app c.ι WalkingParallelPair.one =
            coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫
              NatTrans.app c.ι WalkingParallelPair.one)
[PROOFSTEP]
rw [colimit.ι_desc]
[GOAL]
case h₀
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
c : Cocone F
m : (coequalizerCocone F).pt ⟶ c.pt
J : ∀ (j : WalkingParallelPair), NatTrans.app (coequalizerCocone F).ι j ≫ m = NatTrans.app c.ι j
J1 : pushoutInl F ≫ m = NatTrans.app c.ι WalkingParallelPair.one
⊢ pushout.inl ≫ m =
    NatTrans.app
      (PushoutCocone.mk (NatTrans.app c.ι WalkingParallelPair.one) (NatTrans.app c.ι WalkingParallelPair.one)
          (_ :
            coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫
                NatTrans.app c.ι WalkingParallelPair.one =
              coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫
                NatTrans.app c.ι WalkingParallelPair.one)).ι
      WalkingSpan.left
[PROOFSTEP]
exact J1
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
c : Cocone F
m : (coequalizerCocone F).pt ⟶ c.pt
J : ∀ (j : WalkingParallelPair), NatTrans.app (coequalizerCocone F).ι j ≫ m = NatTrans.app c.ι j
J1 : pushoutInl F ≫ m = NatTrans.app c.ι WalkingParallelPair.one
⊢ pushout.inr ≫ m =
    pushout.inr ≫
      pushout.desc (NatTrans.app c.ι WalkingParallelPair.one) (NatTrans.app c.ι WalkingParallelPair.one)
        (_ :
          coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫
              NatTrans.app c.ι WalkingParallelPair.one =
            coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫
              NatTrans.app c.ι WalkingParallelPair.one)
[PROOFSTEP]
rw [colimit.ι_desc, ← pushoutInl_eq_pushout_inr]
[GOAL]
case h₁
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
c : Cocone F
m : (coequalizerCocone F).pt ⟶ c.pt
J : ∀ (j : WalkingParallelPair), NatTrans.app (coequalizerCocone F).ι j ≫ m = NatTrans.app c.ι j
J1 : pushoutInl F ≫ m = NatTrans.app c.ι WalkingParallelPair.one
⊢ pushoutInl F ≫ m =
    NatTrans.app
      (PushoutCocone.mk (NatTrans.app c.ι WalkingParallelPair.one) (NatTrans.app c.ι WalkingParallelPair.one)
          (_ :
            coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left) ≫
                NatTrans.app c.ι WalkingParallelPair.one =
              coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right) ≫
                NatTrans.app c.ι WalkingParallelPair.one)).ι
      WalkingSpan.right
[PROOFSTEP]
exact J1
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
c : Cocone (K ⋙ G)
⊢ (G.mapCocone (coequalizerCocone K)).pt ⟶ c.pt
[PROOFSTEP]
refine' (PreservesPushout.iso _ _ _).inv ≫ pushout.desc _ _ _
[GOAL]
case refine'_1
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
c : Cocone (K ⋙ G)
⊢ G.obj (K.obj WalkingParallelPair.one) ⟶ c.pt
[PROOFSTEP]
exact c.ι.app WalkingParallelPair.one
[GOAL]
case refine'_2
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
c : Cocone (K ⋙ G)
⊢ G.obj (K.obj WalkingParallelPair.one) ⟶ c.pt
[PROOFSTEP]
exact c.ι.app WalkingParallelPair.one
[GOAL]
case refine'_3
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
c : Cocone (K ⋙ G)
⊢ G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left)) ≫
      NatTrans.app c.ι WalkingParallelPair.one =
    G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right)) ≫
      NatTrans.app c.ι WalkingParallelPair.one
[PROOFSTEP]
apply (mapIsColimitOfPreservesOfIsColimit G _ _ (coprodIsCoprod _ _)).hom_ext
[GOAL]
case refine'_3
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
c : Cocone (K ⋙ G)
⊢ ∀ (j : Discrete WalkingPair),
    NatTrans.app (BinaryCofan.mk (G.map coprod.inl) (G.map coprod.inr)).ι j ≫
        G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left)) ≫
          NatTrans.app c.ι WalkingParallelPair.one =
      NatTrans.app (BinaryCofan.mk (G.map coprod.inl) (G.map coprod.inr)).ι j ≫
        G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right)) ≫
          NatTrans.app c.ι WalkingParallelPair.one
[PROOFSTEP]
rintro (_ | _)
[GOAL]
case refine'_3.mk.left
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
c : Cocone (K ⋙ G)
⊢ NatTrans.app (BinaryCofan.mk (G.map coprod.inl) (G.map coprod.inr)).ι { as := WalkingPair.left } ≫
      G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left)) ≫
        NatTrans.app c.ι WalkingParallelPair.one =
    NatTrans.app (BinaryCofan.mk (G.map coprod.inl) (G.map coprod.inr)).ι { as := WalkingPair.left } ≫
      G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right)) ≫
        NatTrans.app c.ι WalkingParallelPair.one
[PROOFSTEP]
simp only [BinaryCofan.ι_app_left, BinaryCofan.mk_inl, Category.assoc, ← G.map_comp_assoc, coprod.inl_desc]
[GOAL]
case refine'_3.mk.right
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
c : Cocone (K ⋙ G)
⊢ NatTrans.app (BinaryCofan.mk (G.map coprod.inl) (G.map coprod.inr)).ι { as := WalkingPair.right } ≫
      G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left)) ≫
        NatTrans.app c.ι WalkingParallelPair.one =
    NatTrans.app (BinaryCofan.mk (G.map coprod.inl) (G.map coprod.inr)).ι { as := WalkingPair.right } ≫
      G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right)) ≫
        NatTrans.app c.ι WalkingParallelPair.one
[PROOFSTEP]
simp only [BinaryCofan.ι_app_right, BinaryCofan.mk_inr, Category.assoc, ← G.map_comp_assoc, coprod.inr_desc]
[GOAL]
case refine'_3.mk.right
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
c : Cocone (K ⋙ G)
⊢ G.map (K.map WalkingParallelPairHom.left) ≫ NatTrans.app c.ι WalkingParallelPair.one =
    G.map (K.map WalkingParallelPairHom.right) ≫ NatTrans.app c.ι WalkingParallelPair.one
[PROOFSTEP]
exact (c.ι.naturality WalkingParallelPairHom.left).trans (c.ι.naturality WalkingParallelPairHom.right).symm
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
c : Cocone (K ⋙ G)
j : WalkingParallelPair
⊢ NatTrans.app (G.mapCocone (coequalizerCocone K)).ι j ≫
      (fun c =>
          (PreservesPushout.iso G (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left))
                (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right))).inv ≫
            pushout.desc (NatTrans.app c.ι WalkingParallelPair.one) (NatTrans.app c.ι WalkingParallelPair.one)
              (_ :
                G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left)) ≫
                    NatTrans.app c.ι WalkingParallelPair.one =
                  G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right)) ≫
                    NatTrans.app c.ι WalkingParallelPair.one))
        c =
    NatTrans.app c.ι j
[PROOFSTEP]
rcases j with (_ | _)
[GOAL]
case zero
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
c : Cocone (K ⋙ G)
⊢ NatTrans.app (G.mapCocone (coequalizerCocone K)).ι WalkingParallelPair.zero ≫
      (fun c =>
          (PreservesPushout.iso G (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left))
                (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right))).inv ≫
            pushout.desc (NatTrans.app c.ι WalkingParallelPair.one) (NatTrans.app c.ι WalkingParallelPair.one)
              (_ :
                G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left)) ≫
                    NatTrans.app c.ι WalkingParallelPair.one =
                  G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right)) ≫
                    NatTrans.app c.ι WalkingParallelPair.one))
        c =
    NatTrans.app c.ι WalkingParallelPair.zero
[PROOFSTEP]
simp only [Functor.mapCocone_ι_app, Cocone.ofCofork_ι, Category.id_comp, eqToHom_refl, Category.assoc, Functor.map_comp,
  Cofork.ofπ_ι_app, pushout.inl_desc, PreservesPushout.inl_iso_inv_assoc]
[GOAL]
case one
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
c : Cocone (K ⋙ G)
⊢ NatTrans.app (G.mapCocone (coequalizerCocone K)).ι WalkingParallelPair.one ≫
      (fun c =>
          (PreservesPushout.iso G (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left))
                (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right))).inv ≫
            pushout.desc (NatTrans.app c.ι WalkingParallelPair.one) (NatTrans.app c.ι WalkingParallelPair.one)
              (_ :
                G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left)) ≫
                    NatTrans.app c.ι WalkingParallelPair.one =
                  G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right)) ≫
                    NatTrans.app c.ι WalkingParallelPair.one))
        c =
    NatTrans.app c.ι WalkingParallelPair.one
[PROOFSTEP]
simp only [Functor.mapCocone_ι_app, Cocone.ofCofork_ι, Category.id_comp, eqToHom_refl, Category.assoc, Functor.map_comp,
  Cofork.ofπ_ι_app, pushout.inl_desc, PreservesPushout.inl_iso_inv_assoc]
[GOAL]
case zero
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
c : Cocone (K ⋙ G)
⊢ G.map (K.map WalkingParallelPairHom.left) ≫ NatTrans.app c.ι WalkingParallelPair.one =
    NatTrans.app c.ι WalkingParallelPair.zero
[PROOFSTEP]
exact (c.ι.naturality WalkingParallelPairHom.left).trans (Category.comp_id _)
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
s : Cocone (K ⋙ G)
m : (G.mapCocone (coequalizerCocone K)).pt ⟶ s.pt
h : ∀ (j : WalkingParallelPair), NatTrans.app (G.mapCocone (coequalizerCocone K)).ι j ≫ m = NatTrans.app s.ι j
⊢ m =
    (fun c =>
        (PreservesPushout.iso G (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left))
              (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right))).inv ≫
          pushout.desc (NatTrans.app c.ι WalkingParallelPair.one) (NatTrans.app c.ι WalkingParallelPair.one)
            (_ :
              G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left)) ≫
                  NatTrans.app c.ι WalkingParallelPair.one =
                G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right)) ≫
                  NatTrans.app c.ι WalkingParallelPair.one))
      s
[PROOFSTEP]
rw [Iso.eq_inv_comp]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
s : Cocone (K ⋙ G)
m : (G.mapCocone (coequalizerCocone K)).pt ⟶ s.pt
h : ∀ (j : WalkingParallelPair), NatTrans.app (G.mapCocone (coequalizerCocone K)).ι j ≫ m = NatTrans.app s.ι j
⊢ (PreservesPushout.iso G (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left))
          (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right))).hom ≫
      m =
    pushout.desc (NatTrans.app s.ι WalkingParallelPair.one) (NatTrans.app s.ι WalkingParallelPair.one)
      (_ :
        G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left)) ≫
            NatTrans.app s.ι WalkingParallelPair.one =
          G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right)) ≫
            NatTrans.app s.ι WalkingParallelPair.one)
[PROOFSTEP]
have := h WalkingParallelPair.one
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
s : Cocone (K ⋙ G)
m : (G.mapCocone (coequalizerCocone K)).pt ⟶ s.pt
h : ∀ (j : WalkingParallelPair), NatTrans.app (G.mapCocone (coequalizerCocone K)).ι j ≫ m = NatTrans.app s.ι j
this :
  NatTrans.app (G.mapCocone (coequalizerCocone K)).ι WalkingParallelPair.one ≫ m =
    NatTrans.app s.ι WalkingParallelPair.one
⊢ (PreservesPushout.iso G (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left))
          (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right))).hom ≫
      m =
    pushout.desc (NatTrans.app s.ι WalkingParallelPair.one) (NatTrans.app s.ι WalkingParallelPair.one)
      (_ :
        G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left)) ≫
            NatTrans.app s.ι WalkingParallelPair.one =
          G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right)) ≫
            NatTrans.app s.ι WalkingParallelPair.one)
[PROOFSTEP]
dsimp [coequalizerCocone] at this
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
s : Cocone (K ⋙ G)
m : (G.mapCocone (coequalizerCocone K)).pt ⟶ s.pt
h : ∀ (j : WalkingParallelPair), NatTrans.app (G.mapCocone (coequalizerCocone K)).ι j ≫ m = NatTrans.app s.ι j
this : G.map (𝟙 (K.obj WalkingParallelPair.one) ≫ pushoutInl K) ≫ m = NatTrans.app s.ι WalkingParallelPair.one
⊢ (PreservesPushout.iso G (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left))
          (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right))).hom ≫
      m =
    pushout.desc (NatTrans.app s.ι WalkingParallelPair.one) (NatTrans.app s.ι WalkingParallelPair.one)
      (_ :
        G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left)) ≫
            NatTrans.app s.ι WalkingParallelPair.one =
          G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right)) ≫
            NatTrans.app s.ι WalkingParallelPair.one)
[PROOFSTEP]
ext
[GOAL]
case h₀
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
s : Cocone (K ⋙ G)
m : (G.mapCocone (coequalizerCocone K)).pt ⟶ s.pt
h : ∀ (j : WalkingParallelPair), NatTrans.app (G.mapCocone (coequalizerCocone K)).ι j ≫ m = NatTrans.app s.ι j
this : G.map (𝟙 (K.obj WalkingParallelPair.one) ≫ pushoutInl K) ≫ m = NatTrans.app s.ι WalkingParallelPair.one
⊢ pushout.inl ≫
      (PreservesPushout.iso G (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left))
            (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right))).hom ≫
        m =
    pushout.inl ≫
      pushout.desc (NatTrans.app s.ι WalkingParallelPair.one) (NatTrans.app s.ι WalkingParallelPair.one)
        (_ :
          G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left)) ≫
              NatTrans.app s.ι WalkingParallelPair.one =
            G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right)) ≫
              NatTrans.app s.ι WalkingParallelPair.one)
[PROOFSTEP]
simp only [PreservesPushout.inl_iso_hom_assoc, Category.id_comp, pushout.inl_desc, pushout.inr_desc,
  PreservesPushout.inr_iso_hom_assoc, ← pushoutInl_eq_pushout_inr, ← this]
[GOAL]
case h₁
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
G : C ⥤ D
inst✝³ : HasBinaryCoproducts C
inst✝² : HasPushouts C
inst✝¹ : PreservesColimitsOfShape (Discrete WalkingPair) G
inst✝ : PreservesColimitsOfShape WalkingSpan G
K : WalkingParallelPair ⥤ C
s : Cocone (K ⋙ G)
m : (G.mapCocone (coequalizerCocone K)).pt ⟶ s.pt
h : ∀ (j : WalkingParallelPair), NatTrans.app (G.mapCocone (coequalizerCocone K)).ι j ≫ m = NatTrans.app s.ι j
this : G.map (𝟙 (K.obj WalkingParallelPair.one) ≫ pushoutInl K) ≫ m = NatTrans.app s.ι WalkingParallelPair.one
⊢ pushout.inr ≫
      (PreservesPushout.iso G (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left))
            (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right))).hom ≫
        m =
    pushout.inr ≫
      pushout.desc (NatTrans.app s.ι WalkingParallelPair.one) (NatTrans.app s.ι WalkingParallelPair.one)
        (_ :
          G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.left)) ≫
              NatTrans.app s.ι WalkingParallelPair.one =
            G.map (coprod.desc (𝟙 (K.obj WalkingParallelPair.one)) (K.map WalkingParallelPairHom.right)) ≫
              NatTrans.app s.ι WalkingParallelPair.one)
[PROOFSTEP]
simp only [PreservesPushout.inl_iso_hom_assoc, Category.id_comp, pushout.inl_desc, pushout.inr_desc,
  PreservesPushout.inr_iso_hom_assoc, ← pushoutInl_eq_pushout_inr, ← this]


[GOAL]
α ι : Type u
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
⊢ #↑t ≤ a
[PROOFSTEP]
rcases lt_or_le a ℵ₀ with ha | ha
[GOAL]
case inl
α ι : Type u
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
ha : a < ℵ₀
⊢ #↑t ≤ a
[PROOFSTEP]
obtain ⟨n, rfl⟩ : ∃ (n : ℕ), a = n := lt_aleph0.1 ha
[GOAL]
case inl.intro
α ι : Type u
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
n : ℕ
h'f : ∀ (i : ι), #↑(f i) ≤ ↑n
ha : ↑n < ℵ₀
⊢ #↑t ≤ ↑n
[PROOFSTEP]
apply mk_le_iff_forall_finset_subset_card_le.2 (fun s hs ↦ ?_)
[GOAL]
α ι : Type u
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
n : ℕ
h'f : ∀ (i : ι), #↑(f i) ≤ ↑n
ha : ↑n < ℵ₀
s : Finset α
hs : ↑s ⊆ t
⊢ Finset.card s ≤ n
[PROOFSTEP]
have A : ∀ x ∈ s, ∀ᶠ i in l, x ∈ f i := fun x hx ↦ ht x (hs hx)
[GOAL]
α ι : Type u
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
n : ℕ
h'f : ∀ (i : ι), #↑(f i) ≤ ↑n
ha : ↑n < ℵ₀
s : Finset α
hs : ↑s ⊆ t
A : ∀ (x : α), x ∈ s → ∀ᶠ (i : ι) in l, x ∈ f i
⊢ Finset.card s ≤ n
[PROOFSTEP]
have B : ∀ᶠ i in l, ∀ x ∈ s, x ∈ f i := (s.eventually_all).2 A
[GOAL]
α ι : Type u
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
n : ℕ
h'f : ∀ (i : ι), #↑(f i) ≤ ↑n
ha : ↑n < ℵ₀
s : Finset α
hs : ↑s ⊆ t
A : ∀ (x : α), x ∈ s → ∀ᶠ (i : ι) in l, x ∈ f i
B : ∀ᶠ (i : ι) in l, ∀ (x : α), x ∈ s → x ∈ f i
⊢ Finset.card s ≤ n
[PROOFSTEP]
rcases B.exists with ⟨i, hi⟩
[GOAL]
case intro
α ι : Type u
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
n : ℕ
h'f : ∀ (i : ι), #↑(f i) ≤ ↑n
ha : ↑n < ℵ₀
s : Finset α
hs : ↑s ⊆ t
A : ∀ (x : α), x ∈ s → ∀ᶠ (i : ι) in l, x ∈ f i
B : ∀ᶠ (i : ι) in l, ∀ (x : α), x ∈ s → x ∈ f i
i : ι
hi : ∀ (x : α), x ∈ s → x ∈ f i
⊢ Finset.card s ≤ n
[PROOFSTEP]
have : ∀ i, Fintype (f i) := fun i ↦ (lt_aleph0_iff_fintype.1 ((h'f i).trans_lt ha)).some
[GOAL]
case intro
α ι : Type u
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
n : ℕ
h'f : ∀ (i : ι), #↑(f i) ≤ ↑n
ha : ↑n < ℵ₀
s : Finset α
hs : ↑s ⊆ t
A : ∀ (x : α), x ∈ s → ∀ᶠ (i : ι) in l, x ∈ f i
B : ∀ᶠ (i : ι) in l, ∀ (x : α), x ∈ s → x ∈ f i
i : ι
hi : ∀ (x : α), x ∈ s → x ∈ f i
this : (i : ι) → Fintype ↑(f i)
⊢ Finset.card s ≤ n
[PROOFSTEP]
let u : Finset α := (f i).toFinset
[GOAL]
case intro
α ι : Type u
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
n : ℕ
h'f : ∀ (i : ι), #↑(f i) ≤ ↑n
ha : ↑n < ℵ₀
s : Finset α
hs : ↑s ⊆ t
A : ∀ (x : α), x ∈ s → ∀ᶠ (i : ι) in l, x ∈ f i
B : ∀ᶠ (i : ι) in l, ∀ (x : α), x ∈ s → x ∈ f i
i : ι
hi : ∀ (x : α), x ∈ s → x ∈ f i
this : (i : ι) → Fintype ↑(f i)
u : Finset α := toFinset (f i)
⊢ Finset.card s ≤ n
[PROOFSTEP]
have I1 : s.card ≤ u.card :=
  by
  have : s ⊆ u := fun x hx ↦ by simpa only [Set.mem_toFinset] using hi x hx
  exact Finset.card_le_of_subset this
[GOAL]
α ι : Type u
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
n : ℕ
h'f : ∀ (i : ι), #↑(f i) ≤ ↑n
ha : ↑n < ℵ₀
s : Finset α
hs : ↑s ⊆ t
A : ∀ (x : α), x ∈ s → ∀ᶠ (i : ι) in l, x ∈ f i
B : ∀ᶠ (i : ι) in l, ∀ (x : α), x ∈ s → x ∈ f i
i : ι
hi : ∀ (x : α), x ∈ s → x ∈ f i
this : (i : ι) → Fintype ↑(f i)
u : Finset α := toFinset (f i)
⊢ Finset.card s ≤ Finset.card u
[PROOFSTEP]
have : s ⊆ u := fun x hx ↦ by simpa only [Set.mem_toFinset] using hi x hx
[GOAL]
α ι : Type u
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
n : ℕ
h'f : ∀ (i : ι), #↑(f i) ≤ ↑n
ha : ↑n < ℵ₀
s : Finset α
hs : ↑s ⊆ t
A : ∀ (x : α), x ∈ s → ∀ᶠ (i : ι) in l, x ∈ f i
B : ∀ᶠ (i : ι) in l, ∀ (x : α), x ∈ s → x ∈ f i
i : ι
hi : ∀ (x : α), x ∈ s → x ∈ f i
this : (i : ι) → Fintype ↑(f i)
u : Finset α := toFinset (f i)
x : α
hx : x ∈ s
⊢ x ∈ u
[PROOFSTEP]
simpa only [Set.mem_toFinset] using hi x hx
[GOAL]
α ι : Type u
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
n : ℕ
h'f : ∀ (i : ι), #↑(f i) ≤ ↑n
ha : ↑n < ℵ₀
s : Finset α
hs : ↑s ⊆ t
A : ∀ (x : α), x ∈ s → ∀ᶠ (i : ι) in l, x ∈ f i
B : ∀ᶠ (i : ι) in l, ∀ (x : α), x ∈ s → x ∈ f i
i : ι
hi : ∀ (x : α), x ∈ s → x ∈ f i
this✝ : (i : ι) → Fintype ↑(f i)
u : Finset α := toFinset (f i)
this : s ⊆ u
⊢ Finset.card s ≤ Finset.card u
[PROOFSTEP]
exact Finset.card_le_of_subset this
[GOAL]
case intro
α ι : Type u
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
n : ℕ
h'f : ∀ (i : ι), #↑(f i) ≤ ↑n
ha : ↑n < ℵ₀
s : Finset α
hs : ↑s ⊆ t
A : ∀ (x : α), x ∈ s → ∀ᶠ (i : ι) in l, x ∈ f i
B : ∀ᶠ (i : ι) in l, ∀ (x : α), x ∈ s → x ∈ f i
i : ι
hi : ∀ (x : α), x ∈ s → x ∈ f i
this : (i : ι) → Fintype ↑(f i)
u : Finset α := toFinset (f i)
I1 : Finset.card s ≤ Finset.card u
⊢ Finset.card s ≤ n
[PROOFSTEP]
have I2 : (u.card : Cardinal) ≤ n := by convert h'f i; simp only [Set.toFinset_card, mk_fintype]
[GOAL]
α ι : Type u
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
n : ℕ
h'f : ∀ (i : ι), #↑(f i) ≤ ↑n
ha : ↑n < ℵ₀
s : Finset α
hs : ↑s ⊆ t
A : ∀ (x : α), x ∈ s → ∀ᶠ (i : ι) in l, x ∈ f i
B : ∀ᶠ (i : ι) in l, ∀ (x : α), x ∈ s → x ∈ f i
i : ι
hi : ∀ (x : α), x ∈ s → x ∈ f i
this : (i : ι) → Fintype ↑(f i)
u : Finset α := toFinset (f i)
I1 : Finset.card s ≤ Finset.card u
⊢ ↑(Finset.card u) ≤ ↑n
[PROOFSTEP]
convert h'f i
[GOAL]
case h.e'_3
α ι : Type u
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
n : ℕ
h'f : ∀ (i : ι), #↑(f i) ≤ ↑n
ha : ↑n < ℵ₀
s : Finset α
hs : ↑s ⊆ t
A : ∀ (x : α), x ∈ s → ∀ᶠ (i : ι) in l, x ∈ f i
B : ∀ᶠ (i : ι) in l, ∀ (x : α), x ∈ s → x ∈ f i
i : ι
hi : ∀ (x : α), x ∈ s → x ∈ f i
this : (i : ι) → Fintype ↑(f i)
u : Finset α := toFinset (f i)
I1 : Finset.card s ≤ Finset.card u
⊢ ↑(Finset.card u) = #↑(f i)
[PROOFSTEP]
simp only [Set.toFinset_card, mk_fintype]
[GOAL]
case intro
α ι : Type u
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
n : ℕ
h'f : ∀ (i : ι), #↑(f i) ≤ ↑n
ha : ↑n < ℵ₀
s : Finset α
hs : ↑s ⊆ t
A : ∀ (x : α), x ∈ s → ∀ᶠ (i : ι) in l, x ∈ f i
B : ∀ᶠ (i : ι) in l, ∀ (x : α), x ∈ s → x ∈ f i
i : ι
hi : ∀ (x : α), x ∈ s → x ∈ f i
this : (i : ι) → Fintype ↑(f i)
u : Finset α := toFinset (f i)
I1 : Finset.card s ≤ Finset.card u
I2 : ↑(Finset.card u) ≤ ↑n
⊢ Finset.card s ≤ n
[PROOFSTEP]
exact
  I1.trans
    (Nat.cast_le.1 I2)
      -- case `a` infinite:
[GOAL]
case inr
α ι : Type u
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
ha : ℵ₀ ≤ a
⊢ #↑t ≤ a
[PROOFSTEP]
have : t ⊆ ⋃ i, f i := by
  intro x hx
  obtain ⟨i, hi⟩ : ∃ i, x ∈ f i := (ht x hx).exists
  exact mem_iUnion_of_mem i hi
[GOAL]
α ι : Type u
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
ha : ℵ₀ ≤ a
⊢ t ⊆ ⋃ (i : ι), f i
[PROOFSTEP]
intro x hx
[GOAL]
α ι : Type u
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
ha : ℵ₀ ≤ a
x : α
hx : x ∈ t
⊢ x ∈ ⋃ (i : ι), f i
[PROOFSTEP]
obtain ⟨i, hi⟩ : ∃ i, x ∈ f i := (ht x hx).exists
[GOAL]
case intro
α ι : Type u
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
ha : ℵ₀ ≤ a
x : α
hx : x ∈ t
i : ι
hi : x ∈ f i
⊢ x ∈ ⋃ (i : ι), f i
[PROOFSTEP]
exact mem_iUnion_of_mem i hi
[GOAL]
case inr
α ι : Type u
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
ha : ℵ₀ ≤ a
this : t ⊆ ⋃ (i : ι), f i
⊢ #↑t ≤ a
[PROOFSTEP]
calc
  #t ≤ #(⋃ i, f i) := mk_le_mk_of_subset this
  _ ≤ sum (fun i ↦ #(f i)) := mk_iUnion_le_sum_mk
  _ ≤ sum (fun _ ↦ a) := (sum_le_sum _ _ h'f)
  _ = #ι * a := by simp
  _ ≤ ℵ₀ * a := (mul_le_mul_right' mk_le_aleph0 a)
  _ = a := aleph0_mul_eq ha
[GOAL]
α ι : Type u
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
ha : ℵ₀ ≤ a
this : t ⊆ ⋃ (i : ι), f i
⊢ (sum fun x => a) = #ι * a
[PROOFSTEP]
simp
[GOAL]
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
⊢ #↑t ≤ a
[PROOFSTEP]
let g : ULift.{u, v} ι → Set (ULift.{v, u} α) := (ULift.down ⁻¹' ·) ∘ f ∘ ULift.down
[GOAL]
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
g : ULift ι → Set (ULift α) := (fun x => ULift.down ⁻¹' x) ∘ f ∘ ULift.down
⊢ #↑t ≤ a
[PROOFSTEP]
suffices #(ULift.down.{v} ⁻¹' t) ≤ Cardinal.lift.{v, u} a by simpa
[GOAL]
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
g : ULift ι → Set (ULift α) := (fun x => ULift.down ⁻¹' x) ∘ f ∘ ULift.down
this : #↑(ULift.down ⁻¹' t) ≤ lift a
⊢ #↑t ≤ a
[PROOFSTEP]
simpa
[GOAL]
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
g : ULift ι → Set (ULift α) := (fun x => ULift.down ⁻¹' x) ∘ f ∘ ULift.down
⊢ #↑(ULift.down ⁻¹' t) ≤ lift a
[PROOFSTEP]
let l' : Filter (ULift.{u} ι) := Filter.map ULift.up l
[GOAL]
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
g : ULift ι → Set (ULift α) := (fun x => ULift.down ⁻¹' x) ∘ f ∘ ULift.down
l' : Filter (ULift ι) := Filter.map ULift.up l
⊢ #↑(ULift.down ⁻¹' t) ≤ lift a
[PROOFSTEP]
have : NeBot l' := map_neBot
[GOAL]
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
g : ULift ι → Set (ULift α) := (fun x => ULift.down ⁻¹' x) ∘ f ∘ ULift.down
l' : Filter (ULift ι) := Filter.map ULift.up l
this : NeBot l'
⊢ #↑(ULift.down ⁻¹' t) ≤ lift a
[PROOFSTEP]
apply mk_subtype_le_of_countable_eventually_mem_aux (ι := ULift.{u} ι) (l := l') (f := g)
[GOAL]
case ht
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
g : ULift ι → Set (ULift α) := (fun x => ULift.down ⁻¹' x) ∘ f ∘ ULift.down
l' : Filter (ULift ι) := Filter.map ULift.up l
this : NeBot l'
⊢ ∀ (x : ULift α), x ∈ ULift.down ⁻¹' t → ∀ᶠ (i : ULift ι) in l', x ∈ g i
[PROOFSTEP]
intro x hx
[GOAL]
case ht
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
g : ULift ι → Set (ULift α) := (fun x => ULift.down ⁻¹' x) ∘ f ∘ ULift.down
l' : Filter (ULift ι) := Filter.map ULift.up l
this : NeBot l'
x : ULift α
hx : x ∈ ULift.down ⁻¹' t
⊢ ∀ᶠ (i : ULift ι) in l', x ∈ g i
[PROOFSTEP]
simpa only [Function.comp_apply, mem_preimage, eventually_map] using ht _ hx
[GOAL]
case h'f
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
g : ULift ι → Set (ULift α) := (fun x => ULift.down ⁻¹' x) ∘ f ∘ ULift.down
l' : Filter (ULift ι) := Filter.map ULift.up l
this : NeBot l'
⊢ ∀ (i : ULift ι), #↑(g i) ≤ lift a
[PROOFSTEP]
intro i
[GOAL]
case h'f
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
t : Set α
ht : ∀ (x : α), x ∈ t → ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
g : ULift ι → Set (ULift α) := (fun x => ULift.down ⁻¹' x) ∘ f ∘ ULift.down
l' : Filter (ULift ι) := Filter.map ULift.up l
this : NeBot l'
i : ULift ι
⊢ #↑(g i) ≤ lift a
[PROOFSTEP]
simpa using h'f i.down
[GOAL]
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
ht : ∀ (x : α), ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
⊢ #α ≤ a
[PROOFSTEP]
rw [← mk_univ]
[GOAL]
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
ht : ∀ (x : α), ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
⊢ #↑Set.univ ≤ a
[PROOFSTEP]
exact mk_subtype_le_of_countable_eventually_mem (l := l) (fun x _ ↦ ht x) h'f
[GOAL]
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
ht : ∀ (x : α), ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) = a
⊢ #α = a
[PROOFSTEP]
apply le_antisymm
[GOAL]
case a
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
ht : ∀ (x : α), ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) = a
⊢ #α ≤ a
[PROOFSTEP]
apply mk_le_of_countable_eventually_mem ht (fun i ↦ (h'f i).le)
[GOAL]
case a
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
ht : ∀ (x : α), ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) = a
⊢ a ≤ #α
[PROOFSTEP]
obtain ⟨i⟩ : Nonempty ι := nonempty_of_neBot l
[GOAL]
case a.intro
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
ht : ∀ (x : α), ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) = a
i : ι
⊢ a ≤ #α
[PROOFSTEP]
rw [← (h'f i)]
[GOAL]
case a.intro
α : Type u
ι : Type v
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : NeBot l
ht : ∀ (x : α), ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) = a
i : ι
⊢ #↑(f i) ≤ #α
[PROOFSTEP]
exact mk_set_le (f i)