Theorem: Finset.inf_sup
File: Mathlib/Data/Finset/Lattice.lean

tactic: induction' s using Finset.induction with i s hi ih
state_before: F : Type ?u.189518
α : Type u_3
β : Type ?u.189524
γ : Type ?u.189527
ι : Type u_2
κ✝ : Type ?u.189533
inst✝² : DistribLattice α
inst✝¹ : BoundedOrder α
inst✝ : DecidableEq ι
κ : ι → Type u_1
s : Finset ι
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
⊢ (inf s fun i => sup (t i) (f i)) = sup (pi s t) fun g => inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))

tactic: rw [inf_insert, ih, attach_insert, sup_inf_sup]
state_before: case insert
F : Type ?u.189518
α : Type u_3
β : Type ?u.189524
γ : Type ?u.189527
ι : Type u_2
κ✝ : Type ?u.189533
inst✝² : DistribLattice α
inst✝¹ : BoundedOrder α
inst✝ : DecidableEq ι
κ : ι → Type u_1
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih : (inf s fun i => sup (t i) (f i)) = sup (pi s t) fun g => inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))
⊢ (inf (insert i s) fun i => sup (t i) (f i)) =
    sup (pi (insert i s) t) fun g => inf (attach (insert i s)) fun i_1 => f (↑i_1) (g ↑i_1 (_ : ↑i_1 ∈ insert i s))

tactic: refine' eq_of_forall_ge_iff fun c => _
state_before: case insert
F : Type ?u.189518
α : Type u_3
β : Type ?u.189524
γ : Type ?u.189527
ι : Type u_2
κ✝ : Type ?u.189533
inst✝² : DistribLattice α
inst✝¹ : BoundedOrder α
inst✝ : DecidableEq ι
κ : ι → Type u_1
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih : (inf s fun i => sup (t i) (f i)) = sup (pi s t) fun g => inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))
⊢ (sup (t i ×ˢ pi s t) fun i_1 => f i i_1.fst ⊓ inf (attach s) fun i_2 => f (↑i_2) (Prod.snd i_1 ↑i_2 (_ : ↑i_2 ∈ s))) =
    sup (pi (insert i s) t) fun g =>
      inf
        (insert { val := i, property := (_ : i ∈ insert i s) }
          (image (fun x => { val := ↑x, property := (_ : ↑x ∈ insert i s) }) (attach s)))
        fun i_1 => f (↑i_1) (g ↑i_1 (_ : ↑i_1 ∈ insert i s))

tactic: simp only [Finset.sup_le_iff, mem_product, mem_pi, and_imp, Prod.forall,
  inf_insert, inf_image]
state_before: case insert
F : Type ?u.189518
α : Type u_3
β : Type ?u.189524
γ : Type ?u.189527
ι : Type u_2
κ✝ : Type ?u.189533
inst✝² : DistribLattice α
inst✝¹ : BoundedOrder α
inst✝ : DecidableEq ι
κ : ι → Type u_1
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih : (inf s fun i => sup (t i) (f i)) = sup (pi s t) fun g => inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))
c : α
⊢ (sup (t i ×ˢ pi s t) fun i_1 => f i i_1.fst ⊓ inf (attach s) fun i_2 => f (↑i_2) (Prod.snd i_1 ↑i_2 (_ : ↑i_2 ∈ s))) ≤
      c ↔
    (sup (pi (insert i s) t) fun g =>
        inf
          (insert { val := i, property := (_ : i ∈ insert i s) }
            (image (fun x => { val := ↑x, property := (_ : ↑x ∈ insert i s) }) (attach s)))
          fun i_1 => f (↑i_1) (g ↑i_1 (_ : ↑i_1 ∈ insert i s))) ≤
      c

tactic: refine'
  ⟨fun h g hg =>
    h (g i <| mem_insert_self _ _) (fun j hj => g j <| mem_insert_of_mem hj)
      (hg _ <| mem_insert_self _ _) fun j hj => hg _ <| mem_insert_of_mem hj,
    fun h a g ha hg => _⟩
state_before: case insert
F : Type ?u.189518
α : Type u_3
β : Type ?u.189524
γ : Type ?u.189527
ι : Type u_2
κ✝ : Type ?u.189533
inst✝² : DistribLattice α
inst✝¹ : BoundedOrder α
inst✝ : DecidableEq ι
κ : ι → Type u_1
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih : (inf s fun i => sup (t i) (f i)) = sup (pi s t) fun g => inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))
c : α
⊢ (∀ (a : κ i) (b : (a : ι) → a ∈ s → κ a),
      a ∈ t i →
        (∀ (a : ι) (h : a ∈ s), b a h ∈ t a) → (f i a ⊓ inf (attach s) fun i => f (↑i) (b ↑i (_ : ↑i ∈ s))) ≤ c) ↔
    ∀ (b : (a : ι) → a ∈ insert i s → κ a),
      (∀ (a : ι) (h : a ∈ insert i s), b a h ∈ t a) →
        f i
              (b ↑{ val := i, property := (_ : i ∈ insert i s) }
                (_ : ↑{ val := i, property := (_ : i ∈ insert i s) } ∈ insert i s)) ⊓
            inf (attach s)
              ((fun i_1 => f (↑i_1) (b ↑i_1 (_ : ↑i_1 ∈ insert i s))) ∘ fun x =>
                { val := ↑x, property := (_ : ↑x ∈ insert i s) }) ≤
          c

tactic: have aux : ∀ j : { x // x ∈ s }, ↑j ≠ i := fun j : s => ne_of_mem_of_not_mem j.2 hi
state_before: case insert
F : Type ?u.189518
α : Type u_3
β : Type ?u.189524
γ : Type ?u.189527
ι : Type u_2
κ✝ : Type ?u.189533
inst✝² : DistribLattice α
inst✝¹ : BoundedOrder α
inst✝ : DecidableEq ι
κ : ι → Type u_1
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih : (inf s fun i => sup (t i) (f i)) = sup (pi s t) fun g => inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))
c : α
h :
  ∀ (b : (a : ι) → a ∈ insert i s → κ a),
    (∀ (a : ι) (h : a ∈ insert i s), b a h ∈ t a) →
      f i
            (b ↑{ val := i, property := (_ : i ∈ insert i s) }
              (_ : ↑{ val := i, property := (_ : i ∈ insert i s) } ∈ insert i s)) ⊓
          inf (attach s)
            ((fun i_1 => f (↑i_1) (b ↑i_1 (_ : ↑i_1 ∈ insert i s))) ∘ fun x =>
              { val := ↑x, property := (_ : ↑x ∈ insert i s) }) ≤
        c
a : κ i
g : (a : ι) → a ∈ s → κ a
ha : a ∈ t i
hg : ∀ (a : ι) (h : a ∈ s), g a h ∈ t a
⊢ (f i a ⊓ inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))) ≤ c

tactic: have := h (fun j hj => if hji : j = i then cast (congr_arg κ hji.symm) a
    else g _ <| mem_of_mem_insert_of_ne hj hji) (fun j hj => ?_)
state_before: case insert
F : Type ?u.189518
α : Type u_3
β : Type ?u.189524
γ : Type ?u.189527
ι : Type u_2
κ✝ : Type ?u.189533
inst✝² : DistribLattice α
inst✝¹ : BoundedOrder α
inst✝ : DecidableEq ι
κ : ι → Type u_1
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih : (inf s fun i => sup (t i) (f i)) = sup (pi s t) fun g => inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))
c : α
h :
  ∀ (b : (a : ι) → a ∈ insert i s → κ a),
    (∀ (a : ι) (h : a ∈ insert i s), b a h ∈ t a) →
      f i
            (b ↑{ val := i, property := (_ : i ∈ insert i s) }
              (_ : ↑{ val := i, property := (_ : i ∈ insert i s) } ∈ insert i s)) ⊓
          inf (attach s)
            ((fun i_1 => f (↑i_1) (b ↑i_1 (_ : ↑i_1 ∈ insert i s))) ∘ fun x =>
              { val := ↑x, property := (_ : ↑x ∈ insert i s) }) ≤
        c
a : κ i
g : (a : ι) → a ∈ s → κ a
ha : a ∈ t i
hg : ∀ (a : ι) (h : a ∈ s), g a h ∈ t a
aux : ∀ (j : { x // x ∈ s }), ↑j ≠ i
⊢ (f i a ⊓ inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))) ≤ c

tactic: simpa only [cast_eq, dif_pos, Function.comp, Subtype.coe_mk, dif_neg, aux] using this
state_before: case insert.refine_2
F : Type ?u.189518
α : Type u_3
β : Type ?u.189524
γ : Type ?u.189527
ι : Type u_2
κ✝ : Type ?u.189533
inst✝² : DistribLattice α
inst✝¹ : BoundedOrder α
inst✝ : DecidableEq ι
κ : ι → Type u_1
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih : (inf s fun i => sup (t i) (f i)) = sup (pi s t) fun g => inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))
c : α
h :
  ∀ (b : (a : ι) → a ∈ insert i s → κ a),
    (∀ (a : ι) (h : a ∈ insert i s), b a h ∈ t a) →
      f i
            (b ↑{ val := i, property := (_ : i ∈ insert i s) }
              (_ : ↑{ val := i, property := (_ : i ∈ insert i s) } ∈ insert i s)) ⊓
          inf (attach s)
            ((fun i_1 => f (↑i_1) (b ↑i_1 (_ : ↑i_1 ∈ insert i s))) ∘ fun x =>
              { val := ↑x, property := (_ : ↑x ∈ insert i s) }) ≤
        c
a : κ i
g : (a : ι) → a ∈ s → κ a
ha : a ∈ t i
hg : ∀ (a : ι) (h : a ∈ s), g a h ∈ t a
aux : ∀ (j : { x // x ∈ s }), ↑j ≠ i
this :
  f i
        ((fun j hj => if hji : j = i then cast (_ : κ i = κ j) a else g j (_ : j ∈ s))
          ↑{ val := i, property := (_ : i ∈ insert i s) }
          (_ : ↑{ val := i, property := (_ : i ∈ insert i s) } ∈ insert i s)) ⊓
      inf (attach s)
        ((fun i_1 =>
            f (↑i_1)
              ((fun j hj => if hji : j = i then cast (_ : κ i = κ j) a else g j (_ : j ∈ s)) ↑i_1
                (_ : ↑i_1 ∈ insert i s))) ∘
          fun x => { val := ↑x, property := (_ : ↑x ∈ insert i s) }) ≤
    c
⊢ (f i a ⊓ inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))) ≤ c

case insert.refine_1
F : Type ?u.189518
α : Type u_3
β : Type ?u.189524
γ : Type ?u.189527
ι : Type u_2
κ✝ : Type ?u.189533
inst✝² : DistribLattice α
inst✝¹ : BoundedOrder α
inst✝ : DecidableEq ι
κ : ι → Type u_1
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih : (inf s fun i => sup (t i) (f i)) = sup (pi s t) fun g => inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))
c : α
h :
  ∀ (b : (a : ι) → a ∈ insert i s → κ a),
    (∀ (a : ι) (h : a ∈ insert i s), b a h ∈ t a) →
      f i
            (b ↑{ val := i, property := (_ : i ∈ insert i s) }
              (_ : ↑{ val := i, property := (_ : i ∈ insert i s) } ∈ insert i s)) ⊓
          inf (attach s)
            ((fun i_1 => f (↑i_1) (b ↑i_1 (_ : ↑i_1 ∈ insert i s))) ∘ fun x =>
              { val := ↑x, property := (_ : ↑x ∈ insert i s) }) ≤
        c
a : κ i
g : (a : ι) → a ∈ s → κ a
ha : a ∈ t i
hg : ∀ (a : ι) (h : a ∈ s), g a h ∈ t a
aux : ∀ (j : { x // x ∈ s }), ↑j ≠ i
j : ι
hj : j ∈ insert i s
⊢ (fun j hj => if hji : j = i then cast (_ : κ i = κ j) a else g j (_ : j ∈ s)) j hj ∈ t j

tactic: rw [mem_insert] at hj
state_before: case insert.refine_1
F : Type ?u.189518
α : Type u_3
β : Type ?u.189524
γ : Type ?u.189527
ι : Type u_2
κ✝ : Type ?u.189533
inst✝² : DistribLattice α
inst✝¹ : BoundedOrder α
inst✝ : DecidableEq ι
κ : ι → Type u_1
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih : (inf s fun i => sup (t i) (f i)) = sup (pi s t) fun g => inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))
c : α
h :
  ∀ (b : (a : ι) → a ∈ insert i s → κ a),
    (∀ (a : ι) (h : a ∈ insert i s), b a h ∈ t a) →
      f i
            (b ↑{ val := i, property := (_ : i ∈ insert i s) }
              (_ : ↑{ val := i, property := (_ : i ∈ insert i s) } ∈ insert i s)) ⊓
          inf (attach s)
            ((fun i_1 => f (↑i_1) (b ↑i_1 (_ : ↑i_1 ∈ insert i s))) ∘ fun x =>
              { val := ↑x, property := (_ : ↑x ∈ insert i s) }) ≤
        c
a : κ i
g : (a : ι) → a ∈ s → κ a
ha : a ∈ t i
hg : ∀ (a : ι) (h : a ∈ s), g a h ∈ t a
aux : ∀ (j : { x // x ∈ s }), ↑j ≠ i
j : ι
hj : j ∈ insert i s
⊢ (fun j hj => if hji : j = i then cast (_ : κ i = κ j) a else g j (_ : j ∈ s)) j hj ∈ t j

tactic: obtain (rfl | hj) := hj
state_before: case insert.refine_1
F : Type ?u.189518
α : Type u_3
β : Type ?u.189524
γ : Type ?u.189527
ι : Type u_2
κ✝ : Type ?u.189533
inst✝² : DistribLattice α
inst✝¹ : BoundedOrder α
inst✝ : DecidableEq ι
κ : ι → Type u_1
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih : (inf s fun i => sup (t i) (f i)) = sup (pi s t) fun g => inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))
c : α
h :
  ∀ (b : (a : ι) → a ∈ insert i s → κ a),
    (∀ (a : ι) (h : a ∈ insert i s), b a h ∈ t a) →
      f i
            (b ↑{ val := i, property := (_ : i ∈ insert i s) }
              (_ : ↑{ val := i, property := (_ : i ∈ insert i s) } ∈ insert i s)) ⊓
          inf (attach s)
            ((fun i_1 => f (↑i_1) (b ↑i_1 (_ : ↑i_1 ∈ insert i s))) ∘ fun x =>
              { val := ↑x, property := (_ : ↑x ∈ insert i s) }) ≤
        c
a : κ i
g : (a : ι) → a ∈ s → κ a
ha : a ∈ t i
hg : ∀ (a : ι) (h : a ∈ s), g a h ∈ t a
aux : ∀ (j : { x // x ∈ s }), ↑j ≠ i
j : ι
hj✝ : j ∈ insert i s
hj : j = i ∨ j ∈ s
⊢ (fun j hj => if hji : j = i then cast (_ : κ i = κ j) a else g j (_ : j ∈ s)) j hj✝ ∈ t j

tactic: simp
state_before: case empty
F : Type ?u.189518
α : Type u_3
β : Type ?u.189524
γ : Type ?u.189527
ι : Type u_2
κ✝ : Type ?u.189533
inst✝² : DistribLattice α
inst✝¹ : BoundedOrder α
inst✝ : DecidableEq ι
κ : ι → Type u_1
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
⊢ (inf ∅ fun i => sup (t i) (f i)) = sup (pi ∅ t) fun g => inf (attach ∅) fun i => f (↑i) (g ↑i (_ : ↑i ∈ ∅))

tactic: simpa
state_before: case insert.refine_1.inl
F : Type ?u.189518
α : Type u_3
β : Type ?u.189524
γ : Type ?u.189527
ι : Type u_2
κ✝ : Type ?u.189533
inst✝² : DistribLattice α
inst✝¹ : BoundedOrder α
inst✝ : DecidableEq ι
κ : ι → Type u_1
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
s : Finset ι
ih : (inf s fun i => sup (t i) (f i)) = sup (pi s t) fun g => inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))
c : α
g : (a : ι) → a ∈ s → κ a
hg : ∀ (a : ι) (h : a ∈ s), g a h ∈ t a
j : ι
hi : ¬j ∈ s
h :
  ∀ (b : (a : ι) → a ∈ insert j s → κ a),
    (∀ (a : ι) (h : a ∈ insert j s), b a h ∈ t a) →
      f j
            (b ↑{ val := j, property := (_ : j ∈ insert j s) }
              (_ : ↑{ val := j, property := (_ : j ∈ insert j s) } ∈ insert j s)) ⊓
          inf (attach s)
            ((fun i => f (↑i) (b ↑i (_ : ↑i ∈ insert j s))) ∘ fun x =>
              { val := ↑x, property := (_ : ↑x ∈ insert j s) }) ≤
        c
a : κ j
ha : a ∈ t j
aux : ∀ (j_1 : { x // x ∈ s }), ↑j_1 ≠ j
hj : j ∈ insert j s
⊢ (fun j_1 hj => if hji : j_1 = j then cast (_ : κ j = κ j_1) a else g j_1 (_ : j_1 ∈ s)) j hj ∈ t j

tactic: simpa [ne_of_mem_of_not_mem hj hi] using hg _ _
state_before: case insert.refine_1.inr
F : Type ?u.189518
α : Type u_3
β : Type ?u.189524
γ : Type ?u.189527
ι : Type u_2
κ✝ : Type ?u.189533
inst✝² : DistribLattice α
inst✝¹ : BoundedOrder α
inst✝ : DecidableEq ι
κ : ι → Type u_1
t : (i : ι) → Finset (κ i)
f : (i : ι) → κ i → α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih : (inf s fun i => sup (t i) (f i)) = sup (pi s t) fun g => inf (attach s) fun i => f (↑i) (g ↑i (_ : ↑i ∈ s))
c : α
h :
  ∀ (b : (a : ι) → a ∈ insert i s → κ a),
    (∀ (a : ι) (h : a ∈ insert i s), b a h ∈ t a) →
      f i
            (b ↑{ val := i, property := (_ : i ∈ insert i s) }
              (_ : ↑{ val := i, property := (_ : i ∈ insert i s) } ∈ insert i s)) ⊓
          inf (attach s)
            ((fun i_1 => f (↑i_1) (b ↑i_1 (_ : ↑i_1 ∈ insert i s))) ∘ fun x =>
              { val := ↑x, property := (_ : ↑x ∈ insert i s) }) ≤
        c
a : κ i
g : (a : ι) → a ∈ s → κ a
ha : a ∈ t i
hg : ∀ (a : ι) (h : a ∈ s), g a h ∈ t a
aux : ∀ (j : { x // x ∈ s }), ↑j ≠ i
j : ι
hj✝ : j ∈ insert i s
hj : j ∈ s
⊢ (fun j hj => if hji : j = i then cast (_ : κ i = κ j) a else g j (_ : j ∈ s)) j hj✝ ∈ t j