Theorem: NonemptyFinLinOrd.epi_iff_surjective
File: Mathlib/Order/Category/NonemptyFinLinOrd.lean

tactic: constructor
state_before: A B : NonemptyFinLinOrd
f : A ⟶ B
⊢ Epi f ↔ Function.Surjective ⇑f
state_after: case mp
A B : NonemptyFinLinOrd
f : A ⟶ B
⊢ Epi f → Function.Surjective ⇑f

case mpr
A B : NonemptyFinLinOrd
f : A ⟶ B
⊢ Function.Surjective ⇑f → Epi f

tactic: intro
state_before: case mp
A B : NonemptyFinLinOrd
f : A ⟶ B
⊢ Epi f → Function.Surjective ⇑f
state_after: case mp
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
⊢ Function.Surjective ⇑f

tactic: dsimp only [Function.Surjective]
state_before: case mp
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
⊢ Function.Surjective ⇑f
state_after: case mp
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
⊢ ∀ (b : ↑B), ∃ a, f a = b

tactic: by_contra! hf'
state_before: case mp
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
⊢ ∀ (b : ↑B), ∃ a, f a = b
state_after: case mp
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
hf' : ∃ b, ∀ (a : ↑A), f a ≠ b
⊢ False

tactic: rcases hf' with ⟨m, hm⟩
state_before: case mp
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
hf' : ∃ b, ∀ (a : ↑A), f a ≠ b
⊢ False
state_after: case mp.intro
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
⊢ False

tactic: let Y := NonemptyFinLinOrd.of (ULift (Fin 2))
state_before: case mp.intro
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
⊢ False
state_after: case mp.intro
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{?u.21080, 0} (Fin 2))
⊢ False

tactic: simp [Y, DFunLike.coe] at h
state_before: case mp.intro
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
h : p₁ m = p₂ m
⊢ False
state_after: no goals

tactic: simp only
state_before: A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
⊢ (fun b => if b < m then { down := 0 } else { down := 1 }) x₁ ≤
    (fun b => if b < m then { down := 0 } else { down := 1 }) x₂
state_after: A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
⊢ (if x₁ < m then { down := 0 } else { down := 1 }) ≤ if x₂ < m then { down := 0 } else { down := 1 }

tactic: split_ifs with h₁ h₂ h₂
state_before: A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
⊢ (if x₁ < m then { down := 0 } else { down := 1 }) ≤ if x₂ < m then { down := 0 } else { down := 1 }
state_after: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : x₁ < m
h₂ : x₂ < m
⊢ { down := 0 } ≤ { down := 0 }

case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : x₁ < m
h₂ : ¬x₂ < m
⊢ { down := 0 } ≤ { down := 1 }

case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ < m
h₂ : x₂ < m
⊢ { down := 1 } ≤ { down := 0 }

case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ < m
h₂ : ¬x₂ < m
⊢ { down := 1 } ≤ { down := 1 }

tactic: any_goals apply Fin.zero_le
state_before: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : x₁ < m
h₂ : x₂ < m
⊢ { down := 0 } ≤ { down := 0 }

case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : x₁ < m
h₂ : ¬x₂ < m
⊢ { down := 0 } ≤ { down := 1 }

case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ < m
h₂ : x₂ < m
⊢ { down := 1 } ≤ { down := 0 }

case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ < m
h₂ : ¬x₂ < m
⊢ { down := 1 } ≤ { down := 1 }
state_after: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ < m
h₂ : x₂ < m
⊢ { down := 1 } ≤ { down := 0 }

case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ < m
h₂ : ¬x₂ < m
⊢ { down := 1 } ≤ { down := 1 }

tactic: apply Fin.zero_le
state_before: case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : x₁ < m
h₂ : ¬x₂ < m
⊢ { down := 0 } ≤ { down := 1 }
state_after: no goals

tactic: exfalso
state_before: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ < m
h₂ : x₂ < m
⊢ { down := 1 } ≤ { down := 0 }
state_after: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ < m
h₂ : x₂ < m
⊢ False

tactic: exact h₁ (lt_of_le_of_lt h h₂)
state_before: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ < m
h₂ : x₂ < m
⊢ False
state_after: no goals

tactic: rfl
state_before: case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ < m
h₂ : ¬x₂ < m
⊢ { down := 1 } ≤ { down := 1 }
state_after: no goals

tactic: simp only
state_before: A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
⊢ (fun b => if b ≤ m then { down := 0 } else { down := 1 }) x₁ ≤
    (fun b => if b ≤ m then { down := 0 } else { down := 1 }) x₂
state_after: A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
⊢ (if x₁ ≤ m then { down := 0 } else { down := 1 }) ≤ if x₂ ≤ m then { down := 0 } else { down := 1 }

tactic: split_ifs with h₁ h₂ h₂
state_before: A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
⊢ (if x₁ ≤ m then { down := 0 } else { down := 1 }) ≤ if x₂ ≤ m then { down := 0 } else { down := 1 }
state_after: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : x₁ ≤ m
h₂ : x₂ ≤ m
⊢ { down := 0 } ≤ { down := 0 }

case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : x₁ ≤ m
h₂ : ¬x₂ ≤ m
⊢ { down := 0 } ≤ { down := 1 }

case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ ≤ m
h₂ : x₂ ≤ m
⊢ { down := 1 } ≤ { down := 0 }

case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ ≤ m
h₂ : ¬x₂ ≤ m
⊢ { down := 1 } ≤ { down := 1 }

tactic: any_goals apply Fin.zero_le
state_before: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : x₁ ≤ m
h₂ : x₂ ≤ m
⊢ { down := 0 } ≤ { down := 0 }

case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : x₁ ≤ m
h₂ : ¬x₂ ≤ m
⊢ { down := 0 } ≤ { down := 1 }

case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ ≤ m
h₂ : x₂ ≤ m
⊢ { down := 1 } ≤ { down := 0 }

case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ ≤ m
h₂ : ¬x₂ ≤ m
⊢ { down := 1 } ≤ { down := 1 }
state_after: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ ≤ m
h₂ : x₂ ≤ m
⊢ { down := 1 } ≤ { down := 0 }

case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ ≤ m
h₂ : ¬x₂ ≤ m
⊢ { down := 1 } ≤ { down := 1 }

tactic: apply Fin.zero_le
state_before: case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : x₁ ≤ m
h₂ : ¬x₂ ≤ m
⊢ { down := 0 } ≤ { down := 1 }
state_after: no goals

tactic: exfalso
state_before: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ ≤ m
h₂ : x₂ ≤ m
⊢ { down := 1 } ≤ { down := 0 }
state_after: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ ≤ m
h₂ : x₂ ≤ m
⊢ False

tactic: exact h₁ (h.trans h₂)
state_before: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ ≤ m
h₂ : x₂ ≤ m
⊢ False
state_after: no goals

tactic: rfl
state_before: case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
x₁ x₂ : ↑B
h : x₁ ≤ x₂
h₁ : ¬x₁ ≤ m
h₂ : ¬x₂ ≤ m
⊢ { down := 1 } ≤ { down := 1 }
state_after: no goals

tactic: congr
state_before: A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
⊢ p₁ m = p₂ m
state_after: case e_a
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
⊢ p₁ = p₂

tactic: rw [← cancel_epi f]
state_before: case e_a
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
⊢ p₁ = p₂
state_after: case e_a
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
⊢ f ≫ p₁ = f ≫ p₂

tactic: ext a
state_before: case e_a
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
⊢ f ≫ p₁ = f ≫ p₂
state_after: case e_a.w
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
⊢ (f ≫ p₁) a = (f ≫ p₂) a

tactic: simp only [coe_of, comp_apply]
state_before: case e_a.w
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
⊢ (f ≫ p₁) a = (f ≫ p₂) a
state_after: case e_a.w
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
⊢ p₁ (f a) = p₂ (f a)

tactic: change ite _ _ _ = ite _ _ _
state_before: case e_a.w
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
⊢ p₁ (f a) = p₂ (f a)
state_after: case e_a.w
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
⊢ (if f a < m then { down := 0 } else { down := 1 }) = if f a ≤ m then { down := 0 } else { down := 1 }

tactic: split_ifs with h₁ h₂ h₂
state_before: case e_a.w
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
⊢ (if f a < m then { down := 0 } else { down := 1 }) = if f a ≤ m then { down := 0 } else { down := 1 }
state_after: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : f a < m
h₂ : f a ≤ m
⊢ { down := 0 } = { down := 0 }

case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : f a < m
h₂ : ¬f a ≤ m
⊢ { down := 0 } = { down := 1 }

case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : ¬f a < m
h₂ : f a ≤ m
⊢ { down := 1 } = { down := 0 }

case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : ¬f a < m
h₂ : ¬f a ≤ m
⊢ { down := 1 } = { down := 1 }

tactic: any_goals rfl
state_before: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : f a < m
h₂ : f a ≤ m
⊢ { down := 0 } = { down := 0 }

case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : f a < m
h₂ : ¬f a ≤ m
⊢ { down := 0 } = { down := 1 }

case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : ¬f a < m
h₂ : f a ≤ m
⊢ { down := 1 } = { down := 0 }

case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : ¬f a < m
h₂ : ¬f a ≤ m
⊢ { down := 1 } = { down := 1 }
state_after: case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : f a < m
h₂ : ¬f a ≤ m
⊢ { down := 0 } = { down := 1 }

case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : ¬f a < m
h₂ : f a ≤ m
⊢ { down := 1 } = { down := 0 }

tactic: rfl
state_before: case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : ¬f a < m
h₂ : ¬f a ≤ m
⊢ { down := 1 } = { down := 1 }
state_after: no goals

tactic: exfalso
state_before: case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : f a < m
h₂ : ¬f a ≤ m
⊢ { down := 0 } = { down := 1 }
state_after: case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : f a < m
h₂ : ¬f a ≤ m
⊢ False

tactic: exact h₂ (le_of_lt h₁)
state_before: case neg
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : f a < m
h₂ : ¬f a ≤ m
⊢ False
state_after: no goals

tactic: exfalso
state_before: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : ¬f a < m
h₂ : f a ≤ m
⊢ { down := 1 } = { down := 0 }
state_after: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : ¬f a < m
h₂ : f a ≤ m
⊢ False

tactic: exact hm a (eq_of_le_of_not_lt h₂ h₁)
state_before: case pos
A B : NonemptyFinLinOrd
f : A ⟶ B
a✝ : Epi f
m : ↑B
hm : ∀ (a : ↑A), f a ≠ m
Y : NonemptyFinLinOrd := of (ULift.{u, 0} (Fin 2))
p₁ : B ⟶ Y := { toFun := fun b => if b < m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
p₂ : B ⟶ Y := { toFun := fun b => if b ≤ m then { down := 0 } else { down := 1 }, monotone' := ⋯ }
a : (forget NonemptyFinLinOrd).obj A
h₁ : ¬f a < m
h₂ : f a ≤ m
⊢ False
state_after: no goals

tactic: intro h
state_before: case mpr
A B : NonemptyFinLinOrd
f : A ⟶ B
⊢ Function.Surjective ⇑f → Epi f
state_after: case mpr
A B : NonemptyFinLinOrd
f : A ⟶ B
h : Function.Surjective ⇑f
⊢ Epi f

tactic: exact ConcreteCategory.epi_of_surjective f h
state_before: case mpr
A B : NonemptyFinLinOrd
f : A ⟶ B
h : Function.Surjective ⇑f
⊢ Epi f
state_after: no goals