Theorem: CategoryTheory.Limits.limitConeOfUnique_cone_π
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

Proof steps:
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Unique β
f : β → C
x✝ : Discrete β
j : β
⊢ ((Functor.const (Discrete β)).obj (f default)).obj { as := j } = (Discrete.functor f).obj { as := j }
state_after: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Unique β
f : β → C
x✝ : Discrete β
j : β
⊢ f default = f j
tactic: dsimp
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Unique β
f : β → C
x✝ : Discrete β
j : β
⊢ f default = f j
state_after: case e_a
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Unique β
f : β → C
x✝ : Discrete β
j : β
⊢ default = j
tactic: congr
state_before: case e_a
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Unique β
f : β → C
x✝ : Discrete β
j : β
⊢ default = j
state_after: no goals
tactic: subsingleton
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Unique β
f : β → C
s : Cone (Discrete.functor f)
j : Discrete β
⊢ (fun s => s.π.app default) s ≫
      { pt := f default,
              π :=
                Discrete.natTrans fun x =>
                  match x with
                  | { as := j } => eqToHom ⋯ }.π.app
        j =
    s.π.app j
state_after: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Unique β
f : β → C
s : Cone (Discrete.functor f)
j : Discrete β
h : j = default
⊢ (fun s => s.π.app default) s ≫
      { pt := f default,
              π :=
                Discrete.natTrans fun x =>
                  match x with
                  | { as := j } => eqToHom ⋯ }.π.app
        j =
    s.π.app j
tactic: have h := Subsingleton.elim j default
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Unique β
f : β → C
s : Cone (Discrete.functor f)
j : Discrete β
h : j = default
⊢ (fun s => s.π.app default) s ≫
      { pt := f default,
              π :=
                Discrete.natTrans fun x =>
                  match x with
                  | { as := j } => eqToHom ⋯ }.π.app
        j =
    s.π.app j
state_after: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Unique β
f : β → C
s : Cone (Discrete.functor f)
⊢ (fun s => s.π.app default) s ≫
      { pt := f default,
              π :=
                Discrete.natTrans fun x =>
                  match x with
                  | { as := j } => eqToHom ⋯ }.π.app
        default =
    s.π.app default
tactic: subst h
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Unique β
f : β → C
s : Cone (Discrete.functor f)
⊢ (fun s => s.π.app default) s ≫
      { pt := f default,
              π :=
                Discrete.natTrans fun x =>
                  match x with
                  | { as := j } => eqToHom ⋯ }.π.app
        default =
    s.π.app default
state_after: no goals
tactic: simp
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Unique β
f : β → C
s : Cone (Discrete.functor f)
m :
  s.pt ⟶
    { pt := f default,
        π :=
          Discrete.natTrans fun x =>
            match x with
            | { as := j } => eqToHom ⋯ }.pt
w :
  ∀ (j : Discrete β),
    m ≫
        { pt := f default,
                π :=
                  Discrete.natTrans fun x =>
                    match x with
                    | { as := j } => eqToHom ⋯ }.π.app
          j =
      s.π.app j
⊢ m = (fun s => s.π.app default) s
state_after: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Unique β
f : β → C
s : Cone (Discrete.functor f)
m :
  s.pt ⟶
    { pt := f default,
        π :=
          Discrete.natTrans fun x =>
            match x with
            | { as := j } => eqToHom ⋯ }.pt
w :
  m ≫
      { pt := f default,
              π :=
                Discrete.natTrans fun x =>
                  match x with
                  | { as := j } => eqToHom ⋯ }.π.app
        default =
    s.π.app default
⊢ m = (fun s => s.π.app default) s
tactic: specialize w default
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Unique β
f : β → C
s : Cone (Discrete.functor f)
m :
  s.pt ⟶
    { pt := f default,
        π :=
          Discrete.natTrans fun x =>
            match x with
            | { as := j } => eqToHom ⋯ }.pt
w :
  m ≫
      { pt := f default,
              π :=
                Discrete.natTrans fun x =>
                  match x with
                  | { as := j } => eqToHom ⋯ }.π.app
        default =
    s.π.app default
⊢ m = (fun s => s.π.app default) s
state_after: no goals
tactic: simpa using w