l3lab/ntp-mathlib huggingface dataset:
/-- 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.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✝¹ : α
val✝ : β
⊢ map₂ f (some val✝¹) (Option.map g (some val✝)) = Option.map g' (map₂ f' (some val✝¹) (some val✝))

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

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

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

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

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

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

Next tactic:
simp [h_antidistrib]
theorem map_map₂_antidistrib {g : γ → δ} {f' : β' → α' → δ} {g₁ : β → β'} {g₂ : α → α'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g₁ b) (g₂ a)) :
    (map₂ f a b).map g = map₂ f' (b.map g₁) (a.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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ b) (g₂ a)
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_antidistrib]
/-- Symmetric statement to `Option.map₂_map_left_anticomm`. -/
theorem map_map₂_antidistrib_left {g : γ → δ} {f' : β' → α → δ} {g' : β → β'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g' b) a) :
    (map₂ f a b).map g = map₂ f' (b.map g') a :=
  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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g' b) a
⊢ Option.map g (map₂ f a b) = map₂ f' (Option.map g' b) a

Next tactic:
cases a
/-- Symmetric statement to `Option.map₂_map_left_anticomm`. -/
theorem map_map₂_antidistrib_left {g : γ → δ} {f' : β' → α → δ} {g' : β → β'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g' b) a) :
    (map₂ f a b).map g = map₂ f' (b.map g') a :=
  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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g' b) a
⊢ Option.map g (map₂ f none b) = map₂ f' (Option.map g' b) none

Next tactic:
cases b
/-- Symmetric statement to `Option.map₂_map_left_anticomm`. -/
theorem map_map₂_antidistrib_left {g : γ → δ} {f' : β' → α → δ} {g' : β → β'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g' b) a) :
    (map₂ f a b).map g = map₂ f' (b.map g') a :=
  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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g' b) a
val✝ : α
⊢ Option.map g (map₂ f (some val✝) b) = map₂ f' (Option.map g' b) (some val✝)

Next tactic:
cases b
/-- Symmetric statement to `Option.map₂_map_left_anticomm`. -/
theorem map_map₂_antidistrib_left {g : γ → δ} {f' : β' → α → δ} {g' : β → β'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g' b) a) :
    (map₂ f a b).map g = map₂ f' (b.map g') a :=
  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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g' b) a
⊢ Option.map g (map₂ f none none) = map₂ f' (Option.map g' none) none

Next tactic:
simp [h_antidistrib]
/-- Symmetric statement to `Option.map₂_map_left_anticomm`. -/
theorem map_map₂_antidistrib_left {g : γ → δ} {f' : β' → α → δ} {g' : β → β'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g' b) a) :
    (map₂ f a b).map g = map₂ f' (b.map g') a :=
  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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g' b) a
val✝ : β
⊢ Option.map g (map₂ f none (some val✝)) = map₂ f' (Option.map g' (some val✝)) none

Next tactic:
simp [h_antidistrib]
/-- Symmetric statement to `Option.map₂_map_left_anticomm`. -/
theorem map_map₂_antidistrib_left {g : γ → δ} {f' : β' → α → δ} {g' : β → β'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g' b) a) :
    (map₂ f a b).map g = map₂ f' (b.map g') a :=
  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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g' b) a
val✝ : α
⊢ Option.map g (map₂ f (some val✝) none) = map₂ f' (Option.map g' none) (some val✝)

Next tactic:
simp [h_antidistrib]
/-- Symmetric statement to `Option.map₂_map_left_anticomm`. -/
theorem map_map₂_antidistrib_left {g : γ → δ} {f' : β' → α → δ} {g' : β → β'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g' b) a) :
    (map₂ f a b).map g = map₂ f' (b.map g') a :=
  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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g' b) a
val✝¹ : α
val✝ : β
⊢ Option.map g (map₂ f (some val✝¹) (some val✝)) = map₂ f' (Option.map g' (some val✝)) (some val✝¹)

Next tactic:
simp [h_antidistrib]
/-- Symmetric statement to `Option.map_map₂_right_anticomm`. -/
theorem map_map₂_antidistrib_right {g : γ → δ} {f' : β → α' → δ} {g' : α → α'}
    (h_antidistrib : ∀ a b, g (f a b) = f' b (g' a)) : (map₂ f a b).map g = map₂ f' b (a.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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' b (g' a)
⊢ Option.map g (map₂ f a b) = map₂ f' b (Option.map g' a)

Next tactic:
cases a
/-- Symmetric statement to `Option.map_map₂_right_anticomm`. -/
theorem map_map₂_antidistrib_right {g : γ → δ} {f' : β → α' → δ} {g' : α → α'}
    (h_antidistrib : ∀ a b, g (f a b) = f' b (g' a)) : (map₂ f a b).map g = map₂ f' b (a.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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' b (g' a)
⊢ Option.map g (map₂ f none b) = map₂ f' b (Option.map g' none)

Next tactic:
cases b
/-- Symmetric statement to `Option.map_map₂_right_anticomm`. -/
theorem map_map₂_antidistrib_right {g : γ → δ} {f' : β → α' → δ} {g' : α → α'}
    (h_antidistrib : ∀ a b, g (f a b) = f' b (g' a)) : (map₂ f a b).map g = map₂ f' b (a.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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' b (g' a)
val✝ : α
⊢ Option.map g (map₂ f (some val✝) b) = map₂ f' b (Option.map g' (some val✝))

Next tactic:
cases b
/-- Symmetric statement to `Option.map_map₂_right_anticomm`. -/
theorem map_map₂_antidistrib_right {g : γ → δ} {f' : β → α' → δ} {g' : α → α'}
    (h_antidistrib : ∀ a b, g (f a b) = f' b (g' a)) : (map₂ f a b).map g = map₂ f' b (a.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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' b (g' a)
⊢ Option.map g (map₂ f none none) = map₂ f' none (Option.map g' none)

Next tactic:
simp [h_antidistrib]
/-- Symmetric statement to `Option.map_map₂_right_anticomm`. -/
theorem map_map₂_antidistrib_right {g : γ → δ} {f' : β → α' → δ} {g' : α → α'}
    (h_antidistrib : ∀ a b, g (f a b) = f' b (g' a)) : (map₂ f a b).map g = map₂ f' b (a.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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' b (g' a)
val✝ : β
⊢ Option.map g (map₂ f none (some val✝)) = map₂ f' (some val✝) (Option.map g' none)

Next tactic:
simp [h_antidistrib]
/-- Symmetric statement to `Option.map_map₂_right_anticomm`. -/
theorem map_map₂_antidistrib_right {g : γ → δ} {f' : β → α' → δ} {g' : α → α'}
    (h_antidistrib : ∀ a b, g (f a b) = f' b (g' a)) : (map₂ f a b).map g = map₂ f' b (a.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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' b (g' a)
val✝ : α
⊢ Option.map g (map₂ f (some val✝) none) = map₂ f' none (Option.map g' (some val✝))

Next tactic:
simp [h_antidistrib]
/-- Symmetric statement to `Option.map_map₂_right_anticomm`. -/
theorem map_map₂_antidistrib_right {g : γ → δ} {f' : β → α' → δ} {g' : α → α'}
    (h_antidistrib : ∀ a b, g (f a b) = f' b (g' a)) : (map₂ f a b).map g = map₂ f' b (a.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_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' b (g' a)
val✝¹ : α
val✝ : β
⊢ Option.map g (map₂ f (some val✝¹) (some val✝)) = map₂ f' (some val✝) (Option.map g' (some val✝¹))

Next tactic:
simp [h_antidistrib]
/-- Symmetric statement to `Option.map_map₂_antidistrib_left`. -/
theorem map₂_map_left_anticomm {f : α' → β → γ} {g : α → α'} {f' : β → α → δ} {g' : δ → γ}
    (h_left_anticomm : ∀ a b, f (g a) b = g' (f' b a)) :
    map₂ f (a.map g) b = (map₂ f' b a).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_anticomm : ∀ (a : α) (b : β), f (g a) b = g' (f' b a)
⊢ map₂ f (Option.map g a) b = Option.map g' (map₂ f' b a)

Next tactic:
cases a
/-- Symmetric statement to `Option.map_map₂_antidistrib_left`. -/
theorem map₂_map_left_anticomm {f : α' → β → γ} {g : α → α'} {f' : β → α → δ} {g' : δ → γ}
    (h_left_anticomm : ∀ a b, f (g a) b = g' (f' b a)) :
    map₂ f (a.map g) b = (map₂ f' b a).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_anticomm : ∀ (a : α) (b : β), f (g a) b = g' (f' b a)
⊢ map₂ f (Option.map g none) b = Option.map g' (map₂ f' b none)

Next tactic:
cases b
/-- Symmetric statement to `Option.map_map₂_antidistrib_left`. -/
theorem map₂_map_left_anticomm {f : α' → β → γ} {g : α → α'} {f' : β → α → δ} {g' : δ → γ}
    (h_left_anticomm : ∀ a b, f (g a) b = g' (f' b a)) :
    map₂ f (a.map g) b = (map₂ f' b a).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_anticomm : ∀ (a : α) (b : β), f (g a) b = g' (f' b a)
val✝ : α
⊢ map₂ f (Option.map g (some val✝)) b = Option.map g' (map₂ f' b (some val✝))

Next tactic:
cases b
/-- Symmetric statement to `Option.map_map₂_antidistrib_left`. -/
theorem map₂_map_left_anticomm {f : α' → β → γ} {g : α → α'} {f' : β → α → δ} {g' : δ → γ}
    (h_left_anticomm : ∀ a b, f (g a) b = g' (f' b a)) :
    map₂ f (a.map g) b = (map₂ f' b a).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_anticomm : ∀ (a : α) (b : β), f (g a) b = g' (f' b a)
⊢ map₂ f (Option.map g none) none = Option.map g' (map₂ f' none none)

Next tactic:
simp [h_left_anticomm]
/-- Symmetric statement to `Option.map_map₂_antidistrib_left`. -/
theorem map₂_map_left_anticomm {f : α' → β → γ} {g : α → α'} {f' : β → α → δ} {g' : δ → γ}
    (h_left_anticomm : ∀ a b, f (g a) b = g' (f' b a)) :
    map₂ f (a.map g) b = (map₂ f' b a).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_anticomm : ∀ (a : α) (b : β), f (g a) b = g' (f' b a)
val✝ : β
⊢ map₂ f (Option.map g none) (some val✝) = Option.map g' (map₂ f' (some val✝) none)

Next tactic:
simp [h_left_anticomm]
/-- Symmetric statement to `Option.map_map₂_antidistrib_left`. -/
theorem map₂_map_left_anticomm {f : α' → β → γ} {g : α → α'} {f' : β → α → δ} {g' : δ → γ}
    (h_left_anticomm : ∀ a b, f (g a) b = g' (f' b a)) :
    map₂ f (a.map g) b = (map₂ f' b a).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_anticomm : ∀ (a : α) (b : β), f (g a) b = g' (f' b a)
val✝ : α
⊢ map₂ f (Option.map g (some val✝)) none = Option.map g' (map₂ f' none (some val✝))

Next tactic:
simp [h_left_anticomm]
/-- Symmetric statement to `Option.map_map₂_antidistrib_left`. -/
theorem map₂_map_left_anticomm {f : α' → β → γ} {g : α → α'} {f' : β → α → δ} {g' : δ → γ}
    (h_left_anticomm : ∀ a b, f (g a) b = g' (f' b a)) :
    map₂ f (a.map g) b = (map₂ f' b a).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_anticomm : ∀ (a : α) (b : β), f (g a) b = g' (f' b a)
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_anticomm]
/-- Symmetric statement to `Option.map_map₂_antidistrib_right`. -/
theorem map_map₂_right_anticomm {f : α → β' → γ} {g : β → β'} {f' : β → α → δ} {g' : δ → γ}
    (h_right_anticomm : ∀ a b, f a (g b) = g' (f' b a)) :
    map₂ f a (b.map g) = (map₂ f' b a).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_anticomm : ∀ (a : α) (b : β), f a (g b) = g' (f' b a)
⊢ map₂ f a (Option.map g b) = Option.map g' (map₂ f' b a)

Next tactic:
cases a
/-- Symmetric statement to `Option.map_map₂_antidistrib_right`. -/
theorem map_map₂_right_anticomm {f : α → β' → γ} {g : β → β'} {f' : β → α → δ} {g' : δ → γ}
    (h_right_anticomm : ∀ a b, f a (g b) = g' (f' b a)) :
    map₂ f a (b.map g) = (map₂ f' b a).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_anticomm : ∀ (a : α) (b : β), f a (g b) = g' (f' b a)
⊢ map₂ f none (Option.map g b) = Option.map g' (map₂ f' b none)

Next tactic:
cases b
/-- Symmetric statement to `Option.map_map₂_antidistrib_right`. -/
theorem map_map₂_right_anticomm {f : α → β' → γ} {g : β → β'} {f' : β → α → δ} {g' : δ → γ}
    (h_right_anticomm : ∀ a b, f a (g b) = g' (f' b a)) :
    map₂ f a (b.map g) = (map₂ f' b a).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_anticomm : ∀ (a : α) (b : β), f a (g b) = g' (f' b a)
val✝ : α
⊢ map₂ f (some val✝) (Option.map g b) = Option.map g' (map₂ f' b (some val✝))

Next tactic:
cases b
/-- Symmetric statement to `Option.map_map₂_antidistrib_right`. -/
theorem map_map₂_right_anticomm {f : α → β' → γ} {g : β → β'} {f' : β → α → δ} {g' : δ → γ}
    (h_right_anticomm : ∀ a b, f a (g b) = g' (f' b a)) :
    map₂ f a (b.map g) = (map₂ f' b a).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_anticomm : ∀ (a : α) (b : β), f a (g b) = g' (f' b a)
⊢ map₂ f none (Option.map g none) = Option.map g' (map₂ f' none none)

Next tactic:
simp [h_right_anticomm]
/-- Symmetric statement to `Option.map_map₂_antidistrib_right`. -/
theorem map_map₂_right_anticomm {f : α → β' → γ} {g : β → β'} {f' : β → α → δ} {g' : δ → γ}
    (h_right_anticomm : ∀ a b, f a (g b) = g' (f' b a)) :
    map₂ f a (b.map g) = (map₂ f' b a).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_anticomm : ∀ (a : α) (b : β), f a (g b) = g' (f' b a)
val✝ : β
⊢ map₂ f none (Option.map g (some val✝)) = Option.map g' (map₂ f' (some val✝) none)

Next tactic:
simp [h_right_anticomm]
/-- Symmetric statement to `Option.map_map₂_antidistrib_right`. -/
theorem map_map₂_right_anticomm {f : α → β' → γ} {g : β → β'} {f' : β → α → δ} {g' : δ → γ}
    (h_right_anticomm : ∀ a b, f a (g b) = g' (f' b a)) :
    map₂ f a (b.map g) = (map₂ f' b a).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_anticomm : ∀ (a : α) (b : β), f a (g b) = g' (f' b a)
val✝ : α
⊢ map₂ f (some val✝) (Option.map g none) = Option.map g' (map₂ f' none (some val✝))

Next tactic:
simp [h_right_anticomm]
/-- Symmetric statement to `Option.map_map₂_antidistrib_right`. -/
theorem map_map₂_right_anticomm {f : α → β' → γ} {g : β → β'} {f' : β → α → δ} {g' : δ → γ}
    (h_right_anticomm : ∀ a b, f a (g b) = g' (f' b a)) :
    map₂ f a (b.map g) = (map₂ f' b a).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
f : α → β' → γ
g : β → β'
f' : β → α → δ
g' : δ → γ
h_right_anticomm : ∀ (a : α) (b : β), f a (g b) = g' (f' b a)
val✝¹ : α
val✝ : β
⊢ map₂ f (some val✝¹) (Option.map g (some val✝)) = Option.map g' (map₂ f' (some val✝) (some val✝¹))

Next tactic:
simp [h_right_anticomm]
/-- If `a` is a left identity for a binary operation `f`, then `some a` is a left identity for
`Option.map₂ f`. -/
lemma map₂_left_identity {f : α → β → β} {a : α} (h : ∀ b, f a b = b) (o : Option β) :
    map₂ f (some a) o = o := by
  

Proof state:
α : Type u_2
β : Type u_1
γ : Type ?u.31371
f✝ : α → β → γ
a✝ : Option α
b : Option β
c : Option γ
f : α → β → β
a : α
h : ∀ (b : β), f a b = b
o : Option β
⊢ map₂ f (some a) o = o

Next tactic:
cases o
/-- If `a` is a left identity for a binary operation `f`, then `some a` is a left identity for
`Option.map₂ f`. -/
lemma map₂_left_identity {f : α → β → β} {a : α} (h : ∀ b, f a b = b) (o : Option β) :
    map₂ f (some a) o = o := by
  cases o; 

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

Next tactic:
exacts [rfl, congr_arg some (h _)]
/-- If `b` is a right identity for a binary operation `f`, then `some b` is a right identity for
`Option.map₂ f`. -/
lemma map₂_right_identity {f : α → β → α} {b : β} (h : ∀ a, f a b = a) (o : Option α) :
    map₂ f o (some b) = o := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type ?u.31561
f✝ : α → β → γ
a : Option α
b✝ : Option β
c : Option γ
f : α → β → α
b : β
h : ∀ (a : α), f a b = a
o : Option α
⊢ map₂ f o (some b) = o

Next tactic:
simp [h, map₂]
theorem rayleigh_smul (x : E) {c : 𝕜} (hc : c ≠ 0) :
    rayleighQuotient T (c • x) = rayleighQuotient T x := by
  

Proof state:
𝕜 : Type u_1
inst✝² : IsROrC 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →L[𝕜] E
x : E
c : 𝕜
hc : c ≠ 0
⊢ rayleighQuotient T (c • x) = rayleighQuotient T x

Next tactic:
by_cases hx : x = 0