url stringclasses 147
values | commit stringclasses 147
values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.rankD_findAux | [210, 1] | [220, 42] | split <;> [rfl; skip] | i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
⊢ rankD
(if (Array.get self.arr x).parent = ↑x then self.arr
else
Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
rank self i | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
⊢ rankD
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
rank self i | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
⊢ rankD
(if (Array.get self.arr x).parent = ↑x then self.arr
else
Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
rank self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.rankD_findAux | [210, 1] | [220, 42] | have := Nat.sub_lt_sub_left (self.lt_rankMax x) (self.rank'_lt _ ‹_›) | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
⊢ rankD
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
rank self i | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ rankD
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
rank self i | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
⊢ rankD
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
rank self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.rankD_findAux | [210, 1] | [220, 42] | have := lt_of_parentD (by rwa [parentD_eq]) | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ rankD
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
rank self i | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this✝ : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
this : ↑x < Array.size self.arr
⊢ rankD
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
rank self i | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ rankD
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
rank self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.rankD_findAux | [210, 1] | [220, 42] | rw [rankD_eq' (by simp [FindAux.size_eq, h]), Array.get_modify (by rwa [FindAux.size_eq])] | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this✝ : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
this : ↑x < Array.size self.arr
⊢ rankD
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
rank self i | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this✝ : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
this : ↑x < Array.size self.arr
⊢ (if ↑x = i then
{ parent := root self ↑x,
rank :=
(Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
{ val := i, isLt := ⋯ }).rank }
else
Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s { val := i, isLt := ⋯ }).rank =
rank self i | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this✝ : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
this : ↑x < Array.size self.arr
⊢ rankD
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
rank self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.rankD_findAux | [210, 1] | [220, 42] | split <;> simp [← rankD_eq, rankD_findAux (x := ⟨_, self.parent'_lt x⟩)] | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this✝ : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
this : ↑x < Array.size self.arr
⊢ (if ↑x = i then
{ parent := root self ↑x,
rank :=
(Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
{ val := i, isLt := ⋯ }).rank }
else
Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s { val := i, isLt := ⋯ }).rank =
rank self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this✝ : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
this : ↑x < Array.size self.arr
⊢ (if ↑x = i then
{ parent := root self ↑x,
rank :=
(Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
{ val := i, isLt := ⋯ }).rank }
else
Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s { val := i, isLt := ⋯ }).rank =
rank self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.rankD_findAux | [210, 1] | [220, 42] | rwa [parentD_eq] | i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ parentD ?m.115685 ?m.115686 ≠ ?m.115686 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ parentD ?m.115685 ?m.115686 ≠ ?m.115686
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.rankD_findAux | [210, 1] | [220, 42] | simp [FindAux.size_eq, h] | i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this✝ : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
this : ↑x < Array.size self.arr
⊢ i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this✝ : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
this : ↑x < Array.size self.arr
⊢ i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.rankD_findAux | [210, 1] | [220, 42] | rwa [FindAux.size_eq] | i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this✝ : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
this : ↑x < Array.size self.arr
⊢ i < Array.size (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h✝ : ¬(Array.get self.arr x).parent = ↑x
this✝ : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
this : ↑x < Array.size self.arr
⊢ i < Array.size (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.rankD_findAux | [210, 1] | [220, 42] | simp [rank, rankD] | i : Nat
self : UnionFind
x : Fin (size self)
h : ¬i < size self
⊢ rankD (findAux self x).s i = rank self i | i : Nat
self : UnionFind
x : Fin (size self)
h : ¬i < size self
⊢ (if h : i < Array.size (findAux self x).s then (Array.get (findAux self x).s { val := i, isLt := h }).rank else 0) =
if h : i < Array.size self.arr then (Array.get self.arr { val := i, isLt := h }).rank else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬i < size self
⊢ rankD (findAux self x).s i = rank self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.rankD_findAux | [210, 1] | [220, 42] | rw [dif_neg (by rwa [FindAux.size_eq]), dif_neg h] | i : Nat
self : UnionFind
x : Fin (size self)
h : ¬i < size self
⊢ (if h : i < Array.size (findAux self x).s then (Array.get (findAux self x).s { val := i, isLt := h }).rank else 0) =
if h : i < Array.size self.arr then (Array.get self.arr { val := i, isLt := h }).rank else 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬i < size self
⊢ (if h : i < Array.size (findAux self x).s then (Array.get (findAux self x).s { val := i, isLt := h }).rank else 0) =
if h : i < Array.size self.arr then (Array.get self.arr { val := i, isLt := h }).rank else 0
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.rankD_findAux | [210, 1] | [220, 42] | rwa [FindAux.size_eq] | i : Nat
self : UnionFind
x : Fin (size self)
h : ¬i < size self
⊢ ¬i < Array.size (findAux self x).s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬i < size self
⊢ ¬i < Array.size (findAux self x).s
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | rw [findAux_s] | i : Nat
self : UnionFind
x : Fin (size self)
⊢ parentD (findAux self x).s i =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | i : Nat
self : UnionFind
x : Fin (size self)
⊢ parentD
(if (Array.get self.arr x).parent = ↑x then self.arr
else
Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
⊢ parentD (findAux self x).s i =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | split <;> [split; skip] | i : Nat
self : UnionFind
x : Fin (size self)
⊢ parentD
(if (Array.get self.arr x).parent = ↑x then self.arr
else
Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | case inl.inl
i : Nat
self : UnionFind
x : Fin (size self)
h✝¹ : (Array.get self.arr x).parent = ↑x
h✝ : i = ↑x
⊢ parentD self.arr i = root self ↑x
case inl.inr
i : Nat
self : UnionFind
x : Fin (size self)
h✝¹ : (Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
⊢ parentD self.arr i = parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i
case inr
i : Nat
self : UnionFind
x : Fin (size self)
h✝ : ¬(Array.get self.arr x).parent = ↑x
⊢ parentD
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
⊢ parentD
(if (Array.get self.arr x).parent = ↑x then self.arr
else
Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | subst i | case inl.inl
i : Nat
self : UnionFind
x : Fin (size self)
h✝¹ : (Array.get self.arr x).parent = ↑x
h✝ : i = ↑x
⊢ parentD self.arr i = root self ↑x | case inl.inl
self : UnionFind
x : Fin (size self)
h✝ : (Array.get self.arr x).parent = ↑x
⊢ parentD self.arr ↑x = root self ↑x | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inl
i : Nat
self : UnionFind
x : Fin (size self)
h✝¹ : (Array.get self.arr x).parent = ↑x
h✝ : i = ↑x
⊢ parentD self.arr i = root self ↑x
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | rw [root_eq_self.2 _] <;> simp [parentD_eq, *] | case inl.inl
self : UnionFind
x : Fin (size self)
h✝ : (Array.get self.arr x).parent = ↑x
⊢ parentD self.arr ↑x = root self ↑x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inl
self : UnionFind
x : Fin (size self)
h✝ : (Array.get self.arr x).parent = ↑x
⊢ parentD self.arr ↑x = root self ↑x
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | rw [findAux_s] | case inl.inr
i : Nat
self : UnionFind
x : Fin (size self)
h✝¹ : (Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
⊢ parentD self.arr i = parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | case inl.inr
i : Nat
self : UnionFind
x : Fin (size self)
h✝¹ : (Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
⊢ parentD self.arr i =
parentD
(if
(Array.get self.arr { val := (Array.get self.arr x).parent, isLt := ⋯ }).parent =
↑{ val := (Array.get self.arr x).parent, isLt := ⋯ } then
self.arr
else
Array.modify
(findAux self
{ val := (Array.get self.arr { val := (Array.get self.arr x).parent, isLt := ⋯ }).parent, isLt := ⋯ }).s
↑{ val := (Array.get self.arr x).parent, isLt := ⋯ } fun s =>
{ parent := root self ↑{ val := (Array.get self.arr x).parent, isLt := ⋯ }, rank := s.rank })
i | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr
i : Nat
self : UnionFind
x : Fin (size self)
h✝¹ : (Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
⊢ parentD self.arr i = parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | simp [*] | case inl.inr
i : Nat
self : UnionFind
x : Fin (size self)
h✝¹ : (Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
⊢ parentD self.arr i =
parentD
(if
(Array.get self.arr { val := (Array.get self.arr x).parent, isLt := ⋯ }).parent =
↑{ val := (Array.get self.arr x).parent, isLt := ⋯ } then
self.arr
else
Array.modify
(findAux self
{ val := (Array.get self.arr { val := (Array.get self.arr x).parent, isLt := ⋯ }).parent, isLt := ⋯ }).s
↑{ val := (Array.get self.arr x).parent, isLt := ⋯ } fun s =>
{ parent := root self ↑{ val := (Array.get self.arr x).parent, isLt := ⋯ }, rank := s.rank })
i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr
i : Nat
self : UnionFind
x : Fin (size self)
h✝¹ : (Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
⊢ parentD self.arr i =
parentD
(if
(Array.get self.arr { val := (Array.get self.arr x).parent, isLt := ⋯ }).parent =
↑{ val := (Array.get self.arr x).parent, isLt := ⋯ } then
self.arr
else
Array.modify
(findAux self
{ val := (Array.get self.arr { val := (Array.get self.arr x).parent, isLt := ⋯ }).parent, isLt := ⋯ }).s
↑{ val := (Array.get self.arr x).parent, isLt := ⋯ } fun s =>
{ parent := root self ↑{ val := (Array.get self.arr x).parent, isLt := ⋯ }, rank := s.rank })
i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | rw [parentD] | i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
⊢ parentD
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
⊢ (if h :
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank }) then
(Array.get
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
{ val := i, isLt := h }).parent
else i) =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
⊢ parentD
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
i =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | split <;> rename_i h' | i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
⊢ (if h :
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank }) then
(Array.get
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
{ val := i, isLt := h }).parent
else i) =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | case inl
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ (Array.get
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
{ val := i, isLt := h' }).parent =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i
case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
¬i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ i = if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
⊢ (if h :
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank }) then
(Array.get
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
{ val := i, isLt := h }).parent
else i) =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | rw [Array.get_modify (by simpa using h')] | case inl
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ (Array.get
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
{ val := i, isLt := h' }).parent =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | case inl
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ (if ↑x = i then
{ parent := root self ↑x,
rank :=
(Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
{ val := i, isLt := ⋯ }).rank }
else
Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s { val := i, isLt := ⋯ }).parent =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ (Array.get
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
{ val := i, isLt := h' }).parent =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | simp [@eq_comm _ i] | case inl
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ (if ↑x = i then
{ parent := root self ↑x,
rank :=
(Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
{ val := i, isLt := ⋯ }).rank }
else
Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s { val := i, isLt := ⋯ }).parent =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | case inl
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ (if ↑x = i then
{ parent := root self ↑x,
rank :=
(Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
{ val := i, isLt := ⋯ }).rank }
else
Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s { val := i, isLt := ⋯ }).parent =
if ↑x = i then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ (if ↑x = i then
{ parent := root self ↑x,
rank :=
(Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
{ val := i, isLt := ⋯ }).rank }
else
Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s { val := i, isLt := ⋯ }).parent =
if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | split <;> simp [← parentD_eq] | case inl
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ (if ↑x = i then
{ parent := root self ↑x,
rank :=
(Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
{ val := i, isLt := ⋯ }).rank }
else
Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s { val := i, isLt := ⋯ }).parent =
if ↑x = i then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ (if ↑x = i then
{ parent := root self ↑x,
rank :=
(Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
{ val := i, isLt := ⋯ }).rank }
else
Array.get (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s { val := i, isLt := ⋯ }).parent =
if ↑x = i then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | simpa using h' | i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ i < Array.size (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ i < Array.size (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | rw [if_neg (mt (by rintro rfl; simp [FindAux.size_eq]) h')] | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
¬i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ i = if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
¬i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ i = parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
¬i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ i = if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | rw [parentD, dif_neg] | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
¬i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ i = parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i | case inr.hnc
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
¬i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ ¬i < Array.size (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
¬i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ i = parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | simpa using h' | case inr.hnc
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
¬i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ ¬i < Array.size (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.hnc
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
¬i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ ¬i < Array.size (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | rintro rfl | i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
¬i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ i = ↑x →
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank }) | self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
¬↑x <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ ↑x <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank }) | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
¬i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ i = ↑x →
i <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux | [222, 1] | [233, 44] | simp [FindAux.size_eq] | self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
¬↑x <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ ↑x <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
h' :
¬↑x <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
⊢ ↑x <
Array.size
(Array.modify (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s ↑x fun s =>
{ parent := root self ↑x, rank := s.rank })
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_root | [235, 1] | [242, 42] | rw [parentD_findAux] | self : UnionFind
x : Fin (size self)
⊢ parentD (findAux self x).s (root self ↑x) = root self ↑x | self : UnionFind
x : Fin (size self)
⊢ (if root self ↑x = ↑x then root self ↑x
else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s (root self ↑x)) =
root self ↑x | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
⊢ parentD (findAux self x).s (root self ↑x) = root self ↑x
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_root | [235, 1] | [242, 42] | split <;> [rfl; rename_i h] | self : UnionFind
x : Fin (size self)
⊢ (if root self ↑x = ↑x then root self ↑x
else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s (root self ↑x)) =
root self ↑x | case inr
self : UnionFind
x : Fin (size self)
h : ¬root self ↑x = ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s (root self ↑x) = root self ↑x | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
⊢ (if root self ↑x = ↑x then root self ↑x
else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s (root self ↑x)) =
root self ↑x
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_root | [235, 1] | [242, 42] | rw [root_eq_self, parent, parentD_eq] at h | case inr
self : UnionFind
x : Fin (size self)
h : ¬root self ↑x = ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s (root self ↑x) = root self ↑x | case inr
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s (root self ↑x) = root self ↑x | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
self : UnionFind
x : Fin (size self)
h : ¬root self ↑x = ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s (root self ↑x) = root self ↑x
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_root | [235, 1] | [242, 42] | have := Nat.sub_lt_sub_left (self.lt_rankMax x) (self.rank'_lt _ ‹_›) | case inr
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s (root self ↑x) = root self ↑x | case inr
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s (root self ↑x) = root self ↑x | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s (root self ↑x) = root self ↑x
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_root | [235, 1] | [242, 42] | rw [← root_parent, parent, parentD_eq] | case inr
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s (root self ↑x) = root self ↑x | case inr
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
(root self (Array.get self.arr x).parent) =
root self (Array.get self.arr x).parent | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s (root self ↑x) = root self ↑x
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_root | [235, 1] | [242, 42] | exact parentD_findAux_root (x := ⟨_, self.parent'_lt x⟩) | case inr
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
(root self (Array.get self.arr x).parent) =
root self (Array.get self.arr x).parent | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
self : UnionFind
x : Fin (size self)
h : ¬(Array.get self.arr x).parent = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s
(root self (Array.get self.arr x).parent) =
root self (Array.get self.arr x).parent
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_lt | [244, 1] | [252, 42] | if h' : (self.arr.get x).parent = x then
rw [findAux_s, if_pos h']; apply self.parentD_lt h
else
rw [parentD_findAux]; split <;> [simp [root_lt]; skip]
have := Nat.sub_lt_sub_left (self.lt_rankMax x) (self.rank'_lt _ ‹_›)
apply parentD_findAux_lt h | i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
⊢ parentD (findAux self x).s i < size self | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
⊢ parentD (findAux self x).s i < size self
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_lt | [244, 1] | [252, 42] | rw [findAux_s, if_pos h'] | i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self x).s i < size self | i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD self.arr i < size self | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self x).s i < size self
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_lt | [244, 1] | [252, 42] | apply self.parentD_lt h | i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD self.arr i < size self | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD self.arr i < size self
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_lt | [244, 1] | [252, 42] | rw [parentD_findAux] | i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self x).s i < size self | i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ (if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) <
size self | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self x).s i < size self
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_lt | [244, 1] | [252, 42] | split <;> [simp [root_lt]; skip] | i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ (if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) <
size self | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : ¬(Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i < size self | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ (if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) <
size self
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_lt | [244, 1] | [252, 42] | have := Nat.sub_lt_sub_left (self.lt_rankMax x) (self.rank'_lt _ ‹_›) | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : ¬(Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i < size self | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : ¬(Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i < size self | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : ¬(Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i < size self
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_lt | [244, 1] | [252, 42] | apply parentD_findAux_lt h | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : ¬(Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i < size self | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
i : Nat
self : UnionFind
x : Fin (size self)
h : i < size self
h' : ¬(Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i < size self
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_or | [254, 1] | [264, 42] | if h' : (self.arr.get x).parent = x then
rw [findAux_s, if_pos h']; exact .inr rfl
else
rw [parentD_findAux]; split <;> [simp [*]; skip]
have := Nat.sub_lt_sub_left (self.lt_rankMax x) (self.rank'_lt _ ‹_›)
exact (parentD_findAux_or self ⟨_, self.parent'_lt x⟩ i).imp_left <| .imp_right fun h => by
simp [h, ← parentD_eq, root_parent] | self : UnionFind
x : Fin (size self)
i : Nat
⊢ parentD (findAux self x).s i = root self i ∧ root self i = root self ↑x ∨ parentD (findAux self x).s i = parent self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
i : Nat
⊢ parentD (findAux self x).s i = root self i ∧ root self i = root self ↑x ∨ parentD (findAux self x).s i = parent self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_or | [254, 1] | [264, 42] | rw [findAux_s, if_pos h'] | self : UnionFind
x : Fin (size self)
i : Nat
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self x).s i = root self i ∧ root self i = root self ↑x ∨ parentD (findAux self x).s i = parent self i | self : UnionFind
x : Fin (size self)
i : Nat
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD self.arr i = root self i ∧ root self i = root self ↑x ∨ parentD self.arr i = parent self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
i : Nat
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self x).s i = root self i ∧ root self i = root self ↑x ∨ parentD (findAux self x).s i = parent self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_or | [254, 1] | [264, 42] | exact .inr rfl | self : UnionFind
x : Fin (size self)
i : Nat
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD self.arr i = root self i ∧ root self i = root self ↑x ∨ parentD self.arr i = parent self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
i : Nat
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD self.arr i = root self i ∧ root self i = root self ↑x ∨ parentD self.arr i = parent self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_or | [254, 1] | [264, 42] | rw [parentD_findAux] | self : UnionFind
x : Fin (size self)
i : Nat
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self x).s i = root self i ∧ root self i = root self ↑x ∨ parentD (findAux self x).s i = parent self i | self : UnionFind
x : Fin (size self)
i : Nat
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ (if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) =
root self i ∧
root self i = root self ↑x ∨
(if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) =
parent self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
i : Nat
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self x).s i = root self i ∧ root self i = root self ↑x ∨ parentD (findAux self x).s i = parent self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_or | [254, 1] | [264, 42] | split <;> [simp [*]; skip] | self : UnionFind
x : Fin (size self)
i : Nat
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ (if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) =
root self i ∧
root self i = root self ↑x ∨
(if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) =
parent self i | case inr
self : UnionFind
x : Fin (size self)
i : Nat
h' : ¬(Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i = root self i ∧
root self i = root self ↑x ∨
parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i = parent self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
i : Nat
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ (if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) =
root self i ∧
root self i = root self ↑x ∨
(if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) =
parent self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_or | [254, 1] | [264, 42] | have := Nat.sub_lt_sub_left (self.lt_rankMax x) (self.rank'_lt _ ‹_›) | case inr
self : UnionFind
x : Fin (size self)
i : Nat
h' : ¬(Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i = root self i ∧
root self i = root self ↑x ∨
parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i = parent self i | case inr
self : UnionFind
x : Fin (size self)
i : Nat
h' : ¬(Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i = root self i ∧
root self i = root self ↑x ∨
parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i = parent self i | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
self : UnionFind
x : Fin (size self)
i : Nat
h' : ¬(Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i = root self i ∧
root self i = root self ↑x ∨
parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i = parent self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_or | [254, 1] | [264, 42] | exact (parentD_findAux_or self ⟨_, self.parent'_lt x⟩ i).imp_left <| .imp_right fun h => by
simp [h, ← parentD_eq, root_parent] | case inr
self : UnionFind
x : Fin (size self)
i : Nat
h' : ¬(Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i = root self i ∧
root self i = root self ↑x ∨
parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i = parent self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
self : UnionFind
x : Fin (size self)
i : Nat
h' : ¬(Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i = root self i ∧
root self i = root self ↑x ∨
parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i = parent self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.parentD_findAux_or | [254, 1] | [264, 42] | simp [h, ← parentD_eq, root_parent] | self : UnionFind
x : Fin (size self)
i : Nat
h' : ¬(Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
h : root self i = root self ↑{ val := (Array.get self.arr x).parent, isLt := ⋯ }
⊢ root self i = root self ↑x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
i : Nat
h' : ¬(Array.get self.arr x).parent = ↑x
h✝ : ¬i = ↑x
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
h : root self i = root self ↑{ val := (Array.get self.arr x).parent, isLt := ⋯ }
⊢ root self i = root self ↑x
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.lt_rankD_findAux | [266, 1] | [276, 42] | rw [findAux_s, if_pos h'] | i : Nat
self : UnionFind
x : Fin (size self)
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self x).s i ≠ i → rank self i < rank self (parentD (findAux self x).s i) | i : Nat
self : UnionFind
x : Fin (size self)
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD self.arr i ≠ i → rank self i < rank self (parentD self.arr i) | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self x).s i ≠ i → rank self i < rank self (parentD (findAux self x).s i)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.lt_rankD_findAux | [266, 1] | [276, 42] | apply self.rank_lt | i : Nat
self : UnionFind
x : Fin (size self)
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD self.arr i ≠ i → rank self i < rank self (parentD self.arr i) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h' : (Array.get self.arr x).parent = ↑x
⊢ parentD self.arr i ≠ i → rank self i < rank self (parentD self.arr i)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.lt_rankD_findAux | [266, 1] | [276, 42] | rw [parentD_findAux] | i : Nat
self : UnionFind
x : Fin (size self)
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self x).s i ≠ i → rank self i < rank self (parentD (findAux self x).s i) | i : Nat
self : UnionFind
x : Fin (size self)
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ (if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) ≠
i →
rank self i <
rank self
(if i = ↑x then root self ↑x
else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ parentD (findAux self x).s i ≠ i → rank self i < rank self (parentD (findAux self x).s i)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.lt_rankD_findAux | [266, 1] | [276, 42] | split <;> rename_i h <;> intro h' | i : Nat
self : UnionFind
x : Fin (size self)
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ (if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) ≠
i →
rank self i <
rank self
(if i = ↑x then root self ↑x
else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) | case inl
i : Nat
self : UnionFind
x : Fin (size self)
h'✝ : ¬(Array.get self.arr x).parent = ↑x
h : i = ↑x
h' : root self ↑x ≠ i
⊢ rank self i < rank self (root self ↑x)
case inr
i : Nat
self : UnionFind
x : Fin (size self)
h'✝ : ¬(Array.get self.arr x).parent = ↑x
h : ¬i = ↑x
h' : parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i ≠ i
⊢ rank self i < rank self (parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) | Please generate a tactic in lean4 to solve the state.
STATE:
i : Nat
self : UnionFind
x : Fin (size self)
h' : ¬(Array.get self.arr x).parent = ↑x
⊢ (if i = ↑x then root self ↑x else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) ≠
i →
rank self i <
rank self
(if i = ↑x then root self ↑x
else parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.lt_rankD_findAux | [266, 1] | [276, 42] | subst i | case inl
i : Nat
self : UnionFind
x : Fin (size self)
h'✝ : ¬(Array.get self.arr x).parent = ↑x
h : i = ↑x
h' : root self ↑x ≠ i
⊢ rank self i < rank self (root self ↑x) | case inl
self : UnionFind
x : Fin (size self)
h'✝ : ¬(Array.get self.arr x).parent = ↑x
h' : root self ↑x ≠ ↑x
⊢ rank self ↑x < rank self (root self ↑x) | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
i : Nat
self : UnionFind
x : Fin (size self)
h'✝ : ¬(Array.get self.arr x).parent = ↑x
h : i = ↑x
h' : root self ↑x ≠ i
⊢ rank self i < rank self (root self ↑x)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.lt_rankD_findAux | [266, 1] | [276, 42] | rwa [lt_rank_root, Ne, ← root_eq_self] | case inl
self : UnionFind
x : Fin (size self)
h'✝ : ¬(Array.get self.arr x).parent = ↑x
h' : root self ↑x ≠ ↑x
⊢ rank self ↑x < rank self (root self ↑x) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
self : UnionFind
x : Fin (size self)
h'✝ : ¬(Array.get self.arr x).parent = ↑x
h' : root self ↑x ≠ ↑x
⊢ rank self ↑x < rank self (root self ↑x)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.lt_rankD_findAux | [266, 1] | [276, 42] | have := Nat.sub_lt_sub_left (self.lt_rankMax x) (self.rank'_lt _ ‹_›) | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h'✝ : ¬(Array.get self.arr x).parent = ↑x
h : ¬i = ↑x
h' : parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i ≠ i
⊢ rank self i < rank self (parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h'✝ : ¬(Array.get self.arr x).parent = ↑x
h : ¬i = ↑x
h' : parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i ≠ i
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ rank self i < rank self (parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
i : Nat
self : UnionFind
x : Fin (size self)
h'✝ : ¬(Array.get self.arr x).parent = ↑x
h : ¬i = ↑x
h' : parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i ≠ i
⊢ rank self i < rank self (parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.lt_rankD_findAux | [266, 1] | [276, 42] | apply lt_rankD_findAux h' | case inr
i : Nat
self : UnionFind
x : Fin (size self)
h'✝ : ¬(Array.get self.arr x).parent = ↑x
h : ¬i = ↑x
h' : parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i ≠ i
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ rank self i < rank self (parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
i : Nat
self : UnionFind
x : Fin (size self)
h'✝ : ¬(Array.get self.arr x).parent = ↑x
h : ¬i = ↑x
h' : parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i ≠ i
this : rankMax self - rank self (Array.get self.arr x).parent < rankMax self - rank self ↑x
⊢ rank self i < rank self (parentD (findAux self { val := (Array.get self.arr x).parent, isLt := ⋯ }).s i)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.find_size | [288, 9] | [289, 78] | simp [find, size, FindAux.size_eq] | self : UnionFind
x : Fin (size self)
⊢ size (find self x).fst = size self | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
⊢ size (find self x).fst = size self
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.find_root_2 | [291, 9] | [292, 76] | simp [find, findAux_root, root] | self : UnionFind
x : Fin (size self)
⊢ ↑(find self x).snd.val = root self ↑x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
⊢ ↑(find self x).snd.val = root self ↑x
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.find_parent_1 | [294, 9] | [296, 56] | simp [find, parent] | self : UnionFind
x : Fin (size self)
⊢ parent (find self x).fst ↑x = root self ↑x | self : UnionFind
x : Fin (size self)
⊢ parentD (findAux self x).s ↑x = root self ↑x | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
⊢ parent (find self x).fst ↑x = root self ↑x
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.find_parent_1 | [294, 9] | [296, 56] | rw [parentD_findAux, if_pos rfl] | self : UnionFind
x : Fin (size self)
⊢ parentD (findAux self x).s ↑x = root self ↑x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
⊢ parentD (findAux self x).s ↑x = root self ↑x
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.find_root_1 | [302, 9] | [316, 25] | rw [root_eq_self.2 h] | self : UnionFind
x : Fin (size self)
i : Nat
h : parent (find self x).fst i = i
⊢ root (find self x).fst i = root self i | self : UnionFind
x : Fin (size self)
i : Nat
h : parent (find self x).fst i = i
⊢ i = root self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
i : Nat
h : parent (find self x).fst i = i
⊢ root (find self x).fst i = root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.find_root_1 | [302, 9] | [316, 25] | obtain ⟨h1, _⟩ | h1 := find_parent_or self x i <;> rw [h1] at h | self : UnionFind
x : Fin (size self)
i : Nat
h : parent (find self x).fst i = i
⊢ i = root self i | case inl.intro
self : UnionFind
x : Fin (size self)
i : Nat
h : root self i = i
h1 : parent (find self x).fst i = root self i
right✝ : root self i = root self ↑x
⊢ i = root self i
case inr
self : UnionFind
x : Fin (size self)
i : Nat
h : parent self i = i
h1 : parent (find self x).fst i = parent self i
⊢ i = root self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
i : Nat
h : parent (find self x).fst i = i
⊢ i = root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.find_root_1 | [302, 9] | [316, 25] | rw [h] | case inl.intro
self : UnionFind
x : Fin (size self)
i : Nat
h : root self i = i
h1 : parent (find self x).fst i = root self i
right✝ : root self i = root self ↑x
⊢ i = root self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.intro
self : UnionFind
x : Fin (size self)
i : Nat
h : root self i = i
h1 : parent (find self x).fst i = root self i
right✝ : root self i = root self ↑x
⊢ i = root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.find_root_1 | [302, 9] | [316, 25] | rw [root_eq_self.2 h] | case inr
self : UnionFind
x : Fin (size self)
i : Nat
h : parent self i = i
h1 : parent (find self x).fst i = parent self i
⊢ i = root self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
self : UnionFind
x : Fin (size self)
i : Nat
h : parent self i = i
h1 : parent (find self x).fst i = parent self i
⊢ i = root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.find_root_1 | [302, 9] | [316, 25] | have := Nat.sub_lt_sub_left ((self.find x).1.lt_rankMax _) ((self.find x).1.rank_lt h) | self : UnionFind
x : Fin (size self)
i : Nat
h : ¬parent (find self x).fst i = i
⊢ root (find self x).fst i = root self i | self : UnionFind
x : Fin (size self)
i : Nat
h : ¬parent (find self x).fst i = i
this :
rankMax (find self x).fst - rank (find self x).fst (parent (find self x).fst i) <
rankMax (find self x).fst - rank (find self x).fst i
⊢ root (find self x).fst i = root self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
i : Nat
h : ¬parent (find self x).fst i = i
⊢ root (find self x).fst i = root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.find_root_1 | [302, 9] | [316, 25] | rw [← root_parent, find_root_1 self x ((self.find x).1.parent i)] | self : UnionFind
x : Fin (size self)
i : Nat
h : ¬parent (find self x).fst i = i
this :
rankMax (find self x).fst - rank (find self x).fst (parent (find self x).fst i) <
rankMax (find self x).fst - rank (find self x).fst i
⊢ root (find self x).fst i = root self i | self : UnionFind
x : Fin (size self)
i : Nat
h : ¬parent (find self x).fst i = i
this :
rankMax (find self x).fst - rank (find self x).fst (parent (find self x).fst i) <
rankMax (find self x).fst - rank (find self x).fst i
⊢ root self (parent (find self x).fst i) = root self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
i : Nat
h : ¬parent (find self x).fst i = i
this :
rankMax (find self x).fst - rank (find self x).fst (parent (find self x).fst i) <
rankMax (find self x).fst - rank (find self x).fst i
⊢ root (find self x).fst i = root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.find_root_1 | [302, 9] | [316, 25] | obtain ⟨h1, _⟩ | h1 := find_parent_or self x i | self : UnionFind
x : Fin (size self)
i : Nat
h : ¬parent (find self x).fst i = i
this :
rankMax (find self x).fst - rank (find self x).fst (parent (find self x).fst i) <
rankMax (find self x).fst - rank (find self x).fst i
⊢ root self (parent (find self x).fst i) = root self i | case inl.intro
self : UnionFind
x : Fin (size self)
i : Nat
h : ¬parent (find self x).fst i = i
this :
rankMax (find self x).fst - rank (find self x).fst (parent (find self x).fst i) <
rankMax (find self x).fst - rank (find self x).fst i
h1 : parent (find self x).fst i = root self i
right✝ : root self i = root self ↑x
⊢ root self (parent (find self x).fst i) = root self i
case inr
self : UnionFind
x : Fin (size self)
i : Nat
h : ¬parent (find self x).fst i = i
this :
rankMax (find self x).fst - rank (find self x).fst (parent (find self x).fst i) <
rankMax (find self x).fst - rank (find self x).fst i
h1 : parent (find self x).fst i = parent self i
⊢ root self (parent (find self x).fst i) = root self i | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
i : Nat
h : ¬parent (find self x).fst i = i
this :
rankMax (find self x).fst - rank (find self x).fst (parent (find self x).fst i) <
rankMax (find self x).fst - rank (find self x).fst i
⊢ root self (parent (find self x).fst i) = root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.find_root_1 | [302, 9] | [316, 25] | rw [h1, root_root] | case inl.intro
self : UnionFind
x : Fin (size self)
i : Nat
h : ¬parent (find self x).fst i = i
this :
rankMax (find self x).fst - rank (find self x).fst (parent (find self x).fst i) <
rankMax (find self x).fst - rank (find self x).fst i
h1 : parent (find self x).fst i = root self i
right✝ : root self i = root self ↑x
⊢ root self (parent (find self x).fst i) = root self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.intro
self : UnionFind
x : Fin (size self)
i : Nat
h : ¬parent (find self x).fst i = i
this :
rankMax (find self x).fst - rank (find self x).fst (parent (find self x).fst i) <
rankMax (find self x).fst - rank (find self x).fst i
h1 : parent (find self x).fst i = root self i
right✝ : root self i = root self ↑x
⊢ root self (parent (find self x).fst i) = root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.find_root_1 | [302, 9] | [316, 25] | rw [h1, root_parent] | case inr
self : UnionFind
x : Fin (size self)
i : Nat
h : ¬parent (find self x).fst i = i
this :
rankMax (find self x).fst - rank (find self x).fst (parent (find self x).fst i) <
rankMax (find self x).fst - rank (find self x).fst i
h1 : parent (find self x).fst i = parent self i
⊢ root self (parent (find self x).fst i) = root self i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
self : UnionFind
x : Fin (size self)
i : Nat
h : ¬parent (find self x).fst i = i
this :
rankMax (find self x).fst - rank (find self x).fst (parent (find self x).fst i) <
rankMax (find self x).fst - rank (find self x).fst i
h1 : parent (find self x).fst i = parent self i
⊢ root self (parent (find self x).fst i) = root self i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.find_root_1 | [302, 9] | [316, 25] | exact this | self : UnionFind
x : Fin (size self)
i : Nat
a✝ :
∀ (y : Nat),
(invImage (fun a => rankMax (find self x).fst - rank (find self x).fst a) instWellFoundedRelation).1 y i →
root (find self x).fst y = root self y
h : ¬parent (find self x).fst i = i
this :
rankMax (find self x).fst - rank (find self x).fst (parent (find self x).fst i) <
rankMax (find self x).fst - rank (find self x).fst i
⊢ (invImage (fun a => rankMax (find self x).fst - rank (find self x).fst a) instWellFoundedRelation).1
(parent (find self x).fst i) i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : UnionFind
x : Fin (size self)
i : Nat
a✝ :
∀ (y : Nat),
(invImage (fun a => rankMax (find self x).fst - rank (find self x).fst a) instWellFoundedRelation).1 y i →
root (find self x).fst y = root self y
h : ¬parent (find self x).fst i = i
this :
rankMax (find self x).fst - rank (find self x).fst (parent (find self x).fst i) <
rankMax (find self x).fst - rank (find self x).fst i
⊢ (invImage (fun a => rankMax (find self x).fst - rank (find self x).fst a) instWellFoundedRelation).1
(parent (find self x).fst i) i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | simp [hP, hR] at * | arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : parentD arr i ≠ i → rankD arr i < rankD arr (parentD arr i)
hP : parentD arr' i = if ↑x = i then ↑y else parentD arr i
hR :
∀ {i : Nat},
rankD arr' i =
if ↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else rankD arr i
⊢ ¬parentD arr' i = i → rankD arr' i < rankD arr' (parentD arr' i) | arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
⊢ ¬(if ↑x = i then ↑y else parentD arr i) = i →
(if ↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else rankD arr i) <
if (↑y = if ↑x = i then ↑y else parentD arr i) ∧ (Array.get arr x).rank = (Array.get arr y).rank then
(Array.get arr y).rank + 1
else rankD arr (if ↑x = i then ↑y else parentD arr i) | Please generate a tactic in lean4 to solve the state.
STATE:
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : parentD arr i ≠ i → rankD arr i < rankD arr (parentD arr i)
hP : parentD arr' i = if ↑x = i then ↑y else parentD arr i
hR :
∀ {i : Nat},
rankD arr' i =
if ↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else rankD arr i
⊢ ¬parentD arr' i = i → rankD arr' i < rankD arr' (parentD arr' i)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | split <;> rename_i h₁ <;> [simp [← h₁]; skip] <;>
split <;> rename_i h₂ <;> intro h | arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
⊢ ¬(if ↑x = i then ↑y else parentD arr i) = i →
(if ↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else rankD arr i) <
if (↑y = if ↑x = i then ↑y else parentD arr i) ∧ (Array.get arr x).rank = (Array.get arr y).rank then
(Array.get arr y).rank + 1
else rankD arr (if ↑x = i then ↑y else parentD arr i) | case inl.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank
h : ¬↑y = ↑x
⊢ (Array.get arr y).rank + 1 <
if (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else rankD arr ↑y
case inl.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
⊢ rankD arr ↑x < if (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else rankD arr ↑y
case inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank
h : ¬parentD arr i = i
⊢ (Array.get arr y).rank + 1 <
if ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr i)
case inr.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
⊢ rankD arr i <
if ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr i) | Please generate a tactic in lean4 to solve the state.
STATE:
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
⊢ ¬(if ↑x = i then ↑y else parentD arr i) = i →
(if ↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else rankD arr i) <
if (↑y = if ↑x = i then ↑y else parentD arr i) ∧ (Array.get arr x).rank = (Array.get arr y).rank then
(Array.get arr y).rank + 1
else rankD arr (if ↑x = i then ↑y else parentD arr i)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | simp [h₂] at h | case inl.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank
h : ¬↑y = ↑x
⊢ (Array.get arr y).rank + 1 <
if (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else rankD arr ↑y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank
h : ¬↑y = ↑x
⊢ (Array.get arr y).rank + 1 <
if (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else rankD arr ↑y
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | simp [rankD_eq] | case inl.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
⊢ rankD arr ↑x < if (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else rankD arr ↑y | case inl.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
⊢ (Array.get arr x).rank <
if (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else (Array.get arr y).rank | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
⊢ rankD arr ↑x < if (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else rankD arr ↑y
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | split <;> rename_i h₃ | case inl.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
⊢ (Array.get arr x).rank <
if (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else (Array.get arr y).rank | case inl.inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
h₃ : (Array.get arr x).rank = (Array.get arr y).rank
⊢ (Array.get arr x).rank < (Array.get arr y).rank + 1
case inl.inr.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
h₃ : ¬(Array.get arr x).rank = (Array.get arr y).rank
⊢ (Array.get arr x).rank < (Array.get arr y).rank | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
⊢ (Array.get arr x).rank <
if (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else (Array.get arr y).rank
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | rw [← h₃] | case inl.inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
h₃ : (Array.get arr x).rank = (Array.get arr y).rank
⊢ (Array.get arr x).rank < (Array.get arr y).rank + 1 | case inl.inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
h₃ : (Array.get arr x).rank = (Array.get arr y).rank
⊢ (Array.get arr x).rank < (Array.get arr x).rank + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
h₃ : (Array.get arr x).rank = (Array.get arr y).rank
⊢ (Array.get arr x).rank < (Array.get arr y).rank + 1
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | apply Nat.lt_succ_self | case inl.inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
h₃ : (Array.get arr x).rank = (Array.get arr y).rank
⊢ (Array.get arr x).rank < (Array.get arr x).rank + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
h₃ : (Array.get arr x).rank = (Array.get arr y).rank
⊢ (Array.get arr x).rank < (Array.get arr x).rank + 1
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | exact Nat.lt_of_le_of_ne H h₃ | case inl.inr.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
h₃ : ¬(Array.get arr x).rank = (Array.get arr y).rank
⊢ (Array.get arr x).rank < (Array.get arr y).rank | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl.inr.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬↑y = ↑x
h₃ : ¬(Array.get arr x).rank = (Array.get arr y).rank
⊢ (Array.get arr x).rank < (Array.get arr y).rank
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | cases h₂.1 | case inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank
h : ¬parentD arr i = i
⊢ (Array.get arr y).rank + 1 <
if ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr i) | case inr.inl.refl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
hP hR : True
rankD_lt : ¬parentD arr ↑y = ↑y → rankD arr ↑y < rankD arr (parentD arr ↑y)
h₁ : ¬↑x = ↑y
h₂ : ↑y = ↑y ∧ (Array.get arr x).rank = (Array.get arr y).rank
h : ¬parentD arr ↑y = ↑y
⊢ (Array.get arr y).rank + 1 <
if ↑y = parentD arr ↑y ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr ↑y) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank
h : ¬parentD arr i = i
⊢ (Array.get arr y).rank + 1 <
if ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr i)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | simp [h₂.2] at hroot | case inr.inl.refl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
hP hR : True
rankD_lt : ¬parentD arr ↑y = ↑y → rankD arr ↑y < rankD arr (parentD arr ↑y)
h₁ : ¬↑x = ↑y
h₂ : ↑y = ↑y ∧ (Array.get arr x).rank = (Array.get arr y).rank
h : ¬parentD arr ↑y = ↑y
⊢ (Array.get arr y).rank + 1 <
if ↑y = parentD arr ↑y ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr ↑y) | case inr.inl.refl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
hP hR : True
rankD_lt : ¬parentD arr ↑y = ↑y → rankD arr ↑y < rankD arr (parentD arr ↑y)
h₁ : ¬↑x = ↑y
h₂ : ↑y = ↑y ∧ (Array.get arr x).rank = (Array.get arr y).rank
h : ¬parentD arr ↑y = ↑y
hroot : (Array.get arr y).parent = ↑y
⊢ (Array.get arr y).rank + 1 <
if ↑y = parentD arr ↑y ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr ↑y) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.refl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
hP hR : True
rankD_lt : ¬parentD arr ↑y = ↑y → rankD arr ↑y < rankD arr (parentD arr ↑y)
h₁ : ¬↑x = ↑y
h₂ : ↑y = ↑y ∧ (Array.get arr x).rank = (Array.get arr y).rank
h : ¬parentD arr ↑y = ↑y
⊢ (Array.get arr y).rank + 1 <
if ↑y = parentD arr ↑y ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr ↑y)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | simp [hroot, parentD_eq] at h | case inr.inl.refl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
hP hR : True
rankD_lt : ¬parentD arr ↑y = ↑y → rankD arr ↑y < rankD arr (parentD arr ↑y)
h₁ : ¬↑x = ↑y
h₂ : ↑y = ↑y ∧ (Array.get arr x).rank = (Array.get arr y).rank
h : ¬parentD arr ↑y = ↑y
hroot : (Array.get arr y).parent = ↑y
⊢ (Array.get arr y).rank + 1 <
if ↑y = parentD arr ↑y ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr ↑y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inl.refl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
hP hR : True
rankD_lt : ¬parentD arr ↑y = ↑y → rankD arr ↑y < rankD arr (parentD arr ↑y)
h₁ : ¬↑x = ↑y
h₂ : ↑y = ↑y ∧ (Array.get arr x).rank = (Array.get arr y).rank
h : ¬parentD arr ↑y = ↑y
hroot : (Array.get arr y).parent = ↑y
⊢ (Array.get arr y).rank + 1 <
if ↑y = parentD arr ↑y ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr ↑y)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | have := rankD_lt h | case inr.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
⊢ rankD arr i <
if ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr i) | case inr.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
⊢ rankD arr i <
if ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr i) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
⊢ rankD arr i <
if ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr i)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | split <;> rename_i h₃ | case inr.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
⊢ rankD arr i <
if ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr i) | case inr.inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank
⊢ rankD arr i < (Array.get arr y).rank + 1
case inr.inr.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ¬(↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
⊢ rankD arr i < rankD arr (parentD arr i) | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
⊢ rankD arr i <
if ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1
else rankD arr (parentD arr i)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | rw [← rankD_eq, h₃.1] | case inr.inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank
⊢ rankD arr i < (Array.get arr y).rank + 1 | case inr.inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank
⊢ rankD arr i < rankD arr (parentD arr i) + 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank
⊢ rankD arr i < (Array.get arr y).rank + 1
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | exact Nat.lt_succ_of_lt this | case inr.inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank
⊢ rankD arr i < rankD arr (parentD arr i) + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inl
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank
⊢ rankD arr i < rankD arr (parentD arr i) + 1
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParentBump_rankD_lt | [333, 1] | [354, 17] | exact this | case inr.inr.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ¬(↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
⊢ rankD arr i < rankD arr (parentD arr i) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.inr.inr
arr' arr : Array UFNode
x y : Fin (Array.size arr)
hroot : (Array.get arr x).rank < (Array.get arr y).rank ∨ (Array.get arr y).parent = ↑y
H : (Array.get arr x).rank ≤ (Array.get arr y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ¬(↑y = parentD arr i ∧ (Array.get arr x).rank = (Array.get arr y).rank)
⊢ rankD arr i < rankD arr (parentD arr i)
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.setParent_rankD_lt | [356, 1] | [362, 52] | simp [rankD_set, Nat.ne_of_lt h, rankD_eq] | arr : Array UFNode
x y : Fin (Array.size arr)
h : (Array.get arr x).rank < (Array.get arr y).rank
i : Nat
rankD_lt : parentD arr i ≠ i → rankD arr i < rankD arr (parentD arr i)
⊢ ∀ {i : Nat},
rankD (Array.set arr x { parent := ↑y, rank := (Array.get arr x).rank }) i =
if ↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else rankD arr i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
arr : Array UFNode
x y : Fin (Array.size arr)
h : (Array.get arr x).rank < (Array.get arr y).rank
i : Nat
rankD_lt : parentD arr i ≠ i → rankD arr i < rankD arr (parentD arr i)
⊢ ∀ {i : Nat},
rankD (Array.set arr x { parent := ↑y, rank := (Array.get arr x).rank }) i =
if ↑y = i ∧ (Array.get arr x).rank = (Array.get arr y).rank then (Array.get arr y).rank + 1 else rankD arr i
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.linkAux_size | [364, 9] | [365, 68] | simp [linkAux] | self : Array UFNode
x y : Fin (Array.size self)
⊢ Array.size (linkAux self x y) = Array.size self | self : Array UFNode
x y : Fin (Array.size self)
⊢ Array.size
(if ↑x = ↑y then self
else
if (Array.get self y).rank < (Array.get self x).rank then
Array.set self y { parent := ↑x, rank := (Array.get self y).rank }
else
if (Array.get self x).rank = (Array.get self y).rank then
Array.set (Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) { val := ↑y, isLt := ⋯ }
{ parent := (Array.get self y).parent, rank := (Array.get self y).rank + 1 }
else Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) =
Array.size self | Please generate a tactic in lean4 to solve the state.
STATE:
self : Array UFNode
x y : Fin (Array.size self)
⊢ Array.size (linkAux self x y) = Array.size self
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/UnionFind.lean | Lean4Lean.UnionFind.linkAux_size | [364, 9] | [365, 68] | split <;> [rfl; split] <;> [skip; split] <;> simp | self : Array UFNode
x y : Fin (Array.size self)
⊢ Array.size
(if ↑x = ↑y then self
else
if (Array.get self y).rank < (Array.get self x).rank then
Array.set self y { parent := ↑x, rank := (Array.get self y).rank }
else
if (Array.get self x).rank = (Array.get self y).rank then
Array.set (Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) { val := ↑y, isLt := ⋯ }
{ parent := (Array.get self y).parent, rank := (Array.get self y).rank + 1 }
else Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) =
Array.size self | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
self : Array UFNode
x y : Fin (Array.size self)
⊢ Array.size
(if ↑x = ↑y then self
else
if (Array.get self y).rank < (Array.get self x).rank then
Array.set self y { parent := ↑x, rank := (Array.get self y).rank }
else
if (Array.get self x).rank = (Array.get self y).rank then
Array.set (Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) { val := ↑y, isLt := ⋯ }
{ parent := (Array.get self y).parent, rank := (Array.get self y).rank + 1 }
else Array.set self x { parent := ↑y, rank := (Array.get self x).rank }) =
Array.size self
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.isDefEq_iff | [22, 1] | [27, 21] | refine ⟨fun h => ⟨h.hasType.1, h.hasType.2, _, h⟩, fun ⟨_, h2, _, h3⟩ => ?_⟩ | env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
⊢ IsDefEq env U Γ e₁ e₂ A ↔ HasType env U Γ e₁ A ∧ HasType env U Γ e₂ A ∧ IsDefEqU env U Γ e₁ e₂ | env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
x✝ : HasType env U Γ e₁ A ∧ HasType env U Γ e₂ A ∧ IsDefEqU env U Γ e₁ e₂
left✝ : HasType env U Γ e₁ A
h2 : HasType env U Γ e₂ A
w✝ : VExpr
h3 : IsDefEq env U Γ e₁ e₂ w✝
⊢ IsDefEq env U Γ e₁ e₂ A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
⊢ IsDefEq env U Γ e₁ e₂ A ↔ HasType env U Γ e₁ A ∧ HasType env U Γ e₂ A ∧ IsDefEqU env U Γ e₁ e₂
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.isDefEq_iff | [22, 1] | [27, 21] | have ⟨_, h⟩ := h3.uniq henv hΓ h2 | env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
x✝ : HasType env U Γ e₁ A ∧ HasType env U Γ e₂ A ∧ IsDefEqU env U Γ e₁ e₂
left✝ : HasType env U Γ e₁ A
h2 : HasType env U Γ e₂ A
w✝ : VExpr
h3 : IsDefEq env U Γ e₁ e₂ w✝
⊢ IsDefEq env U Γ e₁ e₂ A | env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
x✝ : HasType env U Γ e₁ A ∧ HasType env U Γ e₂ A ∧ IsDefEqU env U Γ e₁ e₂
left✝ : HasType env U Γ e₁ A
h2 : HasType env U Γ e₂ A
w✝¹ : VExpr
h3 : IsDefEq env U Γ e₁ e₂ w✝¹
w✝ : VLevel
h : IsDefEq env U Γ w✝¹ A (VExpr.sort w✝)
⊢ IsDefEq env U Γ e₁ e₂ A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
x✝ : HasType env U Γ e₁ A ∧ HasType env U Γ e₂ A ∧ IsDefEqU env U Γ e₁ e₂
left✝ : HasType env U Γ e₁ A
h2 : HasType env U Γ e₂ A
w✝ : VExpr
h3 : IsDefEq env U Γ e₁ e₂ w✝
⊢ IsDefEq env U Γ e₁ e₂ A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.isDefEq_iff | [22, 1] | [27, 21] | exact h.defeqDF h3 | env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
x✝ : HasType env U Γ e₁ A ∧ HasType env U Γ e₂ A ∧ IsDefEqU env U Γ e₁ e₂
left✝ : HasType env U Γ e₁ A
h2 : HasType env U Γ e₂ A
w✝¹ : VExpr
h3 : IsDefEq env U Γ e₁ e₂ w✝¹
w✝ : VLevel
h : IsDefEq env U Γ w✝¹ A (VExpr.sort w✝)
⊢ IsDefEq env U Γ e₁ e₂ A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
x✝ : HasType env U Γ e₁ A ∧ HasType env U Γ e₂ A ∧ IsDefEqU env U Γ e₁ e₂
left✝ : HasType env U Γ e₁ A
h2 : HasType env U Γ e₂ A
w✝¹ : VExpr
h3 : IsDefEq env U Γ e₁ e₂ w✝¹
w✝ : VLevel
h : IsDefEq env U Γ w✝¹ A (VExpr.sort w✝)
⊢ IsDefEq env U Γ e₁ e₂ A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.trans_r | [29, 1] | [33, 34] | have ⟨_, h⟩ := h₁.uniq henv hΓ h₂ | env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A e₃ B : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁ : IsDefEq env U Γ e₁ e₂ A
h₂ : IsDefEq env U Γ e₂ e₃ B
⊢ IsDefEq env U Γ e₁ e₃ B | env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A e₃ B : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁ : IsDefEq env U Γ e₁ e₂ A
h₂ : IsDefEq env U Γ e₂ e₃ B
w✝ : VLevel
h : IsDefEq env U Γ A B (VExpr.sort w✝)
⊢ IsDefEq env U Γ e₁ e₃ B | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A e₃ B : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁ : IsDefEq env U Γ e₁ e₂ A
h₂ : IsDefEq env U Γ e₂ e₃ B
⊢ IsDefEq env U Γ e₁ e₃ B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.trans_r | [29, 1] | [33, 34] | exact .trans (.defeqDF h h₁) h₂ | env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A e₃ B : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁ : IsDefEq env U Γ e₁ e₂ A
h₂ : IsDefEq env U Γ e₂ e₃ B
w✝ : VLevel
h : IsDefEq env U Γ A B (VExpr.sort w✝)
⊢ IsDefEq env U Γ e₁ e₃ B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A e₃ B : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁ : IsDefEq env U Γ e₁ e₂ A
h₂ : IsDefEq env U Γ e₂ e₃ B
w✝ : VLevel
h : IsDefEq env U Γ A B (VExpr.sort w✝)
⊢ IsDefEq env U Γ e₁ e₃ B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.trans_l | [35, 1] | [39, 41] | have ⟨_, h⟩ := h₁.uniq henv hΓ h₂ | env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A e₃ B : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁ : IsDefEq env U Γ e₁ e₂ A
h₂ : IsDefEq env U Γ e₂ e₃ B
⊢ IsDefEq env U Γ e₁ e₃ A | env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A e₃ B : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁ : IsDefEq env U Γ e₁ e₂ A
h₂ : IsDefEq env U Γ e₂ e₃ B
w✝ : VLevel
h : IsDefEq env U Γ A B (VExpr.sort w✝)
⊢ IsDefEq env U Γ e₁ e₃ A | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A e₃ B : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁ : IsDefEq env U Γ e₁ e₂ A
h₂ : IsDefEq env U Γ e₂ e₃ B
⊢ IsDefEq env U Γ e₁ e₃ A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEq.trans_l | [35, 1] | [39, 41] | exact h₁.trans (.defeqDF (.symm h) h₂) | env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A e₃ B : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁ : IsDefEq env U Γ e₁ e₂ A
h₂ : IsDefEq env U Γ e₂ e₃ B
w✝ : VLevel
h : IsDefEq env U Γ A B (VExpr.sort w✝)
⊢ IsDefEq env U Γ e₁ e₃ A | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ : List VExpr
U : Nat
e₁ e₂ A e₃ B : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁ : IsDefEq env U Γ e₁ e₂ A
h₂ : IsDefEq env U Γ e₂ e₃ B
w✝ : VLevel
h : IsDefEq env U Γ A B (VExpr.sort w✝)
⊢ IsDefEq env U Γ e₁ e₃ A
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEqU.defeqDF | [41, 1] | [46, 44] | have ⟨_, h₁⟩ := h₁ | env : VEnv
Γ : List VExpr
U : Nat
A B e₁ e₂ : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁ : IsDefEqU env U Γ A B
h₂ : IsDefEq env U Γ e₁ e₂ A
⊢ IsDefEq env U Γ e₁ e₂ B | env : VEnv
Γ : List VExpr
U : Nat
A B e₁ e₂ : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁✝ : IsDefEqU env U Γ A B
h₂ : IsDefEq env U Γ e₁ e₂ A
w✝ : VExpr
h₁ : IsDefEq env U Γ A B w✝
⊢ IsDefEq env U Γ e₁ e₂ B | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ : List VExpr
U : Nat
A B e₁ e₂ : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁ : IsDefEqU env U Γ A B
h₂ : IsDefEq env U Γ e₁ e₂ A
⊢ IsDefEq env U Γ e₁ e₂ B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEqU.defeqDF | [41, 1] | [46, 44] | have ⟨_, hA⟩ := h₂.isType henv hΓ | env : VEnv
Γ : List VExpr
U : Nat
A B e₁ e₂ : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁✝ : IsDefEqU env U Γ A B
h₂ : IsDefEq env U Γ e₁ e₂ A
w✝ : VExpr
h₁ : IsDefEq env U Γ A B w✝
⊢ IsDefEq env U Γ e₁ e₂ B | env : VEnv
Γ : List VExpr
U : Nat
A B e₁ e₂ : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁✝ : IsDefEqU env U Γ A B
h₂ : IsDefEq env U Γ e₁ e₂ A
w✝¹ : VExpr
h₁ : IsDefEq env U Γ A B w✝¹
w✝ : VLevel
hA : HasType env U Γ A (VExpr.sort w✝)
⊢ IsDefEq env U Γ e₁ e₂ B | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ : List VExpr
U : Nat
A B e₁ e₂ : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁✝ : IsDefEqU env U Γ A B
h₂ : IsDefEq env U Γ e₁ e₂ A
w✝ : VExpr
h₁ : IsDefEq env U Γ A B w✝
⊢ IsDefEq env U Γ e₁ e₂ B
TACTIC:
|
https://github.com/digama0/lean4lean.git | c534f13d8d25f5e1891b6d18cc76b601ee87aa66 | Lean4Lean/Theory/Typing/UniqueTyping.lean | Lean4Lean.VEnv.IsDefEqU.defeqDF | [41, 1] | [46, 44] | exact .defeqDF (hA.trans_l henv hΓ h₁) h₂ | env : VEnv
Γ : List VExpr
U : Nat
A B e₁ e₂ : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁✝ : IsDefEqU env U Γ A B
h₂ : IsDefEq env U Γ e₁ e₂ A
w✝¹ : VExpr
h₁ : IsDefEq env U Γ A B w✝¹
w✝ : VLevel
hA : HasType env U Γ A (VExpr.sort w✝)
⊢ IsDefEq env U Γ e₁ e₂ B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
env : VEnv
Γ : List VExpr
U : Nat
A B e₁ e₂ : VExpr
henv : Ordered env
hΓ : OnCtx Γ (IsType env U)
h₁✝ : IsDefEqU env U Γ A B
h₂ : IsDefEq env U Γ e₁ e₂ A
w✝¹ : VExpr
h₁ : IsDefEq env U Γ A B w✝¹
w✝ : VLevel
hA : HasType env U Γ A (VExpr.sort w✝)
⊢ IsDefEq env U Γ e₁ e₂ B
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.