Theorem: Equiv.Perm.mem_sumCongrHom_range_of_perm_mapsTo_inl
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: cases nonempty_fintype m
state_before: α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
⊢ σ ∈ MonoidHom.range (sumCongrHom m n)

tactic: cases nonempty_fintype n
state_before: case intro
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝ : Fintype m
⊢ σ ∈ MonoidHom.range (sumCongrHom m n)

tactic: have h1 : ∀ x : Sum m n, (∃ a : m, Sum.inl a = x) → ∃ a : m, Sum.inl a = σ x := by
  rintro x ⟨a, ha⟩
  apply h
  rw [← ha]
  exact ⟨a, rfl⟩
state_before: case intro.intro
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
⊢ σ ∈ MonoidHom.range (sumCongrHom m n)

tactic: have h3 : ∀ x : Sum m n, (∃ b : n, Sum.inr b = x) → ∃ b : n, Sum.inr b = σ x := by
  rintro x ⟨b, hb⟩
  apply (perm_mapsTo_inl_iff_mapsTo_inr σ).mp h
  rw [← hb]
  exact ⟨b, rfl⟩
state_before: case intro.intro
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
⊢ σ ∈ MonoidHom.range (sumCongrHom m n)

tactic: let σ₁' := subtypePermOfFintype σ h1
state_before: case intro.intro
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
h3 : ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x
⊢ σ ∈ MonoidHom.range (sumCongrHom m n)

tactic: let σ₂' := subtypePermOfFintype σ h3
state_before: case intro.intro
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
h3 : ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x
σ₁' : Perm { x // ∃ a, Sum.inl a = x } := subtypePermOfFintype σ h1
⊢ σ ∈ MonoidHom.range (sumCongrHom m n)

tactic: let σ₁ := permCongr (Equiv.ofInjective _ Sum.inl_injective).symm σ₁'
state_before: case intro.intro
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
h3 : ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x
σ₁' : Perm { x // ∃ a, Sum.inl a = x } := subtypePermOfFintype σ h1
σ₂' : Perm { x // ∃ b, Sum.inr b = x } := subtypePermOfFintype σ h3
⊢ σ ∈ MonoidHom.range (sumCongrHom m n)

tactic: let σ₂ := permCongr (Equiv.ofInjective _ Sum.inr_injective).symm σ₂'
state_before: case intro.intro
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
h3 : ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x
σ₁' : Perm { x // ∃ a, Sum.inl a = x } := subtypePermOfFintype σ h1
σ₂' : Perm { x // ∃ b, Sum.inr b = x } := subtypePermOfFintype σ h3
σ₁ : (fun x => Perm m) σ₁' := ↑(permCongr (ofInjective Sum.inl (_ : Injective Sum.inl)).symm) σ₁'
⊢ σ ∈ MonoidHom.range (sumCongrHom m n)

tactic: rw [MonoidHom.mem_range, Prod.exists]
state_before: case intro.intro
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
h3 : ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x
σ₁' : Perm { x // ∃ a, Sum.inl a = x } := subtypePermOfFintype σ h1
σ₂' : Perm { x // ∃ b, Sum.inr b = x } := subtypePermOfFintype σ h3
σ₁ : (fun x => Perm m) σ₁' := ↑(permCongr (ofInjective Sum.inl (_ : Injective Sum.inl)).symm) σ₁'
σ₂ : (fun x => Perm n) σ₂' := ↑(permCongr (ofInjective Sum.inr (_ : Injective Sum.inr)).symm) σ₂'
⊢ σ ∈ MonoidHom.range (sumCongrHom m n)

tactic: use σ₁, σ₂
state_before: case intro.intro
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
h3 : ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x
σ₁' : Perm { x // ∃ a, Sum.inl a = x } := subtypePermOfFintype σ h1
σ₂' : Perm { x // ∃ b, Sum.inr b = x } := subtypePermOfFintype σ h3
σ₁ : (fun x => Perm m) σ₁' := ↑(permCongr (ofInjective Sum.inl (_ : Injective Sum.inl)).symm) σ₁'
σ₂ : (fun x => Perm n) σ₂' := ↑(permCongr (ofInjective Sum.inr (_ : Injective Sum.inr)).symm) σ₂'
⊢ ∃ a b, ↑(sumCongrHom m n) (a, b) = σ

tactic: rw [Perm.sumCongrHom_apply]
state_before: case intro.intro
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
h3 : ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x
σ₁' : Perm { x // ∃ a, Sum.inl a = x } := subtypePermOfFintype σ h1
σ₂' : Perm { x // ∃ b, Sum.inr b = x } := subtypePermOfFintype σ h3
σ₁ : (fun x => Perm m) σ₁' := ↑(permCongr (ofInjective Sum.inl (_ : Injective Sum.inl)).symm) σ₁'
σ₂ : (fun x => Perm n) σ₂' := ↑(permCongr (ofInjective Sum.inr (_ : Injective Sum.inr)).symm) σ₂'
⊢ ↑(sumCongrHom m n) (σ₁, σ₂) = σ

tactic: ext x
state_before: case intro.intro
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
h3 : ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x
σ₁' : Perm { x // ∃ a, Sum.inl a = x } := subtypePermOfFintype σ h1
σ₂' : Perm { x // ∃ b, Sum.inr b = x } := subtypePermOfFintype σ h3
σ₁ : (fun x => Perm m) σ₁' := ↑(permCongr (ofInjective Sum.inl (_ : Injective Sum.inl)).symm) σ₁'
σ₂ : (fun x => Perm n) σ₂' := ↑(permCongr (ofInjective Sum.inr (_ : Injective Sum.inr)).symm) σ₂'
⊢ sumCongr (σ₁, σ₂).fst (σ₁, σ₂).snd = σ

tactic: cases' x with a b
state_before: case intro.intro.H
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
h3 : ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x
σ₁' : Perm { x // ∃ a, Sum.inl a = x } := subtypePermOfFintype σ h1
σ₂' : Perm { x // ∃ b, Sum.inr b = x } := subtypePermOfFintype σ h3
σ₁ : (fun x => Perm m) σ₁' := ↑(permCongr (ofInjective Sum.inl (_ : Injective Sum.inl)).symm) σ₁'
σ₂ : (fun x => Perm n) σ₂' := ↑(permCongr (ofInjective Sum.inr (_ : Injective Sum.inr)).symm) σ₂'
x : m ⊕ n
⊢ ↑(sumCongr (σ₁, σ₂).fst (σ₁, σ₂).snd) x = ↑σ x

tactic: rintro x ⟨a, ha⟩
state_before: α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
⊢ ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x

tactic: apply h
state_before: case intro
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
x : m ⊕ n
a : m
ha : Sum.inl a = x
⊢ ∃ a, Sum.inl a = ↑σ x

tactic: rw [← ha]
state_before: case intro.a
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
x : m ⊕ n
a : m
ha : Sum.inl a = x
⊢ x ∈ Set.range Sum.inl

tactic: exact ⟨a, rfl⟩
state_before: case intro.a
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
x : m ⊕ n
a : m
ha : Sum.inl a = x
⊢ Sum.inl a ∈ Set.range Sum.inl

tactic: rintro x ⟨b, hb⟩
state_before: α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
⊢ ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x

tactic: apply (perm_mapsTo_inl_iff_mapsTo_inr σ).mp h
state_before: case intro
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
x : m ⊕ n
b : n
hb : Sum.inr b = x
⊢ ∃ b, Sum.inr b = ↑σ x

tactic: rw [← hb]
state_before: case intro.a
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
x : m ⊕ n
b : n
hb : Sum.inr b = x
⊢ x ∈ Set.range Sum.inr

tactic: exact ⟨b, rfl⟩
state_before: case intro.a
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
x : m ⊕ n
b : n
hb : Sum.inr b = x
⊢ Sum.inr b ∈ Set.range Sum.inr

tactic: rw [Equiv.sumCongr_apply, Sum.map_inl, permCongr_apply, Equiv.symm_symm,
  apply_ofInjective_symm Sum.inl_injective]
state_before: case intro.intro.H.inl
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
h3 : ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x
σ₁' : Perm { x // ∃ a, Sum.inl a = x } := subtypePermOfFintype σ h1
σ₂' : Perm { x // ∃ b, Sum.inr b = x } := subtypePermOfFintype σ h3
σ₁ : (fun x => Perm m) σ₁' := ↑(permCongr (ofInjective Sum.inl (_ : Injective Sum.inl)).symm) σ₁'
σ₂ : (fun x => Perm n) σ₂' := ↑(permCongr (ofInjective Sum.inr (_ : Injective Sum.inr)).symm) σ₂'
a : m
⊢ ↑(sumCongr (σ₁, σ₂).fst (σ₁, σ₂).snd) (Sum.inl a) = ↑σ (Sum.inl a)

tactic: rw [ofInjective_apply, Subtype.coe_mk, Subtype.coe_mk, subtypePerm_apply]
state_before: case intro.intro.H.inl
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
h3 : ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x
σ₁' : Perm { x // ∃ a, Sum.inl a = x } := subtypePermOfFintype σ h1
σ₂' : Perm { x // ∃ b, Sum.inr b = x } := subtypePermOfFintype σ h3
σ₁ : (fun x => Perm m) σ₁' := ↑(permCongr (ofInjective Sum.inl (_ : Injective Sum.inl)).symm) σ₁'
σ₂ : (fun x => Perm n) σ₂' := ↑(permCongr (ofInjective Sum.inr (_ : Injective Sum.inr)).symm) σ₂'
a : m
⊢ ↑(↑σ₁' (↑(ofInjective Sum.inl (_ : Injective Sum.inl)) a)) = ↑σ (Sum.inl a)

tactic: rw [Equiv.sumCongr_apply, Sum.map_inr, permCongr_apply, Equiv.symm_symm,
  apply_ofInjective_symm Sum.inr_injective]
state_before: case intro.intro.H.inr
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
h3 : ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x
σ₁' : Perm { x // ∃ a, Sum.inl a = x } := subtypePermOfFintype σ h1
σ₂' : Perm { x // ∃ b, Sum.inr b = x } := subtypePermOfFintype σ h3
σ₁ : (fun x => Perm m) σ₁' := ↑(permCongr (ofInjective Sum.inl (_ : Injective Sum.inl)).symm) σ₁'
σ₂ : (fun x => Perm n) σ₂' := ↑(permCongr (ofInjective Sum.inr (_ : Injective Sum.inr)).symm) σ₂'
b : n
⊢ ↑(sumCongr (σ₁, σ₂).fst (σ₁, σ₂).snd) (Sum.inr b) = ↑σ (Sum.inr b)

tactic: erw [subtypePerm_apply]
state_before: case intro.intro.H.inr
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
h3 : ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x
σ₁' : Perm { x // ∃ a, Sum.inl a = x } := subtypePermOfFintype σ h1
σ₂' : Perm { x // ∃ b, Sum.inr b = x } := subtypePermOfFintype σ h3
σ₁ : (fun x => Perm m) σ₁' := ↑(permCongr (ofInjective Sum.inl (_ : Injective Sum.inl)).symm) σ₁'
σ₂ : (fun x => Perm n) σ₂' := ↑(permCongr (ofInjective Sum.inr (_ : Injective Sum.inr)).symm) σ₂'
b : n
⊢ ↑(↑σ₂' (↑(ofInjective Sum.inr (_ : Injective Sum.inr)) b)) = ↑σ (Sum.inr b)

tactic: rw [ofInjective_apply, Subtype.coe_mk, Subtype.coe_mk]
state_before: case intro.intro.H.inr
α : Type u
β : Type v
m : Type u_1
n : Type u_2
inst✝¹ : Finite m
inst✝ : Finite n
σ : Perm (m ⊕ n)
h : Set.MapsTo (↑σ) (Set.range Sum.inl) (Set.range Sum.inl)
val✝¹ : Fintype m
val✝ : Fintype n
h1 : ∀ (x : m ⊕ n), (∃ a, Sum.inl a = x) → ∃ a, Sum.inl a = ↑σ x
h3 : ∀ (x : m ⊕ n), (∃ b, Sum.inr b = x) → ∃ b, Sum.inr b = ↑σ x
σ₁' : Perm { x // ∃ a, Sum.inl a = x } := subtypePermOfFintype σ h1
σ₂' : Perm { x // ∃ b, Sum.inr b = x } := subtypePermOfFintype σ h3
σ₁ : (fun x => Perm m) σ₁' := ↑(permCongr (ofInjective Sum.inl (_ : Injective Sum.inl)).symm) σ₁'
σ₂ : (fun x => Perm n) σ₂' := ↑(permCongr (ofInjective Sum.inr (_ : Injective Sum.inr)).symm) σ₂'
b : n
⊢ ↑{ val := ↑σ ↑(↑(ofInjective Sum.inr (_ : Injective Sum.inr)) b),
        property := (_ : (fun x => ∃ b, Sum.inr b = x) (↑σ ↑(↑(ofInjective Sum.inr (_ : Injective Sum.inr)) b))) } =
    ↑σ (Sum.inr b)