l3lab/ntp-mathlib huggingface dataset:
theorem map₂_assoc {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'}
    (h_assoc : ∀ a b c, f (g a b) c = f' a (g' b c)) :
    map₂ f (map₂ g a b) c = map₂ f' a (map₂ g' b c) :=
  by cases a <;> cases b <;> 

Proof state:
case none.some
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
c : Option γ
δ : Type u_1
ε : Type u_2
ε' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → ε' → ε
g' : β → γ → ε'
h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)
val✝ : β
⊢ map₂ f (map₂ g none (some val✝)) c = map₂ f' none (map₂ g' (some val✝) c)

Next tactic:
cases c
theorem map₂_assoc {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'}
    (h_assoc : ∀ a b c, f (g a b) c = f' a (g' b c)) :
    map₂ f (map₂ g a b) c = map₂ f' a (map₂ g' b c) :=
  by cases a <;> cases b <;> 

Proof state:
case some.none
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
c : Option γ
δ : Type u_1
ε : Type u_2
ε' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → ε' → ε
g' : β → γ → ε'
h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)
val✝ : α
⊢ map₂ f (map₂ g (some val✝) none) c = map₂ f' (some val✝) (map₂ g' none c)

Next tactic:
cases c
theorem map₂_assoc {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'}
    (h_assoc : ∀ a b c, f (g a b) c = f' a (g' b c)) :
    map₂ f (map₂ g a b) c = map₂ f' a (map₂ g' b c) :=
  by cases a <;> cases b <;> 

Proof state:
case some.some
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
c : Option γ
δ : Type u_1
ε : Type u_2
ε' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → ε' → ε
g' : β → γ → ε'
h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)
val✝¹ : α
val✝ : β
⊢ map₂ f (map₂ g (some val✝¹) (some val✝)) c = map₂ f' (some val✝¹) (map₂ g' (some val✝) c)

Next tactic:
cases c
theorem map₂_assoc {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'}
    (h_assoc : ∀ a b c, f (g a b) c = f' a (g' b c)) :
    map₂ f (map₂ g a b) c = map₂ f' a (map₂ g' b c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case none.none.none
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
ε' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → ε' → ε
g' : β → γ → ε'
h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)
⊢ map₂ f (map₂ g none none) none = map₂ f' none (map₂ g' none none)

Next tactic:
simp [h_assoc]
theorem map₂_assoc {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'}
    (h_assoc : ∀ a b c, f (g a b) c = f' a (g' b c)) :
    map₂ f (map₂ g a b) c = map₂ f' a (map₂ g' b c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case none.none.some
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
ε' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → ε' → ε
g' : β → γ → ε'
h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)
val✝ : γ
⊢ map₂ f (map₂ g none none) (some val✝) = map₂ f' none (map₂ g' none (some val✝))

Next tactic:
simp [h_assoc]
theorem map₂_assoc {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'}
    (h_assoc : ∀ a b c, f (g a b) c = f' a (g' b c)) :
    map₂ f (map₂ g a b) c = map₂ f' a (map₂ g' b c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case none.some.none
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
ε' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → ε' → ε
g' : β → γ → ε'
h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)
val✝ : β
⊢ map₂ f (map₂ g none (some val✝)) none = map₂ f' none (map₂ g' (some val✝) none)

Next tactic:
simp [h_assoc]
theorem map₂_assoc {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'}
    (h_assoc : ∀ a b c, f (g a b) c = f' a (g' b c)) :
    map₂ f (map₂ g a b) c = map₂ f' a (map₂ g' b c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case none.some.some
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
ε' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → ε' → ε
g' : β → γ → ε'
h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)
val✝¹ : β
val✝ : γ
⊢ map₂ f (map₂ g none (some val✝¹)) (some val✝) = map₂ f' none (map₂ g' (some val✝¹) (some val✝))

Next tactic:
simp [h_assoc]
theorem map₂_assoc {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'}
    (h_assoc : ∀ a b c, f (g a b) c = f' a (g' b c)) :
    map₂ f (map₂ g a b) c = map₂ f' a (map₂ g' b c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case some.none.none
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
ε' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → ε' → ε
g' : β → γ → ε'
h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)
val✝ : α
⊢ map₂ f (map₂ g (some val✝) none) none = map₂ f' (some val✝) (map₂ g' none none)

Next tactic:
simp [h_assoc]
theorem map₂_assoc {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'}
    (h_assoc : ∀ a b c, f (g a b) c = f' a (g' b c)) :
    map₂ f (map₂ g a b) c = map₂ f' a (map₂ g' b c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case some.none.some
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
ε' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → ε' → ε
g' : β → γ → ε'
h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)
val✝¹ : α
val✝ : γ
⊢ map₂ f (map₂ g (some val✝¹) none) (some val✝) = map₂ f' (some val✝¹) (map₂ g' none (some val✝))

Next tactic:
simp [h_assoc]
theorem map₂_assoc {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'}
    (h_assoc : ∀ a b c, f (g a b) c = f' a (g' b c)) :
    map₂ f (map₂ g a b) c = map₂ f' a (map₂ g' b c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case some.some.none
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
ε' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → ε' → ε
g' : β → γ → ε'
h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)
val✝¹ : α
val✝ : β
⊢ map₂ f (map₂ g (some val✝¹) (some val✝)) none = map₂ f' (some val✝¹) (map₂ g' (some val✝) none)

Next tactic:
simp [h_assoc]
theorem map₂_assoc {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'}
    (h_assoc : ∀ a b c, f (g a b) c = f' a (g' b c)) :
    map₂ f (map₂ g a b) c = map₂ f' a (map₂ g' b c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case some.some.some
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
ε' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → ε' → ε
g' : β → γ → ε'
h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)
val✝² : α
val✝¹ : β
val✝ : γ
⊢ map₂ f (map₂ g (some val✝²) (some val✝¹)) (some val✝) = map₂ f' (some val✝²) (map₂ g' (some val✝¹) (some val✝))

Next tactic:
simp [h_assoc]
theorem map₂_comm {g : β → α → γ} (h_comm : ∀ a b, f a b = g b a) : map₂ f a b = map₂ g b a :=
  by 

Proof state:
α : Type u_2
β : Type u_3
γ : Type u_1
f : α → β → γ
a : Option α
b : Option β
c : Option γ
g : β → α → γ
h_comm : ∀ (a : α) (b : β), f a b = g b a
⊢ map₂ f a b = map₂ g b a

Next tactic:
cases a
theorem map₂_comm {g : β → α → γ} (h_comm : ∀ a b, f a b = g b a) : map₂ f a b = map₂ g b a :=
  by cases a <;> 

Proof state:
case none
α : Type u_2
β : Type u_3
γ : Type u_1
f : α → β → γ
b : Option β
c : Option γ
g : β → α → γ
h_comm : ∀ (a : α) (b : β), f a b = g b a
⊢ map₂ f none b = map₂ g b none

Next tactic:
cases b
theorem map₂_comm {g : β → α → γ} (h_comm : ∀ a b, f a b = g b a) : map₂ f a b = map₂ g b a :=
  by cases a <;> 

Proof state:
case some
α : Type u_2
β : Type u_3
γ : Type u_1
f : α → β → γ
b : Option β
c : Option γ
g : β → α → γ
h_comm : ∀ (a : α) (b : β), f a b = g b a
val✝ : α
⊢ map₂ f (some val✝) b = map₂ g b (some val✝)

Next tactic:
cases b
theorem map₂_comm {g : β → α → γ} (h_comm : ∀ a b, f a b = g b a) : map₂ f a b = map₂ g b a :=
  by cases a <;> cases b <;> 

Proof state:
case none.none
α : Type u_2
β : Type u_3
γ : Type u_1
f : α → β → γ
c : Option γ
g : β → α → γ
h_comm : ∀ (a : α) (b : β), f a b = g b a
⊢ map₂ f none none = map₂ g none none

Next tactic:
simp [h_comm]
theorem map₂_comm {g : β → α → γ} (h_comm : ∀ a b, f a b = g b a) : map₂ f a b = map₂ g b a :=
  by cases a <;> cases b <;> 

Proof state:
case none.some
α : Type u_2
β : Type u_3
γ : Type u_1
f : α → β → γ
c : Option γ
g : β → α → γ
h_comm : ∀ (a : α) (b : β), f a b = g b a
val✝ : β
⊢ map₂ f none (some val✝) = map₂ g (some val✝) none

Next tactic:
simp [h_comm]
theorem map₂_comm {g : β → α → γ} (h_comm : ∀ a b, f a b = g b a) : map₂ f a b = map₂ g b a :=
  by cases a <;> cases b <;> 

Proof state:
case some.none
α : Type u_2
β : Type u_3
γ : Type u_1
f : α → β → γ
c : Option γ
g : β → α → γ
h_comm : ∀ (a : α) (b : β), f a b = g b a
val✝ : α
⊢ map₂ f (some val✝) none = map₂ g none (some val✝)

Next tactic:
simp [h_comm]
theorem map₂_comm {g : β → α → γ} (h_comm : ∀ a b, f a b = g b a) : map₂ f a b = map₂ g b a :=
  by cases a <;> cases b <;> 

Proof state:
case some.some
α : Type u_2
β : Type u_3
γ : Type u_1
f : α → β → γ
c : Option γ
g : β → α → γ
h_comm : ∀ (a : α) (b : β), f a b = g b a
val✝¹ : α
val✝ : β
⊢ map₂ f (some val✝¹) (some val✝) = map₂ g (some val✝) (some val✝¹)

Next tactic:
simp [h_comm]
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by 

Proof state:
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
a : Option α
b : Option β
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
⊢ map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c)

Next tactic:
cases a
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by cases a <;> 

Proof state:
case none
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
b : Option β
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
⊢ map₂ f none (map₂ g b c) = map₂ g' b (map₂ f' none c)

Next tactic:
cases b
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by cases a <;> 

Proof state:
case some
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
b : Option β
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
val✝ : α
⊢ map₂ f (some val✝) (map₂ g b c) = map₂ g' b (map₂ f' (some val✝) c)

Next tactic:
cases b
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by cases a <;> cases b <;> 

Proof state:
case none.none
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
⊢ map₂ f none (map₂ g none c) = map₂ g' none (map₂ f' none c)

Next tactic:
cases c
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by cases a <;> cases b <;> 

Proof state:
case none.some
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
val✝ : β
⊢ map₂ f none (map₂ g (some val✝) c) = map₂ g' (some val✝) (map₂ f' none c)

Next tactic:
cases c
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by cases a <;> cases b <;> 

Proof state:
case some.none
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
val✝ : α
⊢ map₂ f (some val✝) (map₂ g none c) = map₂ g' none (map₂ f' (some val✝) c)

Next tactic:
cases c
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by cases a <;> cases b <;> 

Proof state:
case some.some
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
val✝¹ : α
val✝ : β
⊢ map₂ f (some val✝¹) (map₂ g (some val✝) c) = map₂ g' (some val✝) (map₂ f' (some val✝¹) c)

Next tactic:
cases c
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case none.none.none
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
⊢ map₂ f none (map₂ g none none) = map₂ g' none (map₂ f' none none)

Next tactic:
simp [h_left_comm]
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case none.none.some
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
val✝ : γ
⊢ map₂ f none (map₂ g none (some val✝)) = map₂ g' none (map₂ f' none (some val✝))

Next tactic:
simp [h_left_comm]
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case none.some.none
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
val✝ : β
⊢ map₂ f none (map₂ g (some val✝) none) = map₂ g' (some val✝) (map₂ f' none none)

Next tactic:
simp [h_left_comm]
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case none.some.some
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
val✝¹ : β
val✝ : γ
⊢ map₂ f none (map₂ g (some val✝¹) (some val✝)) = map₂ g' (some val✝¹) (map₂ f' none (some val✝))

Next tactic:
simp [h_left_comm]
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case some.none.none
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
val✝ : α
⊢ map₂ f (some val✝) (map₂ g none none) = map₂ g' none (map₂ f' (some val✝) none)

Next tactic:
simp [h_left_comm]
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case some.none.some
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
val✝¹ : α
val✝ : γ
⊢ map₂ f (some val✝¹) (map₂ g none (some val✝)) = map₂ g' none (map₂ f' (some val✝¹) (some val✝))

Next tactic:
simp [h_left_comm]
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case some.some.none
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
val✝¹ : α
val✝ : β
⊢ map₂ f (some val✝¹) (map₂ g (some val✝) none) = map₂ g' (some val✝) (map₂ f' (some val✝¹) none)

Next tactic:
simp [h_left_comm]
theorem map₂_left_comm {f : α → δ → ε} {g : β → γ → δ} {f' : α → γ → δ'} {g' : β → δ' → ε}
    (h_left_comm : ∀ a b c, f a (g b c) = g' b (f' a c)) :
    map₂ f a (map₂ g b c) = map₂ g' b (map₂ f' a c) :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case some.some.some
α : Type u_4
β : Type u_5
γ : Type u_6
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
val✝² : α
val✝¹ : β
val✝ : γ
⊢ map₂ f (some val✝²) (map₂ g (some val✝¹) (some val✝)) = map₂ g' (some val✝¹) (map₂ f' (some val✝²) (some val✝))

Next tactic:
simp [h_left_comm]
theorem map₂_right_comm {f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε}
    (h_right_comm : ∀ a b c, f (g a b) c = g' (f' a c) b) :
    map₂ f (map₂ g a b) c = map₂ g' (map₂ f' a c) b :=
  by 

Proof state:
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
a : Option α
b : Option β
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → γ → δ'
g' : δ' → β → ε
h_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b
⊢ map₂ f (map₂ g a b) c = map₂ g' (map₂ f' a c) b

Next tactic:
cases a
theorem map₂_right_comm {f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε}
    (h_right_comm : ∀ a b c, f (g a b) c = g' (f' a c) b) :
    map₂ f (map₂ g a b) c = map₂ g' (map₂ f' a c) b :=
  by cases a <;> 

Proof state:
case none
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
b : Option β
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → γ → δ'
g' : δ' → β → ε
h_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b
⊢ map₂ f (map₂ g none b) c = map₂ g' (map₂ f' none c) b

Next tactic:
cases b
theorem map₂_right_comm {f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε}
    (h_right_comm : ∀ a b c, f (g a b) c = g' (f' a c) b) :
    map₂ f (map₂ g a b) c = map₂ g' (map₂ f' a c) b :=
  by cases a <;> 

Proof state:
case some
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
b : Option β
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → γ → δ'
g' : δ' → β → ε
h_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b
val✝ : α
⊢ map₂ f (map₂ g (some val✝) b) c = map₂ g' (map₂ f' (some val✝) c) b

Next tactic:
cases b
theorem map₂_right_comm {f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε}
    (h_right_comm : ∀ a b c, f (g a b) c = g' (f' a c) b) :
    map₂ f (map₂ g a b) c = map₂ g' (map₂ f' a c) b :=
  by cases a <;> cases b <;> 

Proof state:
case none.none
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → γ → δ'
g' : δ' → β → ε
h_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b
⊢ map₂ f (map₂ g none none) c = map₂ g' (map₂ f' none c) none

Next tactic:
cases c
theorem map₂_right_comm {f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε}
    (h_right_comm : ∀ a b c, f (g a b) c = g' (f' a c) b) :
    map₂ f (map₂ g a b) c = map₂ g' (map₂ f' a c) b :=
  by cases a <;> cases b <;> 

Proof state:
case none.some
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → γ → δ'
g' : δ' → β → ε
h_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b
val✝ : β
⊢ map₂ f (map₂ g none (some val✝)) c = map₂ g' (map₂ f' none c) (some val✝)

Next tactic:
cases c
theorem map₂_right_comm {f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε}
    (h_right_comm : ∀ a b c, f (g a b) c = g' (f' a c) b) :
    map₂ f (map₂ g a b) c = map₂ g' (map₂ f' a c) b :=
  by cases a <;> cases b <;> 

Proof state:
case some.none
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → γ → δ'
g' : δ' → β → ε
h_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b
val✝ : α
⊢ map₂ f (map₂ g (some val✝) none) c = map₂ g' (map₂ f' (some val✝) c) none

Next tactic:
cases c
theorem map₂_right_comm {f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε}
    (h_right_comm : ∀ a b c, f (g a b) c = g' (f' a c) b) :
    map₂ f (map₂ g a b) c = map₂ g' (map₂ f' a c) b :=
  by cases a <;> cases b <;> 

Proof state:
case some.some
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
c : Option γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → γ → δ'
g' : δ' → β → ε
h_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b
val✝¹ : α
val✝ : β
⊢ map₂ f (map₂ g (some val✝¹) (some val✝)) c = map₂ g' (map₂ f' (some val✝¹) c) (some val✝)

Next tactic:
cases c
theorem map₂_right_comm {f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε}
    (h_right_comm : ∀ a b c, f (g a b) c = g' (f' a c) b) :
    map₂ f (map₂ g a b) c = map₂ g' (map₂ f' a c) b :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case none.none.none
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → γ → δ'
g' : δ' → β → ε
h_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b
⊢ map₂ f (map₂ g none none) none = map₂ g' (map₂ f' none none) none

Next tactic:
simp [h_right_comm]
theorem map₂_right_comm {f : δ → γ → ε} {g : α → β → δ} {f' : α → γ → δ'} {g' : δ' → β → ε}
    (h_right_comm : ∀ a b c, f (g a b) c = g' (f' a c) b) :
    map₂ f (map₂ g a b) c = map₂ g' (map₂ f' a c) b :=
  by cases a <;> cases b <;> cases c <;> 

Proof state:
case none.none.some
α : Type u_5
β : Type u_6
γ : Type u_4
f✝ : α → β → γ
δ : Type u_1
ε : Type u_2
δ' : Type u_3
f : δ → γ → ε
g : α → β → δ
f' : α → γ → δ'
g' : δ' → β → ε
h_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b
val✝ : γ
⊢ map₂ f (map₂ g none none) (some val✝) = map₂ g' (map₂ f' none (some val✝)) none

Next tactic:
simp [h_right_comm]