formal
stringlengths 41
427k
| informal
stringclasses 1
value |
|---|---|
String.utf8SetAux_of_valid ** c' : Char cs cs' : List Char i p : Nat hp : i + utf8Len [] = p ⊢ utf8SetAux c' ([] ++ []) { byteIdx := i } { byteIdx := p } = [] ++ List.modifyHead (fun x => c') [] ** rfl ** c' : Char cs cs'✝ : List Char i p : Nat c : Char cs' : List Char hp : i + utf8Len [] = p ⊢ utf8SetAux c' ([] ++ c :: cs') { byteIdx := i } { byteIdx := p } = [] ++ List.modifyHead (fun x => c') (c :: cs') ** simp [← hp, utf8SetAux] ** c' : Char cs✝ cs'✝ : List Char i p : Nat c : Char cs cs' : List Char hp : i + utf8Len (c :: cs) = p ⊢ utf8SetAux c' (c :: cs ++ cs') { byteIdx := i } { byteIdx := p } = c :: cs ++ List.modifyHead (fun x => c') cs' ** simp [utf8SetAux] ** c' : Char cs✝ cs'✝ : List Char i p : Nat c : Char cs cs' : List Char hp : i + utf8Len (c :: cs) = p ⊢ (if { byteIdx := i } = { byteIdx := p } then c' :: (cs ++ cs') else c :: utf8SetAux c' (cs ++ cs') ({ byteIdx := i } + c) { byteIdx := p }) = c :: (cs ++ match cs' with | [] => [] | a :: l => c' :: l) ** rw [if_neg] ** c' : Char cs✝ cs'✝ : List Char i p : Nat c : Char cs cs' : List Char hp : i + utf8Len (c :: cs) = p ⊢ c :: utf8SetAux c' (cs ++ cs') ({ byteIdx := i } + c) { byteIdx := p } = c :: (cs ++ match cs' with | [] => [] | a :: l => c' :: l) case hnc c' : Char cs✝ cs'✝ : List Char i p : Nat c : Char cs cs' : List Char hp : i + utf8Len (c :: cs) = p ⊢ ¬{ byteIdx := i } = { byteIdx := p } ** case hnc => simp [← hp, Pos.ext_iff]; exact ne_self_add_add_csize ** c' : Char cs✝ cs'✝ : List Char i p : Nat c : Char cs cs' : List Char hp : i + utf8Len (c :: cs) = p ⊢ { byteIdx := i }.byteIdx + csize c + utf8Len cs = p ** simpa [Nat.add_assoc, Nat.add_comm] using hp ** c' : Char cs✝ cs'✝ : List Char i p : Nat c : Char cs cs' : List Char hp : i + utf8Len (c :: cs) = p ⊢ ¬{ byteIdx := i } = { byteIdx := p } ** simp [← hp, Pos.ext_iff] ** c' : Char cs✝ cs'✝ : List Char i p : Nat c : Char cs cs' : List Char hp : i + utf8Len (c :: cs) = p ⊢ ¬i = i + (utf8Len cs + csize c) ** exact ne_self_add_add_csize ** Qed
| |
String.modify_of_valid ** f : Char → Char cs cs' : List Char ⊢ modify { data := cs ++ cs' } { byteIdx := utf8Len cs } f = { data := cs ++ List.modifyHead f cs' } ** rw [modify, set_of_valid, get_of_valid] ** f : Char → Char cs cs' : List Char ⊢ { data := cs ++ List.modifyHead (fun x => f (List.headD cs' default)) cs' } = { data := cs ++ List.modifyHead f cs' } ** cases cs' <;> rfl ** Qed
| |
String.next_of_valid' ** cs cs' : List Char ⊢ next { data := cs ++ cs' } { byteIdx := utf8Len cs } = { byteIdx := utf8Len cs + csize (List.headD cs' default) } ** simp only [next, get_of_valid] ** cs cs' : List Char ⊢ { byteIdx := utf8Len cs } + List.headD cs' default = { byteIdx := utf8Len cs + csize (List.headD cs' default) } ** rfl ** Qed
| |
String.utf8PrevAux_of_valid ** cs cs' : List Char c : Char i p : Nat hp : i + (utf8Len cs + csize c) = p ⊢ utf8PrevAux (cs ++ c :: cs') { byteIdx := i } { byteIdx := p } = { byteIdx := i + utf8Len cs } ** match cs with
| [] => simp [utf8PrevAux, ← hp, Pos.addChar_eq]
| c'::cs =>
simp [utf8PrevAux, Pos.addChar_eq, ← hp]; rw [if_neg]
case hnc =>
simp [Pos.ext_iff]; rw [Nat.add_right_comm, Nat.add_left_comm]; apply ne_add_csize_add_self
refine (utf8PrevAux_of_valid (by simp [Nat.add_assoc, Nat.add_left_comm])).trans ?_
simp [Nat.add_assoc, Nat.add_comm] ** cs cs' : List Char c : Char i p : Nat hp : i + (utf8Len [] + csize c) = p ⊢ utf8PrevAux ([] ++ c :: cs') { byteIdx := i } { byteIdx := p } = { byteIdx := i + utf8Len [] } ** simp [utf8PrevAux, ← hp, Pos.addChar_eq] ** cs✝ cs' : List Char c : Char i p : Nat c' : Char cs : List Char hp : i + (utf8Len (c' :: cs) + csize c) = p ⊢ utf8PrevAux (c' :: cs ++ c :: cs') { byteIdx := i } { byteIdx := p } = { byteIdx := i + utf8Len (c' :: cs) } ** simp [utf8PrevAux, Pos.addChar_eq, ← hp] ** cs✝ cs' : List Char c : Char i p : Nat c' : Char cs : List Char hp : i + (utf8Len (c' :: cs) + csize c) = p ⊢ (if { byteIdx := i + csize c' } = { byteIdx := i + (utf8Len cs + csize c' + csize c) } then { byteIdx := i } else utf8PrevAux (cs ++ c :: cs') { byteIdx := i + csize c' } { byteIdx := i + (utf8Len cs + csize c' + csize c) }) = { byteIdx := i + (utf8Len cs + csize c') } ** rw [if_neg] ** cs✝ cs' : List Char c : Char i p : Nat c' : Char cs : List Char hp : i + (utf8Len (c' :: cs) + csize c) = p ⊢ utf8PrevAux (cs ++ c :: cs') { byteIdx := i + csize c' } { byteIdx := i + (utf8Len cs + csize c' + csize c) } = { byteIdx := i + (utf8Len cs + csize c') } case hnc cs✝ cs' : List Char c : Char i p : Nat c' : Char cs : List Char hp : i + (utf8Len (c' :: cs) + csize c) = p ⊢ ¬{ byteIdx := i + csize c' } = { byteIdx := i + (utf8Len cs + csize c' + csize c) } ** case hnc =>
simp [Pos.ext_iff]; rw [Nat.add_right_comm, Nat.add_left_comm]; apply ne_add_csize_add_self ** cs✝ cs' : List Char c : Char i p : Nat c' : Char cs : List Char hp : i + (utf8Len (c' :: cs) + csize c) = p ⊢ utf8PrevAux (cs ++ c :: cs') { byteIdx := i + csize c' } { byteIdx := i + (utf8Len cs + csize c' + csize c) } = { byteIdx := i + (utf8Len cs + csize c') } ** refine (utf8PrevAux_of_valid (by simp [Nat.add_assoc, Nat.add_left_comm])).trans ?_ ** cs✝ cs' : List Char c : Char i p : Nat c' : Char cs : List Char hp : i + (utf8Len (c' :: cs) + csize c) = p ⊢ { byteIdx := i + csize c' + utf8Len cs } = { byteIdx := i + (utf8Len cs + csize c') } ** simp [Nat.add_assoc, Nat.add_comm] ** cs✝ cs' : List Char c : Char i p : Nat c' : Char cs : List Char hp : i + (utf8Len (c' :: cs) + csize c) = p ⊢ ¬{ byteIdx := i + csize c' } = { byteIdx := i + (utf8Len cs + csize c' + csize c) } ** simp [Pos.ext_iff] ** cs✝ cs' : List Char c : Char i p : Nat c' : Char cs : List Char hp : i + (utf8Len (c' :: cs) + csize c) = p ⊢ ¬i + csize c' = i + (utf8Len cs + csize c' + csize c) ** rw [Nat.add_right_comm, Nat.add_left_comm] ** cs✝ cs' : List Char c : Char i p : Nat c' : Char cs : List Char hp : i + (utf8Len (c' :: cs) + csize c) = p ⊢ ¬i + csize c' = utf8Len cs + csize c + (i + csize c') ** apply ne_add_csize_add_self ** cs✝ cs' : List Char c : Char i p : Nat c' : Char cs : List Char hp : i + (utf8Len (c' :: cs) + csize c) = p ⊢ i + csize c' + (utf8Len cs + csize c) = i + (utf8Len cs + csize c' + csize c) ** simp [Nat.add_assoc, Nat.add_left_comm] ** Qed
| |
String.prev_of_valid' ** cs cs' : List Char ⊢ prev { data := cs ++ cs' } { byteIdx := utf8Len cs } = { byteIdx := utf8Len (List.dropLast cs) } ** match cs, cs.eq_nil_or_concat with
| _, .inl rfl => rfl
| _, .inr ⟨cs, c, rfl⟩ => simp [prev_of_valid] ** cs cs' : List Char ⊢ prev { data := [] ++ cs' } { byteIdx := utf8Len [] } = { byteIdx := utf8Len (List.dropLast []) } ** rfl ** cs✝ cs' cs : List Char c : Char ⊢ prev { data := cs ++ [c] ++ cs' } { byteIdx := utf8Len (cs ++ [c]) } = { byteIdx := utf8Len (List.dropLast (cs ++ [c])) } ** simp [prev_of_valid] ** Qed
| |
String.front_eq ** s : String ⊢ front s = List.headD s.data default ** unfold front ** s : String ⊢ get s 0 = List.headD s.data default ** exact get_of_valid [] s.1 ** Qed
| |
String.findAux_of_valid ** p : Char → Bool l r : List Char ⊢ findAux { data := l ++ [] ++ r } p { byteIdx := utf8Len l + utf8Len [] } { byteIdx := utf8Len l } = { byteIdx := utf8Len l + utf8Len (List.takeWhile (fun x => !p x) []) } ** unfold findAux List.takeWhile ** p : Char → Bool l r : List Char ⊢ (if h : { byteIdx := utf8Len l } < { byteIdx := utf8Len l + utf8Len [] } then if p (get { data := l ++ [] ++ r } { byteIdx := utf8Len l }) = true then { byteIdx := utf8Len l } else let_fun this := (_ : { byteIdx := utf8Len l + utf8Len [] }.byteIdx - (next { data := l ++ [] ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len [] }.byteIdx - { byteIdx := utf8Len l }.byteIdx); findAux { data := l ++ [] ++ r } p { byteIdx := utf8Len l + utf8Len [] } (next { data := l ++ [] ++ r } { byteIdx := utf8Len l }) else { byteIdx := utf8Len l }) = { byteIdx := utf8Len l + utf8Len [] } ** simp ** p : Char → Bool l : List Char c : Char m r : List Char ⊢ findAux { data := l ++ c :: m ++ r } p { byteIdx := utf8Len l + utf8Len (c :: m) } { byteIdx := utf8Len l } = { byteIdx := utf8Len l + utf8Len (List.takeWhile (fun x => !p x) (c :: m)) } ** unfold findAux List.takeWhile ** p : Char → Bool l : List Char c : Char m r : List Char ⊢ (if h : { byteIdx := utf8Len l } < { byteIdx := utf8Len l + utf8Len (c :: m) } then if p (get { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) = true then { byteIdx := utf8Len l } else let_fun this := (_ : { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - { byteIdx := utf8Len l }.byteIdx); findAux { data := l ++ c :: m ++ r } p { byteIdx := utf8Len l + utf8Len (c :: m) } (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) else { byteIdx := utf8Len l }) = { byteIdx := utf8Len l + utf8Len (match !p c with | true => c :: List.takeWhile (fun x => !p x) m | false => []) } ** rw [dif_pos (by exact Nat.lt_add_of_pos_right add_csize_pos)] ** p : Char → Bool l : List Char c : Char m r : List Char ⊢ (if p (get { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) = true then { byteIdx := utf8Len l } else let_fun this := (_ : { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - { byteIdx := utf8Len l }.byteIdx); findAux { data := l ++ c :: m ++ r } p { byteIdx := utf8Len l + utf8Len (c :: m) } (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l })) = { byteIdx := utf8Len l + utf8Len (match !p c with | true => c :: List.takeWhile (fun x => !p x) m | false => []) } ** have h1 := get_of_valid l (c::m++r) ** p : Char → Bool l : List Char c : Char m r : List Char h1 : get { data := l ++ (c :: m ++ r) } { byteIdx := utf8Len l } = List.headD (c :: m ++ r) default ⊢ (if p (get { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) = true then { byteIdx := utf8Len l } else let_fun this := (_ : { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - { byteIdx := utf8Len l }.byteIdx); findAux { data := l ++ c :: m ++ r } p { byteIdx := utf8Len l + utf8Len (c :: m) } (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l })) = { byteIdx := utf8Len l + utf8Len (match !p c with | true => c :: List.takeWhile (fun x => !p x) m | false => []) } ** have h2 := next_of_valid l c (m++r) ** p : Char → Bool l : List Char c : Char m r : List Char h1 : get { data := l ++ (c :: m ++ r) } { byteIdx := utf8Len l } = List.headD (c :: m ++ r) default h2 : next { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l } = { byteIdx := utf8Len l + csize c } ⊢ (if p (get { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) = true then { byteIdx := utf8Len l } else let_fun this := (_ : { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - { byteIdx := utf8Len l }.byteIdx); findAux { data := l ++ c :: m ++ r } p { byteIdx := utf8Len l + utf8Len (c :: m) } (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l })) = { byteIdx := utf8Len l + utf8Len (match !p c with | true => c :: List.takeWhile (fun x => !p x) m | false => []) } ** simp at h1 h2 ** p : Char → Bool l : List Char c : Char m r : List Char h1 : get { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l } = c h2 : next { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l } = { byteIdx := utf8Len l + csize c } ⊢ (if p (get { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) = true then { byteIdx := utf8Len l } else let_fun this := (_ : { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - { byteIdx := utf8Len l }.byteIdx); findAux { data := l ++ c :: m ++ r } p { byteIdx := utf8Len l + utf8Len (c :: m) } (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l })) = { byteIdx := utf8Len l + utf8Len (match !p c with | true => c :: List.takeWhile (fun x => !p x) m | false => []) } ** simp [h1, h2] ** p : Char → Bool l : List Char c : Char m r : List Char h1 : get { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l } = c h2 : next { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l } = { byteIdx := utf8Len l + csize c } ⊢ (if p c = true then { byteIdx := utf8Len l } else findAux { data := l ++ c :: (m ++ r) } p { byteIdx := utf8Len l + (utf8Len m + csize c) } { byteIdx := utf8Len l + csize c }) = { byteIdx := utf8Len l + utf8Len (match !p c with | true => c :: List.takeWhile (fun x => !p x) m | false => []) } ** cases p c <;> simp ** case false p : Char → Bool l : List Char c : Char m r : List Char h1 : get { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l } = c h2 : next { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l } = { byteIdx := utf8Len l + csize c } ⊢ findAux { data := l ++ c :: (m ++ r) } p { byteIdx := utf8Len l + (utf8Len m + csize c) } { byteIdx := utf8Len l + csize c } = { byteIdx := utf8Len l + (utf8Len (List.takeWhile (fun x => !p x) m) + csize c) } ** have foo := findAux_of_valid p (l++[c]) m r ** case false p : Char → Bool l : List Char c : Char m r : List Char h1 : get { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l } = c h2 : next { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l } = { byteIdx := utf8Len l + csize c } foo : findAux { data := l ++ [c] ++ m ++ r } p { byteIdx := utf8Len (l ++ [c]) + utf8Len m } { byteIdx := utf8Len (l ++ [c]) } = { byteIdx := utf8Len (l ++ [c]) + utf8Len (List.takeWhile (fun x => !p x) m) } ⊢ findAux { data := l ++ c :: (m ++ r) } p { byteIdx := utf8Len l + (utf8Len m + csize c) } { byteIdx := utf8Len l + csize c } = { byteIdx := utf8Len l + (utf8Len (List.takeWhile (fun x => !p x) m) + csize c) } ** simp at foo ** case false p : Char → Bool l : List Char c : Char m r : List Char h1 : get { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l } = c h2 : next { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l } = { byteIdx := utf8Len l + csize c } foo : findAux { data := l ++ c :: (m ++ r) } p { byteIdx := utf8Len l + csize c + utf8Len m } { byteIdx := utf8Len l + csize c } = { byteIdx := utf8Len l + csize c + utf8Len (List.takeWhile (fun x => !p x) m) } ⊢ findAux { data := l ++ c :: (m ++ r) } p { byteIdx := utf8Len l + (utf8Len m + csize c) } { byteIdx := utf8Len l + csize c } = { byteIdx := utf8Len l + (utf8Len (List.takeWhile (fun x => !p x) m) + csize c) } ** rw [Nat.add_right_comm, Nat.add_assoc] at foo ** case false p : Char → Bool l : List Char c : Char m r : List Char h1 : get { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l } = c h2 : next { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l } = { byteIdx := utf8Len l + csize c } foo : findAux { data := l ++ c :: (m ++ r) } p { byteIdx := utf8Len l + (utf8Len m + csize c) } { byteIdx := utf8Len l + csize c } = { byteIdx := utf8Len l + csize c + utf8Len (List.takeWhile (fun x => !p x) m) } ⊢ findAux { data := l ++ c :: (m ++ r) } p { byteIdx := utf8Len l + (utf8Len m + csize c) } { byteIdx := utf8Len l + csize c } = { byteIdx := utf8Len l + (utf8Len (List.takeWhile (fun x => !p x) m) + csize c) } ** rw [foo, Nat.add_right_comm, Nat.add_assoc] ** p : Char → Bool l : List Char c : Char m r : List Char ⊢ { byteIdx := utf8Len l } < { byteIdx := utf8Len l + utf8Len (c :: m) } ** exact Nat.lt_add_of_pos_right add_csize_pos ** Qed
| |
String.revFindAux_of_valid ** p : Char → Bool r : List Char ⊢ revFindAux { data := List.reverse [] ++ r } p { byteIdx := utf8Len [] } = Option.map (fun x => { byteIdx := utf8Len x }) (List.tail? (List.dropWhile (fun x => !p x) [])) ** unfold revFindAux List.dropWhile ** p : Char → Bool r : List Char ⊢ (if h : { byteIdx := utf8Len [] } = 0 then none else let_fun this := (_ : (prev { data := List.reverse [] ++ r } { byteIdx := utf8Len [] }).byteIdx < { byteIdx := utf8Len [] }.byteIdx); let pos := prev { data := List.reverse [] ++ r } { byteIdx := utf8Len [] }; if p (get { data := List.reverse [] ++ r } pos) = true then some pos else revFindAux { data := List.reverse [] ++ r } p pos) = Option.map (fun x => { byteIdx := utf8Len x }) (List.tail? []) ** simp ** p : Char → Bool c : Char l r : List Char ⊢ revFindAux { data := List.reverse (c :: l) ++ r } p { byteIdx := utf8Len (c :: l) } = Option.map (fun x => { byteIdx := utf8Len x }) (List.tail? (List.dropWhile (fun x => !p x) (c :: l))) ** unfold revFindAux List.dropWhile ** p : Char → Bool c : Char l r : List Char ⊢ (if h : { byteIdx := utf8Len (c :: l) } = 0 then none else let_fun this := (_ : (prev { data := List.reverse (c :: l) ++ r } { byteIdx := utf8Len (c :: l) }).byteIdx < { byteIdx := utf8Len (c :: l) }.byteIdx); let pos := prev { data := List.reverse (c :: l) ++ r } { byteIdx := utf8Len (c :: l) }; if p (get { data := List.reverse (c :: l) ++ r } pos) = true then some pos else revFindAux { data := List.reverse (c :: l) ++ r } p pos) = Option.map (fun x => { byteIdx := utf8Len x }) (List.tail? (match !p c with | true => List.dropWhile (fun x => !p x) l | false => c :: l)) ** rw [dif_neg (by exact Pos.ne_of_gt add_csize_pos)] ** p : Char → Bool c : Char l r : List Char ⊢ (let_fun this := (_ : (prev { data := List.reverse (c :: l) ++ r } { byteIdx := utf8Len (c :: l) }).byteIdx < { byteIdx := utf8Len (c :: l) }.byteIdx); let pos := prev { data := List.reverse (c :: l) ++ r } { byteIdx := utf8Len (c :: l) }; if p (get { data := List.reverse (c :: l) ++ r } pos) = true then some pos else revFindAux { data := List.reverse (c :: l) ++ r } p pos) = Option.map (fun x => { byteIdx := utf8Len x }) (List.tail? (match !p c with | true => List.dropWhile (fun x => !p x) l | false => c :: l)) ** have h1 := get_of_valid l.reverse (c::r) ** p : Char → Bool c : Char l r : List Char h1 : get { data := List.reverse l ++ c :: r } { byteIdx := utf8Len (List.reverse l) } = List.headD (c :: r) default ⊢ (let_fun this := (_ : (prev { data := List.reverse (c :: l) ++ r } { byteIdx := utf8Len (c :: l) }).byteIdx < { byteIdx := utf8Len (c :: l) }.byteIdx); let pos := prev { data := List.reverse (c :: l) ++ r } { byteIdx := utf8Len (c :: l) }; if p (get { data := List.reverse (c :: l) ++ r } pos) = true then some pos else revFindAux { data := List.reverse (c :: l) ++ r } p pos) = Option.map (fun x => { byteIdx := utf8Len x }) (List.tail? (match !p c with | true => List.dropWhile (fun x => !p x) l | false => c :: l)) ** have h2 := prev_of_valid l.reverse c r ** p : Char → Bool c : Char l r : List Char h1 : get { data := List.reverse l ++ c :: r } { byteIdx := utf8Len (List.reverse l) } = List.headD (c :: r) default h2 : prev { data := List.reverse l ++ c :: r } { byteIdx := utf8Len (List.reverse l) + csize c } = { byteIdx := utf8Len (List.reverse l) } ⊢ (let_fun this := (_ : (prev { data := List.reverse (c :: l) ++ r } { byteIdx := utf8Len (c :: l) }).byteIdx < { byteIdx := utf8Len (c :: l) }.byteIdx); let pos := prev { data := List.reverse (c :: l) ++ r } { byteIdx := utf8Len (c :: l) }; if p (get { data := List.reverse (c :: l) ++ r } pos) = true then some pos else revFindAux { data := List.reverse (c :: l) ++ r } p pos) = Option.map (fun x => { byteIdx := utf8Len x }) (List.tail? (match !p c with | true => List.dropWhile (fun x => !p x) l | false => c :: l)) ** simp at h1 h2 ** p : Char → Bool c : Char l r : List Char h1 : get { data := List.reverse l ++ c :: r } { byteIdx := utf8Len l } = c h2 : prev { data := List.reverse l ++ c :: r } { byteIdx := utf8Len l + csize c } = { byteIdx := utf8Len l } ⊢ (let_fun this := (_ : (prev { data := List.reverse (c :: l) ++ r } { byteIdx := utf8Len (c :: l) }).byteIdx < { byteIdx := utf8Len (c :: l) }.byteIdx); let pos := prev { data := List.reverse (c :: l) ++ r } { byteIdx := utf8Len (c :: l) }; if p (get { data := List.reverse (c :: l) ++ r } pos) = true then some pos else revFindAux { data := List.reverse (c :: l) ++ r } p pos) = Option.map (fun x => { byteIdx := utf8Len x }) (List.tail? (match !p c with | true => List.dropWhile (fun x => !p x) l | false => c :: l)) ** simp [h1, h2] ** p : Char → Bool c : Char l r : List Char h1 : get { data := List.reverse l ++ c :: r } { byteIdx := utf8Len l } = c h2 : prev { data := List.reverse l ++ c :: r } { byteIdx := utf8Len l + csize c } = { byteIdx := utf8Len l } ⊢ (if p c = true then some { byteIdx := utf8Len l } else revFindAux { data := List.reverse l ++ c :: r } p { byteIdx := utf8Len l }) = Option.map (fun x => { byteIdx := utf8Len x }) (List.tail? (match !p c with | true => List.dropWhile (fun x => !p x) l | false => c :: l)) ** cases p c <;> simp ** case false p : Char → Bool c : Char l r : List Char h1 : get { data := List.reverse l ++ c :: r } { byteIdx := utf8Len l } = c h2 : prev { data := List.reverse l ++ c :: r } { byteIdx := utf8Len l + csize c } = { byteIdx := utf8Len l } ⊢ revFindAux { data := List.reverse l ++ c :: r } p { byteIdx := utf8Len l } = Option.map (fun x => { byteIdx := utf8Len x }) (List.tail? (List.dropWhile (fun x => !p x) l)) ** exact revFindAux_of_valid p l (c::r) ** p : Char → Bool c : Char l r : List Char ⊢ ¬{ byteIdx := utf8Len (c :: l) } = 0 ** exact Pos.ne_of_gt add_csize_pos ** Qed
| |
String.firstDiffPos_loop_eq ** l₁ l₂ r₁ r₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ hstop : stop = min (utf8Len l₁ + utf8Len r₁) (utf8Len l₂ + utf8Len r₂) ⊢ firstDiffPos.loop { data := l₁ ++ r₁ } { data := l₂ ++ r₂ } { byteIdx := stop } { byteIdx := p } = { byteIdx := p + utf8Len (List.takeWhile₂ (fun x x_1 => decide (x = x_1)) r₁ r₂).fst } ** unfold List.takeWhile₂ ** l₁ l₂ r₁ r₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ hstop : stop = min (utf8Len l₁ + utf8Len r₁) (utf8Len l₂ + utf8Len r₂) ⊢ firstDiffPos.loop { data := l₁ ++ r₁ } { data := l₂ ++ r₂ } { byteIdx := stop } { byteIdx := p } = { byteIdx := p + utf8Len (match r₁, r₂ with | a :: as, b :: bs => if decide (a = b) = true then match List.takeWhile₂ (fun x x_1 => decide (x = x_1)) as bs with | (as', bs') => (a :: as', b :: bs') else ([], []) | x, x_1 => ([], [])).fst } ** split <;> unfold firstDiffPos.loop ** case h_1 l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a✝ : Char as✝ : List Char b✝ : Char bs✝ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a✝ :: as✝)) (utf8Len l₂ + utf8Len (b✝ :: bs✝)) ⊢ (if h : { byteIdx := p } < { byteIdx := stop } then if (get { data := l₁ ++ a✝ :: as✝ } { byteIdx := p } != get { data := l₂ ++ b✝ :: bs✝ } { byteIdx := p }) = true then { byteIdx := p } else let_fun this := (_ : { byteIdx := stop }.byteIdx - (next { data := l₁ ++ a✝ :: as✝ } { byteIdx := p }).byteIdx < { byteIdx := stop }.byteIdx - { byteIdx := p }.byteIdx); firstDiffPos.loop { data := l₁ ++ a✝ :: as✝ } { data := l₂ ++ b✝ :: bs✝ } { byteIdx := stop } (next { data := l₁ ++ a✝ :: as✝ } { byteIdx := p }) else { byteIdx := p }) = { byteIdx := p + utf8Len (if decide (a✝ = b✝) = true then match List.takeWhile₂ (fun x x_1 => decide (x = x_1)) as✝ bs✝ with | (as', bs') => (a✝ :: as', b✝ :: bs') else ([], [])).fst } ** next a r₁ b r₂ =>
rw [
dif_pos <| by
rw [hstop, ← hl₁, ← hl₂]
refine Nat.lt_min.2 ⟨?_, ?_⟩ <;> exact Nat.lt_add_of_pos_right add_csize_pos,
show get ⟨l₁ ++ a :: r₁⟩ ⟨p⟩ = a by simp [hl₁, get_of_valid],
show get ⟨l₂ ++ b :: r₂⟩ ⟨p⟩ = b by simp [hl₂, get_of_valid]]
simp [bne]; split <;> simp
subst b
rw [show next ⟨l₁ ++ a :: r₁⟩ ⟨p⟩ = ⟨utf8Len l₁ + csize a⟩ by simp [hl₁, next_of_valid]]
simpa [← hl₁, ← Nat.add_assoc, Nat.add_right_comm] using
firstDiffPos_loop_eq (l₁ ++ [a]) (l₂ ++ [a]) r₁ r₂ stop (p + csize a)
(by simp [hl₁]) (by simp [hl₂]) (by simp [hstop, ← Nat.add_assoc, Nat.add_right_comm]) ** l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a : Char r₁ : List Char b : Char r₂ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a :: r₁)) (utf8Len l₂ + utf8Len (b :: r₂)) ⊢ (if h : { byteIdx := p } < { byteIdx := stop } then if (get { data := l₁ ++ a :: r₁ } { byteIdx := p } != get { data := l₂ ++ b :: r₂ } { byteIdx := p }) = true then { byteIdx := p } else let_fun this := (_ : { byteIdx := stop }.byteIdx - (next { data := l₁ ++ a :: r₁ } { byteIdx := p }).byteIdx < { byteIdx := stop }.byteIdx - { byteIdx := p }.byteIdx); firstDiffPos.loop { data := l₁ ++ a :: r₁ } { data := l₂ ++ b :: r₂ } { byteIdx := stop } (next { data := l₁ ++ a :: r₁ } { byteIdx := p }) else { byteIdx := p }) = { byteIdx := p + utf8Len (if decide (a = b) = true then match List.takeWhile₂ (fun x x_1 => decide (x = x_1)) r₁ r₂ with | (as', bs') => (a :: as', b :: bs') else ([], [])).fst } ** rw [
dif_pos <| by
rw [hstop, ← hl₁, ← hl₂]
refine Nat.lt_min.2 ⟨?_, ?_⟩ <;> exact Nat.lt_add_of_pos_right add_csize_pos,
show get ⟨l₁ ++ a :: r₁⟩ ⟨p⟩ = a by simp [hl₁, get_of_valid],
show get ⟨l₂ ++ b :: r₂⟩ ⟨p⟩ = b by simp [hl₂, get_of_valid]] ** l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a : Char r₁ : List Char b : Char r₂ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a :: r₁)) (utf8Len l₂ + utf8Len (b :: r₂)) ⊢ (if (a != b) = true then { byteIdx := p } else let_fun this := (_ : { byteIdx := stop }.byteIdx - (next { data := l₁ ++ a :: r₁ } { byteIdx := p }).byteIdx < { byteIdx := stop }.byteIdx - { byteIdx := p }.byteIdx); firstDiffPos.loop { data := l₁ ++ a :: r₁ } { data := l₂ ++ b :: r₂ } { byteIdx := stop } (next { data := l₁ ++ a :: r₁ } { byteIdx := p })) = { byteIdx := p + utf8Len (if decide (a = b) = true then match List.takeWhile₂ (fun x x_1 => decide (x = x_1)) r₁ r₂ with | (as', bs') => (a :: as', b :: bs') else ([], [])).fst } ** simp [bne] ** l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a : Char r₁ : List Char b : Char r₂ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a :: r₁)) (utf8Len l₂ + utf8Len (b :: r₂)) ⊢ (if a = b then firstDiffPos.loop { data := l₁ ++ a :: r₁ } { data := l₂ ++ b :: r₂ } { byteIdx := stop } (next { data := l₁ ++ a :: r₁ } { byteIdx := p }) else { byteIdx := p }) = { byteIdx := p + utf8Len (if a = b then (a :: (List.takeWhile₂ (fun x x_1 => decide (x = x_1)) r₁ r₂).fst, b :: (List.takeWhile₂ (fun x x_1 => decide (x = x_1)) r₁ r₂).snd) else ([], [])).fst } ** split <;> simp ** case inl l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a : Char r₁ : List Char b : Char r₂ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a :: r₁)) (utf8Len l₂ + utf8Len (b :: r₂)) h✝ : a = b ⊢ firstDiffPos.loop { data := l₁ ++ a :: r₁ } { data := l₂ ++ b :: r₂ } { byteIdx := stop } (next { data := l₁ ++ a :: r₁ } { byteIdx := p }) = { byteIdx := p + (utf8Len (List.takeWhile₂ (fun x x_1 => decide (x = x_1)) r₁ r₂).fst + csize a) } ** subst b ** case inl l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a : Char r₁ r₂ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a :: r₁)) (utf8Len l₂ + utf8Len (a :: r₂)) ⊢ firstDiffPos.loop { data := l₁ ++ a :: r₁ } { data := l₂ ++ a :: r₂ } { byteIdx := stop } (next { data := l₁ ++ a :: r₁ } { byteIdx := p }) = { byteIdx := p + (utf8Len (List.takeWhile₂ (fun x x_1 => decide (x = x_1)) r₁ r₂).fst + csize a) } ** rw [show next ⟨l₁ ++ a :: r₁⟩ ⟨p⟩ = ⟨utf8Len l₁ + csize a⟩ by simp [hl₁, next_of_valid]] ** case inl l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a : Char r₁ r₂ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a :: r₁)) (utf8Len l₂ + utf8Len (a :: r₂)) ⊢ firstDiffPos.loop { data := l₁ ++ a :: r₁ } { data := l₂ ++ a :: r₂ } { byteIdx := stop } { byteIdx := utf8Len l₁ + csize a } = { byteIdx := p + (utf8Len (List.takeWhile₂ (fun x x_1 => decide (x = x_1)) r₁ r₂).fst + csize a) } ** simpa [← hl₁, ← Nat.add_assoc, Nat.add_right_comm] using
firstDiffPos_loop_eq (l₁ ++ [a]) (l₂ ++ [a]) r₁ r₂ stop (p + csize a)
(by simp [hl₁]) (by simp [hl₂]) (by simp [hstop, ← Nat.add_assoc, Nat.add_right_comm]) ** l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a : Char r₁ : List Char b : Char r₂ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a :: r₁)) (utf8Len l₂ + utf8Len (b :: r₂)) ⊢ { byteIdx := p } < { byteIdx := stop } ** rw [hstop, ← hl₁, ← hl₂] ** l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a : Char r₁ : List Char b : Char r₂ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a :: r₁)) (utf8Len l₂ + utf8Len (b :: r₂)) ⊢ { byteIdx := p } < { byteIdx := min (p + utf8Len (a :: r₁)) (p + utf8Len (b :: r₂)) } ** refine Nat.lt_min.2 ⟨?_, ?_⟩ <;> exact Nat.lt_add_of_pos_right add_csize_pos ** l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a : Char r₁ : List Char b : Char r₂ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a :: r₁)) (utf8Len l₂ + utf8Len (b :: r₂)) ⊢ get { data := l₁ ++ a :: r₁ } { byteIdx := p } = a ** simp [hl₁, get_of_valid] ** l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a : Char r₁ : List Char b : Char r₂ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a :: r₁)) (utf8Len l₂ + utf8Len (b :: r₂)) ⊢ get { data := l₂ ++ b :: r₂ } { byteIdx := p } = b ** simp [hl₂, get_of_valid] ** l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a : Char r₁ r₂ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a :: r₁)) (utf8Len l₂ + utf8Len (a :: r₂)) ⊢ next { data := l₁ ++ a :: r₁ } { byteIdx := p } = { byteIdx := utf8Len l₁ + csize a } ** simp [hl₁, next_of_valid] ** l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a : Char r₁ r₂ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a :: r₁)) (utf8Len l₂ + utf8Len (a :: r₂)) ⊢ p + csize a = utf8Len (l₁ ++ [a]) ** simp [hl₁] ** l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a : Char r₁ r₂ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a :: r₁)) (utf8Len l₂ + utf8Len (a :: r₂)) ⊢ p + csize a = utf8Len (l₂ ++ [a]) ** simp [hl₂] ** l₁ l₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ x✝¹ x✝ : List Char a : Char r₁ r₂ : List Char hstop : stop = min (utf8Len l₁ + utf8Len (a :: r₁)) (utf8Len l₂ + utf8Len (a :: r₂)) ⊢ stop = min (utf8Len (l₁ ++ [a]) + utf8Len r₁) (utf8Len (l₂ ++ [a]) + utf8Len r₂) ** simp [hstop, ← Nat.add_assoc, Nat.add_right_comm] ** case h_2 l₁ l₂ r₁ r₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ hstop : stop = min (utf8Len l₁ + utf8Len r₁) (utf8Len l₂ + utf8Len r₂) x✝² x✝¹ : List Char x✝ : ∀ (a : Char) (as : List Char) (b : Char) (bs : List Char), r₁ = a :: as → r₂ = b :: bs → False ⊢ (if h : { byteIdx := p } < { byteIdx := stop } then if (get { data := l₁ ++ r₁ } { byteIdx := p } != get { data := l₂ ++ r₂ } { byteIdx := p }) = true then { byteIdx := p } else let_fun this := (_ : { byteIdx := stop }.byteIdx - (next { data := l₁ ++ r₁ } { byteIdx := p }).byteIdx < { byteIdx := stop }.byteIdx - { byteIdx := p }.byteIdx); firstDiffPos.loop { data := l₁ ++ r₁ } { data := l₂ ++ r₂ } { byteIdx := stop } (next { data := l₁ ++ r₁ } { byteIdx := p }) else { byteIdx := p }) = { byteIdx := p + utf8Len ([], []).fst } ** next h =>
rw [dif_neg] <;> simp [hstop, ← hl₁, ← hl₂, -Nat.not_lt, Nat.lt_min]
intro h₁ h₂
have : ∀ {cs}, p < p + utf8Len cs → cs ≠ [] := by rintro _ h rfl; simp at h
obtain ⟨a, as, e₁⟩ := List.exists_cons_of_ne_nil (this h₁)
obtain ⟨b, bs, e₂⟩ := List.exists_cons_of_ne_nil (this h₂)
exact h _ _ _ _ e₁ e₂ ** l₁ l₂ r₁ r₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ hstop : stop = min (utf8Len l₁ + utf8Len r₁) (utf8Len l₂ + utf8Len r₂) x✝¹ x✝ : List Char h : ∀ (a : Char) (as : List Char) (b : Char) (bs : List Char), r₁ = a :: as → r₂ = b :: bs → False ⊢ (if h : { byteIdx := p } < { byteIdx := stop } then if (get { data := l₁ ++ r₁ } { byteIdx := p } != get { data := l₂ ++ r₂ } { byteIdx := p }) = true then { byteIdx := p } else let_fun this := (_ : { byteIdx := stop }.byteIdx - (next { data := l₁ ++ r₁ } { byteIdx := p }).byteIdx < { byteIdx := stop }.byteIdx - { byteIdx := p }.byteIdx); firstDiffPos.loop { data := l₁ ++ r₁ } { data := l₂ ++ r₂ } { byteIdx := stop } (next { data := l₁ ++ r₁ } { byteIdx := p }) else { byteIdx := p }) = { byteIdx := p + utf8Len ([], []).fst } ** rw [dif_neg] <;> simp [hstop, ← hl₁, ← hl₂, -Nat.not_lt, Nat.lt_min] ** case hnc l₁ l₂ r₁ r₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ hstop : stop = min (utf8Len l₁ + utf8Len r₁) (utf8Len l₂ + utf8Len r₂) x✝¹ x✝ : List Char h : ∀ (a : Char) (as : List Char) (b : Char) (bs : List Char), r₁ = a :: as → r₂ = b :: bs → False ⊢ p < p + utf8Len r₁ → ¬p < p + utf8Len r₂ ** intro h₁ h₂ ** case hnc l₁ l₂ r₁ r₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ hstop : stop = min (utf8Len l₁ + utf8Len r₁) (utf8Len l₂ + utf8Len r₂) x✝¹ x✝ : List Char h : ∀ (a : Char) (as : List Char) (b : Char) (bs : List Char), r₁ = a :: as → r₂ = b :: bs → False h₁ : p < p + utf8Len r₁ h₂ : p < p + utf8Len r₂ ⊢ False ** have : ∀ {cs}, p < p + utf8Len cs → cs ≠ [] := by rintro _ h rfl; simp at h ** case hnc l₁ l₂ r₁ r₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ hstop : stop = min (utf8Len l₁ + utf8Len r₁) (utf8Len l₂ + utf8Len r₂) x✝¹ x✝ : List Char h : ∀ (a : Char) (as : List Char) (b : Char) (bs : List Char), r₁ = a :: as → r₂ = b :: bs → False h₁ : p < p + utf8Len r₁ h₂ : p < p + utf8Len r₂ this : ∀ {cs : List Char}, p < p + utf8Len cs → cs ≠ [] ⊢ False ** obtain ⟨a, as, e₁⟩ := List.exists_cons_of_ne_nil (this h₁) ** case hnc.intro.intro l₁ l₂ r₁ r₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ hstop : stop = min (utf8Len l₁ + utf8Len r₁) (utf8Len l₂ + utf8Len r₂) x✝¹ x✝ : List Char h : ∀ (a : Char) (as : List Char) (b : Char) (bs : List Char), r₁ = a :: as → r₂ = b :: bs → False h₁ : p < p + utf8Len r₁ h₂ : p < p + utf8Len r₂ this : ∀ {cs : List Char}, p < p + utf8Len cs → cs ≠ [] a : Char as : List Char e₁ : r₁ = a :: as ⊢ False ** obtain ⟨b, bs, e₂⟩ := List.exists_cons_of_ne_nil (this h₂) ** case hnc.intro.intro.intro.intro l₁ l₂ r₁ r₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ hstop : stop = min (utf8Len l₁ + utf8Len r₁) (utf8Len l₂ + utf8Len r₂) x✝¹ x✝ : List Char h : ∀ (a : Char) (as : List Char) (b : Char) (bs : List Char), r₁ = a :: as → r₂ = b :: bs → False h₁ : p < p + utf8Len r₁ h₂ : p < p + utf8Len r₂ this : ∀ {cs : List Char}, p < p + utf8Len cs → cs ≠ [] a : Char as : List Char e₁ : r₁ = a :: as b : Char bs : List Char e₂ : r₂ = b :: bs ⊢ False ** exact h _ _ _ _ e₁ e₂ ** l₁ l₂ r₁ r₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ hstop : stop = min (utf8Len l₁ + utf8Len r₁) (utf8Len l₂ + utf8Len r₂) x✝¹ x✝ : List Char h : ∀ (a : Char) (as : List Char) (b : Char) (bs : List Char), r₁ = a :: as → r₂ = b :: bs → False h₁ : p < p + utf8Len r₁ h₂ : p < p + utf8Len r₂ ⊢ ∀ {cs : List Char}, p < p + utf8Len cs → cs ≠ [] ** rintro _ h rfl ** l₁ l₂ r₁ r₂ : List Char stop p : Nat hl₁ : p = utf8Len l₁ hl₂ : p = utf8Len l₂ hstop : stop = min (utf8Len l₁ + utf8Len r₁) (utf8Len l₂ + utf8Len r₂) x✝¹ x✝ : List Char h✝ : ∀ (a : Char) (as : List Char) (b : Char) (bs : List Char), r₁ = a :: as → r₂ = b :: bs → False h₁ : p < p + utf8Len r₁ h₂ : p < p + utf8Len r₂ h : p < p + utf8Len [] ⊢ False ** simp at h ** Qed
| |
String.extract.go₂_add_right_cancel ** s : List Char i e n : Nat ⊢ go₂ s { byteIdx := i + n } { byteIdx := e + n } = go₂ s { byteIdx := i } { byteIdx := e } ** apply utf8InductionOn s ⟨i⟩ ⟨e⟩ (motive := fun s i =>
go₂ s ⟨i.byteIdx + n⟩ ⟨e + n⟩ = go₂ s i ⟨e⟩) <;> simp [go₂] ** case ind s : List Char i e n : Nat ⊢ ∀ (c : Char) (cs : List Char) (i : Pos), ¬i = { byteIdx := e } → go₂ cs { byteIdx := i.byteIdx + csize c + n } { byteIdx := e + n } = go₂ cs (i + c) { byteIdx := e } → (if { byteIdx := i.byteIdx + n } = { byteIdx := e + n } then [] else c :: go₂ cs ({ byteIdx := i.byteIdx + n } + c) { byteIdx := e + n }) = if i = { byteIdx := e } then [] else c :: go₂ cs (i + c) { byteIdx := e } ** intro c cs ⟨i⟩ h ih ** case ind s : List Char i✝ e n : Nat c : Char cs : List Char i : Nat h : ¬{ byteIdx := i } = { byteIdx := e } ih : go₂ cs { byteIdx := { byteIdx := i }.byteIdx + csize c + n } { byteIdx := e + n } = go₂ cs ({ byteIdx := i } + c) { byteIdx := e } ⊢ (if { byteIdx := { byteIdx := i }.byteIdx + n } = { byteIdx := e + n } then [] else c :: go₂ cs ({ byteIdx := { byteIdx := i }.byteIdx + n } + c) { byteIdx := e + n }) = if { byteIdx := i } = { byteIdx := e } then [] else c :: go₂ cs ({ byteIdx := i } + c) { byteIdx := e } ** simp [Pos.ext_iff, Pos.addChar_eq] at h ⊢ ** case ind s : List Char i✝ e n : Nat c : Char cs : List Char i : Nat ih : go₂ cs { byteIdx := { byteIdx := i }.byteIdx + csize c + n } { byteIdx := e + n } = go₂ cs ({ byteIdx := i } + c) { byteIdx := e } h : ¬i = e ⊢ (if i + n = e + n then [] else c :: go₂ cs { byteIdx := i + n + csize c } { byteIdx := e + n }) = if i = e then [] else c :: go₂ cs { byteIdx := i + csize c } { byteIdx := e } ** simp [Nat.add_right_cancel_iff, h] ** case ind s : List Char i✝ e n : Nat c : Char cs : List Char i : Nat ih : go₂ cs { byteIdx := { byteIdx := i }.byteIdx + csize c + n } { byteIdx := e + n } = go₂ cs ({ byteIdx := i } + c) { byteIdx := e } h : ¬i = e ⊢ go₂ cs { byteIdx := i + n + csize c } { byteIdx := e + n } = go₂ cs { byteIdx := i + csize c } { byteIdx := e } ** rw [Nat.add_right_comm] ** case ind s : List Char i✝ e n : Nat c : Char cs : List Char i : Nat ih : go₂ cs { byteIdx := { byteIdx := i }.byteIdx + csize c + n } { byteIdx := e + n } = go₂ cs ({ byteIdx := i } + c) { byteIdx := e } h : ¬i = e ⊢ go₂ cs { byteIdx := i + csize c + n } { byteIdx := e + n } = go₂ cs { byteIdx := i + csize c } { byteIdx := e } ** exact ih ** Qed
| |
String.extract.go₂_append_left ** t : List Char i : Nat ⊢ go₂ ([] ++ t) { byteIdx := i } { byteIdx := utf8Len [] + i } = [] ** cases t <;> simp [go₂] ** c : Char cs t : List Char i : Nat ⊢ go₂ (c :: cs ++ t) { byteIdx := i } { byteIdx := utf8Len (c :: cs) + i } = c :: cs ** simp [go₂, Pos.ext_iff, ne_add_csize_add_self, Pos.addChar_eq] ** c : Char cs t : List Char i : Nat ⊢ go₂ (cs ++ t) { byteIdx := i + csize c } { byteIdx := utf8Len cs + csize c + i } = cs ** apply go₂_append_left ** case a c : Char cs t : List Char i : Nat ⊢ utf8Len cs + csize c + i = utf8Len cs + (i + csize c) ** rw [Nat.add_right_comm, Nat.add_assoc] ** Qed
| |
String.extract.go₁_append_right ** t : List Char i : Nat e : Pos ⊢ go₁ ([] ++ t) { byteIdx := i } { byteIdx := utf8Len [] + i } e = go₂ t { byteIdx := utf8Len [] + i } e ** cases t <;> simp [go₁, go₂] ** c : Char cs t : List Char i : Nat e : Pos ⊢ go₁ (c :: cs ++ t) { byteIdx := i } { byteIdx := utf8Len (c :: cs) + i } e = go₂ t { byteIdx := utf8Len (c :: cs) + i } e ** simp [go₁, Pos.ext_iff, ne_add_csize_add_self, Pos.addChar_eq] ** c : Char cs t : List Char i : Nat e : Pos ⊢ go₁ (cs ++ t) { byteIdx := i + csize c } { byteIdx := utf8Len cs + csize c + i } e = go₂ t { byteIdx := utf8Len cs + csize c + i } e ** apply go₁_append_right ** case a c : Char cs t : List Char i : Nat e : Pos ⊢ utf8Len cs + csize c + i = utf8Len cs + (i + csize c) ** rw [Nat.add_right_comm, Nat.add_assoc] ** Qed
| |
String.extract.go₁_zero_utf8Len ** s : List Char ⊢ go₂ s { byteIdx := 0 } { byteIdx := utf8Len s } = s ** simpa using go₂_append_left s [] 0 (utf8Len s) rfl ** Qed
| |
String.extract_of_valid ** l m r : List Char ⊢ extract { data := l ++ m ++ r } { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } = { data := m } ** simp only [extract] ** l m r : List Char ⊢ (if utf8Len l ≥ utf8Len l + utf8Len m then "" else { data := extract.go₁ (l ++ m ++ r) 0 { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } }) = { data := m } ** split ** case inl l m r : List Char h✝ : utf8Len l ≥ utf8Len l + utf8Len m ⊢ "" = { data := m } ** next h => rw [utf8Len_eq_zero.1 <| Nat.le_zero.1 <| (Nat.add_le_add_iff_left _ _ 0).1 h] ** l m r : List Char h : utf8Len l ≥ utf8Len l + utf8Len m ⊢ "" = { data := m } ** rw [utf8Len_eq_zero.1 <| Nat.le_zero.1 <| (Nat.add_le_add_iff_left _ _ 0).1 h] ** case inr l m r : List Char h✝ : ¬utf8Len l ≥ utf8Len l + utf8Len m ⊢ { data := extract.go₁ (l ++ m ++ r) 0 { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } } = { data := m } ** congr ** case inr.e_data l m r : List Char h✝ : ¬utf8Len l ≥ utf8Len l + utf8Len m ⊢ extract.go₁ (l ++ m ++ r) 0 { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } = m ** rw [List.append_assoc, extract.go₁_append_right _ _ _ _ _ (by rfl)] ** case inr.e_data l m r : List Char h✝ : ¬utf8Len l ≥ utf8Len l + utf8Len m ⊢ extract.go₂ (m ++ r) { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } = m ** apply extract.go₂_append_left ** case inr.e_data.a l m r : List Char h✝ : ¬utf8Len l ≥ utf8Len l + utf8Len m ⊢ utf8Len l + utf8Len m = utf8Len m + utf8Len l ** apply Nat.add_comm ** l m r : List Char h✝ : ¬utf8Len l ≥ utf8Len l + utf8Len m ⊢ utf8Len l = utf8Len l + 0.byteIdx ** rfl ** Qed
| |
String.splitAux_of_valid ** p : Char → Bool l m r : List Char acc : List String ⊢ splitAux { data := l ++ m ++ r } p { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } acc = List.reverse acc ++ List.map mk (List.splitOnP.go p r (List.reverse m)) ** unfold splitAux ** p : Char → Bool l m r : List Char acc : List String ⊢ (if h : atEnd { data := l ++ m ++ r } { byteIdx := utf8Len l + utf8Len m } = true then let r := extract { data := l ++ m ++ r } { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } :: acc; List.reverse r else let_fun this := (_ : utf8ByteSize { data := l ++ m ++ r } - (next { data := l ++ m ++ r } { byteIdx := utf8Len l + utf8Len m }).byteIdx < utf8ByteSize { data := l ++ m ++ r } - { byteIdx := utf8Len l + utf8Len m }.byteIdx); if p (get { data := l ++ m ++ r } { byteIdx := utf8Len l + utf8Len m }) = true then let i' := next { data := l ++ m ++ r } { byteIdx := utf8Len l + utf8Len m }; splitAux { data := l ++ m ++ r } p i' i' (extract { data := l ++ m ++ r } { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } :: acc) else splitAux { data := l ++ m ++ r } p { byteIdx := utf8Len l } (next { data := l ++ m ++ r } { byteIdx := utf8Len l + utf8Len m }) acc) = List.reverse acc ++ List.map mk (List.splitOnP.go p r (List.reverse m)) ** simp [by simpa using atEnd_of_valid (l ++ m) r] ** p : Char → Bool l m r : List Char acc : List String ⊢ (if h : r = [] then List.reverse acc ++ [extract { data := l ++ (m ++ r) } { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m }] else if p (get { data := l ++ (m ++ r) } { byteIdx := utf8Len l + utf8Len m }) = true then splitAux { data := l ++ (m ++ r) } p (next { data := l ++ (m ++ r) } { byteIdx := utf8Len l + utf8Len m }) (next { data := l ++ (m ++ r) } { byteIdx := utf8Len l + utf8Len m }) (extract { data := l ++ (m ++ r) } { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } :: acc) else splitAux { data := l ++ (m ++ r) } p { byteIdx := utf8Len l } (next { data := l ++ (m ++ r) } { byteIdx := utf8Len l + utf8Len m }) acc) = List.reverse acc ++ List.map mk (List.splitOnP.go p r (List.reverse m)) ** split ** p : Char → Bool l m r : List Char acc : List String ⊢ ?m.106734 ** simpa using atEnd_of_valid (l ++ m) r ** case inl p : Char → Bool l m r : List Char acc : List String h✝ : r = [] ⊢ List.reverse acc ++ [extract { data := l ++ (m ++ r) } { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m }] = List.reverse acc ++ List.map mk (List.splitOnP.go p r (List.reverse m)) ** subst r ** case inl p : Char → Bool l m : List Char acc : List String ⊢ List.reverse acc ++ [extract { data := l ++ (m ++ []) } { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m }] = List.reverse acc ++ List.map mk (List.splitOnP.go p [] (List.reverse m)) ** simpa [List.splitOnP.go] using extract_of_valid l m [] ** case inr p : Char → Bool l m r : List Char acc : List String h✝ : ¬r = [] ⊢ (if p (get { data := l ++ (m ++ r) } { byteIdx := utf8Len l + utf8Len m }) = true then splitAux { data := l ++ (m ++ r) } p (next { data := l ++ (m ++ r) } { byteIdx := utf8Len l + utf8Len m }) (next { data := l ++ (m ++ r) } { byteIdx := utf8Len l + utf8Len m }) (extract { data := l ++ (m ++ r) } { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } :: acc) else splitAux { data := l ++ (m ++ r) } p { byteIdx := utf8Len l } (next { data := l ++ (m ++ r) } { byteIdx := utf8Len l + utf8Len m }) acc) = List.reverse acc ++ List.map mk (List.splitOnP.go p r (List.reverse m)) ** obtain ⟨c, r, rfl⟩ := r.exists_cons_of_ne_nil ‹_› ** case inr.intro.intro p : Char → Bool l m : List Char acc : List String c : Char r : List Char h✝ : ¬c :: r = [] ⊢ (if p (get { data := l ++ (m ++ c :: r) } { byteIdx := utf8Len l + utf8Len m }) = true then splitAux { data := l ++ (m ++ c :: r) } p (next { data := l ++ (m ++ c :: r) } { byteIdx := utf8Len l + utf8Len m }) (next { data := l ++ (m ++ c :: r) } { byteIdx := utf8Len l + utf8Len m }) (extract { data := l ++ (m ++ c :: r) } { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } :: acc) else splitAux { data := l ++ (m ++ c :: r) } p { byteIdx := utf8Len l } (next { data := l ++ (m ++ c :: r) } { byteIdx := utf8Len l + utf8Len m }) acc) = List.reverse acc ++ List.map mk (List.splitOnP.go p (c :: r) (List.reverse m)) ** simp [by simpa using (⟨get_of_valid (l++m) (c::r), next_of_valid (l++m) c r,
extract_of_valid l m (c::r)⟩ : _∧_∧_), List.splitOnP.go] ** case inr.intro.intro p : Char → Bool l m : List Char acc : List String c : Char r : List Char h✝ : ¬c :: r = [] ⊢ (if p c = true then splitAux { data := l ++ (m ++ c :: r) } p { byteIdx := utf8Len l + utf8Len m + csize c } { byteIdx := utf8Len l + utf8Len m + csize c } ({ data := m } :: acc) else splitAux { data := l ++ (m ++ c :: r) } p { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m + csize c } acc) = List.reverse acc ++ List.map mk (if p c = true then m :: List.splitOnP.go p r [] else List.splitOnP.go p r (c :: List.reverse m)) ** split ** p : Char → Bool l m : List Char acc : List String c : Char r : List Char h✝ : ¬c :: r = [] ⊢ ?m.109179 ** simpa using (⟨get_of_valid (l++m) (c::r), next_of_valid (l++m) c r,
extract_of_valid l m (c::r)⟩ : _∧_∧_) ** case inr.intro.intro.inl p : Char → Bool l m : List Char acc : List String c : Char r : List Char h✝¹ : ¬c :: r = [] h✝ : p c = true ⊢ splitAux { data := l ++ (m ++ c :: r) } p { byteIdx := utf8Len l + utf8Len m + csize c } { byteIdx := utf8Len l + utf8Len m + csize c } ({ data := m } :: acc) = List.reverse acc ++ List.map mk (m :: List.splitOnP.go p r []) ** simpa [Nat.add_assoc] using splitAux_of_valid p (l++m++[c]) [] r (⟨m⟩::acc) ** case inr.intro.intro.inr p : Char → Bool l m : List Char acc : List String c : Char r : List Char h✝¹ : ¬c :: r = [] h✝ : ¬p c = true ⊢ splitAux { data := l ++ (m ++ c :: r) } p { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m + csize c } acc = List.reverse acc ++ List.map mk (List.splitOnP.go p r (c :: List.reverse m)) ** simpa [Nat.add_assoc] using splitAux_of_valid p l (m++[c]) r acc ** Qed
| |
String.join_eq ** ss : List String x✝ : List Char ⊢ List.foldl (fun x x_1 => x ++ x_1) { data := x✝ } [] = { data := x✝ ++ List.join (List.map data []) } ** simp ** ss✝ : List String s : List Char ss : List String x✝ : List Char ⊢ { data := x✝ ++ s ++ List.join (List.map data ss) } = { data := x✝ ++ List.join (List.map data ({ data := s } :: ss)) } ** simp ** Qed
| |
String.Iterator.forward_eq_nextn ** ⊢ forward = nextn ** funext it n ** case h.h it : Iterator n : Nat ⊢ forward it n = nextn it n ** induction n generalizing it <;> simp [forward, nextn, *] ** Qed
| |
String.Iterator.hasNext_cons_addChar ** c : Char cs : List Char i : Pos ⊢ hasNext { s := { data := c :: cs }, i := i + c } = hasNext { s := { data := cs }, i := i } ** simp [hasNext, Nat.add_lt_add_iff_right] ** Qed
| |
String.Iterator.ValidFor.valid ** l r : List Char ⊢ Valid { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l } } ** simpa [List.reverseAux_eq] using Pos.Valid.mk l.reverse r ** Qed
| |
String.Iterator.ValidFor.out' ** l r : List Char ⊢ { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l } } = { s := { data := List.reverse l ++ r }, i := { byteIdx := utf8Len (List.reverse l) } } ** simp [List.reverseAux_eq] ** Qed
| |
String.Iterator.ValidFor.mk' ** l r : List Char ⊢ ValidFor l r { s := { data := List.reverse l ++ r }, i := { byteIdx := utf8Len (List.reverse l) } } ** simpa [List.reverseAux_eq] using mk ** Qed
| |
String.Iterator.ValidFor.pos_eq_zero ** l r : List Char it : Iterator h : ValidFor l r it ⊢ it.i = 0 ↔ l = [] ** simp [h.pos, Pos.ext_iff] ** Qed
| |
String.Iterator.ValidFor.pos_eq_endPos ** l r : List Char it : Iterator h : ValidFor l r it ⊢ it.i = endPos it.s ↔ r = [] ** simp [h.pos, h.toString, Pos.ext_iff] ** l r : List Char it : Iterator h : ValidFor l r it ⊢ utf8Len l = utf8Len l + utf8Len r ↔ r = [] ** exact (Nat.add_left_cancel_iff (m := 0)).trans <| eq_comm.trans utf8Len_eq_zero ** Qed
| |
String.Iterator.ValidFor.curr ** l r : List Char it : Iterator h : ValidFor l r it ⊢ Iterator.curr it = List.headD r default ** cases h.out' ** case refl l r : List Char h : ValidFor l r { s := { data := List.reverse l ++ r }, i := { byteIdx := utf8Len (List.reverse l) } } ⊢ Iterator.curr { s := { data := List.reverse l ++ r }, i := { byteIdx := utf8Len (List.reverse l) } } = List.headD r default ** apply get_of_valid ** Qed
| |
String.Iterator.ValidFor.prev ** c : Char l r : List Char it : Iterator h : ValidFor (c :: l) r it ⊢ ValidFor l (c :: r) (Iterator.prev it) ** cases h.out' ** case refl c : Char l r : List Char h : ValidFor (c :: l) r { s := { data := List.reverse (c :: l) ++ r }, i := { byteIdx := utf8Len (List.reverse (c :: l)) } } ⊢ ValidFor l (c :: r) (Iterator.prev { s := { data := List.reverse (c :: l) ++ r }, i := { byteIdx := utf8Len (List.reverse (c :: l)) } }) ** have := prev_of_valid l.reverse c r ** case refl c : Char l r : List Char h : ValidFor (c :: l) r { s := { data := List.reverse (c :: l) ++ r }, i := { byteIdx := utf8Len (List.reverse (c :: l)) } } this : String.prev { data := List.reverse l ++ c :: r } { byteIdx := utf8Len (List.reverse l) + csize c } = { byteIdx := utf8Len (List.reverse l) } ⊢ ValidFor l (c :: r) (Iterator.prev { s := { data := List.reverse (c :: l) ++ r }, i := { byteIdx := utf8Len (List.reverse (c :: l)) } }) ** simp at this ** case refl c : Char l r : List Char h : ValidFor (c :: l) r { s := { data := List.reverse (c :: l) ++ r }, i := { byteIdx := utf8Len (List.reverse (c :: l)) } } this : String.prev { data := List.reverse l ++ c :: r } { byteIdx := utf8Len l + csize c } = { byteIdx := utf8Len l } ⊢ ValidFor l (c :: r) (Iterator.prev { s := { data := List.reverse (c :: l) ++ r }, i := { byteIdx := utf8Len (List.reverse (c :: l)) } }) ** simp [Iterator.prev, this] ** case refl c : Char l r : List Char h : ValidFor (c :: l) r { s := { data := List.reverse (c :: l) ++ r }, i := { byteIdx := utf8Len (List.reverse (c :: l)) } } this : String.prev { data := List.reverse l ++ c :: r } { byteIdx := utf8Len l + csize c } = { byteIdx := utf8Len l } ⊢ ValidFor l (c :: r) { s := { data := List.reverse l ++ c :: r }, i := { byteIdx := utf8Len l } } ** exact .of_eq _ (by simp [List.reverseAux_eq]) (by simp) ** c : Char l r : List Char h : ValidFor (c :: l) r { s := { data := List.reverse (c :: l) ++ r }, i := { byteIdx := utf8Len (List.reverse (c :: l)) } } this : String.prev { data := List.reverse l ++ c :: r } { byteIdx := utf8Len l + csize c } = { byteIdx := utf8Len l } ⊢ { s := { data := List.reverse l ++ c :: r }, i := { byteIdx := utf8Len l } }.s.data = List.reverseAux l (c :: r) ** simp [List.reverseAux_eq] ** c : Char l r : List Char h : ValidFor (c :: l) r { s := { data := List.reverse (c :: l) ++ r }, i := { byteIdx := utf8Len (List.reverse (c :: l)) } } this : String.prev { data := List.reverse l ++ c :: r } { byteIdx := utf8Len l + csize c } = { byteIdx := utf8Len l } ⊢ { s := { data := List.reverse l ++ c :: r }, i := { byteIdx := utf8Len l } }.i.byteIdx = utf8Len l ** simp ** Qed
| |
String.Iterator.ValidFor.prev_nil ** r : List Char it : Iterator h : ValidFor [] r it ⊢ ValidFor [] r (Iterator.prev it) ** simp [Iterator.prev, h.toString, h.pos] ** r : List Char it : Iterator h : ValidFor [] r it ⊢ ValidFor [] r { s := { data := r }, i := 0 } ** constructor ** Qed
| |
String.Iterator.ValidFor.atEnd ** l r : List Char it : Iterator h : ValidFor l r it ⊢ Iterator.atEnd it = true ↔ r = [] ** simp [Iterator.atEnd, h.pos, h.toString] ** l r : List Char it : Iterator h : ValidFor l r it ⊢ utf8Len l ≥ utf8Len l + utf8Len r ↔ r = [] ** exact (Nat.add_le_add_iff_left _ _ 0).trans <| Nat.le_zero.trans utf8Len_eq_zero ** Qed
| |
String.Iterator.ValidFor.hasNext ** l r : List Char it : Iterator h : ValidFor l r it ⊢ Iterator.hasNext it = true ↔ r ≠ [] ** simp [Iterator.hasNext, ← h.atEnd, Iterator.atEnd] ** Qed
| |
String.Iterator.ValidFor.toEnd ** l r : List Char it : Iterator h : ValidFor l r it ⊢ ValidFor (List.reverse r ++ l) [] (Iterator.toEnd it) ** simp [Iterator.toEnd, h.toString] ** l r : List Char it : Iterator h : ValidFor l r it ⊢ ValidFor (List.reverse r ++ l) [] { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l + utf8Len r } } ** exact .of_eq _ (by simp [List.reverseAux_eq]) (by simp [Nat.add_comm]) ** l r : List Char it : Iterator h : ValidFor l r it ⊢ { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l + utf8Len r } }.s.data = List.reverseAux (List.reverse r ++ l) [] ** simp [List.reverseAux_eq] ** l r : List Char it : Iterator h : ValidFor l r it ⊢ { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l + utf8Len r } }.i.byteIdx = utf8Len (List.reverse r ++ l) ** simp [Nat.add_comm] ** Qed
| |
String.Iterator.ValidFor.toEnd' ** it : Iterator ⊢ ValidFor (List.reverse it.s.data) [] (Iterator.toEnd it) ** simp [Iterator.toEnd] ** it : Iterator ⊢ ValidFor (List.reverse it.s.data) [] { s := it.s, i := endPos it.s } ** exact .of_eq _ (by simp [List.reverseAux_eq]) (by simp [endPos, utf8ByteSize]) ** it : Iterator ⊢ { s := it.s, i := endPos it.s }.s.data = List.reverseAux (List.reverse it.s.data) [] ** simp [List.reverseAux_eq] ** it : Iterator ⊢ { s := it.s, i := endPos it.s }.i.byteIdx = utf8Len (List.reverse it.s.data) ** simp [endPos, utf8ByteSize] ** Qed
| |
String.Iterator.ValidFor.remainingToString ** l r : List Char it : Iterator h : ValidFor l r it ⊢ Iterator.remainingToString it = { data := r } ** cases h.out ** case refl l r : List Char h : ValidFor l r { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l } } ⊢ Iterator.remainingToString { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l } } = { data := r } ** simpa [Iterator.remainingToString, List.reverseAux_eq] using extract_of_valid l.reverse r [] ** Qed
| |
String.Iterator.ValidFor.nextn ** l r : List Char it : Iterator h : ValidFor l r it x✝ : 0 ≤ List.length r ⊢ ValidFor (List.reverse (List.take 0 r) ++ l) (List.drop 0 r) (Iterator.nextn it 0) ** simp [h, Iterator.nextn] ** l r : List Char it : Iterator h : ValidFor l r it n : Nat hn : n + 1 ≤ List.length r ⊢ ValidFor (List.reverse (List.take (n + 1) r) ++ l) (List.drop (n + 1) r) (Iterator.nextn it (n + 1)) ** simp [h, Iterator.nextn] ** l r : List Char it : Iterator h : ValidFor l r it n : Nat hn : n + 1 ≤ List.length r ⊢ ValidFor (List.reverse (List.take (n + 1) r) ++ l) (List.drop (n + 1) r) (Iterator.nextn (Iterator.next it) n) ** have a::r := r ** l r✝ : List Char it : Iterator n : Nat a : Char r : List Char h : ValidFor l (a :: r) it hn : n + 1 ≤ List.length (a :: r) ⊢ ValidFor (List.reverse (List.take (n + 1) (a :: r)) ++ l) (List.drop (n + 1) (a :: r)) (Iterator.nextn (Iterator.next it) n) ** simpa using h.next.nextn _ (Nat.le_of_succ_le_succ hn) ** Qed
| |
String.Iterator.ValidFor.prevn ** l r : List Char it : Iterator h : ValidFor l r it x✝ : 0 ≤ List.length l ⊢ ValidFor (List.drop 0 l) (List.reverse (List.take 0 l) ++ r) (Iterator.prevn it 0) ** simp [h, Iterator.prevn] ** l r : List Char it : Iterator h : ValidFor l r it n : Nat hn : n + 1 ≤ List.length l ⊢ ValidFor (List.drop (n + 1) l) (List.reverse (List.take (n + 1) l) ++ r) (Iterator.prevn it (n + 1)) ** simp [h, Iterator.prevn] ** l r : List Char it : Iterator h : ValidFor l r it n : Nat hn : n + 1 ≤ List.length l ⊢ ValidFor (List.drop (n + 1) l) (List.reverse (List.take (n + 1) l) ++ r) (Iterator.prevn (Iterator.prev it) n) ** have a::l := l ** l✝ r : List Char it : Iterator n : Nat a : Char l : List Char h : ValidFor (a :: l) r it hn : n + 1 ≤ List.length (a :: l) ⊢ ValidFor (List.drop (n + 1) (a :: l)) (List.reverse (List.take (n + 1) (a :: l)) ++ r) (Iterator.prevn (Iterator.prev it) n) ** simpa using h.prev.prevn _ (Nat.le_of_succ_le_succ hn) ** Qed
| |
String.Iterator.Valid.validFor ** l r : List Char ⊢ ValidFor (List.reverse l) r { s := { data := l ++ r }, i := { byteIdx := utf8ByteSize.go l } } ** simpa [List.reverseAux_eq] using @ValidFor.mk l.reverse r ** Qed
| |
String.Iterator.Valid.remainingBytes_le ** x✝ : Iterator h✝ : Valid x✝ l r : List Char h : ValidFor l r x✝ ⊢ remainingBytes x✝ ≤ utf8ByteSize x✝.s ** simp [h.remainingBytes, h.toString, Nat.le_add_left] ** Qed
| |
String.Iterator.Valid.next ** x✝ : Iterator h : Valid x✝ hn : hasNext x✝ = true ⊢ Valid (Iterator.next x✝) ** let ⟨l, r, h⟩ := h.validFor ** x✝ : Iterator h✝ : Valid x✝ hn : hasNext x✝ = true l r : List Char h : ValidFor l r x✝ ⊢ Valid (Iterator.next x✝) ** obtain ⟨c, r, rfl⟩ := List.exists_cons_of_ne_nil (h.hasNext.1 hn) ** case intro.intro x✝ : Iterator h✝ : Valid x✝ hn : hasNext x✝ = true l : List Char c : Char r : List Char h : ValidFor l (c :: r) x✝ ⊢ Valid (Iterator.next x✝) ** exact h.next.valid ** Qed
| |
String.Iterator.Valid.setCurr ** c : Char it : Iterator h : Valid it ⊢ Valid (Iterator.setCurr it c) ** let ⟨l, r, h⟩ := h.validFor ** c : Char it : Iterator h✝ : Valid it l r : List Char h : ValidFor l r it ⊢ Valid (Iterator.setCurr it c) ** exact h.setCurr'.valid ** Qed
| |
String.Iterator.Valid.remainingToString ** l r : List Char it : Iterator h : ValidFor l r it ⊢ Iterator.remainingToString it = { data := r } ** cases h.out ** case refl l r : List Char h : ValidFor l r { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l } } ⊢ Iterator.remainingToString { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l } } = { data := r } ** simpa [Iterator.remainingToString, List.reverseAux_eq] using extract_of_valid l.reverse r [] ** Qed
| |
String.offsetOfPosAux_of_valid ** l r : List Char n : Nat ⊢ offsetOfPosAux { data := l ++ [] ++ r } { byteIdx := utf8Len l + utf8Len [] } { byteIdx := utf8Len l } n = n + List.length [] ** unfold offsetOfPosAux ** l r : List Char n : Nat ⊢ (if { byteIdx := utf8Len l } ≥ { byteIdx := utf8Len l + utf8Len [] } then n else if h : atEnd { data := l ++ [] ++ r } { byteIdx := utf8Len l } = true then n else let_fun this := (_ : utf8ByteSize { data := l ++ [] ++ r } - (next { data := l ++ [] ++ r } { byteIdx := utf8Len l }).byteIdx < utf8ByteSize { data := l ++ [] ++ r } - { byteIdx := utf8Len l }.byteIdx); offsetOfPosAux { data := l ++ [] ++ r } { byteIdx := utf8Len l + utf8Len [] } (next { data := l ++ [] ++ r } { byteIdx := utf8Len l }) (n + 1)) = n + List.length [] ** simp ** l : List Char c : Char m r : List Char n : Nat ⊢ offsetOfPosAux { data := l ++ c :: m ++ r } { byteIdx := utf8Len l + utf8Len (c :: m) } { byteIdx := utf8Len l } n = n + List.length (c :: m) ** unfold offsetOfPosAux ** l : List Char c : Char m r : List Char n : Nat ⊢ (if { byteIdx := utf8Len l } ≥ { byteIdx := utf8Len l + utf8Len (c :: m) } then n else if h : atEnd { data := l ++ c :: m ++ r } { byteIdx := utf8Len l } = true then n else let_fun this := (_ : utf8ByteSize { data := l ++ c :: m ++ r } - (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }).byteIdx < utf8ByteSize { data := l ++ c :: m ++ r } - { byteIdx := utf8Len l }.byteIdx); offsetOfPosAux { data := l ++ c :: m ++ r } { byteIdx := utf8Len l + utf8Len (c :: m) } (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) (n + 1)) = n + List.length (c :: m) ** rw [if_neg (by exact Nat.not_le.2 (Nat.lt_add_of_pos_right add_csize_pos))] ** l : List Char c : Char m r : List Char n : Nat ⊢ (if h : atEnd { data := l ++ c :: m ++ r } { byteIdx := utf8Len l } = true then n else let_fun this := (_ : utf8ByteSize { data := l ++ c :: m ++ r } - (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }).byteIdx < utf8ByteSize { data := l ++ c :: m ++ r } - { byteIdx := utf8Len l }.byteIdx); offsetOfPosAux { data := l ++ c :: m ++ r } { byteIdx := utf8Len l + utf8Len (c :: m) } (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) (n + 1)) = n + List.length (c :: m) ** simp only [List.append_assoc, atEnd_of_valid l (c::m++r)] ** l : List Char c : Char m r : List Char n : Nat ⊢ (if h : c :: m ++ r = [] then n else offsetOfPosAux { data := l ++ (c :: m ++ r) } { byteIdx := utf8Len l + utf8Len (c :: m) } (next { data := l ++ (c :: m ++ r) } { byteIdx := utf8Len l }) (n + 1)) = n + List.length (c :: m) ** simp [next_of_valid l c (m++r)] ** l : List Char c : Char m r : List Char n : Nat ⊢ offsetOfPosAux { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l + (utf8Len m + csize c) } { byteIdx := utf8Len l + csize c } (n + 1) = n + Nat.succ (List.length m) ** simpa [← Nat.add_assoc, Nat.add_right_comm, Nat.succ_eq_add_one] using
offsetOfPosAux_of_valid (l++[c]) m r (n + 1) ** l : List Char c : Char m r : List Char n : Nat ⊢ ¬{ byteIdx := utf8Len l } ≥ { byteIdx := utf8Len l + utf8Len (c :: m) } ** exact Nat.not_le.2 (Nat.lt_add_of_pos_right add_csize_pos) ** Qed
| |
String.foldlAux_of_valid ** α : Type u_1 f : α → Char → α l r : List Char a : α ⊢ foldlAux f { data := l ++ [] ++ r } { byteIdx := utf8Len l + utf8Len [] } { byteIdx := utf8Len l } a = List.foldl f a [] ** unfold foldlAux ** α : Type u_1 f : α → Char → α l r : List Char a : α ⊢ (if h : { byteIdx := utf8Len l } < { byteIdx := utf8Len l + utf8Len [] } then let_fun this := (_ : { byteIdx := utf8Len l + utf8Len [] }.byteIdx - (next { data := l ++ [] ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len [] }.byteIdx - { byteIdx := utf8Len l }.byteIdx); foldlAux f { data := l ++ [] ++ r } { byteIdx := utf8Len l + utf8Len [] } (next { data := l ++ [] ++ r } { byteIdx := utf8Len l }) (f a (get { data := l ++ [] ++ r } { byteIdx := utf8Len l })) else a) = List.foldl f a [] ** simp ** α : Type u_1 f : α → Char → α l : List Char c : Char m r : List Char a : α ⊢ foldlAux f { data := l ++ c :: m ++ r } { byteIdx := utf8Len l + utf8Len (c :: m) } { byteIdx := utf8Len l } a = List.foldl f a (c :: m) ** unfold foldlAux ** α : Type u_1 f : α → Char → α l : List Char c : Char m r : List Char a : α ⊢ (if h : { byteIdx := utf8Len l } < { byteIdx := utf8Len l + utf8Len (c :: m) } then let_fun this := (_ : { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - { byteIdx := utf8Len l }.byteIdx); foldlAux f { data := l ++ c :: m ++ r } { byteIdx := utf8Len l + utf8Len (c :: m) } (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) (f a (get { data := l ++ c :: m ++ r } { byteIdx := utf8Len l })) else a) = List.foldl f a (c :: m) ** rw [dif_pos (by exact Nat.lt_add_of_pos_right add_csize_pos)] ** α : Type u_1 f : α → Char → α l : List Char c : Char m r : List Char a : α ⊢ (let_fun this := (_ : { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - { byteIdx := utf8Len l }.byteIdx); foldlAux f { data := l ++ c :: m ++ r } { byteIdx := utf8Len l + utf8Len (c :: m) } (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) (f a (get { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }))) = List.foldl f a (c :: m) ** simp [get_of_valid l (c::(m++r)), next_of_valid l c (m++r)] ** α : Type u_1 f : α → Char → α l : List Char c : Char m r : List Char a : α ⊢ foldlAux f { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l + (utf8Len m + csize c) } { byteIdx := utf8Len l + csize c } (f a c) = List.foldl f (f a c) m ** simpa [← Nat.add_assoc, Nat.add_right_comm] using foldlAux_of_valid f (l++[c]) m r (f a c) ** α : Type u_1 f : α → Char → α l : List Char c : Char m r : List Char a : α ⊢ { byteIdx := utf8Len l } < { byteIdx := utf8Len l + utf8Len (c :: m) } ** exact Nat.lt_add_of_pos_right add_csize_pos ** Qed
| |
String.foldrAux_of_valid ** α : Type u_1 f : Char → α → α l m r : List Char a : α ⊢ foldrAux f a { data := l ++ m ++ r } { byteIdx := utf8Len l + utf8Len m } { byteIdx := utf8Len l } = List.foldr f a m ** rw [← m.reverse_reverse] ** α : Type u_1 f : Char → α → α l m r : List Char a : α ⊢ foldrAux f a { data := l ++ List.reverse (List.reverse m) ++ r } { byteIdx := utf8Len l + utf8Len (List.reverse (List.reverse m)) } { byteIdx := utf8Len l } = List.foldr f a (List.reverse (List.reverse m)) ** induction m.reverse generalizing r a with (unfold foldrAux; simp)
| cons c m IH =>
rw [dif_pos (by exact Nat.lt_add_of_pos_right add_csize_pos)]
simp [← Nat.add_assoc, by simpa using prev_of_valid (l++m.reverse) c r]
simp [by simpa using get_of_valid (l++m.reverse) (c::r)]
simpa using IH (c::r) (f c a) ** case nil α : Type u_1 f : Char → α → α l m r : List Char a : α ⊢ foldrAux f a { data := l ++ List.reverse [] ++ r } { byteIdx := utf8Len l + utf8Len (List.reverse []) } { byteIdx := utf8Len l } = List.foldr f a (List.reverse []) ** unfold foldrAux ** case nil α : Type u_1 f : Char → α → α l m r : List Char a : α ⊢ (if h : { byteIdx := utf8Len l } < { byteIdx := utf8Len l + utf8Len (List.reverse []) } then let_fun this := (_ : (prev { data := l ++ List.reverse [] ++ r } { byteIdx := utf8Len l + utf8Len (List.reverse []) }).byteIdx < { byteIdx := utf8Len l + utf8Len (List.reverse []) }.byteIdx); let i := prev { data := l ++ List.reverse [] ++ r } { byteIdx := utf8Len l + utf8Len (List.reverse []) }; let a := f (get { data := l ++ List.reverse [] ++ r } i) a; foldrAux f a { data := l ++ List.reverse [] ++ r } i { byteIdx := utf8Len l } else a) = List.foldr f a (List.reverse []) ** simp ** case cons α : Type u_1 f : Char → α → α l m✝ : List Char c : Char m : List Char IH : ∀ (r : List Char) (a : α), foldrAux f a { data := l ++ List.reverse m ++ r } { byteIdx := utf8Len l + utf8Len (List.reverse m) } { byteIdx := utf8Len l } = List.foldr f a (List.reverse m) r : List Char a : α ⊢ (if h : utf8Len l < utf8Len l + (utf8Len m + csize c) then foldrAux f (f (get { data := l ++ (List.reverse m ++ c :: r) } (prev { data := l ++ (List.reverse m ++ c :: r) } { byteIdx := utf8Len l + (utf8Len m + csize c) })) a) { data := l ++ (List.reverse m ++ c :: r) } (prev { data := l ++ (List.reverse m ++ c :: r) } { byteIdx := utf8Len l + (utf8Len m + csize c) }) { byteIdx := utf8Len l } else a) = List.foldl (fun x y => f y x) (f c a) m ** rw [dif_pos (by exact Nat.lt_add_of_pos_right add_csize_pos)] ** case cons α : Type u_1 f : Char → α → α l m✝ : List Char c : Char m : List Char IH : ∀ (r : List Char) (a : α), foldrAux f a { data := l ++ List.reverse m ++ r } { byteIdx := utf8Len l + utf8Len (List.reverse m) } { byteIdx := utf8Len l } = List.foldr f a (List.reverse m) r : List Char a : α ⊢ foldrAux f (f (get { data := l ++ (List.reverse m ++ c :: r) } (prev { data := l ++ (List.reverse m ++ c :: r) } { byteIdx := utf8Len l + (utf8Len m + csize c) })) a) { data := l ++ (List.reverse m ++ c :: r) } (prev { data := l ++ (List.reverse m ++ c :: r) } { byteIdx := utf8Len l + (utf8Len m + csize c) }) { byteIdx := utf8Len l } = List.foldl (fun x y => f y x) (f c a) m ** simp [← Nat.add_assoc, by simpa using prev_of_valid (l++m.reverse) c r] ** case cons α : Type u_1 f : Char → α → α l m✝ : List Char c : Char m : List Char IH : ∀ (r : List Char) (a : α), foldrAux f a { data := l ++ List.reverse m ++ r } { byteIdx := utf8Len l + utf8Len (List.reverse m) } { byteIdx := utf8Len l } = List.foldr f a (List.reverse m) r : List Char a : α ⊢ foldrAux f (f (get { data := l ++ (List.reverse m ++ c :: r) } { byteIdx := utf8Len l + utf8Len m }) a) { data := l ++ (List.reverse m ++ c :: r) } { byteIdx := utf8Len l + utf8Len m } { byteIdx := utf8Len l } = List.foldl (fun x y => f y x) (f c a) m ** simp [by simpa using get_of_valid (l++m.reverse) (c::r)] ** case cons α : Type u_1 f : Char → α → α l m✝ : List Char c : Char m : List Char IH : ∀ (r : List Char) (a : α), foldrAux f a { data := l ++ List.reverse m ++ r } { byteIdx := utf8Len l + utf8Len (List.reverse m) } { byteIdx := utf8Len l } = List.foldr f a (List.reverse m) r : List Char a : α ⊢ foldrAux f (f c a) { data := l ++ (List.reverse m ++ c :: r) } { byteIdx := utf8Len l + utf8Len m } { byteIdx := utf8Len l } = List.foldl (fun x y => f y x) (f c a) m ** simpa using IH (c::r) (f c a) ** α : Type u_1 f : Char → α → α l m✝ : List Char c : Char m : List Char IH : ∀ (r : List Char) (a : α), foldrAux f a { data := l ++ List.reverse m ++ r } { byteIdx := utf8Len l + utf8Len (List.reverse m) } { byteIdx := utf8Len l } = List.foldr f a (List.reverse m) r : List Char a : α ⊢ utf8Len l < utf8Len l + (utf8Len m + csize c) ** exact Nat.lt_add_of_pos_right add_csize_pos ** α : Type u_1 f : Char → α → α l m✝ : List Char c : Char m : List Char IH : ∀ (r : List Char) (a : α), foldrAux f a { data := l ++ List.reverse m ++ r } { byteIdx := utf8Len l + utf8Len (List.reverse m) } { byteIdx := utf8Len l } = List.foldr f a (List.reverse m) r : List Char a : α ⊢ ?m.174498 ** simpa using prev_of_valid (l++m.reverse) c r ** α : Type u_1 f : Char → α → α l m✝ : List Char c : Char m : List Char IH : ∀ (r : List Char) (a : α), foldrAux f a { data := l ++ List.reverse m ++ r } { byteIdx := utf8Len l + utf8Len (List.reverse m) } { byteIdx := utf8Len l } = List.foldr f a (List.reverse m) r : List Char a : α ⊢ ?m.174726 ** simpa using get_of_valid (l++m.reverse) (c::r) ** Qed
| |
String.anyAux_of_valid ** p : Char → Bool l r : List Char ⊢ anyAux { data := l ++ [] ++ r } { byteIdx := utf8Len l + utf8Len [] } p { byteIdx := utf8Len l } = List.any [] p ** unfold anyAux ** p : Char → Bool l r : List Char ⊢ (if h : { byteIdx := utf8Len l } < { byteIdx := utf8Len l + utf8Len [] } then if p (get { data := l ++ [] ++ r } { byteIdx := utf8Len l }) = true then true else let_fun this := (_ : { byteIdx := utf8Len l + utf8Len [] }.byteIdx - (next { data := l ++ [] ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len [] }.byteIdx - { byteIdx := utf8Len l }.byteIdx); anyAux { data := l ++ [] ++ r } { byteIdx := utf8Len l + utf8Len [] } p (next { data := l ++ [] ++ r } { byteIdx := utf8Len l }) else false) = List.any [] p ** simp ** p : Char → Bool l : List Char c : Char m r : List Char ⊢ anyAux { data := l ++ c :: m ++ r } { byteIdx := utf8Len l + utf8Len (c :: m) } p { byteIdx := utf8Len l } = List.any (c :: m) p ** unfold anyAux ** p : Char → Bool l : List Char c : Char m r : List Char ⊢ (if h : { byteIdx := utf8Len l } < { byteIdx := utf8Len l + utf8Len (c :: m) } then if p (get { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) = true then true else let_fun this := (_ : { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - { byteIdx := utf8Len l }.byteIdx); anyAux { data := l ++ c :: m ++ r } { byteIdx := utf8Len l + utf8Len (c :: m) } p (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) else false) = List.any (c :: m) p ** rw [dif_pos (by exact Nat.lt_add_of_pos_right add_csize_pos)] ** p : Char → Bool l : List Char c : Char m r : List Char ⊢ (if p (get { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) = true then true else let_fun this := (_ : { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - { byteIdx := utf8Len l }.byteIdx); anyAux { data := l ++ c :: m ++ r } { byteIdx := utf8Len l + utf8Len (c :: m) } p (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l })) = List.any (c :: m) p ** simp [get_of_valid l (c::(m++r)), next_of_valid l c (m++r)] ** p : Char → Bool l : List Char c : Char m r : List Char ⊢ (if p c = true then true else anyAux { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l + (utf8Len m + csize c) } p { byteIdx := utf8Len l + csize c }) = (p c || List.any m p) ** cases p c <;> simp ** case false p : Char → Bool l : List Char c : Char m r : List Char ⊢ anyAux { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l + (utf8Len m + csize c) } p { byteIdx := utf8Len l + csize c } = List.any m p ** simpa [← Nat.add_assoc, Nat.add_right_comm] using anyAux_of_valid p (l++[c]) m r ** p : Char → Bool l : List Char c : Char m r : List Char ⊢ { byteIdx := utf8Len l } < { byteIdx := utf8Len l + utf8Len (c :: m) } ** exact Nat.lt_add_of_pos_right add_csize_pos ** Qed
| |
String.any_eq ** s : String p : Char → Bool ⊢ any s p = List.any s.data p ** simpa using anyAux_of_valid p [] s.1 [] ** Qed
| |
String.any_iff ** s : String p : Char → Bool ⊢ any s p = true ↔ ∃ c, c ∈ s.data ∧ p c = true ** simp [any_eq] ** Qed
| |
String.all_eq ** s : String p : Char → Bool ⊢ all s p = List.all s.data p ** rw [all, any_eq, List.all_eq_not_any_not] ** Qed
| |
String.mapAux_of_valid ** f : Char → Char l : List Char ⊢ mapAux f { byteIdx := utf8Len l } { data := l ++ [] } = { data := l ++ List.map f [] } ** unfold mapAux ** f : Char → Char l : List Char ⊢ (if h : atEnd { data := l ++ [] } { byteIdx := utf8Len l } = true then { data := l ++ [] } else let c := f (get { data := l ++ [] } { byteIdx := utf8Len l }); let_fun this := (_ : (endPos (set { data := l ++ [] } { byteIdx := utf8Len l } c)).byteIdx - (next (set { data := l ++ [] } { byteIdx := utf8Len l } c) { byteIdx := utf8Len l }).byteIdx < (endPos { data := l ++ [] }).byteIdx - { byteIdx := utf8Len l }.byteIdx); let s := set { data := l ++ [] } { byteIdx := utf8Len l } c; mapAux f (next s { byteIdx := utf8Len l }) s) = { data := l ++ List.map f [] } ** simp ** f : Char → Char l : List Char c : Char r : List Char ⊢ mapAux f { byteIdx := utf8Len l } { data := l ++ c :: r } = { data := l ++ List.map f (c :: r) } ** unfold mapAux ** f : Char → Char l : List Char c : Char r : List Char ⊢ (if h : atEnd { data := l ++ c :: r } { byteIdx := utf8Len l } = true then { data := l ++ c :: r } else let c_1 := f (get { data := l ++ c :: r } { byteIdx := utf8Len l }); let_fun this := (_ : (endPos (set { data := l ++ c :: r } { byteIdx := utf8Len l } c_1)).byteIdx - (next (set { data := l ++ c :: r } { byteIdx := utf8Len l } c_1) { byteIdx := utf8Len l }).byteIdx < (endPos { data := l ++ c :: r }).byteIdx - { byteIdx := utf8Len l }.byteIdx); let s := set { data := l ++ c :: r } { byteIdx := utf8Len l } c_1; mapAux f (next s { byteIdx := utf8Len l }) s) = { data := l ++ List.map f (c :: r) } ** rw [dif_neg (by rw [atEnd_of_valid]; simp)] ** f : Char → Char l : List Char c : Char r : List Char ⊢ (let c_1 := f (get { data := l ++ c :: r } { byteIdx := utf8Len l }); let_fun this := (_ : (endPos (set { data := l ++ c :: r } { byteIdx := utf8Len l } c_1)).byteIdx - (next (set { data := l ++ c :: r } { byteIdx := utf8Len l } c_1) { byteIdx := utf8Len l }).byteIdx < (endPos { data := l ++ c :: r }).byteIdx - { byteIdx := utf8Len l }.byteIdx); let s := set { data := l ++ c :: r } { byteIdx := utf8Len l } c_1; mapAux f (next s { byteIdx := utf8Len l }) s) = { data := l ++ List.map f (c :: r) } ** simp [set_of_valid l (c::r), get_of_valid l (c::r), next_of_valid l (f c) r] ** f : Char → Char l : List Char c : Char r : List Char ⊢ mapAux f { byteIdx := utf8Len l + csize (f c) } { data := l ++ f c :: r } = { data := l ++ f c :: List.map f r } ** simpa using mapAux_of_valid f (l++[f c]) r ** f : Char → Char l : List Char c : Char r : List Char ⊢ ¬atEnd { data := l ++ c :: r } { byteIdx := utf8Len l } = true ** rw [atEnd_of_valid] ** f : Char → Char l : List Char c : Char r : List Char ⊢ ¬c :: r = [] ** simp ** Qed
| |
String.takeWhileAux_of_valid ** p : Char → Bool l r : List Char ⊢ Substring.takeWhileAux { data := l ++ [] ++ r } { byteIdx := utf8Len l + utf8Len [] } p { byteIdx := utf8Len l } = { byteIdx := utf8Len l + utf8Len (List.takeWhile p []) } ** unfold Substring.takeWhileAux List.takeWhile ** p : Char → Bool l r : List Char ⊢ (if h : { byteIdx := utf8Len l } < { byteIdx := utf8Len l + utf8Len [] } then if p (get { data := l ++ [] ++ r } { byteIdx := utf8Len l }) = true then let_fun this := (_ : { byteIdx := utf8Len l + utf8Len [] }.byteIdx - (next { data := l ++ [] ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len [] }.byteIdx - { byteIdx := utf8Len l }.byteIdx); Substring.takeWhileAux { data := l ++ [] ++ r } { byteIdx := utf8Len l + utf8Len [] } p (next { data := l ++ [] ++ r } { byteIdx := utf8Len l }) else { byteIdx := utf8Len l } else { byteIdx := utf8Len l }) = { byteIdx := utf8Len l + utf8Len [] } ** simp ** p : Char → Bool l : List Char c : Char m r : List Char ⊢ Substring.takeWhileAux { data := l ++ c :: m ++ r } { byteIdx := utf8Len l + utf8Len (c :: m) } p { byteIdx := utf8Len l } = { byteIdx := utf8Len l + utf8Len (List.takeWhile p (c :: m)) } ** unfold Substring.takeWhileAux List.takeWhile ** p : Char → Bool l : List Char c : Char m r : List Char ⊢ (if h : { byteIdx := utf8Len l } < { byteIdx := utf8Len l + utf8Len (c :: m) } then if p (get { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) = true then let_fun this := (_ : { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - { byteIdx := utf8Len l }.byteIdx); Substring.takeWhileAux { data := l ++ c :: m ++ r } { byteIdx := utf8Len l + utf8Len (c :: m) } p (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) else { byteIdx := utf8Len l } else { byteIdx := utf8Len l }) = { byteIdx := utf8Len l + utf8Len (match p c with | true => c :: List.takeWhile p m | false => []) } ** rw [dif_pos (by exact Nat.lt_add_of_pos_right add_csize_pos)] ** p : Char → Bool l : List Char c : Char m r : List Char ⊢ (if p (get { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) = true then let_fun this := (_ : { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }).byteIdx < { byteIdx := utf8Len l + utf8Len (c :: m) }.byteIdx - { byteIdx := utf8Len l }.byteIdx); Substring.takeWhileAux { data := l ++ c :: m ++ r } { byteIdx := utf8Len l + utf8Len (c :: m) } p (next { data := l ++ c :: m ++ r } { byteIdx := utf8Len l }) else { byteIdx := utf8Len l }) = { byteIdx := utf8Len l + utf8Len (match p c with | true => c :: List.takeWhile p m | false => []) } ** simp [get_of_valid l (c::(m++r)), next_of_valid l c (m++r)] ** p : Char → Bool l : List Char c : Char m r : List Char ⊢ (if p c = true then Substring.takeWhileAux { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l + (utf8Len m + csize c) } p { byteIdx := utf8Len l + csize c } else { byteIdx := utf8Len l }) = { byteIdx := utf8Len l + utf8Len (match p c with | true => c :: List.takeWhile p m | false => []) } ** cases p c <;> simp ** case true p : Char → Bool l : List Char c : Char m r : List Char ⊢ Substring.takeWhileAux { data := l ++ c :: (m ++ r) } { byteIdx := utf8Len l + (utf8Len m + csize c) } p { byteIdx := utf8Len l + csize c } = { byteIdx := utf8Len l + (utf8Len (List.takeWhile p m) + csize c) } ** simpa [← Nat.add_assoc, Nat.add_right_comm] using takeWhileAux_of_valid p (l++[c]) m r ** p : Char → Bool l : List Char c : Char m r : List Char ⊢ { byteIdx := utf8Len l } < { byteIdx := utf8Len l + utf8Len (c :: m) } ** exact Nat.lt_add_of_pos_right add_csize_pos ** Qed
| |
Substring.prev_zero ** s : Substring ⊢ prev s 0 = 0 ** simp [prev, Pos.add_eq] ** Qed
| |
Substring.prevn_zero ** s : Substring n : Nat ⊢ prevn s (n + 1) 0 = 0 ** simp [prevn, prevn_zero s n] ** Qed
| |
Substring.ValidFor.valid ** l m r : List Char ⊢ l ++ (m ++ r) = { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l }, stopPos := { byteIdx := utf8Len l + utf8Len m } }.str.data ∧ { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l }, stopPos := { byteIdx := utf8Len l + utf8Len m } }.startPos.byteIdx = utf8Len l ** simp ** l m r : List Char ⊢ l ++ m ++ r = { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l }, stopPos := { byteIdx := utf8Len l + utf8Len m } }.str.data ∧ { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l }, stopPos := { byteIdx := utf8Len l + utf8Len m } }.stopPos.byteIdx = utf8Len (l ++ m) ** simp ** Qed
| |
String.validFor_toSubstring ** s : String ⊢ (toSubstring s).str.data = [] ++ s.data ++ [] ** simp [toSubstring] ** s : String ⊢ (toSubstring s).stopPos.byteIdx = utf8Len [] + utf8Len s.data ** simp [toSubstring, endPos, utf8ByteSize] ** Qed
| |
Substring.ValidFor.get ** l m₁ : List Char c : Char m₂ r : List Char ⊢ Substring.get { str := { data := l ++ (m₁ ++ c :: m₂) ++ r }, startPos := { byteIdx := utf8Len l }, stopPos := { byteIdx := utf8Len l + utf8Len (m₁ ++ c :: m₂) } } { byteIdx := utf8Len m₁ } = c ** simpa using get_of_valid (l ++ m₁) (c :: m₂ ++ r) ** Qed
| |
Substring.ValidFor.next ** l m₁ : List Char c : Char m₂ r : List Char ⊢ Substring.next { str := { data := l ++ (m₁ ++ c :: m₂) ++ r }, startPos := { byteIdx := utf8Len l }, stopPos := { byteIdx := utf8Len l + utf8Len (m₁ ++ c :: m₂) } } { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + csize c } ** simp [Substring.next] ** l m₁ : List Char c : Char m₂ r : List Char ⊢ (if { byteIdx := utf8Len l } + { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len l + (utf8Len m₁ + (utf8Len m₂ + csize c)) } then { byteIdx := utf8Len m₁ } else { byteIdx := (String.next { data := l ++ (m₁ ++ c :: (m₂ ++ r)) } ({ byteIdx := utf8Len l } + { byteIdx := utf8Len m₁ })).byteIdx - utf8Len l }) = { byteIdx := utf8Len m₁ + csize c } ** rw [if_neg (mt Pos.ext_iff.1 ?a)] ** l m₁ : List Char c : Char m₂ r : List Char ⊢ { byteIdx := (String.next { data := l ++ (m₁ ++ c :: (m₂ ++ r)) } ({ byteIdx := utf8Len l } + { byteIdx := utf8Len m₁ })).byteIdx - utf8Len l } = { byteIdx := utf8Len m₁ + csize c } case a l m₁ : List Char c : Char m₂ r : List Char ⊢ ¬({ byteIdx := utf8Len l } + { byteIdx := utf8Len m₁ }).byteIdx = { byteIdx := utf8Len l + (utf8Len m₁ + (utf8Len m₂ + csize c)) }.byteIdx ** case a =>
simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using
@ne_add_csize_add_self (utf8Len l + utf8Len m₁) (utf8Len m₂) c ** l m₁ : List Char c : Char m₂ r : List Char ⊢ { byteIdx := (String.next { data := l ++ (m₁ ++ c :: (m₂ ++ r)) } ({ byteIdx := utf8Len l } + { byteIdx := utf8Len m₁ })).byteIdx - utf8Len l } = { byteIdx := utf8Len m₁ + csize c } ** have := next_of_valid (l ++ m₁) c (m₂ ++ r) ** l m₁ : List Char c : Char m₂ r : List Char this : String.next { data := l ++ m₁ ++ c :: (m₂ ++ r) } { byteIdx := utf8Len (l ++ m₁) } = { byteIdx := utf8Len (l ++ m₁) + csize c } ⊢ { byteIdx := (String.next { data := l ++ (m₁ ++ c :: (m₂ ++ r)) } ({ byteIdx := utf8Len l } + { byteIdx := utf8Len m₁ })).byteIdx - utf8Len l } = { byteIdx := utf8Len m₁ + csize c } ** simp [Pos.add_eq] at this ⊢ ** l m₁ : List Char c : Char m₂ r : List Char this : String.next { data := l ++ (m₁ ++ c :: (m₂ ++ r)) } { byteIdx := utf8Len l + utf8Len m₁ } = { byteIdx := utf8Len l + utf8Len m₁ + csize c } ⊢ { byteIdx := (String.next { data := l ++ (m₁ ++ c :: (m₂ ++ r)) } { byteIdx := utf8Len l + utf8Len m₁ }).byteIdx - utf8Len l } = { byteIdx := utf8Len m₁ + csize c } ** rw [this] ** l m₁ : List Char c : Char m₂ r : List Char this : String.next { data := l ++ (m₁ ++ c :: (m₂ ++ r)) } { byteIdx := utf8Len l + utf8Len m₁ } = { byteIdx := utf8Len l + utf8Len m₁ + csize c } ⊢ { byteIdx := { byteIdx := utf8Len l + utf8Len m₁ + csize c }.byteIdx - utf8Len l } = { byteIdx := utf8Len m₁ + csize c } ** simp [Nat.add_assoc, Nat.add_sub_cancel_left] ** l m₁ : List Char c : Char m₂ r : List Char ⊢ ¬({ byteIdx := utf8Len l } + { byteIdx := utf8Len m₁ }).byteIdx = { byteIdx := utf8Len l + (utf8Len m₁ + (utf8Len m₂ + csize c)) }.byteIdx ** simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using
@ne_add_csize_add_self (utf8Len l + utf8Len m₁) (utf8Len m₂) c ** Qed
| |
Substring.ValidFor.next_stop ** l m r : List Char ⊢ Substring.next { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l }, stopPos := { byteIdx := utf8Len l + utf8Len m } } { byteIdx := utf8Len m } = { byteIdx := utf8Len m } ** simp [Substring.next, Pos.add_eq] ** Qed
| |
Substring.ValidFor.prev ** l m₁ : List Char c : Char m₂ r : List Char ⊢ Substring.prev { str := { data := l ++ (m₁ ++ c :: m₂) ++ r }, startPos := { byteIdx := utf8Len l }, stopPos := { byteIdx := utf8Len l + utf8Len (m₁ ++ c :: m₂) } } { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ } ** simp [Substring.prev] ** l m₁ : List Char c : Char m₂ r : List Char ⊢ (if { byteIdx := utf8Len l } + { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len l } then { byteIdx := utf8Len m₁ + csize c } else { byteIdx := (String.prev { data := l ++ (m₁ ++ c :: (m₂ ++ r)) } ({ byteIdx := utf8Len l } + { byteIdx := utf8Len m₁ + csize c })).byteIdx - utf8Len l }) = { byteIdx := utf8Len m₁ } ** rw [if_neg (mt Pos.ext_iff.1 <| Ne.symm ?a)] ** l m₁ : List Char c : Char m₂ r : List Char ⊢ { byteIdx := (String.prev { data := l ++ (m₁ ++ c :: (m₂ ++ r)) } ({ byteIdx := utf8Len l } + { byteIdx := utf8Len m₁ + csize c })).byteIdx - utf8Len l } = { byteIdx := utf8Len m₁ } case a l m₁ : List Char c : Char m₂ r : List Char ⊢ { byteIdx := utf8Len l }.byteIdx ≠ ({ byteIdx := utf8Len l } + { byteIdx := utf8Len m₁ + csize c }).byteIdx ** case a => simpa [Nat.add_comm] using @ne_add_csize_add_self (utf8Len l) (utf8Len m₁) c ** l m₁ : List Char c : Char m₂ r : List Char ⊢ { byteIdx := (String.prev { data := l ++ (m₁ ++ c :: (m₂ ++ r)) } ({ byteIdx := utf8Len l } + { byteIdx := utf8Len m₁ + csize c })).byteIdx - utf8Len l } = { byteIdx := utf8Len m₁ } ** have := prev_of_valid (l ++ m₁) c (m₂ ++ r) ** l m₁ : List Char c : Char m₂ r : List Char this : String.prev { data := l ++ m₁ ++ c :: (m₂ ++ r) } { byteIdx := utf8Len (l ++ m₁) + csize c } = { byteIdx := utf8Len (l ++ m₁) } ⊢ { byteIdx := (String.prev { data := l ++ (m₁ ++ c :: (m₂ ++ r)) } ({ byteIdx := utf8Len l } + { byteIdx := utf8Len m₁ + csize c })).byteIdx - utf8Len l } = { byteIdx := utf8Len m₁ } ** simp [Pos.add_eq, Nat.add_assoc] at this ⊢ ** l m₁ : List Char c : Char m₂ r : List Char this : String.prev { data := l ++ (m₁ ++ c :: (m₂ ++ r)) } { byteIdx := utf8Len l + (utf8Len m₁ + csize c) } = { byteIdx := utf8Len l + utf8Len m₁ } ⊢ { byteIdx := (String.prev { data := l ++ (m₁ ++ c :: (m₂ ++ r)) } { byteIdx := utf8Len l + (utf8Len m₁ + csize c) }).byteIdx - utf8Len l } = { byteIdx := utf8Len m₁ } ** rw [this] ** l m₁ : List Char c : Char m₂ r : List Char this : String.prev { data := l ++ (m₁ ++ c :: (m₂ ++ r)) } { byteIdx := utf8Len l + (utf8Len m₁ + csize c) } = { byteIdx := utf8Len l + utf8Len m₁ } ⊢ { byteIdx := { byteIdx := utf8Len l + utf8Len m₁ }.byteIdx - utf8Len l } = { byteIdx := utf8Len m₁ } ** simp [Nat.add_sub_cancel_left] ** l m₁ : List Char c : Char m₂ r : List Char ⊢ { byteIdx := utf8Len l }.byteIdx ≠ ({ byteIdx := utf8Len l } + { byteIdx := utf8Len m₁ + csize c }).byteIdx ** simpa [Nat.add_comm] using @ne_add_csize_add_self (utf8Len l) (utf8Len m₁) c ** Qed
| |
Substring.ValidFor.nextn_stop ** l m r : List Char x✝ : Substring h : ValidFor l m r x✝ n : Nat ⊢ nextn x✝ (n + 1) { byteIdx := utf8Len m } = { byteIdx := utf8Len m } ** simp [Substring.nextn, h.next_stop, h.nextn_stop n] ** Qed
| |
Substring.ValidFor.nextn ** l m₁ m₂ r : List Char x✝¹ : Substring x✝ : ValidFor l (m₁ ++ m₂) r x✝¹ ⊢ Substring.nextn x✝¹ 0 { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + utf8Len (List.take 0 m₂) } ** simp [Substring.nextn] ** l m₁ m₂ r : List Char s : Substring h : ValidFor l (m₁ ++ m₂) r s n : Nat ⊢ Substring.nextn s (n + 1) { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + utf8Len (List.take (n + 1) m₂) } ** simp [Substring.nextn] ** l m₁ m₂ r : List Char s : Substring h : ValidFor l (m₁ ++ m₂) r s n : Nat ⊢ Substring.nextn s n (Substring.next s { byteIdx := utf8Len m₁ }) = { byteIdx := utf8Len m₁ + utf8Len (List.take (n + 1) m₂) } ** match m₂ with
| [] => simp at h; simp [h.next_stop, h.nextn_stop]
| c::m₂ =>
rw [h.next]
have := @nextn l (m₁ ++ [c]) m₂ r s (by simp [h]) n
simp at this; rw [this]; simp [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] ** l m₁ m₂ r : List Char s : Substring n : Nat h : ValidFor l (m₁ ++ []) r s ⊢ Substring.nextn s n (Substring.next s { byteIdx := utf8Len m₁ }) = { byteIdx := utf8Len m₁ + utf8Len (List.take (n + 1) []) } ** simp at h ** l m₁ m₂ r : List Char s : Substring n : Nat h : ValidFor l m₁ r s ⊢ Substring.nextn s n (Substring.next s { byteIdx := utf8Len m₁ }) = { byteIdx := utf8Len m₁ + utf8Len (List.take (n + 1) []) } ** simp [h.next_stop, h.nextn_stop] ** l m₁ m₂✝ r : List Char s : Substring n : Nat c : Char m₂ : List Char h : ValidFor l (m₁ ++ c :: m₂) r s ⊢ Substring.nextn s n (Substring.next s { byteIdx := utf8Len m₁ }) = { byteIdx := utf8Len m₁ + utf8Len (List.take (n + 1) (c :: m₂)) } ** rw [h.next] ** l m₁ m₂✝ r : List Char s : Substring n : Nat c : Char m₂ : List Char h : ValidFor l (m₁ ++ c :: m₂) r s ⊢ Substring.nextn s n { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ + utf8Len (List.take (n + 1) (c :: m₂)) } ** have := @nextn l (m₁ ++ [c]) m₂ r s (by simp [h]) n ** l m₁ m₂✝ r : List Char s : Substring n : Nat c : Char m₂ : List Char h : ValidFor l (m₁ ++ c :: m₂) r s this : Substring.nextn s n { byteIdx := utf8Len (m₁ ++ [c]) } = { byteIdx := utf8Len (m₁ ++ [c]) + utf8Len (List.take n m₂) } ⊢ Substring.nextn s n { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ + utf8Len (List.take (n + 1) (c :: m₂)) } ** simp at this ** l m₁ m₂✝ r : List Char s : Substring n : Nat c : Char m₂ : List Char h : ValidFor l (m₁ ++ c :: m₂) r s this : Substring.nextn s n { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ + csize c + utf8Len (List.take n m₂) } ⊢ Substring.nextn s n { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ + utf8Len (List.take (n + 1) (c :: m₂)) } ** rw [this] ** l m₁ m₂✝ r : List Char s : Substring n : Nat c : Char m₂ : List Char h : ValidFor l (m₁ ++ c :: m₂) r s this : Substring.nextn s n { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ + csize c + utf8Len (List.take n m₂) } ⊢ { byteIdx := utf8Len m₁ + csize c + utf8Len (List.take n m₂) } = { byteIdx := utf8Len m₁ + utf8Len (List.take (n + 1) (c :: m₂)) } ** simp [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] ** l m₁ m₂✝ r : List Char s : Substring n : Nat c : Char m₂ : List Char h : ValidFor l (m₁ ++ c :: m₂) r s ⊢ ValidFor l (m₁ ++ [c] ++ m₂) r s ** simp [h] ** Qed
| |
Substring.ValidFor.prevn ** l m₂ r m₁ : List Char x✝¹ : Substring x✝ : ValidFor l (List.reverse m₁ ++ m₂) r x✝¹ ⊢ Substring.prevn x✝¹ 0 { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop 0 m₁) } ** simp [Substring.prevn] ** l m₂ r m₁ : List Char s : Substring h : ValidFor l (List.reverse m₁ ++ m₂) r s n : Nat ⊢ Substring.prevn s (n + 1) { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop (n + 1) m₁) } ** simp [Substring.prevn] ** l m₂ r m₁ : List Char s : Substring h : ValidFor l (List.reverse m₁ ++ m₂) r s n : Nat ⊢ Substring.prevn s n (Substring.prev s { byteIdx := utf8Len m₁ }) = { byteIdx := utf8Len (List.drop (n + 1) m₁) } ** match m₁ with
| [] => simp
| c::m₁ =>
rw [List.reverse_cons, List.append_assoc] at h
have := h.prev; simp at this; simp [this, h.prevn n] ** l m₂ r m₁ : List Char s : Substring n : Nat h : ValidFor l (List.reverse [] ++ m₂) r s ⊢ Substring.prevn s n (Substring.prev s { byteIdx := utf8Len [] }) = { byteIdx := utf8Len (List.drop (n + 1) []) } ** simp ** l m₂ r m₁✝ : List Char s : Substring n : Nat c : Char m₁ : List Char h : ValidFor l (List.reverse (c :: m₁) ++ m₂) r s ⊢ Substring.prevn s n (Substring.prev s { byteIdx := utf8Len (c :: m₁) }) = { byteIdx := utf8Len (List.drop (n + 1) (c :: m₁)) } ** rw [List.reverse_cons, List.append_assoc] at h ** l m₂ r m₁✝ : List Char s : Substring n : Nat c : Char m₁ : List Char h : ValidFor l (List.reverse m₁ ++ ([c] ++ m₂)) r s ⊢ Substring.prevn s n (Substring.prev s { byteIdx := utf8Len (c :: m₁) }) = { byteIdx := utf8Len (List.drop (n + 1) (c :: m₁)) } ** have := h.prev ** l m₂ r m₁✝ : List Char s : Substring n : Nat c : Char m₁ : List Char h : ValidFor l (List.reverse m₁ ++ ([c] ++ m₂)) r s this : Substring.prev s { byteIdx := utf8Len (List.reverse m₁) + csize c } = { byteIdx := utf8Len (List.reverse m₁) } ⊢ Substring.prevn s n (Substring.prev s { byteIdx := utf8Len (c :: m₁) }) = { byteIdx := utf8Len (List.drop (n + 1) (c :: m₁)) } ** simp at this ** l m₂ r m₁✝ : List Char s : Substring n : Nat c : Char m₁ : List Char h : ValidFor l (List.reverse m₁ ++ ([c] ++ m₂)) r s this : Substring.prev s { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ } ⊢ Substring.prevn s n (Substring.prev s { byteIdx := utf8Len (c :: m₁) }) = { byteIdx := utf8Len (List.drop (n + 1) (c :: m₁)) } ** simp [this, h.prevn n] ** Qed
| |
Substring.Valid.valid ** l m r : List Char ⊢ l ++ (m ++ r) = { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l }, stopPos := { byteIdx := utf8Len l + utf8Len m } }.str.data ∧ { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l }, stopPos := { byteIdx := utf8Len l + utf8Len m } }.startPos.byteIdx = utf8Len l ** simp ** l m r : List Char ⊢ l ++ m ++ r = { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l }, stopPos := { byteIdx := utf8Len l + utf8Len m } }.str.data ∧ { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l }, stopPos := { byteIdx := utf8Len l + utf8Len m } }.stopPos.byteIdx = utf8Len (l ++ m) ** simp ** Qed
| |
Substring.Valid.bsize ** x✝ : Substring h✝ : Valid x✝ l m r : List Char h : ValidFor l m r x✝ ⊢ Substring.bsize x✝ = utf8Len (toString x✝).data ** simp [h.bsize, h.toString] ** Qed
| |
Substring.Valid.get ** m₁ : List Char c : Char m₂ : List Char x✝ : Substring h : Valid x✝ e : (toString x✝).data = m₁ ++ c :: m₂ ⊢ Substring.get x✝ { byteIdx := utf8Len m₁ } = c ** let ⟨l, m, r, h⟩ := h.validFor ** m₁ : List Char c : Char m₂ : List Char x✝ : Substring h✝ : Valid x✝ e : (toString x✝).data = m₁ ++ c :: m₂ l m r : List Char h : ValidFor l m r x✝ ⊢ Substring.get x✝ { byteIdx := utf8Len m₁ } = c ** simp [h.toString] at e ** m₁ : List Char c : Char m₂ : List Char x✝ : Substring h✝ : Valid x✝ l m r : List Char h : ValidFor l m r x✝ e : m = m₁ ++ c :: m₂ ⊢ Substring.get x✝ { byteIdx := utf8Len m₁ } = c ** subst e ** m₁ : List Char c : Char m₂ : List Char x✝ : Substring h✝ : Valid x✝ l r : List Char h : ValidFor l (m₁ ++ c :: m₂) r x✝ ⊢ Substring.get x✝ { byteIdx := utf8Len m₁ } = c ** simp [h.get] ** Qed
| |
Substring.Valid.next ** m₁ : List Char c : Char m₂ : List Char x✝ : Substring h : Valid x✝ e : (toString x✝).data = m₁ ++ c :: m₂ ⊢ Substring.next x✝ { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + csize c } ** let ⟨l, m, r, h⟩ := h.validFor ** m₁ : List Char c : Char m₂ : List Char x✝ : Substring h✝ : Valid x✝ e : (toString x✝).data = m₁ ++ c :: m₂ l m r : List Char h : ValidFor l m r x✝ ⊢ Substring.next x✝ { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + csize c } ** simp [h.toString] at e ** m₁ : List Char c : Char m₂ : List Char x✝ : Substring h✝ : Valid x✝ l m r : List Char h : ValidFor l m r x✝ e : m = m₁ ++ c :: m₂ ⊢ Substring.next x✝ { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + csize c } ** subst e ** m₁ : List Char c : Char m₂ : List Char x✝ : Substring h✝ : Valid x✝ l r : List Char h : ValidFor l (m₁ ++ c :: m₂) r x✝ ⊢ Substring.next x✝ { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + csize c } ** simp [h.next] ** Qed
| |
Substring.Valid.next_stop ** x✝ : Substring h✝ : Valid x✝ l m r : List Char h : ValidFor l m r x✝ ⊢ Substring.next x✝ { byteIdx := Substring.bsize x✝ } = { byteIdx := Substring.bsize x✝ } ** simp [h.bsize, h.next_stop] ** Qed
| |
Substring.Valid.prev ** m₁ : List Char c : Char m₂ : List Char x✝ : Substring h : Valid x✝ e : (toString x✝).data = m₁ ++ c :: m₂ ⊢ Substring.prev x✝ { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ } ** let ⟨l, m, r, h⟩ := h.validFor ** m₁ : List Char c : Char m₂ : List Char x✝ : Substring h✝ : Valid x✝ e : (toString x✝).data = m₁ ++ c :: m₂ l m r : List Char h : ValidFor l m r x✝ ⊢ Substring.prev x✝ { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ } ** simp [h.toString] at e ** m₁ : List Char c : Char m₂ : List Char x✝ : Substring h✝ : Valid x✝ l m r : List Char h : ValidFor l m r x✝ e : m = m₁ ++ c :: m₂ ⊢ Substring.prev x✝ { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ } ** subst e ** m₁ : List Char c : Char m₂ : List Char x✝ : Substring h✝ : Valid x✝ l r : List Char h : ValidFor l (m₁ ++ c :: m₂) r x✝ ⊢ Substring.prev x✝ { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ } ** simp [h.prev] ** Qed
| |
Substring.Valid.nextn_stop ** x✝ : Substring h✝ : Valid x✝ n : Nat l m r : List Char h : ValidFor l m r x✝ ⊢ nextn x✝ n { byteIdx := Substring.bsize x✝ } = { byteIdx := Substring.bsize x✝ } ** simp [h.bsize, h.nextn_stop] ** Qed
| |
Substring.Valid.nextn ** m₁ m₂ : List Char x✝ : Substring h : Valid x✝ e : (toString x✝).data = m₁ ++ m₂ ⊢ ∀ (n : Nat), Substring.nextn x✝ n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + utf8Len (List.take n m₂) } ** let ⟨l, m, r, h⟩ := h.validFor ** m₁ m₂ : List Char x✝ : Substring h✝ : Valid x✝ e : (toString x✝).data = m₁ ++ m₂ l m r : List Char h : ValidFor l m r x✝ ⊢ ∀ (n : Nat), Substring.nextn x✝ n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + utf8Len (List.take n m₂) } ** simp [h.toString] at e ** m₁ m₂ : List Char x✝ : Substring h✝ : Valid x✝ l m r : List Char h : ValidFor l m r x✝ e : m = m₁ ++ m₂ ⊢ ∀ (n : Nat), Substring.nextn x✝ n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + utf8Len (List.take n m₂) } ** subst e ** m₁ m₂ : List Char x✝ : Substring h✝ : Valid x✝ l r : List Char h : ValidFor l (m₁ ++ m₂) r x✝ ⊢ ∀ (n : Nat), Substring.nextn x✝ n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len m₁ + utf8Len (List.take n m₂) } ** simp [h.nextn] ** Qed
| |
Substring.Valid.prevn ** m₂ m₁ : List Char x✝ : Substring h : Valid x✝ e : (toString x✝).data = List.reverse m₁ ++ m₂ ⊢ ∀ (n : Nat), Substring.prevn x✝ n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop n m₁) } ** let ⟨l, m, r, h⟩ := h.validFor ** m₂ m₁ : List Char x✝ : Substring h✝ : Valid x✝ e : (toString x✝).data = List.reverse m₁ ++ m₂ l m r : List Char h : ValidFor l m r x✝ ⊢ ∀ (n : Nat), Substring.prevn x✝ n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop n m₁) } ** simp [h.toString] at e ** m₂ m₁ : List Char x✝ : Substring h✝ : Valid x✝ l m r : List Char h : ValidFor l m r x✝ e : m = List.reverse m₁ ++ m₂ ⊢ ∀ (n : Nat), Substring.prevn x✝ n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop n m₁) } ** subst e ** m₂ m₁ : List Char x✝ : Substring h✝ : Valid x✝ l r : List Char h : ValidFor l (List.reverse m₁ ++ m₂) r x✝ ⊢ ∀ (n : Nat), Substring.prevn x✝ n { byteIdx := utf8Len m₁ } = { byteIdx := utf8Len (List.drop n m₁) } ** simp [h.prevn] ** Qed
| |
Substring.Valid.data_drop ** x✝¹ : Substring h✝ : Valid x✝¹ x✝ : Nat w✝² w✝¹ w✝ : List Char h : ValidFor w✝² w✝¹ w✝ x✝¹ ⊢ (toString (Substring.drop x✝¹ x✝)).data = List.drop x✝ (toString x✝¹).data ** simp [(h.drop _).toString, h.toString] ** Qed
| |
Substring.Valid.data_take ** x✝¹ : Substring h✝ : Valid x✝¹ x✝ : Nat w✝² w✝¹ w✝ : List Char h : ValidFor w✝² w✝¹ w✝ x✝¹ ⊢ (toString (Substring.take x✝¹ x✝)).data = List.take x✝ (toString x✝¹).data ** simp [(h.take _).toString, h.toString] ** Qed
| |
Substring.Valid.atEnd ** p : Nat x✝ : Substring h✝ : Valid x✝ w✝² w✝¹ w✝ : List Char h : ValidFor w✝² w✝¹ w✝ x✝ ⊢ Substring.atEnd x✝ { byteIdx := p } = true ↔ p = utf8ByteSize (toString x✝) ** simp [h.atEnd, h.toString] ** Qed
| |
Substring.Valid.extract ** b e : Pos x✝ : Substring h₁ : Valid x✝ h₂ : Valid { str := toString x✝, startPos := b, stopPos := e } ⊢ Valid (Substring.extract x✝ b e) ** let ⟨l, m, r, h₁⟩ := h₁.validFor ** b e : Pos x✝ : Substring h₁✝ : Valid x✝ h₂ : Valid { str := toString x✝, startPos := b, stopPos := e } l m r : List Char h₁ : ValidFor l m r x✝ ⊢ Valid (Substring.extract x✝ b e) ** rw [h₁.toString] at h₂ ** b e : Pos x✝ : Substring h₁✝ : Valid x✝ l m : List Char h₂ : Valid { str := { data := m }, startPos := b, stopPos := e } r : List Char h₁ : ValidFor l m r x✝ ⊢ Valid (Substring.extract x✝ b e) ** let ⟨ml, mm, mr, h₂⟩ := h₂.validFor ** b e : Pos x✝ : Substring h₁✝ : Valid x✝ l m : List Char h₂✝ : Valid { str := { data := m }, startPos := b, stopPos := e } r : List Char h₁ : ValidFor l m r x✝ ml mm mr : List Char h₂ : ValidFor ml mm mr { str := { data := m }, startPos := b, stopPos := e } ⊢ Valid (Substring.extract x✝ b e) ** have ⟨l', r', h₃⟩ := h₁.extract h₂ ** b e : Pos x✝ : Substring h₁✝ : Valid x✝ l m : List Char h₂✝ : Valid { str := { data := m }, startPos := b, stopPos := e } r : List Char h₁ : ValidFor l m r x✝ ml mm mr : List Char h₂ : ValidFor ml mm mr { str := { data := m }, startPos := b, stopPos := e } l' r' : List Char h₃ : ValidFor l' mm r' (Substring.extract x✝ b e) ⊢ Valid (Substring.extract x✝ b e) ** exact h₃.valid ** Qed
| |
Substring.Valid.toString_extract ** b e : Pos x✝ : Substring h₁ : Valid x✝ h₂ : Valid { str := toString x✝, startPos := b, stopPos := e } ⊢ toString (Substring.extract x✝ b e) = String.extract (toString x✝) b e ** let ⟨l, m, r, h₁⟩ := h₁.validFor ** b e : Pos x✝ : Substring h₁✝ : Valid x✝ h₂ : Valid { str := toString x✝, startPos := b, stopPos := e } l m r : List Char h₁ : ValidFor l m r x✝ ⊢ toString (Substring.extract x✝ b e) = String.extract (toString x✝) b e ** rw [h₁.toString] at h₂ ** b e : Pos x✝ : Substring h₁✝ : Valid x✝ l m : List Char h₂ : Valid { str := { data := m }, startPos := b, stopPos := e } r : List Char h₁ : ValidFor l m r x✝ ⊢ toString (Substring.extract x✝ b e) = String.extract (toString x✝) b e ** let ⟨ml, mm, mr, h₂⟩ := h₂.validFor ** b e : Pos x✝ : Substring h₁✝ : Valid x✝ l m : List Char h₂✝ : Valid { str := { data := m }, startPos := b, stopPos := e } r : List Char h₁ : ValidFor l m r x✝ ml mm mr : List Char h₂ : ValidFor ml mm mr { str := { data := m }, startPos := b, stopPos := e } ⊢ toString (Substring.extract x✝ b e) = String.extract (toString x✝) b e ** have ⟨l', r', h₃⟩ := h₁.extract h₂ ** b e : Pos x✝ : Substring h₁✝ : Valid x✝ l m : List Char h₂✝ : Valid { str := { data := m }, startPos := b, stopPos := e } r : List Char h₁ : ValidFor l m r x✝ ml mm mr : List Char h₂ : ValidFor ml mm mr { str := { data := m }, startPos := b, stopPos := e } l' r' : List Char h₃ : ValidFor l' mm r' (Substring.extract x✝ b e) ⊢ toString (Substring.extract x✝ b e) = String.extract (toString x✝) b e ** rw [h₃.toString, h₁.toString, ← h₂.toString, toString] ** Qed
| |
Substring.Valid.foldl ** α : Type u_1 f : α → Char → α init : α x✝ : Substring h✝ : Valid x✝ w✝² w✝¹ w✝ : List Char h : ValidFor w✝² w✝¹ w✝ x✝ ⊢ Substring.foldl f init x✝ = List.foldl f init (toString x✝).data ** simp [h.foldl, h.toString] ** Qed
| |
Substring.Valid.foldr ** α : Type u_1 f : Char → α → α init : α x✝ : Substring h✝ : Valid x✝ w✝² w✝¹ w✝ : List Char h : ValidFor w✝² w✝¹ w✝ x✝ ⊢ Substring.foldr f init x✝ = List.foldr f init (toString x✝).data ** simp [h.foldr, h.toString] ** Qed
| |
Substring.Valid.any ** f : Char → Bool x✝ : Substring h✝ : Valid x✝ w✝² w✝¹ w✝ : List Char h : ValidFor w✝² w✝¹ w✝ x✝ ⊢ Substring.any x✝ f = List.any (toString x✝).data f ** simp [h.any, h.toString] ** Qed
| |
Substring.Valid.all ** f : Char → Bool x✝ : Substring h✝ : Valid x✝ w✝² w✝¹ w✝ : List Char h : ValidFor w✝² w✝¹ w✝ x✝ ⊢ Substring.all x✝ f = List.all (toString x✝).data f ** simp [h.all, h.toString] ** Qed
| |
Substring.Valid.contains ** c : Char x✝ : Substring h✝ : Valid x✝ w✝² w✝¹ w✝ : List Char h : ValidFor w✝² w✝¹ w✝ x✝ ⊢ Substring.contains x✝ c = true ↔ c ∈ (toString x✝).data ** simp [h.contains, h.toString] ** Qed
| |
Substring.Valid.data_takeWhile ** p : Char → Bool x✝ : Substring h✝ : Valid x✝ w✝² w✝¹ w✝ : List Char h : ValidFor w✝² w✝¹ w✝ x✝ ⊢ (toString (Substring.takeWhile x✝ p)).data = List.takeWhile p (toString x✝).data ** simp [(h.takeWhile _).toString, h.toString] ** Qed
| |
Substring.Valid.data_dropWhile ** p : Char → Bool x✝ : Substring h✝ : Valid x✝ w✝² w✝¹ w✝ : List Char h : ValidFor w✝² w✝¹ w✝ x✝ ⊢ (toString (Substring.dropWhile x✝ p)).data = List.dropWhile p (toString x✝).data ** simp [(h.dropWhile _).toString, h.toString] ** Qed
| |
String.data_drop ** s : String n : Nat ⊢ (drop s n).data = List.drop n s.data ** rw [drop_eq] ** Qed
| |
Std.RBNode.All_def ** α : Type u_1 p : α → Prop t : RBNode α ⊢ All p t ↔ ∀ (x : α), x ∈ t → p x ** induction t <;> simp [or_imp, forall_and, *] ** Qed
| |
Std.RBNode.Any_def ** α : Type u_1 p : α → Prop t : RBNode α ⊢ Any p t ↔ ∃ x, x ∈ t ∧ p x ** induction t <;> simp [or_and_right, exists_or, *] ** Qed
| |
Std.RBNode.mem_congr ** α : Type u_1 cmp : α → α → Ordering x y : α inst✝ : TransCmp cmp t : RBNode α h : cmp x y = Ordering.eq ⊢ Mem cmp x t ↔ Mem cmp y t ** simp [Mem, TransCmp.cmp_congr_left' h] ** Qed
| |
Std.RBNode.IsCut.congr ** α✝ : Sort u_1 cmp : α✝ → α✝ → Ordering cut : α✝ → Ordering x y : α✝ inst✝¹ : IsCut cmp cut inst✝ : TransCmp cmp H : cmp x y = Ordering.eq ⊢ cut x = cut y ** cases ey : cut y ** case lt α✝ : Sort u_1 cmp : α✝ → α✝ → Ordering cut : α✝ → Ordering x y : α✝ inst✝¹ : IsCut cmp cut inst✝ : TransCmp cmp H : cmp x y = Ordering.eq ey : cut y = Ordering.lt ⊢ cut x = Ordering.lt ** exact IsCut.le_lt_trans (fun h => nomatch H.symm.trans <| OrientedCmp.cmp_eq_gt.1 h) ey ** case eq α✝ : Sort u_1 cmp : α✝ → α✝ → Ordering cut : α✝ → Ordering x y : α✝ inst✝¹ : IsCut cmp cut inst✝ : TransCmp cmp H : cmp x y = Ordering.eq ey : cut y = Ordering.eq ⊢ cut x = Ordering.eq ** cases ex : cut x ** case eq.lt α✝ : Sort u_1 cmp : α✝ → α✝ → Ordering cut : α✝ → Ordering x y : α✝ inst✝¹ : IsCut cmp cut inst✝ : TransCmp cmp H : cmp x y = Ordering.eq ey : cut y = Ordering.eq ex : cut x = Ordering.lt ⊢ Ordering.lt = Ordering.eq ** exact IsCut.le_lt_trans (fun h => nomatch H.symm.trans h) ex |>.symm.trans ey ** case eq.eq α✝ : Sort u_1 cmp : α✝ → α✝ → Ordering cut : α✝ → Ordering x y : α✝ inst✝¹ : IsCut cmp cut inst✝ : TransCmp cmp H : cmp x y = Ordering.eq ey : cut y = Ordering.eq ex : cut x = Ordering.eq ⊢ Ordering.eq = Ordering.eq ** rfl ** case eq.gt α✝ : Sort u_1 cmp : α✝ → α✝ → Ordering cut : α✝ → Ordering x y : α✝ inst✝¹ : IsCut cmp cut inst✝ : TransCmp cmp H : cmp x y = Ordering.eq ey : cut y = Ordering.eq ex : cut x = Ordering.gt ⊢ Ordering.gt = Ordering.eq ** refine IsCut.le_gt_trans (cmp := cmp) (fun h => ?_) ex |>.symm.trans ey ** case eq.gt α✝ : Sort u_1 cmp : α✝ → α✝ → Ordering cut : α✝ → Ordering x y : α✝ inst✝¹ : IsCut cmp cut inst✝ : TransCmp cmp H : cmp x y = Ordering.eq ey : cut y = Ordering.eq ex : cut x = Ordering.gt h : cmp y x = Ordering.gt ⊢ False ** cases H.symm.trans <| OrientedCmp.cmp_eq_gt.1 h ** case gt α✝ : Sort u_1 cmp : α✝ → α✝ → Ordering cut : α✝ → Ordering x y : α✝ inst✝¹ : IsCut cmp cut inst✝ : TransCmp cmp H : cmp x y = Ordering.eq ey : cut y = Ordering.gt ⊢ cut x = Ordering.gt ** exact IsCut.le_gt_trans (fun h => nomatch H.symm.trans h) ey ** Qed
| |
Std.RBNode.find?_some_eq_eq ** α : Type u_1 x : α cut : α → Ordering t : RBNode α ⊢ x ∈ find? cut t → cut x = Ordering.eq ** induction t <;> simp [find?] ** case node α : Type u_1 x : α cut : α → Ordering c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α l_ih✝ : x ∈ find? cut l✝ → cut x = Ordering.eq r_ih✝ : x ∈ find? cut r✝ → cut x = Ordering.eq ⊢ (match cut v✝ with | Ordering.lt => find? cut l✝ | Ordering.gt => find? cut r✝ | Ordering.eq => some v✝) = some x → cut x = Ordering.eq ** split <;> try assumption ** case node.h_3 α : Type u_1 x : α cut : α → Ordering c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α l_ih✝ : x ∈ find? cut l✝ → cut x = Ordering.eq r_ih✝ : x ∈ find? cut r✝ → cut x = Ordering.eq x✝ : Ordering heq✝ : cut v✝ = Ordering.eq ⊢ some v✝ = some x → cut x = Ordering.eq ** intro | rfl => assumption ** case node.h_2 α : Type u_1 x : α cut : α → Ordering c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α l_ih✝ : x ∈ find? cut l✝ → cut x = Ordering.eq r_ih✝ : x ∈ find? cut r✝ → cut x = Ordering.eq x✝ : Ordering heq✝ : cut v✝ = Ordering.gt ⊢ find? cut r✝ = some x → cut x = Ordering.eq ** assumption ** α : Type u_1 x : α cut : α → Ordering c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α x✝¹ : Ordering heq✝ : cut v✝ = Ordering.eq x✝ : some v✝ = some x l_ih✝ : v✝ ∈ find? cut l✝ → cut v✝ = Ordering.eq r_ih✝ : v✝ ∈ find? cut r✝ → cut v✝ = Ordering.eq ⊢ cut v✝ = Ordering.eq ** assumption ** Qed
| |
Std.RBNode.find?_some_mem ** α : Type u_1 x : α cut : α → Ordering t : RBNode α ⊢ x ∈ find? cut t → x ∈ t ** induction t <;> simp [find?] ** case node α : Type u_1 x : α cut : α → Ordering c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α l_ih✝ : x ∈ find? cut l✝ → x ∈ l✝ r_ih✝ : x ∈ find? cut r✝ → x ∈ r✝ ⊢ (match cut v✝ with | Ordering.lt => find? cut l✝ | Ordering.gt => find? cut r✝ | Ordering.eq => some v✝) = some x → x = v✝ ∨ x ∈ l✝ ∨ x ∈ r✝ ** split <;> simp (config := {contextual := true}) [*] ** Qed
| |
Std.RBNode.Ordered.memP_iff_find? ** α : Type u_1 cmp : α → α → Ordering cut : α → Ordering t : RBNode α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut ht : Ordered cmp t ⊢ MemP cut t ↔ ∃ x, find? cut t = some x ** refine ⟨fun H => ?_, fun ⟨x, h⟩ => find?_some_memP h⟩ ** case nil α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut ht : Ordered cmp nil H : MemP cut nil ⊢ False ** cases H ** case node α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) H : MemP cut (node c✝ l v✝ r) ⊢ ∃ x, (match cut v✝ with | Ordering.lt => find? cut l | Ordering.gt => find? cut r | Ordering.eq => some v✝) = some x ** let ⟨lx, xr, hl, hr⟩ := ht ** case node α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) H : MemP cut (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r ⊢ ∃ x, (match cut v✝ with | Ordering.lt => find? cut l | Ordering.gt => find? cut r | Ordering.eq => some v✝) = some x ** split ** α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) H : MemP cut (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r x✝ : Ordering ev : cut v✝ = Ordering.lt ⊢ ∃ x, find? cut l = some x ** refine ihl hl ?_ ** α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) H : MemP cut (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r x✝ : Ordering ev : cut v✝ = Ordering.lt ⊢ MemP cut l ** rcases H with ev' | hx | hx ** case inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r x✝ : Ordering ev : cut v✝ = Ordering.lt ev' : cut v✝ = Ordering.eq ⊢ MemP cut l ** cases ev.symm.trans ev' ** case inr.inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r x✝ : Ordering ev : cut v✝ = Ordering.lt hx : Any (fun x => cut x = Ordering.eq) l ⊢ MemP cut l ** exact hx ** case inr.inr α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r x✝ : Ordering ev : cut v✝ = Ordering.lt hx : Any (fun x => cut x = Ordering.eq) r ⊢ MemP cut l ** have ⟨z, hz, ez⟩ := Any_def.1 hx ** case inr.inr α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r x✝ : Ordering ev : cut v✝ = Ordering.lt hx : Any (fun x => cut x = Ordering.eq) r z : α hz : z ∈ r ez : cut z = Ordering.eq ⊢ MemP cut l ** cases ez.symm.trans <| IsCut.lt_trans (All_def.1 xr _ hz).1 ev ** α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) H : MemP cut (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r x✝ : Ordering ev : cut v✝ = Ordering.gt ⊢ ∃ x, find? cut r = some x ** refine ihr hr ?_ ** α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) H : MemP cut (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r x✝ : Ordering ev : cut v✝ = Ordering.gt ⊢ MemP cut r ** rcases H with ev' | hx | hx ** case inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r x✝ : Ordering ev : cut v✝ = Ordering.gt ev' : cut v✝ = Ordering.eq ⊢ MemP cut r ** cases ev.symm.trans ev' ** case inr.inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r x✝ : Ordering ev : cut v✝ = Ordering.gt hx : Any (fun x => cut x = Ordering.eq) l ⊢ MemP cut r ** have ⟨z, hz, ez⟩ := Any_def.1 hx ** case inr.inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r x✝ : Ordering ev : cut v✝ = Ordering.gt hx : Any (fun x => cut x = Ordering.eq) l z : α hz : z ∈ l ez : cut z = Ordering.eq ⊢ MemP cut r ** cases ez.symm.trans <| IsCut.gt_trans (All_def.1 lx _ hz).1 ev ** case inr.inr α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r x✝ : Ordering ev : cut v✝ = Ordering.gt hx : Any (fun x => cut x = Ordering.eq) r ⊢ MemP cut r ** exact hx ** case node.h_3 α : Type u_1 cmp : α → α → Ordering cut : α → Ordering inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → MemP cut l → ∃ x, find? cut l = some x ihr : Ordered cmp r → MemP cut r → ∃ x, find? cut r = some x ht : Ordered cmp (node c✝ l v✝ r) H : MemP cut (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r x✝ : Ordering heq✝ : cut v✝ = Ordering.eq ⊢ ∃ x, some v✝ = some x ** exact ⟨_, rfl⟩ ** Qed
| |
Std.RBNode.Ordered.unique ** case nil α : Type u_1 cmp : α → α → Ordering x y : α inst✝ : TransCmp cmp e : cmp x y = Ordering.eq ht : Ordered cmp nil hx : x ∈ nil hy : y ∈ nil ⊢ x = y ** cases hx ** case node α : Type u_1 cmp : α → α → Ordering x y : α inst✝ : TransCmp cmp e : cmp x y = Ordering.eq c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → x ∈ l → y ∈ l → x = y ihr : Ordered cmp r → x ∈ r → y ∈ r → x = y ht : Ordered cmp (node c✝ l v✝ r) hx : x ∈ node c✝ l v✝ r hy : y ∈ node c✝ l v✝ r ⊢ x = y ** let ⟨lx, xr, hl, hr⟩ := ht ** case node α : Type u_1 cmp : α → α → Ordering x y : α inst✝ : TransCmp cmp e : cmp x y = Ordering.eq c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → x ∈ l → y ∈ l → x = y ihr : Ordered cmp r → x ∈ r → y ∈ r → x = y ht : Ordered cmp (node c✝ l v✝ r) hx : x ∈ node c✝ l v✝ r hy : y ∈ node c✝ l v✝ r lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r ⊢ x = y ** rcases hx, hy with ⟨rfl | hx | hx, rfl | hy | hy⟩ ** case node.inl.inl α : Type u_1 cmp : α → α → Ordering y : α inst✝ : TransCmp cmp c✝ : RBColor l r : RBNode α hl : Ordered cmp l hr : Ordered cmp r e : cmp y y = Ordering.eq ihl : Ordered cmp l → y ∈ l → y ∈ l → y = y ihr : Ordered cmp r → y ∈ r → y ∈ r → y = y ht : Ordered cmp (node c✝ l y r) lx : All (fun x => cmpLT cmp x y) l xr : All (fun x => cmpLT cmp y x) r ⊢ y = y ** rfl ** case node.inl.inr.inl α : Type u_1 cmp : α → α → Ordering x y : α inst✝ : TransCmp cmp e : cmp x y = Ordering.eq c✝ : RBColor l r : RBNode α ihl : Ordered cmp l → x ∈ l → y ∈ l → x = y ihr : Ordered cmp r → x ∈ r → y ∈ r → x = y hl : Ordered cmp l hr : Ordered cmp r ht : Ordered cmp (node c✝ l x r) lx : All (fun x_1 => cmpLT cmp x_1 x) l xr : All (fun x_1 => cmpLT cmp x x_1) r hy : Any (fun x => y = x) l ⊢ x = y ** cases e.symm.trans <| OrientedCmp.cmp_eq_gt.2 (All_def.1 lx _ hy).1 ** case node.inl.inr.inr α : Type u_1 cmp : α → α → Ordering x y : α inst✝ : TransCmp cmp e : cmp x y = Ordering.eq c✝ : RBColor l r : RBNode α ihl : Ordered cmp l → x ∈ l → y ∈ l → x = y ihr : Ordered cmp r → x ∈ r → y ∈ r → x = y hl : Ordered cmp l hr : Ordered cmp r ht : Ordered cmp (node c✝ l x r) lx : All (fun x_1 => cmpLT cmp x_1 x) l xr : All (fun x_1 => cmpLT cmp x x_1) r hy : Any (fun x => y = x) r ⊢ x = y ** cases e.symm.trans (All_def.1 xr _ hy).1 ** case node.inr.inl.inl α : Type u_1 cmp : α → α → Ordering x y : α inst✝ : TransCmp cmp e : cmp x y = Ordering.eq c✝ : RBColor l r : RBNode α ihl : Ordered cmp l → x ∈ l → y ∈ l → x = y ihr : Ordered cmp r → x ∈ r → y ∈ r → x = y hl : Ordered cmp l hr : Ordered cmp r hx : Any (fun x_1 => x = x_1) l ht : Ordered cmp (node c✝ l y r) lx : All (fun x => cmpLT cmp x y) l xr : All (fun x => cmpLT cmp y x) r ⊢ x = y ** cases e.symm.trans (All_def.1 lx _ hx).1 ** case node.inr.inl.inr.inl α : Type u_1 cmp : α → α → Ordering x y : α inst✝ : TransCmp cmp e : cmp x y = Ordering.eq c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → x ∈ l → y ∈ l → x = y ihr : Ordered cmp r → x ∈ r → y ∈ r → x = y ht : Ordered cmp (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r hx : Any (fun x_1 => x = x_1) l hy : Any (fun x => y = x) l ⊢ x = y ** exact ihl hl hx hy ** case node.inr.inl.inr.inr α : Type u_1 cmp : α → α → Ordering x y : α inst✝ : TransCmp cmp e : cmp x y = Ordering.eq c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → x ∈ l → y ∈ l → x = y ihr : Ordered cmp r → x ∈ r → y ∈ r → x = y ht : Ordered cmp (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r hx : Any (fun x_1 => x = x_1) l hy : Any (fun x => y = x) r ⊢ x = y ** cases e.symm.trans ((All_def.1 lx _ hx).trans (All_def.1 xr _ hy)).1 ** case node.inr.inr.inl α : Type u_1 cmp : α → α → Ordering x y : α inst✝ : TransCmp cmp e : cmp x y = Ordering.eq c✝ : RBColor l r : RBNode α ihl : Ordered cmp l → x ∈ l → y ∈ l → x = y ihr : Ordered cmp r → x ∈ r → y ∈ r → x = y hl : Ordered cmp l hr : Ordered cmp r hx : Any (fun x_1 => x = x_1) r ht : Ordered cmp (node c✝ l y r) lx : All (fun x => cmpLT cmp x y) l xr : All (fun x => cmpLT cmp y x) r ⊢ x = y ** cases e.symm.trans <| OrientedCmp.cmp_eq_gt.2 (All_def.1 xr _ hx).1 ** case node.inr.inr.inr.inl α : Type u_1 cmp : α → α → Ordering x y : α inst✝ : TransCmp cmp e : cmp x y = Ordering.eq c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → x ∈ l → y ∈ l → x = y ihr : Ordered cmp r → x ∈ r → y ∈ r → x = y ht : Ordered cmp (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r hx : Any (fun x_1 => x = x_1) r hy : Any (fun x => y = x) l ⊢ x = y ** cases e.symm.trans <| OrientedCmp.cmp_eq_gt.2
((All_def.1 lx _ hy).trans (All_def.1 xr _ hx)).1 ** case node.inr.inr.inr.inr α : Type u_1 cmp : α → α → Ordering x y : α inst✝ : TransCmp cmp e : cmp x y = Ordering.eq c✝ : RBColor l : RBNode α v✝ : α r : RBNode α ihl : Ordered cmp l → x ∈ l → y ∈ l → x = y ihr : Ordered cmp r → x ∈ r → y ∈ r → x = y ht : Ordered cmp (node c✝ l v✝ r) lx : All (fun x => cmpLT cmp x v✝) l xr : All (fun x => cmpLT cmp v✝ x) r hl : Ordered cmp l hr : Ordered cmp r hx : Any (fun x_1 => x = x_1) r hy : Any (fun x => y = x) r ⊢ x = y ** exact ihr hr hx hy ** Qed
| |
Std.RBNode.Ordered.find?_some ** α : Type u_1 cmp : α → α → Ordering cut : α → Ordering t : RBNode α x : α inst✝¹ : TransCmp cmp inst✝ : IsStrictCut cmp cut ht : Ordered cmp t ⊢ find? cut t = some x ↔ x ∈ t ∧ cut x = Ordering.eq ** refine ⟨fun h => ⟨find?_some_mem h, find?_some_eq_eq h⟩, fun ⟨hx, e⟩ => ?_⟩ ** α : Type u_1 cmp : α → α → Ordering cut : α → Ordering t : RBNode α x : α inst✝¹ : TransCmp cmp inst✝ : IsStrictCut cmp cut ht : Ordered cmp t x✝ : x ∈ t ∧ cut x = Ordering.eq hx : x ∈ t e : cut x = Ordering.eq ⊢ find? cut t = some x ** have ⟨y, hy⟩ := ht.memP_iff_find?.1 (memP_def.2 ⟨_, hx, e⟩) ** α : Type u_1 cmp : α → α → Ordering cut : α → Ordering t : RBNode α x : α inst✝¹ : TransCmp cmp inst✝ : IsStrictCut cmp cut ht : Ordered cmp t x✝ : x ∈ t ∧ cut x = Ordering.eq hx : x ∈ t e : cut x = Ordering.eq y : α hy : find? cut t = some y ⊢ find? cut t = some x ** exact ht.unique hx (find?_some_mem hy) ((IsStrictCut.exact e).trans (find?_some_eq_eq hy)) ▸ hy ** Qed
| |
Std.RBNode.lowerBound?_le' ** case nil α : Type u_1 cut : α → Ordering x : α lb : Option α H : ∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt ⊢ lowerBound? cut nil lb = some x → cut x ≠ Ordering.lt ** exact H ** case node α : Type u_1 cut : α → Ordering x : α c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut l✝ lb = some x → cut x ≠ Ordering.lt ihr : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut r✝ lb = some x → cut x ≠ Ordering.lt lb : Option α H : ∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt ⊢ lowerBound? cut (node c✝ l✝ v✝ r✝) lb = some x → cut x ≠ Ordering.lt ** simp [lowerBound?] ** case node α : Type u_1 cut : α → Ordering x : α c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut l✝ lb = some x → cut x ≠ Ordering.lt ihr : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut r✝ lb = some x → cut x ≠ Ordering.lt lb : Option α H : ∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt ⊢ (match cut v✝ with | Ordering.lt => lowerBound? cut l✝ lb | Ordering.gt => lowerBound? cut r✝ (some v✝) | Ordering.eq => some v✝) = some x → ¬cut x = Ordering.lt ** split ** case node.h_1 α : Type u_1 cut : α → Ordering x : α c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut l✝ lb = some x → cut x ≠ Ordering.lt ihr : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut r✝ lb = some x → cut x ≠ Ordering.lt lb : Option α H : ∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt x✝ : Ordering heq✝ : cut v✝ = Ordering.lt ⊢ lowerBound? cut l✝ lb = some x → ¬cut x = Ordering.lt ** exact ihl H ** case node.h_2 α : Type u_1 cut : α → Ordering x : α c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut l✝ lb = some x → cut x ≠ Ordering.lt ihr : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut r✝ lb = some x → cut x ≠ Ordering.lt lb : Option α H : ∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt x✝ : Ordering heq✝ : cut v✝ = Ordering.gt ⊢ lowerBound? cut r✝ (some v✝) = some x → ¬cut x = Ordering.lt ** next hv => exact ihr fun | rfl, e => nomatch hv.symm.trans e ** α : Type u_1 cut : α → Ordering x : α c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut l✝ lb = some x → cut x ≠ Ordering.lt ihr : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut r✝ lb = some x → cut x ≠ Ordering.lt lb : Option α H : ∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt x✝ : Ordering hv : cut v✝ = Ordering.gt ⊢ lowerBound? cut r✝ (some v✝) = some x → ¬cut x = Ordering.lt ** exact ihr fun | rfl, e => nomatch hv.symm.trans e ** case node.h_3 α : Type u_1 cut : α → Ordering x : α c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut l✝ lb = some x → cut x ≠ Ordering.lt ihr : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut r✝ lb = some x → cut x ≠ Ordering.lt lb : Option α H : ∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt x✝ : Ordering heq✝ : cut v✝ = Ordering.eq ⊢ some v✝ = some x → ¬cut x = Ordering.lt ** next hv => intro | rfl, e => cases hv.symm.trans e ** α : Type u_1 cut : α → Ordering x : α c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut l✝ lb = some x → cut x ≠ Ordering.lt ihr : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut r✝ lb = some x → cut x ≠ Ordering.lt lb : Option α H : ∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt x✝ : Ordering hv : cut v✝ = Ordering.eq ⊢ some v✝ = some x → ¬cut x = Ordering.lt ** intro | rfl, e => cases hv.symm.trans e ** α : Type u_1 cut : α → Ordering x : α c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α lb : Option α H : ∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt x✝² : Ordering hv : cut v✝ = Ordering.eq x✝¹ : some v✝ = some x x✝ : cut x = Ordering.lt e : cut v✝ = Ordering.lt ihl : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut l✝ lb = some v✝ → cut v✝ ≠ Ordering.lt ihr : ∀ {lb : Option α}, (∀ {x : α}, x ∈ lb → cut x ≠ Ordering.lt) → lowerBound? cut r✝ lb = some v✝ → cut v✝ ≠ Ordering.lt ⊢ False ** cases hv.symm.trans e ** Qed
| |
Std.RBNode.All.lowerBound?_lb ** case nil α : Type u_1 p : α → Prop cut : α → Ordering x : α lb : Option α hp : All p nil H : ∀ {x : α}, x ∈ lb → p x ⊢ lowerBound? cut nil lb = some x → p x ** exact H ** case node α : Type u_1 p : α → Prop cut : α → Ordering x : α c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, All p l✝ → (∀ {x : α}, x ∈ lb → p x) → lowerBound? cut l✝ lb = some x → p x ihr : ∀ {lb : Option α}, All p r✝ → (∀ {x : α}, x ∈ lb → p x) → lowerBound? cut r✝ lb = some x → p x lb : Option α hp : All p (node c✝ l✝ v✝ r✝) H : ∀ {x : α}, x ∈ lb → p x ⊢ lowerBound? cut (node c✝ l✝ v✝ r✝) lb = some x → p x ** simp [lowerBound?] ** case node α : Type u_1 p : α → Prop cut : α → Ordering x : α c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, All p l✝ → (∀ {x : α}, x ∈ lb → p x) → lowerBound? cut l✝ lb = some x → p x ihr : ∀ {lb : Option α}, All p r✝ → (∀ {x : α}, x ∈ lb → p x) → lowerBound? cut r✝ lb = some x → p x lb : Option α hp : All p (node c✝ l✝ v✝ r✝) H : ∀ {x : α}, x ∈ lb → p x ⊢ (match cut v✝ with | Ordering.lt => lowerBound? cut l✝ lb | Ordering.gt => lowerBound? cut r✝ (some v✝) | Ordering.eq => some v✝) = some x → p x ** split ** case node.h_1 α : Type u_1 p : α → Prop cut : α → Ordering x : α c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, All p l✝ → (∀ {x : α}, x ∈ lb → p x) → lowerBound? cut l✝ lb = some x → p x ihr : ∀ {lb : Option α}, All p r✝ → (∀ {x : α}, x ∈ lb → p x) → lowerBound? cut r✝ lb = some x → p x lb : Option α hp : All p (node c✝ l✝ v✝ r✝) H : ∀ {x : α}, x ∈ lb → p x x✝ : Ordering heq✝ : cut v✝ = Ordering.lt ⊢ lowerBound? cut l✝ lb = some x → p x ** exact ihl hp.2.1 H ** case node.h_2 α : Type u_1 p : α → Prop cut : α → Ordering x : α c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, All p l✝ → (∀ {x : α}, x ∈ lb → p x) → lowerBound? cut l✝ lb = some x → p x ihr : ∀ {lb : Option α}, All p r✝ → (∀ {x : α}, x ∈ lb → p x) → lowerBound? cut r✝ lb = some x → p x lb : Option α hp : All p (node c✝ l✝ v✝ r✝) H : ∀ {x : α}, x ∈ lb → p x x✝ : Ordering heq✝ : cut v✝ = Ordering.gt ⊢ lowerBound? cut r✝ (some v✝) = some x → p x ** exact ihr hp.2.2 fun | rfl => hp.1 ** case node.h_3 α : Type u_1 p : α → Prop cut : α → Ordering x : α c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, All p l✝ → (∀ {x : α}, x ∈ lb → p x) → lowerBound? cut l✝ lb = some x → p x ihr : ∀ {lb : Option α}, All p r✝ → (∀ {x : α}, x ∈ lb → p x) → lowerBound? cut r✝ lb = some x → p x lb : Option α hp : All p (node c✝ l✝ v✝ r✝) H : ∀ {x : α}, x ∈ lb → p x x✝ : Ordering heq✝ : cut v✝ = Ordering.eq ⊢ some v✝ = some x → p x ** exact fun | rfl => hp.1 ** Qed
| |
Std.RBNode.lowerBound?_of_some ** α : Type u_1 cut : α → Ordering y : α t : RBNode α ⊢ ∃ x, lowerBound? cut t (some y) = some x ** induction t generalizing y <;> simp [lowerBound?] ** case node α : Type u_1 cut : α → Ordering c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α l_ih✝ : ∀ {y : α}, ∃ x, lowerBound? cut l✝ (some y) = some x r_ih✝ : ∀ {y : α}, ∃ x, lowerBound? cut r✝ (some y) = some x y : α ⊢ ∃ x, (match cut v✝ with | Ordering.lt => lowerBound? cut l✝ (some y) | Ordering.gt => lowerBound? cut r✝ (some v✝) | Ordering.eq => some v✝) = some x ** split <;> simp [*] ** Qed
| |
Std.RBNode.Ordered.lowerBound?_least_lb ** case nil α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut lb : Option α h : Ordered cmp nil hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) nil ⊢ lowerBound? cut nil lb = some x → y ∈ nil → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ** intro. ** case node α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α h : Ordered cmp (node c✝ l✝ v✝ r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ v✝ r✝) ⊢ lowerBound? cut (node c✝ l✝ v✝ r✝) lb = some x → y ∈ node c✝ l✝ v✝ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ** simp [lowerBound?] ** case node α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α h : Ordered cmp (node c✝ l✝ v✝ r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ v✝ r✝) ⊢ (match cut v✝ with | Ordering.lt => lowerBound? cut l✝ lb | Ordering.gt => lowerBound? cut r✝ (some v✝) | Ordering.eq => some v✝) = some x → y = v✝ ∨ y ∈ l✝ ∨ y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ** split <;> rename_i hv <;> rintro h₁ (rfl | hy' | hy') hx h₂ ** case node.h_1.inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α x✝ : Ordering h₁ : lowerBound? cut l✝ lb = some x h : Ordered cmp (node c✝ l✝ y r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ y r✝) hv : cut y = Ordering.lt hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt ⊢ cut y = Ordering.lt ** exact hv ** case node.h_1.inr.inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α h : Ordered cmp (node c✝ l✝ v✝ r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ v✝ r✝) x✝ : Ordering hv : cut v✝ = Ordering.lt h₁ : lowerBound? cut l✝ lb = some x hy' : y ∈ l✝ hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt ⊢ cut y = Ordering.lt ** exact ihl h.2.2.1 (fun h => (hlb h).2.1) h₁ hy' hx h₂ ** case node.h_1.inr.inr α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α h : Ordered cmp (node c✝ l✝ v✝ r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ v✝ r✝) x✝ : Ordering hv : cut v✝ = Ordering.lt h₁ : lowerBound? cut l✝ lb = some x hy' : y ∈ r✝ hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt ⊢ cut y = Ordering.lt ** exact IsCut.lt_trans (cut := cut) (cmp := cmp) (All_def.1 h.2.1 _ hy').1 hv ** case node.h_2.inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α x✝ : Ordering h : Ordered cmp (node c✝ l✝ y r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ y r✝) hv : cut y = Ordering.gt h₁ : lowerBound? cut r✝ (some y) = some x hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt ⊢ cut y = Ordering.lt ** rcases lowerBound?_mem_lb h₁ with h₁ | ⟨⟨⟩⟩ ** case node.h_2.inl.inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α x✝ : Ordering h : Ordered cmp (node c✝ l✝ y r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ y r✝) hv : cut y = Ordering.gt h₁✝ : lowerBound? cut r✝ (some y) = some x hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt h₁ : x ∈ r✝ ⊢ cut y = Ordering.lt ** cases TransCmp.lt_asymm h₂ (All_def.1 h.2.1 _ h₁).1 ** case node.h_2.inl.inr.refl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ r✝ : RBNode α lb : Option α x✝ : Ordering hx : cut x = Ordering.gt ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → x ∈ l✝ → cut x = Ordering.gt → cmp x x = Ordering.lt → cut x = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → x ∈ r✝ → cut x = Ordering.gt → cmp x x = Ordering.lt → cut x = Ordering.lt h : Ordered cmp (node c✝ l✝ x r✝) hlb : ∀ {x_1 : α}, lb = some x_1 → All (fun x => cmpLT cmp x_1 x) (node c✝ l✝ x r✝) hv : cut x = Ordering.gt h₁ : lowerBound? cut r✝ (some x) = some x h₂ : cmp x x = Ordering.lt ⊢ cut x = Ordering.lt ** cases TransCmp.lt_asymm h₂ h₂ ** case node.h_2.inr.inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α h : Ordered cmp (node c✝ l✝ v✝ r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ v✝ r✝) x✝ : Ordering hv : cut v✝ = Ordering.gt h₁ : lowerBound? cut r✝ (some v✝) = some x hy' : y ∈ l✝ hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt ⊢ cut y = Ordering.lt ** refine (TransCmp.lt_asymm h₂ ?_).elim ** case node.h_2.inr.inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α h : Ordered cmp (node c✝ l✝ v✝ r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ v✝ r✝) x✝ : Ordering hv : cut v✝ = Ordering.gt h₁ : lowerBound? cut r✝ (some v✝) = some x hy' : y ∈ l✝ hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt ⊢ cmp y x = Ordering.lt ** have := (All_def.1 h.1 _ hy').1 ** case node.h_2.inr.inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α h : Ordered cmp (node c✝ l✝ v✝ r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ v✝ r✝) x✝ : Ordering hv : cut v✝ = Ordering.gt h₁ : lowerBound? cut r✝ (some v✝) = some x hy' : y ∈ l✝ hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt this : cmp y v✝ = Ordering.lt ⊢ cmp y x = Ordering.lt ** rcases lowerBound?_mem_lb h₁ with h₁ | ⟨⟨⟩⟩ ** case node.h_2.inr.inl.inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α h : Ordered cmp (node c✝ l✝ v✝ r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ v✝ r✝) x✝ : Ordering hv : cut v✝ = Ordering.gt h₁✝ : lowerBound? cut r✝ (some v✝) = some x hy' : y ∈ l✝ hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt this : cmp y v✝ = Ordering.lt h₁ : x ∈ r✝ ⊢ cmp y x = Ordering.lt ** exact TransCmp.lt_trans this (All_def.1 h.2.1 _ h₁).1 ** case node.h_2.inr.inl.inr.refl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α x✝ : Ordering hy' : y ∈ l✝ hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt h : Ordered cmp (node c✝ l✝ x r✝) hlb : ∀ {x_1 : α}, lb = some x_1 → All (fun x => cmpLT cmp x_1 x) (node c✝ l✝ x r✝) hv : cut x = Ordering.gt h₁ : lowerBound? cut r✝ (some x) = some x this : cmp y x = Ordering.lt ⊢ cmp y x = Ordering.lt ** exact this ** case node.h_2.inr.inr α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α h : Ordered cmp (node c✝ l✝ v✝ r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ v✝ r✝) x✝ : Ordering hv : cut v✝ = Ordering.gt h₁ : lowerBound? cut r✝ (some v✝) = some x hy' : y ∈ r✝ hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt ⊢ cut y = Ordering.lt ** exact ihr h.2.2.2 (by rintro _ ⟨⟨⟩⟩; exact h.2.1) h₁ hy' hx h₂ ** α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α h : Ordered cmp (node c✝ l✝ v✝ r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ v✝ r✝) x✝ : Ordering hv : cut v✝ = Ordering.gt h₁ : lowerBound? cut r✝ (some v✝) = some x hy' : y ∈ r✝ hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt ⊢ ∀ {x : α}, some v✝ = some x → All (fun x_1 => cmpLT cmp x x_1) r✝ ** rintro _ ⟨⟨⟩⟩ ** case refl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α h : Ordered cmp (node c✝ l✝ v✝ r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ v✝ r✝) x✝ : Ordering hv : cut v✝ = Ordering.gt h₁ : lowerBound? cut r✝ (some v✝) = some x hy' : y ∈ r✝ hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt ⊢ All (fun x => cmpLT cmp v✝ x) r✝ ** exact h.2.1 ** case node.h_3.inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α x✝ : Ordering h : Ordered cmp (node c✝ l✝ y r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ y r✝) hv : cut y = Ordering.eq h₁ : some y = some x hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt ⊢ cut y = Ordering.lt ** cases h₁ ** case node.h_3.inl.refl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ r✝ : RBNode α lb : Option α x✝ : Ordering hx : cut x = Ordering.gt ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → x ∈ l✝ → cut x = Ordering.gt → cmp x x = Ordering.lt → cut x = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → x ∈ r✝ → cut x = Ordering.gt → cmp x x = Ordering.lt → cut x = Ordering.lt h : Ordered cmp (node c✝ l✝ x r✝) hlb : ∀ {x_1 : α}, lb = some x_1 → All (fun x => cmpLT cmp x_1 x) (node c✝ l✝ x r✝) hv : cut x = Ordering.eq h₂ : cmp x x = Ordering.lt ⊢ cut x = Ordering.lt ** cases TransCmp.lt_asymm h₂ h₂ ** case node.h_3.inr.inl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α h : Ordered cmp (node c✝ l✝ v✝ r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ v✝ r✝) x✝ : Ordering hv : cut v✝ = Ordering.eq h₁ : some v✝ = some x hy' : y ∈ l✝ hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt ⊢ cut y = Ordering.lt ** cases h₁ ** case node.h_3.inr.inl.refl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α x✝ : Ordering hy' : y ∈ l✝ hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt h : Ordered cmp (node c✝ l✝ x r✝) hlb : ∀ {x_1 : α}, lb = some x_1 → All (fun x => cmpLT cmp x_1 x) (node c✝ l✝ x r✝) hv : cut x = Ordering.eq ⊢ cut y = Ordering.lt ** cases hx.symm.trans hv ** case node.h_3.inr.inr α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ : RBNode α v✝ : α r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α h : Ordered cmp (node c✝ l✝ v✝ r✝) hlb : ∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) (node c✝ l✝ v✝ r✝) x✝ : Ordering hv : cut v✝ = Ordering.eq h₁ : some v✝ = some x hy' : y ∈ r✝ hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt ⊢ cut y = Ordering.lt ** cases h₁ ** case node.h_3.inr.inr.refl α : Type u_1 cmp : α → α → Ordering cut : α → Ordering x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut c✝ : RBColor l✝ r✝ : RBNode α ihl : ∀ {lb : Option α}, Ordered cmp l✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) l✝) → lowerBound? cut l✝ lb = some x → y ∈ l✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt ihr : ∀ {lb : Option α}, Ordered cmp r✝ → (∀ {x : α}, lb = some x → All (fun x_1 => cmpLT cmp x x_1) r✝) → lowerBound? cut r✝ lb = some x → y ∈ r✝ → cut x = Ordering.gt → cmp x y = Ordering.lt → cut y = Ordering.lt lb : Option α x✝ : Ordering hy' : y ∈ r✝ hx : cut x = Ordering.gt h₂ : cmp x y = Ordering.lt h : Ordered cmp (node c✝ l✝ x r✝) hlb : ∀ {x_1 : α}, lb = some x_1 → All (fun x => cmpLT cmp x_1 x) (node c✝ l✝ x r✝) hv : cut x = Ordering.eq ⊢ cut y = Ordering.lt ** cases hx.symm.trans hv ** Qed
| |
Std.RBNode.Ordered.lowerBound?_least ** α : Type u_1 cmp : α → α → Ordering cut : α → Ordering t : RBNode α x y : α inst✝¹ : TransCmp cmp inst✝ : IsCut cmp cut ht : Ordered cmp t H : lowerBound? cut t none = some x hy : y ∈ t xy : cmp x y = Ordering.lt hx : cut x = Ordering.gt ⊢ ∀ {x : α}, none = some x → All (fun x_1 => cmpLT cmp x x_1) t ** exact fun. ** Qed
| |
Std.RBNode.Ordered.lowerBound?_lt ** α : Type u_1 cmp : α → α → Ordering cut : α → Ordering t : RBNode α x y : α inst✝¹ : TransCmp cmp inst✝ : IsStrictCut cmp cut ht : Ordered cmp t H : lowerBound? cut t none = some x hy : y ∈ t ⊢ cmp x y = Ordering.lt ↔ cut y = Ordering.lt ** refine ⟨fun h => ?_, fun h => OrientedCmp.cmp_eq_gt.1 ?_⟩ ** case refine_1 α : Type u_1 cmp : α → α → Ordering cut : α → Ordering t : RBNode α x y : α inst✝¹ : TransCmp cmp inst✝ : IsStrictCut cmp cut ht : Ordered cmp t H : lowerBound? cut t none = some x hy : y ∈ t h : cmp x y = Ordering.lt ⊢ cut y = Ordering.lt ** cases e : cut x ** case refine_1.lt α : Type u_1 cmp : α → α → Ordering cut : α → Ordering t : RBNode α x y : α inst✝¹ : TransCmp cmp inst✝ : IsStrictCut cmp cut ht : Ordered cmp t H : lowerBound? cut t none = some x hy : y ∈ t h : cmp x y = Ordering.lt e : cut x = Ordering.lt ⊢ cut y = Ordering.lt ** cases lowerBound?_le H e ** case refine_1.eq α : Type u_1 cmp : α → α → Ordering cut : α → Ordering t : RBNode α x y : α inst✝¹ : TransCmp cmp inst✝ : IsStrictCut cmp cut ht : Ordered cmp t H : lowerBound? cut t none = some x hy : y ∈ t h : cmp x y = Ordering.lt e : cut x = Ordering.eq ⊢ cut y = Ordering.lt ** exact IsStrictCut.exact e |>.symm.trans h ** case refine_1.gt α : Type u_1 cmp : α → α → Ordering cut : α → Ordering t : RBNode α x y : α inst✝¹ : TransCmp cmp inst✝ : IsStrictCut cmp cut ht : Ordered cmp t H : lowerBound? cut t none = some x hy : y ∈ t h : cmp x y = Ordering.lt e : cut x = Ordering.gt ⊢ cut y = Ordering.lt ** exact ht.lowerBound?_least H hy h e ** case refine_2 α : Type u_1 cmp : α → α → Ordering cut : α → Ordering t : RBNode α x y : α inst✝¹ : TransCmp cmp inst✝ : IsStrictCut cmp cut ht : Ordered cmp t H : lowerBound? cut t none = some x hy : y ∈ t h : cut y = Ordering.lt ⊢ cmp y x = Ordering.gt ** by_contra h' ** case refine_2 α : Type u_1 cmp : α → α → Ordering cut : α → Ordering t : RBNode α x y : α inst✝¹ : TransCmp cmp inst✝ : IsStrictCut cmp cut ht : Ordered cmp t H : lowerBound? cut t none = some x hy : y ∈ t h : cut y = Ordering.lt h' : ¬cmp y x = Ordering.gt ⊢ False ** exact lowerBound?_le H <| IsCut.le_lt_trans (cmp := cmp) (cut := cut) h' h ** Qed
| |
Std.RBNode.foldr_cons ** α : Type u_1 t : RBNode α l : List α ⊢ foldr (fun x x_1 => x :: x_1) t l = toList t ++ l ** unfold toList ** α : Type u_1 t : RBNode α l : List α ⊢ foldr (fun x x_1 => x :: x_1) t l = foldr (fun x x_1 => x :: x_1) t [] ++ l ** induction t generalizing l with
| nil => rfl
| node _ a _ b iha ihb => rw [foldr, foldr, iha, iha (_::_), ihb]; simp ** case nil α : Type u_1 l : List α ⊢ foldr (fun x x_1 => x :: x_1) nil l = foldr (fun x x_1 => x :: x_1) nil [] ++ l ** rfl ** case node α : Type u_1 c✝ : RBColor a : RBNode α v✝ : α b : RBNode α iha : ∀ (l : List α), foldr (fun x x_1 => x :: x_1) a l = foldr (fun x x_1 => x :: x_1) a [] ++ l ihb : ∀ (l : List α), foldr (fun x x_1 => x :: x_1) b l = foldr (fun x x_1 => x :: x_1) b [] ++ l l : List α ⊢ foldr (fun x x_1 => x :: x_1) (node c✝ a v✝ b) l = foldr (fun x x_1 => x :: x_1) (node c✝ a v✝ b) [] ++ l ** rw [foldr, foldr, iha, iha (_::_), ihb] ** case node α : Type u_1 c✝ : RBColor a : RBNode α v✝ : α b : RBNode α iha : ∀ (l : List α), foldr (fun x x_1 => x :: x_1) a l = foldr (fun x x_1 => x :: x_1) a [] ++ l ihb : ∀ (l : List α), foldr (fun x x_1 => x :: x_1) b l = foldr (fun x x_1 => x :: x_1) b [] ++ l l : List α ⊢ foldr (fun x x_1 => x :: x_1) a [] ++ v✝ :: (foldr (fun x x_1 => x :: x_1) b [] ++ l) = foldr (fun x x_1 => x :: x_1) a [] ++ v✝ :: foldr (fun x x_1 => x :: x_1) b [] ++ l ** simp ** Qed
| |
Std.RBNode.toList_node ** α : Type u_1 c : RBColor a : RBNode α x : α b : RBNode α ⊢ toList (node c a x b) = toList a ++ x :: toList b ** rw [toList, foldr, foldr_cons] ** α : Type u_1 c : RBColor a : RBNode α x : α b : RBNode α ⊢ toList a ++ x :: foldr (fun x x_1 => x :: x_1) b [] = toList a ++ x :: toList b ** rfl ** Qed
| |
Std.RBNode.mem_toList ** α : Type u_1 x : α t : RBNode α ⊢ x ∈ toList t ↔ x ∈ t ** induction t <;> simp [*, or_left_comm] ** Qed
| |
Std.RBNode.foldr_eq_foldr_toList ** α : Type u_1 α✝ : Type u_2 f : α → α✝ → α✝ init : α✝ t : RBNode α ⊢ foldr f t init = List.foldr f init (toList t) ** induction t generalizing init <;> simp [*] ** Qed
| |
Std.RBNode.foldl_eq_foldl_toList ** α : Type u_1 α✝ : Type u_2 f : α✝ → α → α✝ init : α✝ t : RBNode α ⊢ foldl f init t = List.foldl f init (toList t) ** induction t generalizing init <;> simp [*] ** Qed
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.