l3lab/ntp-mathlib huggingface dataset:
/-- Bind operation for `SupIndep`. -/
theorem SupIndep.sigma {β : ι → Type*} {s : Finset ι} {g : ∀ i, Finset (β i)} {f : Sigma β → α}
    (hs : s.SupIndep fun i => (g i).sup fun b => f ⟨i, b⟩)
    (hg : ∀ i ∈ s, (g i).SupIndep fun b => f ⟨i, b⟩) : (s.sigma g).SupIndep f := by
  rintro t ht ⟨i, b⟩ hi hit
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, c⟩ hj
  have hbc := (ne_of_mem_of_not_mem hj hit).symm
  replace hj := ht hj
  rw [mem_sigma] at hi hj
  obtain rfl | hij := eq_or_ne i j
  · exact (hg _ hj.1).pairwiseDisjoint hi.2 hj.2 (sigma_mk_injective.ne_iff.1 hbc)
  · refine' (hs.pairwiseDisjoint hi.1 hj.1 hij).mono _ _
    · 

Proof state:
case mk.mk.inr.refine'_1
α : Type u_1
β✝ : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
β : ι → Type u_5
s : Finset ι
g : (i : ι) → Finset (β i)
f : Sigma β → α
hs : SupIndep s fun i => Finset.sup (g i) fun b => f { fst := i, snd := b }
hg : ∀ i ∈ s, SupIndep (g i) fun b => f { fst := i, snd := b }
t : Finset ((i : ι) × β i)
ht : t ⊆ Finset.sigma s g
i : ι
b : β i
hi : { fst := i, snd := b }.fst ∈ s ∧ { fst := i, snd := b }.snd ∈ g { fst := i, snd := b }.fst
hit : { fst := i, snd := b } ∉ t
j : ι
c : β j
hbc : { fst := i, snd := b } ≠ { fst := j, snd := c }
hj : { fst := j, snd := c }.fst ∈ s ∧ { fst := j, snd := c }.snd ∈ g { fst := j, snd := c }.fst
hij : i ≠ j
⊢ f { fst := i, snd := b } ≤ (fun i => Finset.sup (g i) fun b => f { fst := i, snd := b }) { fst := i, snd := b }.fst

Next tactic:
convert le_sup (α := α) hi.2
/-- Bind operation for `SupIndep`. -/
theorem SupIndep.sigma {β : ι → Type*} {s : Finset ι} {g : ∀ i, Finset (β i)} {f : Sigma β → α}
    (hs : s.SupIndep fun i => (g i).sup fun b => f ⟨i, b⟩)
    (hg : ∀ i ∈ s, (g i).SupIndep fun b => f ⟨i, b⟩) : (s.sigma g).SupIndep f := by
  rintro t ht ⟨i, b⟩ hi hit
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, c⟩ hj
  have hbc := (ne_of_mem_of_not_mem hj hit).symm
  replace hj := ht hj
  rw [mem_sigma] at hi hj
  obtain rfl | hij := eq_or_ne i j
  · exact (hg _ hj.1).pairwiseDisjoint hi.2 hj.2 (sigma_mk_injective.ne_iff.1 hbc)
  · refine' (hs.pairwiseDisjoint hi.1 hj.1 hij).mono _ _
    · convert le_sup (α := α) hi.2; 

Proof state:
case h.e'_3
α : Type u_1
β✝ : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
β : ι → Type u_5
s : Finset ι
g : (i : ι) → Finset (β i)
f : Sigma β → α
hs : SupIndep s fun i => Finset.sup (g i) fun b => f { fst := i, snd := b }
hg : ∀ i ∈ s, SupIndep (g i) fun b => f { fst := i, snd := b }
t : Finset ((i : ι) × β i)
ht : t ⊆ Finset.sigma s g
i : ι
b : β i
hi : { fst := i, snd := b }.fst ∈ s ∧ { fst := i, snd := b }.snd ∈ g { fst := i, snd := b }.fst
hit : { fst := i, snd := b } ∉ t
j : ι
c : β j
hbc : { fst := i, snd := b } ≠ { fst := j, snd := c }
hj : { fst := j, snd := c }.fst ∈ s ∧ { fst := j, snd := c }.snd ∈ g { fst := j, snd := c }.fst
hij : i ≠ j
⊢ f { fst := i, snd := b } = f { fst := { fst := i, snd := b }.fst, snd := { fst := i, snd := b }.snd }

Next tactic:
simp
/-- Bind operation for `SupIndep`. -/
theorem SupIndep.sigma {β : ι → Type*} {s : Finset ι} {g : ∀ i, Finset (β i)} {f : Sigma β → α}
    (hs : s.SupIndep fun i => (g i).sup fun b => f ⟨i, b⟩)
    (hg : ∀ i ∈ s, (g i).SupIndep fun b => f ⟨i, b⟩) : (s.sigma g).SupIndep f := by
  rintro t ht ⟨i, b⟩ hi hit
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, c⟩ hj
  have hbc := (ne_of_mem_of_not_mem hj hit).symm
  replace hj := ht hj
  rw [mem_sigma] at hi hj
  obtain rfl | hij := eq_or_ne i j
  · exact (hg _ hj.1).pairwiseDisjoint hi.2 hj.2 (sigma_mk_injective.ne_iff.1 hbc)
  · refine' (hs.pairwiseDisjoint hi.1 hj.1 hij).mono _ _
    · convert le_sup (α := α) hi.2; simp
    · 

Proof state:
case mk.mk.inr.refine'_2
α : Type u_1
β✝ : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
β : ι → Type u_5
s : Finset ι
g : (i : ι) → Finset (β i)
f : Sigma β → α
hs : SupIndep s fun i => Finset.sup (g i) fun b => f { fst := i, snd := b }
hg : ∀ i ∈ s, SupIndep (g i) fun b => f { fst := i, snd := b }
t : Finset ((i : ι) × β i)
ht : t ⊆ Finset.sigma s g
i : ι
b : β i
hi : { fst := i, snd := b }.fst ∈ s ∧ { fst := i, snd := b }.snd ∈ g { fst := i, snd := b }.fst
hit : { fst := i, snd := b } ∉ t
j : ι
c : β j
hbc : { fst := i, snd := b } ≠ { fst := j, snd := c }
hj : { fst := j, snd := c }.fst ∈ s ∧ { fst := j, snd := c }.snd ∈ g { fst := j, snd := c }.fst
hij : i ≠ j
⊢ f { fst := j, snd := c } ≤ (fun i => Finset.sup (g i) fun b => f { fst := i, snd := b }) { fst := j, snd := c }.fst

Next tactic:
convert le_sup (α := α) hj.2
/-- Bind operation for `SupIndep`. -/
theorem SupIndep.sigma {β : ι → Type*} {s : Finset ι} {g : ∀ i, Finset (β i)} {f : Sigma β → α}
    (hs : s.SupIndep fun i => (g i).sup fun b => f ⟨i, b⟩)
    (hg : ∀ i ∈ s, (g i).SupIndep fun b => f ⟨i, b⟩) : (s.sigma g).SupIndep f := by
  rintro t ht ⟨i, b⟩ hi hit
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, c⟩ hj
  have hbc := (ne_of_mem_of_not_mem hj hit).symm
  replace hj := ht hj
  rw [mem_sigma] at hi hj
  obtain rfl | hij := eq_or_ne i j
  · exact (hg _ hj.1).pairwiseDisjoint hi.2 hj.2 (sigma_mk_injective.ne_iff.1 hbc)
  · refine' (hs.pairwiseDisjoint hi.1 hj.1 hij).mono _ _
    · convert le_sup (α := α) hi.2; simp
    · convert le_sup (α := α) hj.2; 

Proof state:
case h.e'_3
α : Type u_1
β✝ : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
β : ι → Type u_5
s : Finset ι
g : (i : ι) → Finset (β i)
f : Sigma β → α
hs : SupIndep s fun i => Finset.sup (g i) fun b => f { fst := i, snd := b }
hg : ∀ i ∈ s, SupIndep (g i) fun b => f { fst := i, snd := b }
t : Finset ((i : ι) × β i)
ht : t ⊆ Finset.sigma s g
i : ι
b : β i
hi : { fst := i, snd := b }.fst ∈ s ∧ { fst := i, snd := b }.snd ∈ g { fst := i, snd := b }.fst
hit : { fst := i, snd := b } ∉ t
j : ι
c : β j
hbc : { fst := i, snd := b } ≠ { fst := j, snd := c }
hj : { fst := j, snd := c }.fst ∈ s ∧ { fst := j, snd := c }.snd ∈ g { fst := j, snd := c }.fst
hij : i ≠ j
⊢ f { fst := j, snd := c } = f { fst := { fst := j, snd := c }.fst, snd := { fst := j, snd := c }.snd }

Next tactic:
simp
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
⊢ SupIndep (s ×ˢ t) f

Next tactic:
rintro u hu ⟨i, i'⟩ hi hiu
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  

Proof state:
case mk
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i') ∈ s ×ˢ t
hiu : (i, i') ∉ u
⊢ Disjoint (f (i, i')) (Finset.sup u f)

Next tactic:
rw [Finset.disjoint_sup_right]
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  

Proof state:
case mk
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i') ∈ s ×ˢ t
hiu : (i, i') ∉ u
⊢ ∀ ⦃i_1 : ι × ι'⦄, i_1 ∈ u → Disjoint (f (i, i')) (f i_1)

Next tactic:
rintro ⟨j, j'⟩ hj
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, j'⟩ hj
  

Proof state:
case mk.mk
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i') ∈ s ×ˢ t
hiu : (i, i') ∉ u
j : ι
j' : ι'
hj : (j, j') ∈ u
⊢ Disjoint (f (i, i')) (f (j, j'))

Next tactic:
have hij := (ne_of_mem_of_not_mem hj hiu).symm
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, j'⟩ hj
  have hij := (ne_of_mem_of_not_mem hj hiu).symm
  

Proof state:
case mk.mk
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i') ∈ s ×ˢ t
hiu : (i, i') ∉ u
j : ι
j' : ι'
hj : (j, j') ∈ u
hij : (i, i') ≠ (j, j')
⊢ Disjoint (f (i, i')) (f (j, j'))

Next tactic:
replace hj := hu hj
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, j'⟩ hj
  have hij := (ne_of_mem_of_not_mem hj hiu).symm
  replace hj := hu hj
  

Proof state:
case mk.mk
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i') ∈ s ×ˢ t
hiu : (i, i') ∉ u
j : ι
j' : ι'
hij : (i, i') ≠ (j, j')
hj : (j, j') ∈ s ×ˢ t
⊢ Disjoint (f (i, i')) (f (j, j'))

Next tactic:
rw [mem_product] at hi hj
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, j'⟩ hj
  have hij := (ne_of_mem_of_not_mem hj hiu).symm
  replace hj := hu hj
  rw [mem_product] at hi hj
  

Proof state:
case mk.mk
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i').1 ∈ s ∧ (i, i').2 ∈ t
hiu : (i, i') ∉ u
j : ι
j' : ι'
hij : (i, i') ≠ (j, j')
hj : (j, j').1 ∈ s ∧ (j, j').2 ∈ t
⊢ Disjoint (f (i, i')) (f (j, j'))

Next tactic:
obtain rfl | hij := eq_or_ne i j
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, j'⟩ hj
  have hij := (ne_of_mem_of_not_mem hj hiu).symm
  replace hj := hu hj
  rw [mem_product] at hi hj
  obtain rfl | hij := eq_or_ne i j
  · 

Proof state:
case mk.mk.inl
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i').1 ∈ s ∧ (i, i').2 ∈ t
hiu : (i, i') ∉ u
j' : ι'
hij : (i, i') ≠ (i, j')
hj : (i, j').1 ∈ s ∧ (i, j').2 ∈ t
⊢ Disjoint (f (i, i')) (f (i, j'))

Next tactic:
refine' (ht.pairwiseDisjoint hi.2 hj.2 <| (Prod.mk.inj_left _).ne_iff.1 hij).mono _ _
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, j'⟩ hj
  have hij := (ne_of_mem_of_not_mem hj hiu).symm
  replace hj := hu hj
  rw [mem_product] at hi hj
  obtain rfl | hij := eq_or_ne i j
  · refine' (ht.pairwiseDisjoint hi.2 hj.2 <| (Prod.mk.inj_left _).ne_iff.1 hij).mono _ _
    · 

Proof state:
case mk.mk.inl.refine'_1
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i').1 ∈ s ∧ (i, i').2 ∈ t
hiu : (i, i') ∉ u
j' : ι'
hij : (i, i') ≠ (i, j')
hj : (i, j').1 ∈ s ∧ (i, j').2 ∈ t
⊢ f (i, i') ≤ (fun i' => Finset.sup s fun i => f (i, i')) (i, i').2

Next tactic:
convert le_sup (α := α) hi.1
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, j'⟩ hj
  have hij := (ne_of_mem_of_not_mem hj hiu).symm
  replace hj := hu hj
  rw [mem_product] at hi hj
  obtain rfl | hij := eq_or_ne i j
  · refine' (ht.pairwiseDisjoint hi.2 hj.2 <| (Prod.mk.inj_left _).ne_iff.1 hij).mono _ _
    · convert le_sup (α := α) hi.1; 

Proof state:
case h.e'_3
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i').1 ∈ s ∧ (i, i').2 ∈ t
hiu : (i, i') ∉ u
j' : ι'
hij : (i, i') ≠ (i, j')
hj : (i, j').1 ∈ s ∧ (i, j').2 ∈ t
⊢ f (i, i') = f ((i, i').1, (i, i').2)

Next tactic:
simp
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, j'⟩ hj
  have hij := (ne_of_mem_of_not_mem hj hiu).symm
  replace hj := hu hj
  rw [mem_product] at hi hj
  obtain rfl | hij := eq_or_ne i j
  · refine' (ht.pairwiseDisjoint hi.2 hj.2 <| (Prod.mk.inj_left _).ne_iff.1 hij).mono _ _
    · convert le_sup (α := α) hi.1; simp
    · 

Proof state:
case mk.mk.inl.refine'_2
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i').1 ∈ s ∧ (i, i').2 ∈ t
hiu : (i, i') ∉ u
j' : ι'
hij : (i, i') ≠ (i, j')
hj : (i, j').1 ∈ s ∧ (i, j').2 ∈ t
⊢ f (i, j') ≤ (fun i' => Finset.sup s fun i => f (i, i')) (i, j').2

Next tactic:
convert le_sup (α := α) hj.1
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, j'⟩ hj
  have hij := (ne_of_mem_of_not_mem hj hiu).symm
  replace hj := hu hj
  rw [mem_product] at hi hj
  obtain rfl | hij := eq_or_ne i j
  · refine' (ht.pairwiseDisjoint hi.2 hj.2 <| (Prod.mk.inj_left _).ne_iff.1 hij).mono _ _
    · convert le_sup (α := α) hi.1; simp
    · convert le_sup (α := α) hj.1; 

Proof state:
case h.e'_3
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i').1 ∈ s ∧ (i, i').2 ∈ t
hiu : (i, i') ∉ u
j' : ι'
hij : (i, i') ≠ (i, j')
hj : (i, j').1 ∈ s ∧ (i, j').2 ∈ t
⊢ f (i, j') = f ((i, j').1, (i, j').2)

Next tactic:
simp
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, j'⟩ hj
  have hij := (ne_of_mem_of_not_mem hj hiu).symm
  replace hj := hu hj
  rw [mem_product] at hi hj
  obtain rfl | hij := eq_or_ne i j
  · refine' (ht.pairwiseDisjoint hi.2 hj.2 <| (Prod.mk.inj_left _).ne_iff.1 hij).mono _ _
    · convert le_sup (α := α) hi.1; simp
    · convert le_sup (α := α) hj.1; simp
  · 

Proof state:
case mk.mk.inr
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i').1 ∈ s ∧ (i, i').2 ∈ t
hiu : (i, i') ∉ u
j : ι
j' : ι'
hij✝ : (i, i') ≠ (j, j')
hj : (j, j').1 ∈ s ∧ (j, j').2 ∈ t
hij : i ≠ j
⊢ Disjoint (f (i, i')) (f (j, j'))

Next tactic:
refine' (hs.pairwiseDisjoint hi.1 hj.1 hij).mono _ _
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, j'⟩ hj
  have hij := (ne_of_mem_of_not_mem hj hiu).symm
  replace hj := hu hj
  rw [mem_product] at hi hj
  obtain rfl | hij := eq_or_ne i j
  · refine' (ht.pairwiseDisjoint hi.2 hj.2 <| (Prod.mk.inj_left _).ne_iff.1 hij).mono _ _
    · convert le_sup (α := α) hi.1; simp
    · convert le_sup (α := α) hj.1; simp
  · refine' (hs.pairwiseDisjoint hi.1 hj.1 hij).mono _ _
    · 

Proof state:
case mk.mk.inr.refine'_1
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i').1 ∈ s ∧ (i, i').2 ∈ t
hiu : (i, i') ∉ u
j : ι
j' : ι'
hij✝ : (i, i') ≠ (j, j')
hj : (j, j').1 ∈ s ∧ (j, j').2 ∈ t
hij : i ≠ j
⊢ f (i, i') ≤ (fun i => Finset.sup t fun i' => f (i, i')) (i, i').1

Next tactic:
convert le_sup (α := α) hi.2
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, j'⟩ hj
  have hij := (ne_of_mem_of_not_mem hj hiu).symm
  replace hj := hu hj
  rw [mem_product] at hi hj
  obtain rfl | hij := eq_or_ne i j
  · refine' (ht.pairwiseDisjoint hi.2 hj.2 <| (Prod.mk.inj_left _).ne_iff.1 hij).mono _ _
    · convert le_sup (α := α) hi.1; simp
    · convert le_sup (α := α) hj.1; simp
  · refine' (hs.pairwiseDisjoint hi.1 hj.1 hij).mono _ _
    · convert le_sup (α := α) hi.2; 

Proof state:
case h.e'_3
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i').1 ∈ s ∧ (i, i').2 ∈ t
hiu : (i, i') ∉ u
j : ι
j' : ι'
hij✝ : (i, i') ≠ (j, j')
hj : (j, j').1 ∈ s ∧ (j, j').2 ∈ t
hij : i ≠ j
⊢ f (i, i') = f ((i, i').1, (i, i').2)

Next tactic:
simp
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, j'⟩ hj
  have hij := (ne_of_mem_of_not_mem hj hiu).symm
  replace hj := hu hj
  rw [mem_product] at hi hj
  obtain rfl | hij := eq_or_ne i j
  · refine' (ht.pairwiseDisjoint hi.2 hj.2 <| (Prod.mk.inj_left _).ne_iff.1 hij).mono _ _
    · convert le_sup (α := α) hi.1; simp
    · convert le_sup (α := α) hj.1; simp
  · refine' (hs.pairwiseDisjoint hi.1 hj.1 hij).mono _ _
    · convert le_sup (α := α) hi.2; simp
    · 

Proof state:
case mk.mk.inr.refine'_2
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i').1 ∈ s ∧ (i, i').2 ∈ t
hiu : (i, i') ∉ u
j : ι
j' : ι'
hij✝ : (i, i') ≠ (j, j')
hj : (j, j').1 ∈ s ∧ (j, j').2 ∈ t
hij : i ≠ j
⊢ f (j, j') ≤ (fun i => Finset.sup t fun i' => f (i, i')) (j, j').1

Next tactic:
convert le_sup (α := α) hj.2
theorem SupIndep.product {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α}
    (hs : s.SupIndep fun i => t.sup fun i' => f (i, i'))
    (ht : t.SupIndep fun i' => s.sup fun i => f (i, i')) : (s ×ˢ t).SupIndep f := by
  rintro u hu ⟨i, i'⟩ hi hiu
  rw [Finset.disjoint_sup_right]
  rintro ⟨j, j'⟩ hj
  have hij := (ne_of_mem_of_not_mem hj hiu).symm
  replace hj := hu hj
  rw [mem_product] at hi hj
  obtain rfl | hij := eq_or_ne i j
  · refine' (ht.pairwiseDisjoint hi.2 hj.2 <| (Prod.mk.inj_left _).ne_iff.1 hij).mono _ _
    · convert le_sup (α := α) hi.1; simp
    · convert le_sup (α := α) hj.1; simp
  · refine' (hs.pairwiseDisjoint hi.1 hj.1 hij).mono _ _
    · convert le_sup (α := α) hi.2; simp
    · convert le_sup (α := α) hj.2; 

Proof state:
case h.e'_3
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
hs : SupIndep s fun i => Finset.sup t fun i' => f (i, i')
ht : SupIndep t fun i' => Finset.sup s fun i => f (i, i')
u : Finset (ι × ι')
hu : u ⊆ s ×ˢ t
i : ι
i' : ι'
hi : (i, i').1 ∈ s ∧ (i, i').2 ∈ t
hiu : (i, i') ∉ u
j : ι
j' : ι'
hij✝ : (i, i') ≠ (j, j')
hj : (j, j').1 ∈ s ∧ (j, j').2 ∈ t
hij : i ≠ j
⊢ f (j, j') = f ((j, j').1, (j, j').2)

Next tactic:
simp
theorem supIndep_product_iff {s : Finset ι} {t : Finset ι'} {f : ι × ι' → α} :
    (s.product t).SupIndep f ↔ (s.SupIndep fun i => t.sup fun i' => f (i, i'))
      ∧ t.SupIndep fun i' => s.sup fun i => f (i, i') := by
  

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
s : Finset ι
t : Finset ι'
f : ι × ι' → α
⊢ SupIndep (Finset.product s t) f ↔
    (SupIndep s fun i => sup t fun i' => f (i, i')) ∧ SupIndep t fun i' => sup s fun i => f (i, i')

Next tactic:
refine' ⟨_, fun h => h.1.product h.2⟩