l3lab/ntp-mathlib huggingface dataset:
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.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_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b
val✝ : β
⊢ map₂ f (map₂ g none (some val✝)) none = map₂ g' (map₂ f' none none) (some val✝)

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.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_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b
val✝¹ : β
val✝ : γ
⊢ map₂ f (map₂ g none (some val✝¹)) (some val✝) = map₂ g' (map₂ f' none (some val✝)) (some val✝¹)

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 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_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b
val✝ : α
⊢ map₂ f (map₂ g (some val✝) none) none = map₂ g' (map₂ f' (some val✝) 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 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_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b
val✝¹ : α
val✝ : γ
⊢ map₂ f (map₂ g (some val✝¹) none) (some val✝) = map₂ g' (map₂ f' (some val✝¹) (some val✝)) 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 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_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✝)) none = map₂ g' (map₂ f' (some val✝¹) none) (some val✝)

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 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_right_comm : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f' a c) b
val✝² : α
val✝¹ : β
val✝ : γ
⊢ map₂ f (map₂ g (some val✝²) (some val✝¹)) (some val✝) = map₂ g' (map₂ f' (some val✝²) (some val✝)) (some val✝¹)

Next tactic:
simp [h_right_comm]
theorem map_map₂_distrib {g : γ → δ} {f' : α' → β' → δ} {g₁ : α → α'} {g₂ : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' (g₁ a) (g₂ b)) :
    (map₂ f a b).map g = map₂ f' (a.map g₁) (b.map g₂) :=
  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
g : γ → δ
f' : α' → β' → δ
g₁ : α → α'
g₂ : β → β'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ a) (g₂ b)
⊢ Option.map g (map₂ f a b) = map₂ f' (Option.map g₁ a) (Option.map g₂ b)

Next tactic:
cases a
theorem map_map₂_distrib {g : γ → δ} {f' : α' → β' → δ} {g₁ : α → α'} {g₂ : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' (g₁ a) (g₂ b)) :
    (map₂ f a b).map g = map₂ f' (a.map g₁) (b.map g₂) :=
  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
g : γ → δ
f' : α' → β' → δ
g₁ : α → α'
g₂ : β → β'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ a) (g₂ b)
⊢ Option.map g (map₂ f none b) = map₂ f' (Option.map g₁ none) (Option.map g₂ b)

Next tactic:
cases b
theorem map_map₂_distrib {g : γ → δ} {f' : α' → β' → δ} {g₁ : α → α'} {g₂ : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' (g₁ a) (g₂ b)) :
    (map₂ f a b).map g = map₂ f' (a.map g₁) (b.map g₂) :=
  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
g : γ → δ
f' : α' → β' → δ
g₁ : α → α'
g₂ : β → β'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ a) (g₂ b)
val✝ : α
⊢ Option.map g (map₂ f (some val✝) b) = map₂ f' (Option.map g₁ (some val✝)) (Option.map g₂ b)

Next tactic:
cases b
theorem map_map₂_distrib {g : γ → δ} {f' : α' → β' → δ} {g₁ : α → α'} {g₂ : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' (g₁ a) (g₂ b)) :
    (map₂ f a b).map g = map₂ f' (a.map g₁) (b.map g₂) :=
  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
g : γ → δ
f' : α' → β' → δ
g₁ : α → α'
g₂ : β → β'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ a) (g₂ b)
⊢ Option.map g (map₂ f none none) = map₂ f' (Option.map g₁ none) (Option.map g₂ none)

Next tactic:
simp [h_distrib]
theorem map_map₂_distrib {g : γ → δ} {f' : α' → β' → δ} {g₁ : α → α'} {g₂ : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' (g₁ a) (g₂ b)) :
    (map₂ f a b).map g = map₂ f' (a.map g₁) (b.map g₂) :=
  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
g : γ → δ
f' : α' → β' → δ
g₁ : α → α'
g₂ : β → β'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ a) (g₂ b)
val✝ : β
⊢ Option.map g (map₂ f none (some val✝)) = map₂ f' (Option.map g₁ none) (Option.map g₂ (some val✝))

Next tactic:
simp [h_distrib]
theorem map_map₂_distrib {g : γ → δ} {f' : α' → β' → δ} {g₁ : α → α'} {g₂ : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' (g₁ a) (g₂ b)) :
    (map₂ f a b).map g = map₂ f' (a.map g₁) (b.map g₂) :=
  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
g : γ → δ
f' : α' → β' → δ
g₁ : α → α'
g₂ : β → β'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ a) (g₂ b)
val✝ : α
⊢ Option.map g (map₂ f (some val✝) none) = map₂ f' (Option.map g₁ (some val✝)) (Option.map g₂ none)

Next tactic:
simp [h_distrib]
theorem map_map₂_distrib {g : γ → δ} {f' : α' → β' → δ} {g₁ : α → α'} {g₂ : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' (g₁ a) (g₂ b)) :
    (map₂ f a b).map g = map₂ f' (a.map g₁) (b.map g₂) :=
  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
g : γ → δ
f' : α' → β' → δ
g₁ : α → α'
g₂ : β → β'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ a) (g₂ b)
val✝¹ : α
val✝ : β
⊢ Option.map g (map₂ f (some val✝¹) (some val✝)) = map₂ f' (Option.map g₁ (some val✝¹)) (Option.map g₂ (some val✝))

Next tactic:
simp [h_distrib]
/-- Symmetric statement to `Option.map₂_map_left_comm`. -/
theorem map_map₂_distrib_left {g : γ → δ} {f' : α' → β → δ} {g' : α → α'}
    (h_distrib : ∀ a b, g (f a b) = f' (g' a) b) :
    (map₂ f a b).map g = map₂ f' (a.map g') b := by 

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

Next tactic:
cases a
/-- Symmetric statement to `Option.map₂_map_left_comm`. -/
theorem map_map₂_distrib_left {g : γ → δ} {f' : α' → β → δ} {g' : α → α'}
    (h_distrib : ∀ a b, g (f a b) = f' (g' a) b) :
    (map₂ f a b).map g = map₂ f' (a.map g') b := by cases a <;> 

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

Next tactic:
cases b
/-- Symmetric statement to `Option.map₂_map_left_comm`. -/
theorem map_map₂_distrib_left {g : γ → δ} {f' : α' → β → δ} {g' : α → α'}
    (h_distrib : ∀ a b, g (f a b) = f' (g' a) b) :
    (map₂ f a b).map g = map₂ f' (a.map g') b := by cases a <;> 

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

Next tactic:
cases b
/-- Symmetric statement to `Option.map₂_map_left_comm`. -/
theorem map_map₂_distrib_left {g : γ → δ} {f' : α' → β → δ} {g' : α → α'}
    (h_distrib : ∀ a b, g (f a b) = f' (g' a) b) :
    (map₂ f a b).map g = map₂ f' (a.map g') b := by cases a <;> cases b <;> 

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

Next tactic:
simp [h_distrib]
/-- Symmetric statement to `Option.map₂_map_left_comm`. -/
theorem map_map₂_distrib_left {g : γ → δ} {f' : α' → β → δ} {g' : α → α'}
    (h_distrib : ∀ a b, g (f a b) = f' (g' a) b) :
    (map₂ f a b).map g = map₂ f' (a.map g') b := by cases a <;> cases b <;> 

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

Next tactic:
simp [h_distrib]
/-- Symmetric statement to `Option.map₂_map_left_comm`. -/
theorem map_map₂_distrib_left {g : γ → δ} {f' : α' → β → δ} {g' : α → α'}
    (h_distrib : ∀ a b, g (f a b) = f' (g' a) b) :
    (map₂ f a b).map g = map₂ f' (a.map g') b := by cases a <;> cases b <;> 

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

Next tactic:
simp [h_distrib]
/-- Symmetric statement to `Option.map₂_map_left_comm`. -/
theorem map_map₂_distrib_left {g : γ → δ} {f' : α' → β → δ} {g' : α → α'}
    (h_distrib : ∀ a b, g (f a b) = f' (g' a) b) :
    (map₂ f a b).map g = map₂ f' (a.map g') b := by cases a <;> cases b <;> 

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

Next tactic:
simp [h_distrib]
/-- Symmetric statement to `Option.map_map₂_right_comm`. -/
theorem map_map₂_distrib_right {g : γ → δ} {f' : α → β' → δ} {g' : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' a (g' b)) : (map₂ f a b).map g = map₂ f' a (b.map g') :=
  by 

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

Next tactic:
cases a
/-- Symmetric statement to `Option.map_map₂_right_comm`. -/
theorem map_map₂_distrib_right {g : γ → δ} {f' : α → β' → δ} {g' : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' a (g' b)) : (map₂ f a b).map g = map₂ f' a (b.map g') :=
  by cases a <;> 

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

Next tactic:
cases b
/-- Symmetric statement to `Option.map_map₂_right_comm`. -/
theorem map_map₂_distrib_right {g : γ → δ} {f' : α → β' → δ} {g' : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' a (g' b)) : (map₂ f a b).map g = map₂ f' a (b.map g') :=
  by cases a <;> 

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

Next tactic:
cases b
/-- Symmetric statement to `Option.map_map₂_right_comm`. -/
theorem map_map₂_distrib_right {g : γ → δ} {f' : α → β' → δ} {g' : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' a (g' b)) : (map₂ f a b).map g = map₂ f' a (b.map g') :=
  by cases a <;> cases b <;> 

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

Next tactic:
simp [h_distrib]
/-- Symmetric statement to `Option.map_map₂_right_comm`. -/
theorem map_map₂_distrib_right {g : γ → δ} {f' : α → β' → δ} {g' : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' a (g' b)) : (map₂ f a b).map g = map₂ f' a (b.map g') :=
  by cases a <;> cases b <;> 

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

Next tactic:
simp [h_distrib]
/-- Symmetric statement to `Option.map_map₂_right_comm`. -/
theorem map_map₂_distrib_right {g : γ → δ} {f' : α → β' → δ} {g' : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' a (g' b)) : (map₂ f a b).map g = map₂ f' a (b.map g') :=
  by cases a <;> cases b <;> 

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

Next tactic:
simp [h_distrib]
/-- Symmetric statement to `Option.map_map₂_right_comm`. -/
theorem map_map₂_distrib_right {g : γ → δ} {f' : α → β' → δ} {g' : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' a (g' b)) : (map₂ f a b).map g = map₂ f' a (b.map g') :=
  by cases a <;> cases b <;> 

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

Next tactic:
simp [h_distrib]
/-- Symmetric statement to `Option.map_map₂_distrib_left`. -/
theorem map₂_map_left_comm {f : α' → β → γ} {g : α → α'} {f' : α → β → δ} {g' : δ → γ}
    (h_left_comm : ∀ a b, f (g a) b = g' (f' a b)) : map₂ f (a.map g) b = (map₂ f' a b).map g' :=
  by 

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

Next tactic:
cases a
/-- Symmetric statement to `Option.map_map₂_distrib_left`. -/
theorem map₂_map_left_comm {f : α' → β → γ} {g : α → α'} {f' : α → β → δ} {g' : δ → γ}
    (h_left_comm : ∀ a b, f (g a) b = g' (f' a b)) : map₂ f (a.map g) b = (map₂ f' a b).map g' :=
  by cases a <;> 

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

Next tactic:
cases b
/-- Symmetric statement to `Option.map_map₂_distrib_left`. -/
theorem map₂_map_left_comm {f : α' → β → γ} {g : α → α'} {f' : α → β → δ} {g' : δ → γ}
    (h_left_comm : ∀ a b, f (g a) b = g' (f' a b)) : map₂ f (a.map g) b = (map₂ f' a b).map g' :=
  by cases a <;> 

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

Next tactic:
cases b
/-- Symmetric statement to `Option.map_map₂_distrib_left`. -/
theorem map₂_map_left_comm {f : α' → β → γ} {g : α → α'} {f' : α → β → δ} {g' : δ → γ}
    (h_left_comm : ∀ a b, f (g a) b = g' (f' a b)) : map₂ f (a.map g) b = (map₂ f' a b).map g' :=
  by cases a <;> cases b <;> 

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

Next tactic:
simp [h_left_comm]
/-- Symmetric statement to `Option.map_map₂_distrib_left`. -/
theorem map₂_map_left_comm {f : α' → β → γ} {g : α → α'} {f' : α → β → δ} {g' : δ → γ}
    (h_left_comm : ∀ a b, f (g a) b = g' (f' a b)) : map₂ f (a.map g) b = (map₂ f' a b).map g' :=
  by cases a <;> cases b <;> 

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

Next tactic:
simp [h_left_comm]
/-- Symmetric statement to `Option.map_map₂_distrib_left`. -/
theorem map₂_map_left_comm {f : α' → β → γ} {g : α → α'} {f' : α → β → δ} {g' : δ → γ}
    (h_left_comm : ∀ a b, f (g a) b = g' (f' a b)) : map₂ f (a.map g) b = (map₂ f' a b).map g' :=
  by cases a <;> cases b <;> 

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

Next tactic:
simp [h_left_comm]
/-- Symmetric statement to `Option.map_map₂_distrib_left`. -/
theorem map₂_map_left_comm {f : α' → β → γ} {g : α → α'} {f' : α → β → δ} {g' : δ → γ}
    (h_left_comm : ∀ a b, f (g a) b = g' (f' a b)) : map₂ f (a.map g) b = (map₂ f' a b).map g' :=
  by cases a <;> cases b <;> 

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

Next tactic:
simp [h_left_comm]
/-- Symmetric statement to `Option.map_map₂_distrib_right`. -/
theorem map_map₂_right_comm {f : α → β' → γ} {g : β → β'} {f' : α → β → δ} {g' : δ → γ}
    (h_right_comm : ∀ a b, f a (g b) = g' (f' a b)) : map₂ f a (b.map g) = (map₂ f' a b).map g' :=
  by 

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

Next tactic:
cases a
/-- Symmetric statement to `Option.map_map₂_distrib_right`. -/
theorem map_map₂_right_comm {f : α → β' → γ} {g : β → β'} {f' : α → β → δ} {g' : δ → γ}
    (h_right_comm : ∀ a b, f a (g b) = g' (f' a b)) : map₂ f a (b.map g) = (map₂ f' a b).map g' :=
  by cases a <;> 

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

Next tactic:
cases b
/-- Symmetric statement to `Option.map_map₂_distrib_right`. -/
theorem map_map₂_right_comm {f : α → β' → γ} {g : β → β'} {f' : α → β → δ} {g' : δ → γ}
    (h_right_comm : ∀ a b, f a (g b) = g' (f' a b)) : map₂ f a (b.map g) = (map₂ f' a b).map g' :=
  by cases a <;> 

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

Next tactic:
cases b
/-- Symmetric statement to `Option.map_map₂_distrib_right`. -/
theorem map_map₂_right_comm {f : α → β' → γ} {g : β → β'} {f' : α → β → δ} {g' : δ → γ}
    (h_right_comm : ∀ a b, f a (g b) = g' (f' a b)) : map₂ f a (b.map g) = (map₂ f' a b).map g' :=
  by cases a <;> cases b <;> 

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

Next tactic:
simp [h_right_comm]
/-- Symmetric statement to `Option.map_map₂_distrib_right`. -/
theorem map_map₂_right_comm {f : α → β' → γ} {g : β → β'} {f' : α → β → δ} {g' : δ → γ}
    (h_right_comm : ∀ a b, f a (g b) = g' (f' a b)) : map₂ f a (b.map g) = (map₂ f' a b).map g' :=
  by cases a <;> cases b <;> 

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

Next tactic:
simp [h_right_comm]
/-- Symmetric statement to `Option.map_map₂_distrib_right`. -/
theorem map_map₂_right_comm {f : α → β' → γ} {g : β → β'} {f' : α → β → δ} {g' : δ → γ}
    (h_right_comm : ∀ a b, f a (g b) = g' (f' a b)) : map₂ f a (b.map g) = (map₂ f' a b).map g' :=
  by cases a <;> cases b <;> 

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

Next tactic:
simp [h_right_comm]