Theorem: List.ranges_disjoint
File: Mathlib/Data/List/Range.lean

tactic: exact Pairwise.nil
state_before: case nil
α : Type u
⊢ Pairwise Disjoint [].ranges
state_after: no goals

tactic: simp only [ranges, pairwise_cons]
state_before: case cons
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
⊢ Pairwise Disjoint (a :: l).ranges
state_after: case cons
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
⊢ (∀ a' ∈ map (map fun x => a + x) l.ranges, (range a).Disjoint a') ∧
    Pairwise Disjoint (map (map fun x => a + x) l.ranges)

tactic: constructor
state_before: case cons
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
⊢ (∀ a' ∈ map (map fun x => a + x) l.ranges, (range a).Disjoint a') ∧
    Pairwise Disjoint (map (map fun x => a + x) l.ranges)
state_after: case cons.left
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
⊢ ∀ a' ∈ map (map fun x => a + x) l.ranges, (range a).Disjoint a'

case cons.right
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
⊢ Pairwise Disjoint (map (map fun x => a + x) l.ranges)

tactic: intro s hs
state_before: case cons.left
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
⊢ ∀ a' ∈ map (map fun x => a + x) l.ranges, (range a).Disjoint a'
state_after: case cons.left
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
s : List ℕ
hs : s ∈ map (map fun x => a + x) l.ranges
⊢ (range a).Disjoint s

tactic: obtain ⟨s', _, rfl⟩ := mem_map.mp hs
state_before: case cons.left
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
s : List ℕ
hs : s ∈ map (map fun x => a + x) l.ranges
⊢ (range a).Disjoint s
state_after: case cons.left.intro.intro
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
s' : List ℕ
left✝ : s' ∈ l.ranges
hs : map (fun x => a + x) s' ∈ map (map fun x => a + x) l.ranges
⊢ (range a).Disjoint (map (fun x => a + x) s')

tactic: intro u hu
state_before: case cons.left.intro.intro
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
s' : List ℕ
left✝ : s' ∈ l.ranges
hs : map (fun x => a + x) s' ∈ map (map fun x => a + x) l.ranges
⊢ (range a).Disjoint (map (fun x => a + x) s')
state_after: case cons.left.intro.intro
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
s' : List ℕ
left✝ : s' ∈ l.ranges
hs : map (fun x => a + x) s' ∈ map (map fun x => a + x) l.ranges
u : ℕ
hu : u ∈ range a
⊢ u ∈ map (fun x => a + x) s' → False

tactic: rw [mem_map]
state_before: case cons.left.intro.intro
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
s' : List ℕ
left✝ : s' ∈ l.ranges
hs : map (fun x => a + x) s' ∈ map (map fun x => a + x) l.ranges
u : ℕ
hu : u ∈ range a
⊢ u ∈ map (fun x => a + x) s' → False
state_after: case cons.left.intro.intro
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
s' : List ℕ
left✝ : s' ∈ l.ranges
hs : map (fun x => a + x) s' ∈ map (map fun x => a + x) l.ranges
u : ℕ
hu : u ∈ range a
⊢ (∃ a_1 ∈ s', a + a_1 = u) → False

tactic: rintro ⟨v, _, rfl⟩
state_before: case cons.left.intro.intro
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
s' : List ℕ
left✝ : s' ∈ l.ranges
hs : map (fun x => a + x) s' ∈ map (map fun x => a + x) l.ranges
u : ℕ
hu : u ∈ range a
⊢ (∃ a_1 ∈ s', a + a_1 = u) → False
state_after: case cons.left.intro.intro.intro.intro
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
s' : List ℕ
left✝¹ : s' ∈ l.ranges
hs : map (fun x => a + x) s' ∈ map (map fun x => a + x) l.ranges
v : ℕ
left✝ : v ∈ s'
hu : a + v ∈ range a
⊢ False

tactic: rw [mem_range] at hu
state_before: case cons.left.intro.intro.intro.intro
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
s' : List ℕ
left✝¹ : s' ∈ l.ranges
hs : map (fun x => a + x) s' ∈ map (map fun x => a + x) l.ranges
v : ℕ
left✝ : v ∈ s'
hu : a + v ∈ range a
⊢ False
state_after: case cons.left.intro.intro.intro.intro
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
s' : List ℕ
left✝¹ : s' ∈ l.ranges
hs : map (fun x => a + x) s' ∈ map (map fun x => a + x) l.ranges
v : ℕ
left✝ : v ∈ s'
hu : a + v < a
⊢ False

tactic: omega
state_before: case cons.left.intro.intro.intro.intro
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
s' : List ℕ
left✝¹ : s' ∈ l.ranges
hs : map (fun x => a + x) s' ∈ map (map fun x => a + x) l.ranges
v : ℕ
left✝ : v ∈ s'
hu : a + v < a
⊢ False
state_after: no goals

tactic: rw [pairwise_map]
state_before: case cons.right
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
⊢ Pairwise Disjoint (map (map fun x => a + x) l.ranges)
state_after: case cons.right
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
⊢ Pairwise (fun a_1 b => (map (fun x => a + x) a_1).Disjoint (map (fun x => a + x) b)) l.ranges

tactic: apply Pairwise.imp _ hl
state_before: case cons.right
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
⊢ Pairwise (fun a_1 b => (map (fun x => a + x) a_1).Disjoint (map (fun x => a + x) b)) l.ranges
state_after: α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
⊢ ∀ {a_1 b : List ℕ}, a_1.Disjoint b → (map (fun x => a + x) a_1).Disjoint (map (fun x => a + x) b)

tactic: intro u v
state_before: α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
⊢ ∀ {a_1 b : List ℕ}, a_1.Disjoint b → (map (fun x => a + x) a_1).Disjoint (map (fun x => a + x) b)
state_after: α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
u v : List ℕ
⊢ u.Disjoint v → (map (fun x => a + x) u).Disjoint (map (fun x => a + x) v)

tactic: apply disjoint_map
state_before: α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
u v : List ℕ
⊢ u.Disjoint v → (map (fun x => a + x) u).Disjoint (map (fun x => a + x) v)
state_after: case hf
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
u v : List ℕ
⊢ Function.Injective fun x => a + x

tactic: exact fun u v => Nat.add_left_cancel
state_before: case hf
α : Type u
a : ℕ
l : List ℕ
hl : Pairwise Disjoint l.ranges
u v : List ℕ
⊢ Function.Injective fun x => a + x
state_after: no goals