l3lab/ntp-mathlib huggingface dataset:
theorem support_mul [DecidableEq α] {g₁ g₂ : α →₀ β} :
    (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support := by
  intro a h
  

Proof state:
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : a ∈ (g₁ * g₂).support
⊢ a ∈ g₁.support ∩ g₂.support

Next tactic:
simp only [mul_apply, mem_support_iff] at h
theorem support_mul [DecidableEq α] {g₁ g₂ : α →₀ β} :
    (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support := by
  intro a h
  simp only [mul_apply, mem_support_iff] at h
  

Proof state:
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : g₁ a * g₂ a ≠ 0
⊢ a ∈ g₁.support ∩ g₂.support

Next tactic:
simp only [mem_support_iff, mem_inter, Ne.def]
theorem support_mul [DecidableEq α] {g₁ g₂ : α →₀ β} :
    (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support := by
  intro a h
  simp only [mul_apply, mem_support_iff] at h
  simp only [mem_support_iff, mem_inter, Ne.def]
  

Proof state:
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : g₁ a * g₂ a ≠ 0
⊢ ¬g₁ a = 0 ∧ ¬g₂ a = 0

Next tactic:
rw [← not_or]
theorem support_mul [DecidableEq α] {g₁ g₂ : α →₀ β} :
    (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support := by
  intro a h
  simp only [mul_apply, mem_support_iff] at h
  simp only [mem_support_iff, mem_inter, Ne.def]
  rw [← not_or]
  

Proof state:
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : g₁ a * g₂ a ≠ 0
⊢ ¬(g₁ a = 0 ∨ g₂ a = 0)

Next tactic:
intro w
theorem support_mul [DecidableEq α] {g₁ g₂ : α →₀ β} :
    (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support := by
  intro a h
  simp only [mul_apply, mem_support_iff] at h
  simp only [mem_support_iff, mem_inter, Ne.def]
  rw [← not_or]
  intro w
  

Proof state:
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : g₁ a * g₂ a ≠ 0
w : g₁ a = 0 ∨ g₂ a = 0
⊢ False

Next tactic:
apply h
theorem support_mul [DecidableEq α] {g₁ g₂ : α →₀ β} :
    (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support := by
  intro a h
  simp only [mul_apply, mem_support_iff] at h
  simp only [mem_support_iff, mem_inter, Ne.def]
  rw [← not_or]
  intro w
  apply h
  

Proof state:
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : g₁ a * g₂ a ≠ 0
w : g₁ a = 0 ∨ g₂ a = 0
⊢ g₁ a * g₂ a = 0

Next tactic:
cases' w with w w
theorem support_mul [DecidableEq α] {g₁ g₂ : α →₀ β} :
    (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support := by
  intro a h
  simp only [mul_apply, mem_support_iff] at h
  simp only [mem_support_iff, mem_inter, Ne.def]
  rw [← not_or]
  intro w
  apply h
  cases' w with w w <;> (

Proof state:
case inl
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : g₁ a * g₂ a ≠ 0
w : g₁ a = 0
⊢ g₁ a * g₂ a = 0

Next tactic:
rw [w]
theorem support_mul [DecidableEq α] {g₁ g₂ : α →₀ β} :
    (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support := by
  intro a h
  simp only [mul_apply, mem_support_iff] at h
  simp only [mem_support_iff, mem_inter, Ne.def]
  rw [← not_or]
  intro w
  apply h
  cases' w with w w <;> (rw [w]; 

Proof state:
case inl
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : g₁ a * g₂ a ≠ 0
w : g₁ a = 0
⊢ 0 * g₂ a = 0

Next tactic:
simp
theorem support_mul [DecidableEq α] {g₁ g₂ : α →₀ β} :
    (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support := by
  intro a h
  simp only [mul_apply, mem_support_iff] at h
  simp only [mem_support_iff, mem_inter, Ne.def]
  rw [← not_or]
  intro w
  apply h
  cases' w with w w <;> (

Proof state:
case inr
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : g₁ a * g₂ a ≠ 0
w : g₂ a = 0
⊢ g₁ a * g₂ a = 0

Next tactic:
rw [w]
theorem support_mul [DecidableEq α] {g₁ g₂ : α →₀ β} :
    (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support := by
  intro a h
  simp only [mul_apply, mem_support_iff] at h
  simp only [mem_support_iff, mem_inter, Ne.def]
  rw [← not_or]
  intro w
  apply h
  cases' w with w w <;> (rw [w]; 

Proof state:
case inr
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝¹ : MulZeroClass β
inst✝ : DecidableEq α
g₁ g₂ : α →₀ β
a : α
h : g₁ a * g₂ a ≠ 0
w : g₂ a = 0
⊢ g₁ a * 0 = 0

Next tactic:
simp
instance pointwiseScalar [Semiring β] : SMul (α → β) (α →₀ β) where
  smul f g :=
    Finsupp.ofSupportFinite (fun a ↦ f a • g a) (by
      

Proof state:
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝ : Semiring β
f : α → β
g : α →₀ β
⊢ Set.Finite (Function.support fun a => f a • g a)

Next tactic:
apply Set.Finite.subset g.finite_support
instance pointwiseScalar [Semiring β] : SMul (α → β) (α →₀ β) where
  smul f g :=
    Finsupp.ofSupportFinite (fun a ↦ f a • g a) (by
      apply Set.Finite.subset g.finite_support
      

Proof state:
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝ : Semiring β
f : α → β
g : α →₀ β
⊢ (Function.support fun a => f a • g a) ⊆ Function.support ⇑g

Next tactic:
simp only [Function.support_subset_iff, Finsupp.mem_support_iff, Ne.def,
        Finsupp.fun_support_eq, Finset.mem_coe]
instance pointwiseScalar [Semiring β] : SMul (α → β) (α →₀ β) where
  smul f g :=
    Finsupp.ofSupportFinite (fun a ↦ f a • g a) (by
      apply Set.Finite.subset g.finite_support
      simp only [Function.support_subset_iff, Finsupp.mem_support_iff, Ne.def,
        Finsupp.fun_support_eq, Finset.mem_coe]
      

Proof state:
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝ : Semiring β
f : α → β
g : α →₀ β
⊢ ∀ (x : α), ¬f x • g x = 0 → ¬g x = 0

Next tactic:
intro x hx h
instance pointwiseScalar [Semiring β] : SMul (α → β) (α →₀ β) where
  smul f g :=
    Finsupp.ofSupportFinite (fun a ↦ f a • g a) (by
      apply Set.Finite.subset g.finite_support
      simp only [Function.support_subset_iff, Finsupp.mem_support_iff, Ne.def,
        Finsupp.fun_support_eq, Finset.mem_coe]
      intro x hx h
      

Proof state:
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝ : Semiring β
f : α → β
g : α →₀ β
x : α
hx : ¬f x • g x = 0
h : g x = 0
⊢ False

Next tactic:
apply hx
instance pointwiseScalar [Semiring β] : SMul (α → β) (α →₀ β) where
  smul f g :=
    Finsupp.ofSupportFinite (fun a ↦ f a • g a) (by
      apply Set.Finite.subset g.finite_support
      simp only [Function.support_subset_iff, Finsupp.mem_support_iff, Ne.def,
        Finsupp.fun_support_eq, Finset.mem_coe]
      intro x hx h
      apply hx
      

Proof state:
α : Type u₁
β : Type u₂
γ : Type u₃
δ : Type u₄
ι : Type u₅
inst✝ : Semiring β
f : α → β
g : α →₀ β
x : α
hx : ¬f x • g x = 0
h : g x = 0
⊢ f x • g x = 0

Next tactic:
rw [h, smul_zero]
instance : LawfulBitraversable Prod := by
  

Proof state:
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
⊢ LawfulBitraversable Prod

Next tactic:
constructor
instance : LawfulBitraversable Prod := by
  constructor <;> 

Proof state:
case id_bitraverse
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
⊢ ∀ {α β : Type ?u.941} (x : α × β), bitraverse pure pure x = pure x

Next tactic:
intros
instance : LawfulBitraversable Prod := by
  constructor <;> 

Proof state:
case comp_bitraverse
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
⊢ ∀ {F G : Type ?u.941 → Type ?u.941} [inst : Applicative F] [inst_1 : Applicative G] [inst_2 : LawfulApplicative F]
    [inst_3 : LawfulApplicative G] {α α' β β' γ γ' : Type ?u.941} (f : β → F γ) (f' : β' → F γ') (g : α → G β)
    (g' : α' → G β') (x : α × α'),
    bitraverse (Functor.Comp.mk ∘ Functor.map f ∘ g) (Functor.Comp.mk ∘ Functor.map f' ∘ g') x =
      Functor.Comp.mk (bitraverse f f' <$> bitraverse g g' x)

Next tactic:
intros
instance : LawfulBitraversable Prod := by
  constructor <;> 

Proof state:
case bitraverse_eq_bimap_id
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
⊢ ∀ {α α' β β' : Type ?u.941} (f : α → β) (f' : α' → β') (x : α × α'),
    bitraverse (pure ∘ f) (pure ∘ f') x = pure (bimap f f' x)

Next tactic:
intros
instance : LawfulBitraversable Prod := by
  constructor <;> 

Proof state:
case binaturality
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
⊢ ∀ {F G : Type ?u.941 → Type ?u.941} [inst : Applicative F] [inst_1 : Applicative G] [inst_2 : LawfulApplicative F]
    [inst_3 : LawfulApplicative G] (η : ApplicativeTransformation F G) {α α' β β' : Type ?u.941} (f : α → F β)
    (f' : α' → F β') (x : α × α'),
    (fun {α} => ApplicativeTransformation.app η α) (bitraverse f f' x) =
      bitraverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f)
        ((fun {α} => ApplicativeTransformation.app η α) ∘ f') x

Next tactic:
intros
instance : LawfulBitraversable Prod := by
  constructor <;> intros <;> 

Proof state:
case id_bitraverse
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
α✝ β✝ : Type ?u.941
x✝ : α✝ × β✝
⊢ bitraverse pure pure x✝ = pure x✝

Next tactic:
casesm _ × _
instance : LawfulBitraversable Prod := by
  constructor <;> intros <;> 

Proof state:
case comp_bitraverse
t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
F : Type u → Type u
inst✝⁴ : Applicative F
F✝ G✝ : Type ?u.941 → Type ?u.941
inst✝³ : Applicative F✝
inst✝² : Applicative G✝
inst✝¹ : LawfulApplicative F✝
inst✝ : LawfulApplicative G✝
α✝ α'✝ β✝ β'✝ γ✝ γ'✝ : Type ?u.941
f✝ : β✝ → F✝ γ✝
f'✝ : β'✝ → F✝ γ'✝
g✝ : α✝ → G✝ β✝
g'✝ : α'✝ → G✝ β'✝
x✝ : α✝ × α'✝
⊢ bitraverse (Functor.Comp.mk ∘ Functor.map f✝ ∘ g✝) (Functor.Comp.mk ∘ Functor.map f'✝ ∘ g'✝) x✝ =
    Functor.Comp.mk (bitraverse f✝ f'✝ <$> bitraverse g✝ g'✝ x✝)

Next tactic:
casesm _ × _
instance : LawfulBitraversable Prod := by
  constructor <;> intros <;> 

Proof state:
case bitraverse_eq_bimap_id
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
α✝ α'✝ β✝ β'✝ : Type ?u.941
f✝ : α✝ → β✝
f'✝ : α'✝ → β'✝
x✝ : α✝ × α'✝
⊢ bitraverse (pure ∘ f✝) (pure ∘ f'✝) x✝ = pure (bimap f✝ f'✝ x✝)

Next tactic:
casesm _ × _
instance : LawfulBitraversable Prod := by
  constructor <;> intros <;> 

Proof state:
case binaturality
t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
F : Type u → Type u
inst✝⁴ : Applicative F
F✝ G✝ : Type ?u.941 → Type ?u.941
inst✝³ : Applicative F✝
inst✝² : Applicative G✝
inst✝¹ : LawfulApplicative F✝
inst✝ : LawfulApplicative G✝
η✝ : ApplicativeTransformation F✝ G✝
α✝ α'✝ β✝ β'✝ : Type ?u.941
f✝ : α✝ → F✝ β✝
f'✝ : α'✝ → F✝ β'✝
x✝ : α✝ × α'✝
⊢ (fun {α} => ApplicativeTransformation.app η✝ α) (bitraverse f✝ f'✝ x✝) =
    bitraverse ((fun {α} => ApplicativeTransformation.app η✝ α) ∘ f✝)
      ((fun {α} => ApplicativeTransformation.app η✝ α) ∘ f'✝) x✝

Next tactic:
casesm _ × _
instance : LawfulBitraversable Prod := by
  constructor <;> intros <;> casesm _ × _ <;>
    

Proof state:
case id_bitraverse.mk
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
α✝ β✝ : Type ?u.941
fst✝ : α✝
snd✝ : β✝
⊢ bitraverse pure pure (fst✝, snd✝) = pure (fst✝, snd✝)

Next tactic:
simp [bitraverse, Prod.bitraverse, functor_norm, -ApplicativeTransformation.app_eq_coe]
instance : LawfulBitraversable Prod := by
  constructor <;> intros <;> casesm _ × _ <;>
    

Proof state:
case comp_bitraverse.mk
t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
F : Type u → Type u
inst✝⁴ : Applicative F
F✝ G✝ : Type ?u.941 → Type ?u.941
inst✝³ : Applicative F✝
inst✝² : Applicative G✝
inst✝¹ : LawfulApplicative F✝
inst✝ : LawfulApplicative G✝
α✝ α'✝ β✝ β'✝ γ✝ γ'✝ : Type ?u.941
f✝ : β✝ → F✝ γ✝
f'✝ : β'✝ → F✝ γ'✝
g✝ : α✝ → G✝ β✝
g'✝ : α'✝ → G✝ β'✝
fst✝ : α✝
snd✝ : α'✝
⊢ bitraverse (Functor.Comp.mk ∘ Functor.map f✝ ∘ g✝) (Functor.Comp.mk ∘ Functor.map f'✝ ∘ g'✝) (fst✝, snd✝) =
    Functor.Comp.mk (bitraverse f✝ f'✝ <$> bitraverse g✝ g'✝ (fst✝, snd✝))

Next tactic:
simp [bitraverse, Prod.bitraverse, functor_norm, -ApplicativeTransformation.app_eq_coe]
instance : LawfulBitraversable Prod := by
  constructor <;> intros <;> casesm _ × _ <;>
    

Proof state:
case bitraverse_eq_bimap_id.mk
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
α✝ α'✝ β✝ β'✝ : Type ?u.941
f✝ : α✝ → β✝
f'✝ : α'✝ → β'✝
fst✝ : α✝
snd✝ : α'✝
⊢ bitraverse (pure ∘ f✝) (pure ∘ f'✝) (fst✝, snd✝) = pure (bimap f✝ f'✝ (fst✝, snd✝))

Next tactic:
simp [bitraverse, Prod.bitraverse, functor_norm, -ApplicativeTransformation.app_eq_coe]
instance : LawfulBitraversable Prod := by
  constructor <;> intros <;> casesm _ × _ <;>
    

Proof state:
case binaturality.mk
t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
F : Type u → Type u
inst✝⁴ : Applicative F
F✝ G✝ : Type ?u.941 → Type ?u.941
inst✝³ : Applicative F✝
inst✝² : Applicative G✝
inst✝¹ : LawfulApplicative F✝
inst✝ : LawfulApplicative G✝
η✝ : ApplicativeTransformation F✝ G✝
α✝ α'✝ β✝ β'✝ : Type ?u.941
f✝ : α✝ → F✝ β✝
f'✝ : α'✝ → F✝ β'✝
fst✝ : α✝
snd✝ : α'✝
⊢ (fun {α} => ApplicativeTransformation.app η✝ α) (bitraverse f✝ f'✝ (fst✝, snd✝)) =
    bitraverse ((fun {α} => ApplicativeTransformation.app η✝ α) ∘ f✝)
      ((fun {α} => ApplicativeTransformation.app η✝ α) ∘ f'✝) (fst✝, snd✝)

Next tactic:
simp [bitraverse, Prod.bitraverse, functor_norm, -ApplicativeTransformation.app_eq_coe]
instance : LawfulBitraversable Prod := by
  constructor <;> intros <;> casesm _ × _ <;>
    simp [bitraverse, Prod.bitraverse, functor_norm, -ApplicativeTransformation.app_eq_coe] <;> 

Proof state:
case id_bitraverse.mk
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
α✝ β✝ : Type ?u.941
fst✝ : α✝
snd✝ : β✝
⊢ (Seq.seq (Prod.mk fst✝) fun x => snd✝) = (fst✝, snd✝)

Next tactic:
rfl
instance : LawfulBitraversable Prod := by
  constructor <;> intros <;> casesm _ × _ <;>
    simp [bitraverse, Prod.bitraverse, functor_norm, -ApplicativeTransformation.app_eq_coe] <;> 

Proof state:
case comp_bitraverse.mk
t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
F : Type u → Type u
inst✝⁴ : Applicative F
F✝ G✝ : Type ?u.941 → Type ?u.941
inst✝³ : Applicative F✝
inst✝² : Applicative G✝
inst✝¹ : LawfulApplicative F✝
inst✝ : LawfulApplicative G✝
α✝ α'✝ β✝ β'✝ γ✝ γ'✝ : Type ?u.941
f✝ : β✝ → F✝ γ✝
f'✝ : β'✝ → F✝ γ'✝
g✝ : α✝ → G✝ β✝
g'✝ : α'✝ → G✝ β'✝
fst✝ : α✝
snd✝ : α'✝
⊢ Functor.Comp.mk
      (Seq.seq
        (((fun x => x ∘ f'✝) ∘ (fun x x_1 => Seq.seq x fun x => x_1) ∘ (fun x => Prod.mk <$> x) ∘ f✝) <$> g✝ fst✝)
        fun x => g'✝ snd✝) =
    Functor.Comp.mk (Seq.seq (((fun x => Prod.bitraverse f✝ f'✝ ∘ x) ∘ Prod.mk) <$> g✝ fst✝) fun x => g'✝ snd✝)

Next tactic:
rfl
instance : LawfulBitraversable Prod := by
  constructor <;> intros <;> casesm _ × _ <;>
    simp [bitraverse, Prod.bitraverse, functor_norm, -ApplicativeTransformation.app_eq_coe] <;> 

Proof state:
case bitraverse_eq_bimap_id.mk
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
α✝ α'✝ β✝ β'✝ : Type ?u.941
f✝ : α✝ → β✝
f'✝ : α'✝ → β'✝
fst✝ : α✝
snd✝ : α'✝
⊢ (Seq.seq (Prod.mk (f✝ fst✝)) fun x => f'✝ snd✝) = bimap f✝ f'✝ (fst✝, snd✝)

Next tactic:
rfl
instance : LawfulBitraversable Sum := by
  

Proof state:
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
⊢ LawfulBitraversable Sum

Next tactic:
constructor
instance : LawfulBitraversable Sum := by
  constructor <;> 

Proof state:
case id_bitraverse
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
⊢ ∀ {α β : Type ?u.11782} (x : α ⊕ β), bitraverse pure pure x = pure x

Next tactic:
intros
instance : LawfulBitraversable Sum := by
  constructor <;> 

Proof state:
case comp_bitraverse
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
⊢ ∀ {F G : Type ?u.11782 → Type ?u.11782} [inst : Applicative F] [inst_1 : Applicative G] [inst_2 : LawfulApplicative F]
    [inst_3 : LawfulApplicative G] {α α' β β' γ γ' : Type ?u.11782} (f : β → F γ) (f' : β' → F γ') (g : α → G β)
    (g' : α' → G β') (x : α ⊕ α'),
    bitraverse (Comp.mk ∘ map f ∘ g) (Comp.mk ∘ map f' ∘ g') x = Comp.mk (bitraverse f f' <$> bitraverse g g' x)

Next tactic:
intros
instance : LawfulBitraversable Sum := by
  constructor <;> 

Proof state:
case bitraverse_eq_bimap_id
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
⊢ ∀ {α α' β β' : Type ?u.11782} (f : α → β) (f' : α' → β') (x : α ⊕ α'),
    bitraverse (pure ∘ f) (pure ∘ f') x = pure (bimap f f' x)

Next tactic:
intros
instance : LawfulBitraversable Sum := by
  constructor <;> 

Proof state:
case binaturality
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
⊢ ∀ {F G : Type ?u.11782 → Type ?u.11782} [inst : Applicative F] [inst_1 : Applicative G] [inst_2 : LawfulApplicative F]
    [inst_3 : LawfulApplicative G] (η : ApplicativeTransformation F G) {α α' β β' : Type ?u.11782} (f : α → F β)
    (f' : α' → F β') (x : α ⊕ α'),
    (fun {α} => ApplicativeTransformation.app η α) (bitraverse f f' x) =
      bitraverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f)
        ((fun {α} => ApplicativeTransformation.app η α) ∘ f') x

Next tactic:
intros
instance : LawfulBitraversable Sum := by
  constructor <;> intros <;> 

Proof state:
case id_bitraverse
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
α✝ β✝ : Type ?u.11782
x✝ : α✝ ⊕ β✝
⊢ bitraverse pure pure x✝ = pure x✝

Next tactic:
casesm _ ⊕ _
instance : LawfulBitraversable Sum := by
  constructor <;> intros <;> 

Proof state:
case comp_bitraverse
t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
F : Type u → Type u
inst✝⁴ : Applicative F
F✝ G✝ : Type ?u.11782 → Type ?u.11782
inst✝³ : Applicative F✝
inst✝² : Applicative G✝
inst✝¹ : LawfulApplicative F✝
inst✝ : LawfulApplicative G✝
α✝ α'✝ β✝ β'✝ γ✝ γ'✝ : Type ?u.11782
f✝ : β✝ → F✝ γ✝
f'✝ : β'✝ → F✝ γ'✝
g✝ : α✝ → G✝ β✝
g'✝ : α'✝ → G✝ β'✝
x✝ : α✝ ⊕ α'✝
⊢ bitraverse (Comp.mk ∘ map f✝ ∘ g✝) (Comp.mk ∘ map f'✝ ∘ g'✝) x✝ = Comp.mk (bitraverse f✝ f'✝ <$> bitraverse g✝ g'✝ x✝)

Next tactic:
casesm _ ⊕ _
instance : LawfulBitraversable Sum := by
  constructor <;> intros <;> 

Proof state:
case bitraverse_eq_bimap_id
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
α✝ α'✝ β✝ β'✝ : Type ?u.11782
f✝ : α✝ → β✝
f'✝ : α'✝ → β'✝
x✝ : α✝ ⊕ α'✝
⊢ bitraverse (pure ∘ f✝) (pure ∘ f'✝) x✝ = pure (bimap f✝ f'✝ x✝)

Next tactic:
casesm _ ⊕ _
instance : LawfulBitraversable Sum := by
  constructor <;> intros <;> 

Proof state:
case binaturality
t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
F : Type u → Type u
inst✝⁴ : Applicative F
F✝ G✝ : Type ?u.11782 → Type ?u.11782
inst✝³ : Applicative F✝
inst✝² : Applicative G✝
inst✝¹ : LawfulApplicative F✝
inst✝ : LawfulApplicative G✝
η✝ : ApplicativeTransformation F✝ G✝
α✝ α'✝ β✝ β'✝ : Type ?u.11782
f✝ : α✝ → F✝ β✝
f'✝ : α'✝ → F✝ β'✝
x✝ : α✝ ⊕ α'✝
⊢ (fun {α} => ApplicativeTransformation.app η✝ α) (bitraverse f✝ f'✝ x✝) =
    bitraverse ((fun {α} => ApplicativeTransformation.app η✝ α) ∘ f✝)
      ((fun {α} => ApplicativeTransformation.app η✝ α) ∘ f'✝) x✝

Next tactic:
casesm _ ⊕ _
instance : LawfulBitraversable Sum := by
  constructor <;> intros <;> casesm _ ⊕ _ <;>
    

Proof state:
case id_bitraverse.inl
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
α✝ β✝ : Type ?u.11782
val✝ : α✝
⊢ bitraverse pure pure (Sum.inl val✝) = pure (Sum.inl val✝)

Next tactic:
simp [bitraverse, Sum.bitraverse, functor_norm, -ApplicativeTransformation.app_eq_coe]
instance : LawfulBitraversable Sum := by
  constructor <;> intros <;> casesm _ ⊕ _ <;>
    

Proof state:
case id_bitraverse.inr
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
α✝ β✝ : Type ?u.11782
val✝ : β✝
⊢ bitraverse pure pure (Sum.inr val✝) = pure (Sum.inr val✝)

Next tactic:
simp [bitraverse, Sum.bitraverse, functor_norm, -ApplicativeTransformation.app_eq_coe]
instance : LawfulBitraversable Sum := by
  constructor <;> intros <;> casesm _ ⊕ _ <;>
    

Proof state:
case comp_bitraverse.inl
t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
F : Type u → Type u
inst✝⁴ : Applicative F
F✝ G✝ : Type ?u.11782 → Type ?u.11782
inst✝³ : Applicative F✝
inst✝² : Applicative G✝
inst✝¹ : LawfulApplicative F✝
inst✝ : LawfulApplicative G✝
α✝ α'✝ β✝ β'✝ γ✝ γ'✝ : Type ?u.11782
f✝ : β✝ → F✝ γ✝
f'✝ : β'✝ → F✝ γ'✝
g✝ : α✝ → G✝ β✝
g'✝ : α'✝ → G✝ β'✝
val✝ : α✝
⊢ bitraverse (Comp.mk ∘ map f✝ ∘ g✝) (Comp.mk ∘ map f'✝ ∘ g'✝) (Sum.inl val✝) =
    Comp.mk (bitraverse f✝ f'✝ <$> bitraverse g✝ g'✝ (Sum.inl val✝))

Next tactic:
simp [bitraverse, Sum.bitraverse, functor_norm, -ApplicativeTransformation.app_eq_coe]
instance : LawfulBitraversable Sum := by
  constructor <;> intros <;> casesm _ ⊕ _ <;>
    

Proof state:
case comp_bitraverse.inr
t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
F : Type u → Type u
inst✝⁴ : Applicative F
F✝ G✝ : Type ?u.11782 → Type ?u.11782
inst✝³ : Applicative F✝
inst✝² : Applicative G✝
inst✝¹ : LawfulApplicative F✝
inst✝ : LawfulApplicative G✝
α✝ α'✝ β✝ β'✝ γ✝ γ'✝ : Type ?u.11782
f✝ : β✝ → F✝ γ✝
f'✝ : β'✝ → F✝ γ'✝
g✝ : α✝ → G✝ β✝
g'✝ : α'✝ → G✝ β'✝
val✝ : α'✝
⊢ bitraverse (Comp.mk ∘ map f✝ ∘ g✝) (Comp.mk ∘ map f'✝ ∘ g'✝) (Sum.inr val✝) =
    Comp.mk (bitraverse f✝ f'✝ <$> bitraverse g✝ g'✝ (Sum.inr val✝))

Next tactic:
simp [bitraverse, Sum.bitraverse, functor_norm, -ApplicativeTransformation.app_eq_coe]
instance : LawfulBitraversable Sum := by
  constructor <;> intros <;> casesm _ ⊕ _ <;>
    

Proof state:
case bitraverse_eq_bimap_id.inl
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
α✝ α'✝ β✝ β'✝ : Type ?u.11782
f✝ : α✝ → β✝
f'✝ : α'✝ → β'✝
val✝ : α✝
⊢ bitraverse (pure ∘ f✝) (pure ∘ f'✝) (Sum.inl val✝) = pure (bimap f✝ f'✝ (Sum.inl val✝))

Next tactic:
simp [bitraverse, Sum.bitraverse, functor_norm, -ApplicativeTransformation.app_eq_coe]
instance : LawfulBitraversable Sum := by
  constructor <;> intros <;> casesm _ ⊕ _ <;>
    

Proof state:
case bitraverse_eq_bimap_id.inr
t : Type u → Type u → Type u
inst✝¹ : Bitraversable t
F : Type u → Type u
inst✝ : Applicative F
α✝ α'✝ β✝ β'✝ : Type ?u.11782
f✝ : α✝ → β✝
f'✝ : α'✝ → β'✝
val✝ : α'✝
⊢ bitraverse (pure ∘ f✝) (pure ∘ f'✝) (Sum.inr val✝) = pure (bimap f✝ f'✝ (Sum.inr val✝))

Next tactic:
simp [bitraverse, Sum.bitraverse, functor_norm, -ApplicativeTransformation.app_eq_coe]
instance : LawfulBitraversable Sum := by
  constructor <;> intros <;> casesm _ ⊕ _ <;>
    

Proof state:
case binaturality.inl
t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
F : Type u → Type u
inst✝⁴ : Applicative F
F✝ G✝ : Type ?u.11782 → Type ?u.11782
inst✝³ : Applicative F✝
inst✝² : Applicative G✝
inst✝¹ : LawfulApplicative F✝
inst✝ : LawfulApplicative G✝
η✝ : ApplicativeTransformation F✝ G✝
α✝ α'✝ β✝ β'✝ : Type ?u.11782
f✝ : α✝ → F✝ β✝
f'✝ : α'✝ → F✝ β'✝
val✝ : α✝
⊢ (fun {α} => ApplicativeTransformation.app η✝ α) (bitraverse f✝ f'✝ (Sum.inl val✝)) =
    bitraverse ((fun {α} => ApplicativeTransformation.app η✝ α) ∘ f✝)
      ((fun {α} => ApplicativeTransformation.app η✝ α) ∘ f'✝) (Sum.inl val✝)

Next tactic:
simp [bitraverse, Sum.bitraverse, functor_norm, -ApplicativeTransformation.app_eq_coe]