Theorem: List.pairwise_iff_getElem
File: .lake/packages/batteries/Batteries/Data/List/Pairwise.lean

tactic: rw [pairwise_iff_forall_sublist]
state_before: α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
⊢ Pairwise R l ↔ ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
state_after: α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
⊢ (∀ {a b : α✝}, [a, b] <+ l → R a b) ↔ ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]

tactic: constructor <;> intro h
state_before: α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
⊢ (∀ {a b : α✝}, [a, b] <+ l → R a b) ↔ ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
state_after: case mp
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ {a b : α✝}, [a, b] <+ l → R a b
⊢ ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]

case mpr
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
⊢ ∀ {a b : α✝}, [a, b] <+ l → R a b

tactic: intros i j hi hj h'
state_before: case mp
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ {a b : α✝}, [a, b] <+ l → R a b
⊢ ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
state_after: case mp
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ {a b : α✝}, [a, b] <+ l → R a b
i j : Nat
hi : i < l.length
hj : j < l.length
h' : i < j
⊢ R l[i] l[j]

tactic: apply h
state_before: case mp
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ {a b : α✝}, [a, b] <+ l → R a b
i j : Nat
hi : i < l.length
hj : j < l.length
h' : i < j
⊢ R l[i] l[j]
state_after: case mp.a
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ {a b : α✝}, [a, b] <+ l → R a b
i j : Nat
hi : i < l.length
hj : j < l.length
h' : i < j
⊢ [l[i], l[j]] <+ l

tactic: simpa [h'] using map_get_sublist (is := [⟨i, hi⟩, ⟨j, hj⟩])
state_before: case mp.a
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ {a b : α✝}, [a, b] <+ l → R a b
i j : Nat
hi : i < l.length
hj : j < l.length
h' : i < j
⊢ [l[i], l[j]] <+ l
state_after: no goals

tactic: intros a b h'
state_before: case mpr
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
⊢ ∀ {a b : α✝}, [a, b] <+ l → R a b
state_after: case mpr
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
a b : α✝
h' : [a, b] <+ l
⊢ R a b

tactic: have ⟨is, h', hij⟩ := sublist_eq_map_get h'
state_before: case mpr
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
a b : α✝
h' : [a, b] <+ l
⊢ R a b
state_after: case mpr
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
a b : α✝
h'✝ : [a, b] <+ l
is : List (Fin l.length)
h' : [a, b] = map l.get is
hij : Pairwise (fun x x_1 => x < x_1) is
⊢ R a b

tactic: rcases is with ⟨⟩ | ⟨a', ⟨⟩ | ⟨b', ⟨⟩⟩⟩ <;> simp at h'
state_before: case mpr
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
a b : α✝
h'✝ : [a, b] <+ l
is : List (Fin l.length)
h' : [a, b] = map l.get is
hij : Pairwise (fun x x_1 => x < x_1) is
⊢ R a b
state_after: case mpr.cons.cons.nil
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
a b : α✝
h'✝ : [a, b] <+ l
a' b' : Fin l.length
hij : Pairwise (fun x x_1 => x < x_1) [a', b']
h' : a = l[↑a'] ∧ b = l[↑b']
⊢ R a b

tactic: rcases h' with ⟨rfl, rfl⟩
state_before: case mpr.cons.cons.nil
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
a b : α✝
h'✝ : [a, b] <+ l
a' b' : Fin l.length
hij : Pairwise (fun x x_1 => x < x_1) [a', b']
h' : a = l[↑a'] ∧ b = l[↑b']
⊢ R a b
state_after: case mpr.cons.cons.nil.intro
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
a' b' : Fin l.length
hij : Pairwise (fun x x_1 => x < x_1) [a', b']
h' : [l[↑a'], l[↑b']] <+ l
⊢ R l[↑a'] l[↑b']

tactic: apply h
state_before: case mpr.cons.cons.nil.intro
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
a' b' : Fin l.length
hij : Pairwise (fun x x_1 => x < x_1) [a', b']
h' : [l[↑a'], l[↑b']] <+ l
⊢ R l[↑a'] l[↑b']
state_after: case mpr.cons.cons.nil.intro._hij
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
a' b' : Fin l.length
hij : Pairwise (fun x x_1 => x < x_1) [a', b']
h' : [l[↑a'], l[↑b']] <+ l
⊢ ↑a' < ↑b'

tactic: simpa using hij
state_before: case mpr.cons.cons.nil.intro._hij
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
a' b' : Fin l.length
hij : Pairwise (fun x x_1 => x < x_1) [a', b']
h' : [l[↑a'], l[↑b']] <+ l
⊢ ↑a' < ↑b'
state_after: no goals