Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

d13b3a4a

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

75be6b61

bump to nightly-2024-03-17-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

22f01ce4

Diff

@@ -140,7 +140,7 @@ theorem drop_empty {n : ℕ} : "".drop n = "" :=
   induction' n with n hn
   · rfl
   · rcases hs : "" with ⟨_ | ⟨hd, tl⟩⟩
-    · rw [hs] at hn 
+    · rw [hs] at hn
       conv_rhs => rw [← hn]
       simp only [popn, mk_iterator, iterator.nextn, iterator.next]
     · simpa only [← to_list_inj] using hs

75be6b61

bump to nightly-2024-02-05-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

516c6ec2

Diff

@@ -20,7 +20,7 @@ Supplementary theorems about the `string` type.
 
 namespace String
 
-/- ./././Mathport/Syntax/Translate/Command.lean:298:8: warning: using_well_founded used, estimated equivalent -/
+/- ./././Mathport/Syntax/Translate/Command.lean:299:8: warning: using_well_founded used, estimated equivalent -/
 #print String.ltb /-
 /-- `<` on string iterators. This coincides with `<` on strings as lists. -/
 def ltb : Iterator → Iterator → Bool
@@ -34,8 +34,7 @@ def ltb : Iterator → Iterator → Bool
           | ⟨_, a :: l⟩, h => Nat.lt_succ_self _
         ltb s₁.next s₂.next
       else s₁.curr < s₂.curr
-termination_by
-  _ x => WellFounded.wrap (measure_wf fun s => s.1.2.length) x
+termination_by x => WellFounded.wrap (measure_wf fun s => s.1.2.length) x
 #align string.ltb String.ltb
 -/

75be6b61

bump to nightly-2023-12-23-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

b8c74971

Diff

@@ -20,6 +20,7 @@ Supplementary theorems about the `string` type.
 
 namespace String
 
+/- ./././Mathport/Syntax/Translate/Command.lean:298:8: warning: using_well_founded used, estimated equivalent -/
 #print String.ltb /-
 /-- `<` on string iterators. This coincides with `<` on strings as lists. -/
 def ltb : Iterator → Iterator → Bool
@@ -33,7 +34,8 @@ def ltb : Iterator → Iterator → Bool
           | ⟨_, a :: l⟩, h => Nat.lt_succ_self _
         ltb s₁.next s₂.next
       else s₁.curr < s₂.curr
-termination_by' ⟨_, measure_wf fun s => s.1.2.length⟩
+termination_by
+  _ x => WellFounded.wrap (measure_wf fun s => s.1.2.length) x
 #align string.ltb String.ltb
 -/

75be6b61

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2018 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
 -/
-import Mathbin.Data.List.Lex
-import Mathbin.Data.Char
+import Data.List.Lex
+import Data.Char
 
 #align_import data.string.basic from "leanprover-community/mathlib"@"75be6b616681ab6ca66d798ead117e75cd64f125"

75be6b61

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
-
-! This file was ported from Lean 3 source module data.string.basic
-! leanprover-community/mathlib commit 75be6b616681ab6ca66d798ead117e75cd64f125
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.List.Lex
 import Mathbin.Data.Char
 
+#align_import data.string.basic from "leanprover-community/mathlib"@"75be6b616681ab6ca66d798ead117e75cd64f125"
+
 /-!
 # Strings

75be6b61

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -51,6 +51,7 @@ instance decidableLT : @DecidableRel String (· < ·) := by infer_instance
 #align string.decidable_lt String.decidableLT
 -/
 
+#print String.lt_iff_toList_lt /-
 -- short-circuit type class inference
 @[simp]
 theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList < s₂.toList
@@ -69,6 +70,7 @@ theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList
       · simp; refine' ⟨List.Lex.rel, fun e => _⟩
         cases e; · cases h rfl; assumption
 #align string.lt_iff_to_list_lt String.lt_iff_toList_lt
+-/
 
 #print String.LE /-
 instance LE : LE String :=
@@ -81,11 +83,13 @@ instance decidableLE : @DecidableRel String (· ≤ ·) := by infer_instance
 #align string.decidable_le String.decidableLE
 -/
 
+#print String.le_iff_toList_le /-
 -- short-circuit type class inference
 @[simp]
 theorem le_iff_toList_le {s₁ s₂ : String} : s₁ ≤ s₂ ↔ s₁.toList ≤ s₂.toList :=
   (not_congr lt_iff_toList_lt).trans not_lt
 #align string.le_iff_to_list_le String.le_iff_toList_le
+-/
 
 #print String.toList_inj /-
 theorem toList_inj : ∀ {s₁ s₂}, toList s₁ = toList s₂ ↔ s₁ = s₂
@@ -93,14 +97,18 @@ theorem toList_inj : ∀ {s₁ s₂}, toList s₁ = toList s₂ ↔ s₁ = s₂
 #align string.to_list_inj String.toList_inj
 -/
 
+#print String.nil_asString_eq_empty /-
 theorem nil_asString_eq_empty : [].asString = "" :=
   rfl
 #align string.nil_as_string_eq_empty String.nil_asString_eq_empty
+-/
 
+#print String.toList_empty /-
 @[simp]
 theorem toList_empty : "".toList = [] :=
   rfl
 #align string.to_list_empty String.toList_empty
+-/
 
 #print String.asString_inv_toList /-
 theorem asString_inv_toList (s : String) : s.toList.asString = s := by cases s; rfl
@@ -114,15 +122,20 @@ theorem data_singleton (c : Char) : (String.singleton c).toList = [c] :=
 #align string.to_list_singleton String.data_singleton
 -/
 
+#print String.toList_nonempty /-
 theorem toList_nonempty : ∀ {s : String}, s ≠ String.empty → s.toList = s.headI :: (s.drop 1).toList
   | ⟨s⟩, h => by cases s <;> [cases h rfl; rfl]
 #align string.to_list_nonempty String.toList_nonempty
+-/
 
+#print String.head_empty /-
 @[simp]
 theorem head_empty : "".headI = default :=
   rfl
 #align string.head_empty String.head_empty
+-/
 
+#print String.drop_empty /-
 @[simp]
 theorem drop_empty {n : ℕ} : "".drop n = "" :=
   by
@@ -134,6 +147,7 @@ theorem drop_empty {n : ℕ} : "".drop n = "" :=
       simp only [popn, mk_iterator, iterator.nextn, iterator.next]
     · simpa only [← to_list_inj] using hs
 #align string.popn_empty String.drop_empty
+-/
 
 instance : LinearOrder String where
   lt := (· < ·)

75be6b61

bump to nightly-2023-06-01-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

b9c87c70

Diff

@@ -35,8 +35,8 @@ def ltb : Iterator → Iterator → Bool
           match s₁, h₁ with
           | ⟨_, a :: l⟩, h => Nat.lt_succ_self _
         ltb s₁.next s₂.next
-      else s₁.curr < s₂.curr termination_by'
-  ⟨_, measure_wf fun s => s.1.2.length⟩
+      else s₁.curr < s₂.curr
+termination_by' ⟨_, measure_wf fun s => s.1.2.length⟩
 #align string.ltb String.ltb
 -/
 
@@ -115,7 +115,7 @@ theorem data_singleton (c : Char) : (String.singleton c).toList = [c] :=
 -/
 
 theorem toList_nonempty : ∀ {s : String}, s ≠ String.empty → s.toList = s.headI :: (s.drop 1).toList
-  | ⟨s⟩, h => by cases s <;> [cases h rfl;rfl]
+  | ⟨s⟩, h => by cases s <;> [cases h rfl; rfl]
 #align string.to_list_nonempty String.toList_nonempty
 
 @[simp]
@@ -129,7 +129,7 @@ theorem drop_empty {n : ℕ} : "".drop n = "" :=
   induction' n with n hn
   · rfl
   · rcases hs : "" with ⟨_ | ⟨hd, tl⟩⟩
-    · rw [hs] at hn
+    · rw [hs] at hn 
       conv_rhs => rw [← hn]
       simp only [popn, mk_iterator, iterator.nextn, iterator.next]
     · simpa only [← to_list_inj] using hs

75be6b61

bump to nightly-2023-05-28-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

ba5d8b97

Diff

@@ -51,12 +51,6 @@ instance decidableLT : @DecidableRel String (· < ·) := by infer_instance
 #align string.decidable_lt String.decidableLT
 -/
 
-/- warning: string.lt_iff_to_list_lt -> String.lt_iff_toList_lt is a dubious translation:
-lean 3 declaration is
-  forall {s₁ : String} {s₂ : String}, Iff (LT.lt.{0} String String.LT' s₁ s₂) (LT.lt.{0} (List.{0} Char) (List.LT'.{0} Char Char.hasLt) (String.toList s₁) (String.toList s₂))
-but is expected to have type
-  forall {s₁ : String} {s₂ : String}, Iff (LT.lt.{0} String String.LT' s₁ s₂) (LT.lt.{0} (List.{0} Char) (List.LT'.{0} Char Char.instLTChar) (String.toList s₁) (String.toList s₂))
-Case conversion may be inaccurate. Consider using '#align string.lt_iff_to_list_lt String.lt_iff_toList_ltₓ'. -/
 -- short-circuit type class inference
 @[simp]
 theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList < s₂.toList
@@ -87,12 +81,6 @@ instance decidableLE : @DecidableRel String (· ≤ ·) := by infer_instance
 #align string.decidable_le String.decidableLE
 -/
 
-/- warning: string.le_iff_to_list_le -> String.le_iff_toList_le is a dubious translation:
-lean 3 declaration is
-  forall {s₁ : String} {s₂ : String}, Iff (LE.le.{0} String String.LE s₁ s₂) (LE.le.{0} (List.{0} Char) (List.LE'.{0} Char Char.linearOrder) (String.toList s₁) (String.toList s₂))
-but is expected to have type
-  forall {s₁ : String} {s₂ : String}, Iff (LE.le.{0} String String.LE s₁ s₂) (LE.le.{0} (List.{0} Char) (List.LE'.{0} Char instLinearOrderChar) (String.toList s₁) (String.toList s₂))
-Case conversion may be inaccurate. Consider using '#align string.le_iff_to_list_le String.le_iff_toList_leₓ'. -/
 -- short-circuit type class inference
 @[simp]
 theorem le_iff_toList_le {s₁ s₂ : String} : s₁ ≤ s₂ ↔ s₁.toList ≤ s₂.toList :=
@@ -105,22 +93,10 @@ theorem toList_inj : ∀ {s₁ s₂}, toList s₁ = toList s₂ ↔ s₁ = s₂
 #align string.to_list_inj String.toList_inj
 -/
 
-/- warning: string.nil_as_string_eq_empty -> String.nil_asString_eq_empty is a dubious translation:
-lean 3 declaration is
-  Eq.{1} String (List.asString (List.nil.{0} Char)) String.empty
-but is expected to have type
-  Eq.{1} String (List.asString (List.nil.{0} Char)) ""
-Case conversion may be inaccurate. Consider using '#align string.nil_as_string_eq_empty String.nil_asString_eq_emptyₓ'. -/
 theorem nil_asString_eq_empty : [].asString = "" :=
   rfl
 #align string.nil_as_string_eq_empty String.nil_asString_eq_empty
 
-/- warning: string.to_list_empty -> String.toList_empty is a dubious translation:
-lean 3 declaration is
-  Eq.{1} (List.{0} Char) (String.toList String.empty) (List.nil.{0} Char)
-but is expected to have type
-  Eq.{1} (List.{0} Char) (String.toList "") (List.nil.{0} Char)
-Case conversion may be inaccurate. Consider using '#align string.to_list_empty String.toList_emptyₓ'. -/
 @[simp]
 theorem toList_empty : "".toList = [] :=
   rfl
@@ -138,33 +114,15 @@ theorem data_singleton (c : Char) : (String.singleton c).toList = [c] :=
 #align string.to_list_singleton String.data_singleton
 -/
 
-/- warning: string.to_list_nonempty -> String.toList_nonempty is a dubious translation:
-lean 3 declaration is
-  forall {s : String}, (Ne.{1} String s String.empty) -> (Eq.{1} (List.{0} Char) (String.toList s) (List.cons.{0} Char (String.head s) (String.toList (String.drop s (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))))))
-but is expected to have type
-  forall {s : String}, (Ne.{1} String s "") -> (Eq.{1} (List.{0} Char) (String.toList s) (List.cons.{0} Char (String.head s) (String.toList (String.drop s (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))))
-Case conversion may be inaccurate. Consider using '#align string.to_list_nonempty String.toList_nonemptyₓ'. -/
 theorem toList_nonempty : ∀ {s : String}, s ≠ String.empty → s.toList = s.headI :: (s.drop 1).toList
   | ⟨s⟩, h => by cases s <;> [cases h rfl;rfl]
 #align string.to_list_nonempty String.toList_nonempty
 
-/- warning: string.head_empty -> String.head_empty is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Char (String.head String.empty) (Inhabited.default.{1} Char Char.inhabited)
-but is expected to have type
-  Eq.{1} Char (List.head!.{0} Char Char.instInhabitedChar (String.data "")) (Inhabited.default.{1} Char Char.instInhabitedChar)
-Case conversion may be inaccurate. Consider using '#align string.head_empty String.head_emptyₓ'. -/
 @[simp]
 theorem head_empty : "".headI = default :=
   rfl
 #align string.head_empty String.head_empty
 
-/- warning: string.popn_empty -> String.drop_empty is a dubious translation:
-lean 3 declaration is
-  forall {n : Nat}, Eq.{1} String (String.drop String.empty n) String.empty
-but is expected to have type
-  forall {n : Nat}, Eq.{1} String (String.drop "" n) ""
-Case conversion may be inaccurate. Consider using '#align string.popn_empty String.drop_emptyₓ'. -/
 @[simp]
 theorem drop_empty {n : ℕ} : "".drop n = "" :=
   by

75be6b61

bump to nightly-2023-05-28-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

6797a637

Diff

@@ -71,13 +71,9 @@ theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList
     · exact iff_of_false Bool.false_ne_true (not_lt_of_lt List.Lex.nil)
     · dsimp [iterator.has_next, iterator.curr, iterator.next]
       split_ifs
-      · subst b
-        exact IH.trans list.lex.cons_iff.symm
-      · simp
-        refine' ⟨List.Lex.rel, fun e => _⟩
-        cases e
-        · cases h rfl
-        assumption
+      · subst b; exact IH.trans list.lex.cons_iff.symm
+      · simp; refine' ⟨List.Lex.rel, fun e => _⟩
+        cases e; · cases h rfl; assumption
 #align string.lt_iff_to_list_lt String.lt_iff_toList_lt
 
 #print String.LE /-
@@ -131,10 +127,7 @@ theorem toList_empty : "".toList = [] :=
 #align string.to_list_empty String.toList_empty
 
 #print String.asString_inv_toList /-
-theorem asString_inv_toList (s : String) : s.toList.asString = s :=
-  by
-  cases s
-  rfl
+theorem asString_inv_toList (s : String) : s.toList.asString = s := by cases s; rfl
 #align string.as_string_inv_to_list String.asString_inv_toList
 -/
 
@@ -191,15 +184,9 @@ instance : LinearOrder String where
   decidableLe := String.decidableLE
   DecidableEq := by infer_instance
   le_refl a := le_iff_toList_le.2 le_rfl
-  le_trans a b c := by
-    simp only [le_iff_to_list_le]
-    exact fun h₁ h₂ => h₁.trans h₂
-  le_total a b := by
-    simp only [le_iff_to_list_le]
-    exact le_total _ _
-  le_antisymm a b := by
-    simp only [le_iff_to_list_le, ← to_list_inj]
-    apply le_antisymm
+  le_trans a b c := by simp only [le_iff_to_list_le]; exact fun h₁ h₂ => h₁.trans h₂
+  le_total a b := by simp only [le_iff_to_list_le]; exact le_total _ _
+  le_antisymm a b := by simp only [le_iff_to_list_le, ← to_list_inj]; apply le_antisymm
   lt_iff_le_not_le a b := by simp only [le_iff_to_list_le, lt_iff_to_list_lt, lt_iff_le_not_le]
 
 end String
@@ -207,10 +194,8 @@ end String
 open String
 
 #print List.toList_inv_asString /-
-theorem List.toList_inv_asString (l : List Char) : l.asString.toList = l :=
-  by
-  cases hl : l.as_string
-  exact StringImp.mk.inj hl.symm
+theorem List.toList_inv_asString (l : List Char) : l.asString.toList = l := by
+  cases hl : l.as_string; exact StringImp.mk.inj hl.symm
 #align list.to_list_inv_as_string List.toList_inv_asString
 -/

75be6b61

bump to nightly-2023-05-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/8d33f09cd7089ecf074b4791907588245aec5d1b

fbc7b476

Diff

@@ -152,7 +152,7 @@ but is expected to have type
   forall {s : String}, (Ne.{1} String s "") -> (Eq.{1} (List.{0} Char) (String.toList s) (List.cons.{0} Char (String.head s) (String.toList (String.drop s (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))))
 Case conversion may be inaccurate. Consider using '#align string.to_list_nonempty String.toList_nonemptyₓ'. -/
 theorem toList_nonempty : ∀ {s : String}, s ≠ String.empty → s.toList = s.headI :: (s.drop 1).toList
-  | ⟨s⟩, h => by cases s <;> [cases h rfl, rfl]
+  | ⟨s⟩, h => by cases s <;> [cases h rfl;rfl]
 #align string.to_list_nonempty String.toList_nonempty
 
 /- warning: string.head_empty -> String.head_empty is a dubious translation:

75be6b61

bump to nightly-2023-05-17-14

mathlib commit https://github.com/leanprover-community/mathlib/commit/f8c79b0a623404854a2902b836eac32156fd7712

20ad7900

Diff

@@ -138,20 +138,20 @@ theorem asString_inv_toList (s : String) : s.toList.asString = s :=
 #align string.as_string_inv_to_list String.asString_inv_toList
 -/
 
-#print String.toList_singleton /-
+#print String.data_singleton /-
 @[simp]
-theorem toList_singleton (c : Char) : (String.singleton c).toList = [c] :=
+theorem data_singleton (c : Char) : (String.singleton c).toList = [c] :=
   rfl
-#align string.to_list_singleton String.toList_singleton
+#align string.to_list_singleton String.data_singleton
 -/
 
 /- warning: string.to_list_nonempty -> String.toList_nonempty is a dubious translation:
 lean 3 declaration is
-  forall {s : String}, (Ne.{1} String s String.empty) -> (Eq.{1} (List.{0} Char) (String.toList s) (List.cons.{0} Char (String.head s) (String.toList (String.popn s (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))))))
+  forall {s : String}, (Ne.{1} String s String.empty) -> (Eq.{1} (List.{0} Char) (String.toList s) (List.cons.{0} Char (String.head s) (String.toList (String.drop s (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))))))
 but is expected to have type
-  forall {s : String}, (Ne.{1} String s "") -> (Eq.{1} (List.{0} Char) (String.toList s) (List.cons.{0} Char (String.head s) (String.toList (String.popn s (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))))
+  forall {s : String}, (Ne.{1} String s "") -> (Eq.{1} (List.{0} Char) (String.toList s) (List.cons.{0} Char (String.head s) (String.toList (String.drop s (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))))
 Case conversion may be inaccurate. Consider using '#align string.to_list_nonempty String.toList_nonemptyₓ'. -/
-theorem toList_nonempty : ∀ {s : String}, s ≠ String.empty → s.toList = s.headI :: (s.popn 1).toList
+theorem toList_nonempty : ∀ {s : String}, s ≠ String.empty → s.toList = s.headI :: (s.drop 1).toList
   | ⟨s⟩, h => by cases s <;> [cases h rfl, rfl]
 #align string.to_list_nonempty String.toList_nonempty
 
@@ -166,14 +166,14 @@ theorem head_empty : "".headI = default :=
   rfl
 #align string.head_empty String.head_empty
 
-/- warning: string.popn_empty -> String.popn_empty is a dubious translation:
+/- warning: string.popn_empty -> String.drop_empty is a dubious translation:
 lean 3 declaration is
-  forall {n : Nat}, Eq.{1} String (String.popn String.empty n) String.empty
+  forall {n : Nat}, Eq.{1} String (String.drop String.empty n) String.empty
 but is expected to have type
-  forall {n : Nat}, Eq.{1} String (String.popn "" n) ""
-Case conversion may be inaccurate. Consider using '#align string.popn_empty String.popn_emptyₓ'. -/
+  forall {n : Nat}, Eq.{1} String (String.drop "" n) ""
+Case conversion may be inaccurate. Consider using '#align string.popn_empty String.drop_emptyₓ'. -/
 @[simp]
-theorem popn_empty {n : ℕ} : "".popn n = "" :=
+theorem drop_empty {n : ℕ} : "".drop n = "" :=
   by
   induction' n with n hn
   · rfl
@@ -182,7 +182,7 @@ theorem popn_empty {n : ℕ} : "".popn n = "" :=
       conv_rhs => rw [← hn]
       simp only [popn, mk_iterator, iterator.nextn, iterator.next]
     · simpa only [← to_list_inj] using hs
-#align string.popn_empty String.popn_empty
+#align string.popn_empty String.drop_empty
 
 instance : LinearOrder String where
   lt := (· < ·)
@@ -229,11 +229,11 @@ theorem List.asString_inj {l l' : List Char} : l.asString = l'.asString ↔ l =
 #align list.as_string_inj List.asString_inj
 -/
 
-#print String.length_toList /-
+#print String.length_data /-
 @[simp]
-theorem String.length_toList (s : String) : s.toList.length = s.length := by
+theorem String.length_data (s : String) : s.toList.length = s.length := by
   rw [← String.asString_inv_toList s, List.toList_inv_asString, List.length_asString]
-#align string.length_to_list String.length_toList
+#align string.length_to_list String.length_data
 -/
 
 #print List.asString_eq /-

75be6b61

bump to nightly-2023-04-07-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/5ec62c8106221a3f9160e4e4fcc3eed79fe213e9

3f979973

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
 
 ! This file was ported from Lean 3 source module data.string.basic
-! leanprover-community/mathlib commit d13b3a4a392ea7273dfa4727dbd1892e26cfd518
+! leanprover-community/mathlib commit 75be6b616681ab6ca66d798ead117e75cd64f125
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Data.Char
 /-!
 # Strings
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 Supplementary theorems about the `string` type.
 -/

d13b3a4a

bump to nightly-2023-04-05-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/1a4df69ca1a9a0e5e26bfe12e2b92814216016d0

d79d18db

Diff

@@ -20,6 +20,7 @@ Supplementary theorems about the `string` type.
 
 namespace String
 
+#print String.ltb /-
 /-- `<` on string iterators. This coincides with `<` on strings as lists. -/
 def ltb : Iterator → Iterator → Bool
   | s₁, s₂ => by
@@ -34,14 +35,25 @@ def ltb : Iterator → Iterator → Bool
       else s₁.curr < s₂.curr termination_by'
   ⟨_, measure_wf fun s => s.1.2.length⟩
 #align string.ltb String.ltb
+-/
 
-instance hasLt' : LT String :=
+#print String.LT' /-
+instance LT' : LT String :=
   ⟨fun s₁ s₂ => ltb s₁.mkIterator s₂.mkIterator⟩
-#align string.has_lt' String.hasLt'
+#align string.has_lt' String.LT'
+-/
 
-instance decidableLt : @DecidableRel String (· < ·) := by infer_instance
-#align string.decidable_lt String.decidableLt
+#print String.decidableLT /-
+instance decidableLT : @DecidableRel String (· < ·) := by infer_instance
+#align string.decidable_lt String.decidableLT
+-/
 
+/- warning: string.lt_iff_to_list_lt -> String.lt_iff_toList_lt is a dubious translation:
+lean 3 declaration is
+  forall {s₁ : String} {s₂ : String}, Iff (LT.lt.{0} String String.LT' s₁ s₂) (LT.lt.{0} (List.{0} Char) (List.LT'.{0} Char Char.hasLt) (String.toList s₁) (String.toList s₂))
+but is expected to have type
+  forall {s₁ : String} {s₂ : String}, Iff (LT.lt.{0} String String.LT' s₁ s₂) (LT.lt.{0} (List.{0} Char) (List.LT'.{0} Char Char.instLTChar) (String.toList s₁) (String.toList s₂))
+Case conversion may be inaccurate. Consider using '#align string.lt_iff_to_list_lt String.lt_iff_toList_ltₓ'. -/
 -- short-circuit type class inference
 @[simp]
 theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList < s₂.toList
@@ -65,52 +77,98 @@ theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList
         assumption
 #align string.lt_iff_to_list_lt String.lt_iff_toList_lt
 
-instance hasLe : LE String :=
+#print String.LE /-
+instance LE : LE String :=
   ⟨fun s₁ s₂ => ¬s₂ < s₁⟩
-#align string.has_le String.hasLe
+#align string.has_le String.LE
+-/
 
-instance decidableLe : @DecidableRel String (· ≤ ·) := by infer_instance
-#align string.decidable_le String.decidableLe
+#print String.decidableLE /-
+instance decidableLE : @DecidableRel String (· ≤ ·) := by infer_instance
+#align string.decidable_le String.decidableLE
+-/
 
+/- warning: string.le_iff_to_list_le -> String.le_iff_toList_le is a dubious translation:
+lean 3 declaration is
+  forall {s₁ : String} {s₂ : String}, Iff (LE.le.{0} String String.LE s₁ s₂) (LE.le.{0} (List.{0} Char) (List.LE'.{0} Char Char.linearOrder) (String.toList s₁) (String.toList s₂))
+but is expected to have type
+  forall {s₁ : String} {s₂ : String}, Iff (LE.le.{0} String String.LE s₁ s₂) (LE.le.{0} (List.{0} Char) (List.LE'.{0} Char instLinearOrderChar) (String.toList s₁) (String.toList s₂))
+Case conversion may be inaccurate. Consider using '#align string.le_iff_to_list_le String.le_iff_toList_leₓ'. -/
 -- short-circuit type class inference
 @[simp]
 theorem le_iff_toList_le {s₁ s₂ : String} : s₁ ≤ s₂ ↔ s₁.toList ≤ s₂.toList :=
   (not_congr lt_iff_toList_lt).trans not_lt
 #align string.le_iff_to_list_le String.le_iff_toList_le
 
+#print String.toList_inj /-
 theorem toList_inj : ∀ {s₁ s₂}, toList s₁ = toList s₂ ↔ s₁ = s₂
   | ⟨s₁⟩, ⟨s₂⟩ => ⟨congr_arg _, congr_arg _⟩
 #align string.to_list_inj String.toList_inj
+-/
 
+/- warning: string.nil_as_string_eq_empty -> String.nil_asString_eq_empty is a dubious translation:
+lean 3 declaration is
+  Eq.{1} String (List.asString (List.nil.{0} Char)) String.empty
+but is expected to have type
+  Eq.{1} String (List.asString (List.nil.{0} Char)) ""
+Case conversion may be inaccurate. Consider using '#align string.nil_as_string_eq_empty String.nil_asString_eq_emptyₓ'. -/
 theorem nil_asString_eq_empty : [].asString = "" :=
   rfl
 #align string.nil_as_string_eq_empty String.nil_asString_eq_empty
 
+/- warning: string.to_list_empty -> String.toList_empty is a dubious translation:
+lean 3 declaration is
+  Eq.{1} (List.{0} Char) (String.toList String.empty) (List.nil.{0} Char)
+but is expected to have type
+  Eq.{1} (List.{0} Char) (String.toList "") (List.nil.{0} Char)
+Case conversion may be inaccurate. Consider using '#align string.to_list_empty String.toList_emptyₓ'. -/
 @[simp]
 theorem toList_empty : "".toList = [] :=
   rfl
 #align string.to_list_empty String.toList_empty
 
+#print String.asString_inv_toList /-
 theorem asString_inv_toList (s : String) : s.toList.asString = s :=
   by
   cases s
   rfl
 #align string.as_string_inv_to_list String.asString_inv_toList
+-/
 
+#print String.toList_singleton /-
 @[simp]
 theorem toList_singleton (c : Char) : (String.singleton c).toList = [c] :=
   rfl
 #align string.to_list_singleton String.toList_singleton
+-/
 
+/- warning: string.to_list_nonempty -> String.toList_nonempty is a dubious translation:
+lean 3 declaration is
+  forall {s : String}, (Ne.{1} String s String.empty) -> (Eq.{1} (List.{0} Char) (String.toList s) (List.cons.{0} Char (String.head s) (String.toList (String.popn s (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))))))
+but is expected to have type
+  forall {s : String}, (Ne.{1} String s "") -> (Eq.{1} (List.{0} Char) (String.toList s) (List.cons.{0} Char (String.head s) (String.toList (String.popn s (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))))
+Case conversion may be inaccurate. Consider using '#align string.to_list_nonempty String.toList_nonemptyₓ'. -/
 theorem toList_nonempty : ∀ {s : String}, s ≠ String.empty → s.toList = s.headI :: (s.popn 1).toList
   | ⟨s⟩, h => by cases s <;> [cases h rfl, rfl]
 #align string.to_list_nonempty String.toList_nonempty
 
+/- warning: string.head_empty -> String.head_empty is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Char (String.head String.empty) (Inhabited.default.{1} Char Char.inhabited)
+but is expected to have type
+  Eq.{1} Char (List.head!.{0} Char Char.instInhabitedChar (String.data "")) (Inhabited.default.{1} Char Char.instInhabitedChar)
+Case conversion may be inaccurate. Consider using '#align string.head_empty String.head_emptyₓ'. -/
 @[simp]
 theorem head_empty : "".headI = default :=
   rfl
 #align string.head_empty String.head_empty
 
+/- warning: string.popn_empty -> String.popn_empty is a dubious translation:
+lean 3 declaration is
+  forall {n : Nat}, Eq.{1} String (String.popn String.empty n) String.empty
+but is expected to have type
+  forall {n : Nat}, Eq.{1} String (String.popn "" n) ""
+Case conversion may be inaccurate. Consider using '#align string.popn_empty String.popn_emptyₓ'. -/
 @[simp]
 theorem popn_empty {n : ℕ} : "".popn n = "" :=
   by
@@ -127,7 +185,7 @@ instance : LinearOrder String where
   lt := (· < ·)
   le := (· ≤ ·)
   decidableLt := by infer_instance
-  decidableLe := String.decidableLe
+  decidableLe := String.decidableLE
   DecidableEq := by infer_instance
   le_refl a := le_iff_toList_le.2 le_rfl
   le_trans a b c := by
@@ -145,29 +203,39 @@ end String
 
 open String
 
+#print List.toList_inv_asString /-
 theorem List.toList_inv_asString (l : List Char) : l.asString.toList = l :=
   by
   cases hl : l.as_string
   exact StringImp.mk.inj hl.symm
 #align list.to_list_inv_as_string List.toList_inv_asString
+-/
 
+#print List.length_asString /-
 @[simp]
 theorem List.length_asString (l : List Char) : l.asString.length = l.length :=
   rfl
 #align list.length_as_string List.length_asString
+-/
 
+#print List.asString_inj /-
 @[simp]
 theorem List.asString_inj {l l' : List Char} : l.asString = l'.asString ↔ l = l' :=
   ⟨fun h => by rw [← List.toList_inv_asString l, ← List.toList_inv_asString l', to_list_inj, h],
     fun h => h ▸ rfl⟩
 #align list.as_string_inj List.asString_inj
+-/
 
+#print String.length_toList /-
 @[simp]
 theorem String.length_toList (s : String) : s.toList.length = s.length := by
   rw [← String.asString_inv_toList s, List.toList_inv_asString, List.length_asString]
 #align string.length_to_list String.length_toList
+-/
 
+#print List.asString_eq /-
 theorem List.asString_eq {l : List Char} {s : String} : l.asString = s ↔ l = s.toList := by
   rw [← as_string_inv_to_list s, List.asString_inj, as_string_inv_to_list s]
 #align list.as_string_eq List.asString_eq
+-/

d13b3a4a

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

d13b3a4a

chore: move Mathlib to v4.7.0-rc1 (#11162)

This is a very large PR, but it has been reviewed piecemeal already in PRs to the bump/v4.7.0 branch as we update to intermediate nightlies.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: damiano <adomani@gmail.com>

fa48894a

Diff

@@ -77,10 +77,14 @@ theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList
     induction s₁ generalizing s₂ <;> cases s₂
     · decide
     · rename_i c₂ cs₂; apply iff_of_true
-      · unfold ltb; simp [Iterator.hasNext, csize_pos]
+      · unfold ltb
+        -- Adaptation note: v4.7.0-rc1 exclude reduceMk from simp
+        simp [-reduceMk, Iterator.hasNext, csize_pos]
       · apply List.nil_lt_cons
     · rename_i c₁ cs₁ ih; apply iff_of_false
-      · unfold ltb; simp [Iterator.hasNext]
+      · unfold ltb
+        -- Adaptation note: v4.7.0-rc1 exclude reduceMk from simp
+        simp [-reduceMk, Iterator.hasNext]
       · apply not_lt_of_lt; apply List.nil_lt_cons
     · rename_i c₁ cs₁ ih c₂ cs₂; unfold ltb
       simp only [Iterator.hasNext, Pos.byteIdx_zero, endPos, utf8ByteSize, utf8ByteSize.go,

d13b3a4a

chore: avoid non-terminal simps and golf proofs (#10486)

Replace non-terminal simps with simp onlys.
Golf proofs.

ab35bb3e

Diff

@@ -59,17 +59,17 @@ theorem ltb_cons_addChar (c : Char) (cs₁ cs₂ : List Char) (i₁ i₂ : Pos)
     ltb ⟨⟨c :: cs₁⟩, i₁ + c⟩ ⟨⟨c :: cs₂⟩, i₂ + c⟩ = ltb ⟨⟨cs₁⟩, i₁⟩ ⟨⟨cs₂⟩, i₂⟩ := by
   apply ltb.inductionOn ⟨⟨cs₁⟩, i₁⟩ ⟨⟨cs₂⟩, i₂⟩ (motive := fun ⟨⟨cs₁⟩, i₁⟩ ⟨⟨cs₂⟩, i₂⟩ ↦
     ltb ⟨⟨c :: cs₁⟩, i₁ + c⟩ ⟨⟨c :: cs₂⟩, i₂ + c⟩ =
-    ltb ⟨⟨cs₁⟩, i₁⟩ ⟨⟨cs₂⟩, i₂⟩) <;> simp <;>
+    ltb ⟨⟨cs₁⟩, i₁⟩ ⟨⟨cs₂⟩, i₂⟩) <;> simp only <;>
   intro ⟨cs₁⟩ ⟨cs₂⟩ i₁ i₂ <;>
   intros <;>
-  (conv => lhs; rw [ltb]) <;> (conv => rhs; rw [ltb]) <;>
+  (conv => lhs; unfold ltb) <;> (conv => rhs; unfold ltb) <;>
   simp only [Iterator.hasNext_cons_addChar, ite_false, ite_true, *]
   · rename_i h₂ h₁ heq ih
-    simp [Iterator.curr, get_cons_addChar, Iterator.next, next, *] at *
+    simp only [Iterator.next, next, heq, Iterator.curr, get_cons_addChar, ite_true] at ih ⊢
     repeat rw [Pos.addChar_right_comm _ c]
     exact ih
   · rename_i h₂ h₁ hne
-    simp [Iterator.curr, get_cons_addChar, *]
+    simp [Iterator.curr, get_cons_addChar, hne]
 
 @[simp]
 theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList < s₂.toList
@@ -77,20 +77,19 @@ theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList
     induction s₁ generalizing s₂ <;> cases s₂
     · decide
     · rename_i c₂ cs₂; apply iff_of_true
-      · rw [ltb]; simp only [Iterator.hasNext, Iterator.curr]
-        simp [endPos, utf8ByteSize, utf8ByteSize.go, csize_pos]
+      · unfold ltb; simp [Iterator.hasNext, csize_pos]
       · apply List.nil_lt_cons
     · rename_i c₁ cs₁ ih; apply iff_of_false
-      · rw [ltb]; simp [Iterator.hasNext, Iterator.curr]
+      · unfold ltb; simp [Iterator.hasNext]
       · apply not_lt_of_lt; apply List.nil_lt_cons
-    · rename_i c₁ cs₁ ih c₂ cs₂; rw [ltb]
-      simp [Iterator.hasNext, endPos, utf8ByteSize, utf8ByteSize.go, csize_pos, Iterator.curr, get,
-            utf8GetAux, Iterator.next, next]
+    · rename_i c₁ cs₁ ih c₂ cs₂; unfold ltb
+      simp only [Iterator.hasNext, Pos.byteIdx_zero, endPos, utf8ByteSize, utf8ByteSize.go,
+        add_pos_iff, csize_pos, or_true, decide_eq_true_eq, ↓reduceIte, Iterator.curr, get,
+        utf8GetAux, Iterator.next, next, Bool.ite_eq_true_distrib]
       split_ifs with h
       · subst c₂
-        suffices ltb ⟨⟨c₁ :: cs₁⟩, ⟨csize c₁⟩⟩ ⟨⟨c₁ :: cs₂⟩, ⟨csize c₁⟩⟩ = ltb ⟨⟨cs₁⟩, 0⟩ ⟨⟨cs₂⟩, 0⟩
-          by rw [Pos.zero_addChar_eq, this]; exact (ih cs₂).trans List.Lex.cons_iff.symm
-        rw [← Pos.zero_addChar_eq]
+        suffices ltb ⟨⟨c₁ :: cs₁⟩, (0 : Pos) + c₁⟩ ⟨⟨c₁ :: cs₂⟩, (0 : Pos) + c₁⟩ =
+          ltb ⟨⟨cs₁⟩, 0⟩ ⟨⟨cs₂⟩, 0⟩ by rw [this]; exact (ih cs₂).trans List.Lex.cons_iff.symm
         apply ltb_cons_addChar
       · refine ⟨List.Lex.rel, fun e ↦ ?_⟩
         cases e <;> rename_i h'
@@ -134,10 +133,10 @@ theorem asString_inv_toList (s : String) : s.toList.asString = s :=
 theorem toList_nonempty : ∀ {s : String}, s ≠ "" → s.toList = s.head :: (s.drop 1).toList
   | ⟨s⟩, h => by
     cases s with
-    | nil => simp only [ne_eq, not_true_eq_false] at h
+    | nil => simp at h
     | cons c cs =>
-      simp only [toList, List.cons.injEq]
-      constructor <;> [rfl; simp [drop_eq]]
+      simp only [toList, data_drop, List.drop_succ_cons, List.drop_zero, List.cons.injEq, and_true]
+      rfl
 #align string.to_list_nonempty String.toList_nonempty
 
 @[simp]
@@ -162,8 +161,7 @@ instance : LinearOrder String where
     apply le_total
   decidableLE := String.decidableLE
   compare_eq_compareOfLessAndEq a b := by
-    simp only [compare, compareOfLessAndEq, instLTString, List.instLTList, lt_iff_toList_lt,
-      List.LT', toList]
+    simp only [compare, compareOfLessAndEq, instLTString, List.instLTList, lt_iff_toList_lt, toList]
     split_ifs <;>
     simp only [List.lt_iff_lex_lt] at * <;>
     contradiction

d13b3a4a

chore: Remove nonterminal simp at (#7795)

Removes nonterminal uses of simp at. Replaces most of these with instances of simp? ... says.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

4160b2aa

Diff

@@ -165,7 +165,7 @@ instance : LinearOrder String where
     simp only [compare, compareOfLessAndEq, instLTString, List.instLTList, lt_iff_toList_lt,
       List.LT', toList]
     split_ifs <;>
-    simp [List.lt_iff_lex_lt] at * <;>
+    simp only [List.lt_iff_lex_lt] at * <;>
     contradiction
 
 end String

d13b3a4a

chore: tidy various files (#8880)

d510164f

Diff

@@ -133,9 +133,9 @@ theorem asString_inv_toList (s : String) : s.toList.asString = s :=
 
 theorem toList_nonempty : ∀ {s : String}, s ≠ "" → s.toList = s.head :: (s.drop 1).toList
   | ⟨s⟩, h => by
-    cases s
-    · simp only [ne_eq, not_true_eq_false] at h
-    · rename_i c cs
+    cases s with
+    | nil => simp only [ne_eq, not_true_eq_false] at h
+    | cons c cs =>
       simp only [toList, List.cons.injEq]
       constructor <;> [rfl; simp [drop_eq]]
 #align string.to_list_nonempty String.toList_nonempty

d13b3a4a

chore: bump to v4.3.0-rc2 (#8366)

PR contents

This is the supremum of

#8284
#8056
#8023
#8332
#8226 (already approved)
#7834 (already approved)

along with some minor fixes from failures on nightly-testing as Mathlib master is merged into it.

Note that some PRs for changes that are already compatible with the current toolchain and will be necessary have already been split out: #8380.

I am hopeful that in future we will be able to progressively merge adaptation PRs into a bump/v4.X.0 branch, so we never end up with a "big merge" like this. However one of these adaptation PRs (#8056) predates my new scheme for combined CI, and it wasn't possible to keep that PR viable in the meantime.

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

leanprover/lean4#2778

We can get rid of all the

local macro_rules | `($x ^ $y) => `(HPow.hPow $x $y) -- Porting note: See issue [lean4#2220](https://github.com/leanprover/lean4/pull/2220)

macros across Mathlib (and in any projects that want to write natural number powers of reals).

leanprover/lean4#2722

Changes the default behaviour of simp to (config := {decide := false}). This makes simp (and consequentially norm_num) less powerful, but also more consistent, and less likely to blow up in long failures. This requires a variety of changes: changing some previously by simp or norm_num to decide or rfl, or adding (config := {decide := true}).

leanprover/lean4#2783

This changed the behaviour of simp so that simp [f] will only unfold "fully applied" occurrences of f. The old behaviour can be recovered with simp (config := { unfoldPartialApp := true }). We may in future add a syntax for this, e.g. simp [!f]; please provide feedback! In the meantime, we have made the following changes:

switching to using explicit lemmas that have the intended level of application
(config := { unfoldPartialApp := true }) in some places, to recover the old behaviour
Using @[eqns] to manually adjust the equation lemmas for a particular definition, recovering the old behaviour just for that definition. See #8371, where we do this for Function.comp and Function.flip.

This change in Lean may require further changes down the line (e.g. adding the !f syntax, and/or upstreaming the special treatment for Function.comp and Function.flip, and/or removing this special treatment). Please keep an open and skeptical mind about these changes!

Co-authored-by: leanprover-community-mathlib4-bot <leanprover-community-mathlib4-bot@users.noreply.github.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Mauricio Collares <mauricio@collares.org>

40b64f79

Diff

@@ -75,13 +75,13 @@ theorem ltb_cons_addChar (c : Char) (cs₁ cs₂ : List Char) (i₁ i₂ : Pos)
 theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList < s₂.toList
   | ⟨s₁⟩, ⟨s₂⟩ => show ltb ⟨⟨s₁⟩, 0⟩ ⟨⟨s₂⟩, 0⟩ ↔ s₁ < s₂ by
     induction s₁ generalizing s₂ <;> cases s₂
-    · simp
+    · decide
     · rename_i c₂ cs₂; apply iff_of_true
-      · rw [ltb]; simp; apply ne_false_of_eq_true; apply decide_eq_true
+      · rw [ltb]; simp only [Iterator.hasNext, Iterator.curr]
         simp [endPos, utf8ByteSize, utf8ByteSize.go, csize_pos]
       · apply List.nil_lt_cons
     · rename_i c₁ cs₁ ih; apply iff_of_false
-      · rw [ltb]; simp
+      · rw [ltb]; simp [Iterator.hasNext, Iterator.curr]
       · apply not_lt_of_lt; apply List.nil_lt_cons
     · rename_i c₁ cs₁ ih c₂ cs₂; rw [ltb]
       simp [Iterator.hasNext, endPos, utf8ByteSize, utf8ByteSize.go, csize_pos, Iterator.curr, get,
@@ -134,7 +134,7 @@ theorem asString_inv_toList (s : String) : s.toList.asString = s :=
 theorem toList_nonempty : ∀ {s : String}, s ≠ "" → s.toList = s.head :: (s.drop 1).toList
   | ⟨s⟩, h => by
     cases s
-    · simp only at h
+    · simp only [ne_eq, not_true_eq_false] at h
     · rename_i c cs
       simp only [toList, List.cons.injEq]
       constructor <;> [rfl; simp [drop_eq]]

d13b3a4a

chore: remove nonterminal simp (#7580)

Removes nonterminal simps on lines looking like simp [...]

6fc8e6ec

Diff

@@ -63,7 +63,7 @@ theorem ltb_cons_addChar (c : Char) (cs₁ cs₂ : List Char) (i₁ i₂ : Pos)
   intro ⟨cs₁⟩ ⟨cs₂⟩ i₁ i₂ <;>
   intros <;>
   (conv => lhs; rw [ltb]) <;> (conv => rhs; rw [ltb]) <;>
-  simp [Iterator.hasNext_cons_addChar, *]
+  simp only [Iterator.hasNext_cons_addChar, ite_false, ite_true, *]
   · rename_i h₂ h₁ heq ih
     simp [Iterator.curr, get_cons_addChar, Iterator.next, next, *] at *
     repeat rw [Pos.addChar_right_comm _ c]
@@ -162,7 +162,8 @@ instance : LinearOrder String where
     apply le_total
   decidableLE := String.decidableLE
   compare_eq_compareOfLessAndEq a b := by
-    simp [compare, compareOfLessAndEq, toList, instLTString, List.instLTList, List.LT']
+    simp only [compare, compareOfLessAndEq, instLTString, List.instLTList, lt_iff_toList_lt,
+      List.LT', toList]
     split_ifs <;>
     simp [List.lt_iff_lex_lt] at * <;>
     contradiction

d13b3a4a

chore: exactly 4 spaces in theorems (#7328)

Co-authored-by: Moritz Firsching <firsching@google.com>

d3263b23

Diff

@@ -73,29 +73,29 @@ theorem ltb_cons_addChar (c : Char) (cs₁ cs₂ : List Char) (i₁ i₂ : Pos)
 
 @[simp]
 theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList < s₂.toList
-| ⟨s₁⟩, ⟨s₂⟩ => show ltb ⟨⟨s₁⟩, 0⟩ ⟨⟨s₂⟩, 0⟩ ↔ s₁ < s₂ by
-  induction s₁ generalizing s₂ <;> cases s₂
-  · simp
-  · rename_i c₂ cs₂; apply iff_of_true
-    · rw [ltb]; simp; apply ne_false_of_eq_true; apply decide_eq_true
-      simp [endPos, utf8ByteSize, utf8ByteSize.go, csize_pos]
-    · apply List.nil_lt_cons
-  · rename_i c₁ cs₁ ih; apply iff_of_false
-    · rw [ltb]; simp
-    · apply not_lt_of_lt; apply List.nil_lt_cons
-  · rename_i c₁ cs₁ ih c₂ cs₂; rw [ltb]
-    simp [Iterator.hasNext, endPos, utf8ByteSize, utf8ByteSize.go, csize_pos, Iterator.curr, get,
-          utf8GetAux, Iterator.next, next]
-    split_ifs with h
-    · subst c₂
-      suffices ltb ⟨⟨c₁ :: cs₁⟩, ⟨csize c₁⟩⟩ ⟨⟨c₁ :: cs₂⟩, ⟨csize c₁⟩⟩ = ltb ⟨⟨cs₁⟩, 0⟩ ⟨⟨cs₂⟩, 0⟩
-        by rw [Pos.zero_addChar_eq, this]; exact (ih cs₂).trans List.Lex.cons_iff.symm
-      rw [← Pos.zero_addChar_eq]
-      apply ltb_cons_addChar
-    · refine ⟨List.Lex.rel, fun e ↦ ?_⟩
-      cases e <;> rename_i h'
-      · contradiction
-      · assumption
+  | ⟨s₁⟩, ⟨s₂⟩ => show ltb ⟨⟨s₁⟩, 0⟩ ⟨⟨s₂⟩, 0⟩ ↔ s₁ < s₂ by
+    induction s₁ generalizing s₂ <;> cases s₂
+    · simp
+    · rename_i c₂ cs₂; apply iff_of_true
+      · rw [ltb]; simp; apply ne_false_of_eq_true; apply decide_eq_true
+        simp [endPos, utf8ByteSize, utf8ByteSize.go, csize_pos]
+      · apply List.nil_lt_cons
+    · rename_i c₁ cs₁ ih; apply iff_of_false
+      · rw [ltb]; simp
+      · apply not_lt_of_lt; apply List.nil_lt_cons
+    · rename_i c₁ cs₁ ih c₂ cs₂; rw [ltb]
+      simp [Iterator.hasNext, endPos, utf8ByteSize, utf8ByteSize.go, csize_pos, Iterator.curr, get,
+            utf8GetAux, Iterator.next, next]
+      split_ifs with h
+      · subst c₂
+        suffices ltb ⟨⟨c₁ :: cs₁⟩, ⟨csize c₁⟩⟩ ⟨⟨c₁ :: cs₂⟩, ⟨csize c₁⟩⟩ = ltb ⟨⟨cs₁⟩, 0⟩ ⟨⟨cs₂⟩, 0⟩
+          by rw [Pos.zero_addChar_eq, this]; exact (ih cs₂).trans List.Lex.cons_iff.symm
+        rw [← Pos.zero_addChar_eq]
+        apply ltb_cons_addChar
+      · refine ⟨List.Lex.rel, fun e ↦ ?_⟩
+        cases e <;> rename_i h'
+        · contradiction
+        · assumption
 #align string.lt_iff_to_list_lt String.lt_iff_toList_lt
 
 instance LE : LE String :=
@@ -132,12 +132,12 @@ theorem asString_inv_toList (s : String) : s.toList.asString = s :=
 #align string.to_list_singleton String.data_singleton
 
 theorem toList_nonempty : ∀ {s : String}, s ≠ "" → s.toList = s.head :: (s.drop 1).toList
-| ⟨s⟩, h => by
-  cases s
-  · simp only at h
-  · rename_i c cs
-    simp only [toList, List.cons.injEq]
-    constructor <;> [rfl; simp [drop_eq]]
+  | ⟨s⟩, h => by
+    cases s
+    · simp only at h
+    · rename_i c cs
+      simp only [toList, List.cons.injEq]
+      constructor <;> [rfl; simp [drop_eq]]
 #align string.to_list_nonempty String.toList_nonempty
 
 @[simp]

d13b3a4a

chore: bump Std version (#6435)

Notably there is now a l1 ∪ l2 notation for List.union.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Bulhwi Cha <chabulhwi@semmalgil.com>

5f5bef5a

Diff

@@ -16,11 +16,6 @@ Supplementary theorems about the `String` type.
 
 namespace String
 
--- TODO: upstream to std or remove
-theorem Iterator.hasNext_cons_addChar (c : Char) (cs : List Char) (i : Pos) :
-    hasNext ⟨⟨c :: cs⟩, i + c⟩ = hasNext ⟨⟨cs⟩, i⟩ := by
-  simp [hasNext]
-
 /-- `<` on string iterators. This coincides with `<` on strings as lists. -/
 def ltb (s₁ s₂ : Iterator) : Bool :=
   if s₂.hasNext then

d13b3a4a

chore: bump to nightly-2023-07-15 (#5992)

Various adaptations to changes when Fin API was moved to Std. One notable change is that many lemmas are now stated in terms of i ≠ 0 (for i : Fin n) rather then i.1 ≠ 0, and as a consequence many Fin.vne_of_ne applications have been added or removed, mostly removed.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Wojciech Nawrocki <wjnawrocki@protonmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

24924f96

Diff

@@ -19,7 +19,7 @@ namespace String
 -- TODO: upstream to std or remove
 theorem Iterator.hasNext_cons_addChar (c : Char) (cs : List Char) (i : Pos) :
     hasNext ⟨⟨c :: cs⟩, i + c⟩ = hasNext ⟨⟨cs⟩, i⟩ := by
-  simp [hasNext, Nat.add_lt_add_iff_lt_right]
+  simp [hasNext]
 
 /-- `<` on string iterators. This coincides with `<` on strings as lists. -/
 def ltb (s₁ s₂ : Iterator) : Bool :=

d13b3a4a

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
-
-! This file was ported from Lean 3 source module data.string.basic
-! leanprover-community/mathlib commit d13b3a4a392ea7273dfa4727dbd1892e26cfd518
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.List.Lex
 import Mathlib.Data.Char
 
+#align_import data.string.basic from "leanprover-community/mathlib"@"d13b3a4a392ea7273dfa4727dbd1892e26cfd518"
+
 /-!
 # Strings

d13b3a4a

chore: update std 05-22 (#4248)

The main breaking change is that tac <;> [t1, t2] is now written tac <;> [t1; t2], to avoid clashing with tactics like cases and use that take comma-separated lists.

ac36b28e

Diff

@@ -19,6 +19,11 @@ Supplementary theorems about the `String` type.
 
 namespace String
 
+-- TODO: upstream to std or remove
+theorem Iterator.hasNext_cons_addChar (c : Char) (cs : List Char) (i : Pos) :
+    hasNext ⟨⟨c :: cs⟩, i + c⟩ = hasNext ⟨⟨cs⟩, i⟩ := by
+  simp [hasNext, Nat.add_lt_add_iff_lt_right]
+
 /-- `<` on string iterators. This coincides with `<` on strings as lists. -/
 def ltb (s₁ s₂ : Iterator) : Bool :=
   if s₂.hasNext then
@@ -140,7 +145,7 @@ theorem toList_nonempty : ∀ {s : String}, s ≠ "" → s.toList = s.head :: (s
   · simp only at h
   · rename_i c cs
     simp only [toList, List.cons.injEq]
-    constructor <;> [rfl, simp [drop_eq]]
+    constructor <;> [rfl; simp [drop_eq]]
 #align string.to_list_nonempty String.toList_nonempty
 
 @[simp]

d13b3a4a

chore: bump dependencies (#4012)

This just bumps the Std dependency, to get access to Mario's new "Try this:" implementation.

Co-authored-by: Bulhwi Cha <chabulhwi@semmalgil.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

f513eb6d

Diff

@@ -19,27 +19,6 @@ Supplementary theorems about the `String` type.
 
 namespace String
 
-lemma utf8GetAux.add_right_cancel (s : List Char) (i p n : ℕ) :
-    utf8GetAux s ⟨i + n⟩ ⟨p + n⟩ = utf8GetAux s ⟨i⟩ ⟨p⟩ := by
-  apply utf8InductionOn s ⟨i⟩ ⟨p⟩ (motive := fun s i ↦
-    utf8GetAux s ⟨i.byteIdx + n⟩ ⟨p + n⟩ = utf8GetAux s i ⟨p⟩) <;>
-  simp [utf8GetAux]
-  intro c cs ⟨i⟩ h ih
-  simp [Pos.ext_iff] at *
-  simp [h]
-  rw [Pos.addChar_eq, Nat.add_right_comm]
-  exact ih
-
-theorem get.cons_add_csize (c : Char) (cs : List Char) (i : ℕ) :
-    get ⟨c :: cs⟩ ⟨i + csize c⟩ = get ⟨cs⟩ ⟨i⟩ := by
-  have : 0 ≠ i + csize c := Nat.ne_of_lt (Nat.add_pos_right i (csize_pos c))
-  simp [get, utf8GetAux, Pos.ext_iff, this]
-  apply utf8GetAux.add_right_cancel
-
-theorem Iterator.hasNext.cons_add_csize (c : Char) (cs : List Char) (i : ℕ) :
-    hasNext ⟨⟨c :: cs⟩, ⟨i + csize c⟩⟩ = hasNext ⟨⟨cs⟩, ⟨i⟩⟩ := by
-  simp [hasNext, endPos, utf8ByteSize, utf8ByteSize.go]
-
 /-- `<` on string iterators. This coincides with `<` on strings as lists. -/
 def ltb (s₁ s₂ : Iterator) : Bool :=
   if s₂.hasNext then
@@ -79,22 +58,21 @@ def ltb.inductionOn.{u} {motive : Iterator → Iterator → Sort u} (it₁ it₂
     else base₁ it₁.s it₂.s it₁.i it₂.i h₂ h₁
   else base₂ it₁.s it₂.s it₁.i it₂.i h₂
 
-theorem ltb.cons_add_csize (c : Char) (cs₁ cs₂ : List Char) (i₁ i₂ : ℕ) :
-    ltb ⟨⟨c :: cs₁⟩, ⟨i₁ + csize c⟩⟩ ⟨⟨c :: cs₂⟩, ⟨i₂ + csize c⟩⟩ =
-    ltb ⟨⟨cs₁⟩, ⟨i₁⟩⟩ ⟨⟨cs₂⟩, ⟨i₂⟩⟩ := by
-  apply inductionOn ⟨⟨cs₁⟩, ⟨i₁⟩⟩ ⟨⟨cs₂⟩, ⟨i₂⟩⟩ (motive := fun ⟨⟨cs₁⟩, ⟨i₁⟩⟩ ⟨⟨cs₂⟩, ⟨i₂⟩⟩ ↦
-    ltb ⟨⟨c :: cs₁⟩, ⟨i₁ + csize c⟩⟩ ⟨⟨c :: cs₂⟩, ⟨i₂ + csize c⟩⟩ =
-    ltb ⟨⟨cs₁⟩, ⟨i₁⟩⟩ ⟨⟨cs₂⟩, ⟨i₂⟩⟩) <;> simp <;>
-  intro ⟨cs₁⟩ ⟨cs₂⟩ ⟨i₁⟩ ⟨i₂⟩ <;>
+theorem ltb_cons_addChar (c : Char) (cs₁ cs₂ : List Char) (i₁ i₂ : Pos) :
+    ltb ⟨⟨c :: cs₁⟩, i₁ + c⟩ ⟨⟨c :: cs₂⟩, i₂ + c⟩ = ltb ⟨⟨cs₁⟩, i₁⟩ ⟨⟨cs₂⟩, i₂⟩ := by
+  apply ltb.inductionOn ⟨⟨cs₁⟩, i₁⟩ ⟨⟨cs₂⟩, i₂⟩ (motive := fun ⟨⟨cs₁⟩, i₁⟩ ⟨⟨cs₂⟩, i₂⟩ ↦
+    ltb ⟨⟨c :: cs₁⟩, i₁ + c⟩ ⟨⟨c :: cs₂⟩, i₂ + c⟩ =
+    ltb ⟨⟨cs₁⟩, i₁⟩ ⟨⟨cs₂⟩, i₂⟩) <;> simp <;>
+  intro ⟨cs₁⟩ ⟨cs₂⟩ i₁ i₂ <;>
   intros <;>
   (conv => lhs; rw [ltb]) <;> (conv => rhs; rw [ltb]) <;>
-  simp [Iterator.hasNext.cons_add_csize, *]
+  simp [Iterator.hasNext_cons_addChar, *]
   · rename_i h₂ h₁ heq ih
-    simp [Iterator.curr, get.cons_add_csize, Iterator.next, next, Pos.addChar_eq, *] at *
-    repeat rw [Nat.add_right_comm _ (csize c)]
+    simp [Iterator.curr, get_cons_addChar, Iterator.next, next, *] at *
+    repeat rw [Pos.addChar_right_comm _ c]
     exact ih
   · rename_i h₂ h₁ hne
-    simp [Iterator.curr, get.cons_add_csize, *]
+    simp [Iterator.curr, get_cons_addChar, *]
 
 @[simp]
 theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList < s₂.toList
@@ -116,7 +94,7 @@ theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList
       suffices ltb ⟨⟨c₁ :: cs₁⟩, ⟨csize c₁⟩⟩ ⟨⟨c₁ :: cs₂⟩, ⟨csize c₁⟩⟩ = ltb ⟨⟨cs₁⟩, 0⟩ ⟨⟨cs₂⟩, 0⟩
         by rw [Pos.zero_addChar_eq, this]; exact (ih cs₂).trans List.Lex.cons_iff.symm
       rw [← Pos.zero_addChar_eq]
-      apply ltb.cons_add_csize
+      apply ltb_cons_addChar
     · refine ⟨List.Lex.rel, fun e ↦ ?_⟩
       cases e <;> rename_i h'
       · contradiction
@@ -154,19 +132,15 @@ theorem asString_inv_toList (s : String) : s.toList.asString = s :=
   rfl
 #align string.as_string_inv_to_list String.asString_inv_toList
 
-@[simp]
-theorem toList_singleton (c : Char) : (String.singleton c).toList = [c] :=
-  rfl
-#align string.to_list_singleton String.toList_singleton
+#align string.to_list_singleton String.data_singleton
 
-theorem toList_nonempty : ∀ {s : String}, s ≠ "" → s.toList = s.head :: (s.popn 1).toList
+theorem toList_nonempty : ∀ {s : String}, s ≠ "" → s.toList = s.head :: (s.drop 1).toList
 | ⟨s⟩, h => by
   cases s
   · simp only at h
   · rename_i c cs
     simp only [toList, List.cons.injEq]
-    constructor <;>
-    rfl
+    constructor <;> [rfl, simp [drop_eq]]
 #align string.to_list_nonempty String.toList_nonempty
 
 @[simp]
@@ -174,10 +148,7 @@ theorem head_empty : "".data.head! = default :=
   rfl
 #align string.head_empty String.head_empty
 
-@[simp]
-theorem popn_empty {n : ℕ} : "".popn n = "" := by
-  simp [popn]
-#align string.popn_empty String.popn_empty
+#align string.popn_empty String.drop_empty
 
 instance : LinearOrder String where
   le_refl a := le_iff_toList_le.mpr le_rfl
@@ -219,9 +190,9 @@ theorem List.asString_inj {l l' : List Char} : l.asString = l'.asString ↔ l =
 #align list.as_string_inj List.asString_inj
 
 @[simp]
-theorem String.length_toList (s : String) : s.toList.length = s.length := by
-  rw [← String.asString_inv_toList s, List.toList_inv_asString, List.length_asString]
-#align string.length_to_list String.length_toList
+theorem String.length_data (s : String) : s.data.length = s.length :=
+  rfl
+#align string.length_to_list String.length_data
 
 theorem List.asString_eq {l : List Char} {s : String} : l.asString = s ↔ l = s.toList := by
   rw [← asString_inv_toList s, asString_inj, asString_inv_toList s]

d13b3a4a

fix: correct names of LinearOrder decidable fields (#4006)

This renames

decidable_eq to decidableEq
decidable_lt to decidableLT
decidable_le to decidableLE
decidableLT_of_decidableLE to decidableLTOfDecidableLE
decidableEq_of_decidableLE to decidableEqOfDecidableLE

These fields are data not proofs, so they should be lowerCamelCased.

e7280432

Diff

@@ -192,7 +192,7 @@ instance : LinearOrder String where
   le_total a b := by
     simp only [le_iff_toList_le]
     apply le_total
-  decidable_le := String.decidableLE
+  decidableLE := String.decidableLE
   compare_eq_compareOfLessAndEq a b := by
     simp [compare, compareOfLessAndEq, toList, instLTString, List.instLTList, List.LT']
     split_ifs <;>

d13b3a4a

chore: bump to Lean 4 nightly-2023-05-06 (#3817)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

9cf0d9bd

Diff

@@ -19,9 +19,7 @@ Supplementary theorems about the `String` type.
 
 namespace String
 
-open private utf8GetAux from Init.Data.String.Basic
-
-private lemma utf8GetAux.add_right_cancel (s : List Char) (i p n : ℕ) :
+lemma utf8GetAux.add_right_cancel (s : List Char) (i p n : ℕ) :
     utf8GetAux s ⟨i + n⟩ ⟨p + n⟩ = utf8GetAux s ⟨i⟩ ⟨p⟩ := by
   apply utf8InductionOn s ⟨i⟩ ⟨p⟩ (motive := fun s i ↦
     utf8GetAux s ⟨i.byteIdx + n⟩ ⟨p + n⟩ = utf8GetAux s i ⟨p⟩) <;>

d13b3a4a

refactor: delete import line (#3745)

Delete an unnecessary import line.

c21b166f

Diff

@@ -8,7 +8,6 @@ Authors: Mario Carneiro
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
-import Std.Data.String.Lemmas
 import Mathlib.Data.List.Lex
 import Mathlib.Data.Char

d13b3a4a

chore: move theorems on String to std4 (#3712)

https://github.com/leanprover/std4/pull/124 moves the following from Mathlib4 to Std4:

helper simp theorems on String.Pos
String.utf8GetAux.inductionOn

27ba1681

Diff

@@ -8,6 +8,7 @@ Authors: Mario Carneiro
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
+import Std.Data.String.Lemmas
 import Mathlib.Data.List.Lex
 import Mathlib.Data.Char
 
@@ -19,62 +20,26 @@ Supplementary theorems about the `String` type.
 
 namespace String
 
-@[simp]
-theorem Pos.byteIdx_zero : (0 : Pos).byteIdx = 0 :=
-  rfl
-
-@[simp]
-theorem Pos.eq_iff {i₁ i₂ : Pos} : i₁ = i₂ ↔ i₁.byteIdx = i₂.byteIdx :=
-  ⟨fun h ↦ h ▸ rfl, fun h ↦ show ⟨i₁.byteIdx⟩ = (⟨i₂.byteIdx⟩ : Pos) from h ▸ rfl⟩
-
-@[simp]
-theorem Pos.zero_add_char (c : Char) : (0 : Pos) + c = ⟨csize c⟩ :=
-  show ⟨0 + csize c⟩ = (⟨csize c⟩ : Pos) by rw [Nat.zero_add]
-
-@[simp]
-theorem Pos.zero_add_string (s : String) : (0 : Pos) + s = ⟨s.utf8ByteSize⟩ :=
-  show ⟨0 + s.utf8ByteSize⟩ = (⟨s.utf8ByteSize⟩ : Pos) by rw [Nat.zero_add]
-
-/-- Induction on `String.utf8GetAux`. -/
-def utf8GetAux.inductionOn.{u} {motive : List Char → Pos → Pos → Sort u}
-    (s : List Char) (i p : Pos)
-    (nil : ∀ i p, motive [] i p)
-    (eq  : ∀ c cs i p, i = p → motive (c :: cs) i p)
-    (ind : ∀ c cs i p, i ≠ p → motive cs ⟨i.byteIdx + csize c⟩ p → motive (c :: cs) i p) :
-    motive s i p :=
-  match s with
-  | [] => nil i p
-  | c::cs =>
-    if h : i = p then
-      eq c cs i p h
-    else ind c cs i p h (inductionOn cs ⟨i.byteIdx + csize c⟩ p nil eq ind)
-
 open private utf8GetAux from Init.Data.String.Basic
 
 private lemma utf8GetAux.add_right_cancel (s : List Char) (i p n : ℕ) :
     utf8GetAux s ⟨i + n⟩ ⟨p + n⟩ = utf8GetAux s ⟨i⟩ ⟨p⟩ := by
-  apply inductionOn s ⟨i⟩ ⟨p⟩ (motive := fun s i p ↦
-    utf8GetAux s ⟨i.byteIdx + n⟩ ⟨p.byteIdx + n⟩ = utf8GetAux s i p) <;>
+  apply utf8InductionOn s ⟨i⟩ ⟨p⟩ (motive := fun s i ↦
+    utf8GetAux s ⟨i.byteIdx + n⟩ ⟨p + n⟩ = utf8GetAux s i ⟨p⟩) <;>
   simp [utf8GetAux]
-  · intro c cs ⟨i⟩ ⟨p⟩ h
-    simp at h
-    subst i
-    simp
-  · intro c cs ⟨i⟩ ⟨p⟩ h ih
-    simp at h
-    simp [h]
-    show utf8GetAux cs ⟨i + n + csize c⟩ ⟨p + n⟩ = utf8GetAux cs ⟨i + csize c⟩ ⟨p⟩
-    rw [Nat.add_right_comm]
-    exact ih
+  intro c cs ⟨i⟩ h ih
+  simp [Pos.ext_iff] at *
+  simp [h]
+  rw [Pos.addChar_eq, Nat.add_right_comm]
+  exact ih
 
-lemma get.cons_add_csize (c : Char) (cs : List Char) (i : ℕ) :
+theorem get.cons_add_csize (c : Char) (cs : List Char) (i : ℕ) :
     get ⟨c :: cs⟩ ⟨i + csize c⟩ = get ⟨cs⟩ ⟨i⟩ := by
   have : 0 ≠ i + csize c := Nat.ne_of_lt (Nat.add_pos_right i (csize_pos c))
-  simp [get, utf8GetAux, this]
-  rw [← Pos.zero_add_char]
+  simp [get, utf8GetAux, Pos.ext_iff, this]
   apply utf8GetAux.add_right_cancel
 
-lemma Iterator.hasNext.cons_add_csize (c : Char) (cs : List Char) (i : ℕ) :
+theorem Iterator.hasNext.cons_add_csize (c : Char) (cs : List Char) (i : ℕ) :
     hasNext ⟨⟨c :: cs⟩, ⟨i + csize c⟩⟩ = hasNext ⟨⟨cs⟩, ⟨i⟩⟩ := by
   simp [hasNext, endPos, utf8ByteSize, utf8ByteSize.go]
 
@@ -117,7 +82,7 @@ def ltb.inductionOn.{u} {motive : Iterator → Iterator → Sort u} (it₁ it₂
     else base₁ it₁.s it₂.s it₁.i it₂.i h₂ h₁
   else base₂ it₁.s it₂.s it₁.i it₂.i h₂
 
-lemma ltb.cons_add_csize (c : Char) (cs₁ cs₂ : List Char) (i₁ i₂ : ℕ) :
+theorem ltb.cons_add_csize (c : Char) (cs₁ cs₂ : List Char) (i₁ i₂ : ℕ) :
     ltb ⟨⟨c :: cs₁⟩, ⟨i₁ + csize c⟩⟩ ⟨⟨c :: cs₂⟩, ⟨i₂ + csize c⟩⟩ =
     ltb ⟨⟨cs₁⟩, ⟨i₁⟩⟩ ⟨⟨cs₂⟩, ⟨i₂⟩⟩ := by
   apply inductionOn ⟨⟨cs₁⟩, ⟨i₁⟩⟩ ⟨⟨cs₂⟩, ⟨i₂⟩⟩ (motive := fun ⟨⟨cs₁⟩, ⟨i₁⟩⟩ ⟨⟨cs₂⟩, ⟨i₂⟩⟩ ↦
@@ -128,15 +93,11 @@ lemma ltb.cons_add_csize (c : Char) (cs₁ cs₂ : List Char) (i₁ i₂ : ℕ)
   (conv => lhs; rw [ltb]) <;> (conv => rhs; rw [ltb]) <;>
   simp [Iterator.hasNext.cons_add_csize, *]
   · rename_i h₂ h₁ heq ih
-    simp [Iterator.curr, Iterator.next, next, Iterator.hasNext.cons_add_csize,
-          get.cons_add_csize, *] at *
-    show ltb ⟨⟨c :: cs₁⟩, ⟨i₁ + csize c + csize (get ⟨cs₂⟩ ⟨i₂⟩)⟩⟩
-             ⟨⟨c :: cs₂⟩, ⟨i₂ + csize c + csize (get ⟨cs₂⟩ ⟨i₂⟩)⟩⟩ =
-         ltb ⟨⟨cs₁⟩, ⟨i₁ + csize (get ⟨cs₂⟩ ⟨i₂⟩)⟩⟩ ⟨⟨cs₂⟩, ⟨i₂ + csize (get ⟨cs₂⟩ ⟨i₂⟩)⟩⟩
+    simp [Iterator.curr, get.cons_add_csize, Iterator.next, next, Pos.addChar_eq, *] at *
     repeat rw [Nat.add_right_comm _ (csize c)]
     exact ih
   · rename_i h₂ h₁ hne
-    simp [Iterator.curr, Iterator.hasNext.cons_add_csize, get.cons_add_csize, *] at *
+    simp [Iterator.curr, get.cons_add_csize, *]
 
 @[simp]
 theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList < s₂.toList
@@ -151,16 +112,13 @@ theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList
     · rw [ltb]; simp
     · apply not_lt_of_lt; apply List.nil_lt_cons
   · rename_i c₁ cs₁ ih c₂ cs₂; rw [ltb]
-    simp [Iterator.hasNext, Iterator.curr, Iterator.next, next, endPos, utf8ByteSize,
-          utf8ByteSize.go, csize_pos]; rw [decide_eq_true_iff]
-    show (if c₁ = c₂ then
-            ltb ⟨⟨c₁ :: cs₁⟩, ⟨csize c₁⟩⟩ ⟨⟨c₂ :: cs₂⟩, ⟨csize c₂⟩⟩ = true
-          else c₁ < c₂) ↔ c₁ :: cs₁ < c₂ :: cs₂
+    simp [Iterator.hasNext, endPos, utf8ByteSize, utf8ByteSize.go, csize_pos, Iterator.curr, get,
+          utf8GetAux, Iterator.next, next]
     split_ifs with h
     · subst c₂
       suffices ltb ⟨⟨c₁ :: cs₁⟩, ⟨csize c₁⟩⟩ ⟨⟨c₁ :: cs₂⟩, ⟨csize c₁⟩⟩ = ltb ⟨⟨cs₁⟩, 0⟩ ⟨⟨cs₂⟩, 0⟩
-        by rw [this]; exact (ih cs₂).trans List.Lex.cons_iff.symm
-      rw [← Pos.zero_add_char]
+        by rw [Pos.zero_addChar_eq, this]; exact (ih cs₂).trans List.Lex.cons_iff.symm
+      rw [← Pos.zero_addChar_eq]
       apply ltb.cons_add_csize
     · refine ⟨List.Lex.rel, fun e ↦ ?_⟩
       cases e <;> rename_i h'
@@ -207,7 +165,7 @@ theorem toList_singleton (c : Char) : (String.singleton c).toList = [c] :=
 theorem toList_nonempty : ∀ {s : String}, s ≠ "" → s.toList = s.head :: (s.popn 1).toList
 | ⟨s⟩, h => by
   cases s
-  · simp only [toList] at h
+  · simp only at h
   · rename_i c cs
     simp only [toList, List.cons.injEq]
     constructor <;>
@@ -230,7 +188,7 @@ instance : LinearOrder String where
     simp only [le_iff_toList_le]
     apply le_trans
   lt_iff_le_not_le a b := by
-    simp only [le_iff_toList_le, lt_iff_toList_lt, lt_iff_le_not_le]
+    simp only [lt_iff_toList_lt, le_iff_toList_le, lt_iff_le_not_le]
   le_antisymm a b := by
     simp only [le_iff_toList_le, ← toList_inj]
     apply le_antisymm

d13b3a4a

refactor: change arguments order (#3701)

Change the order of the arguments to String.utf8GetAux.add_right_cancel.

a278b14d

Diff

@@ -51,7 +51,7 @@ def utf8GetAux.inductionOn.{u} {motive : List Char → Pos → Pos → Sort u}
 
 open private utf8GetAux from Init.Data.String.Basic
 
-private lemma utf8GetAux.add_right_cancel (i p n : ℕ) (s : List Char) :
+private lemma utf8GetAux.add_right_cancel (s : List Char) (i p n : ℕ) :
     utf8GetAux s ⟨i + n⟩ ⟨p + n⟩ = utf8GetAux s ⟨i⟩ ⟨p⟩ := by
   apply inductionOn s ⟨i⟩ ⟨p⟩ (motive := fun s i p ↦
     utf8GetAux s ⟨i.byteIdx + n⟩ ⟨p.byteIdx + n⟩ = utf8GetAux s i p) <;>

d13b3a4a

doc: move comments (#3666)

Two comments were in the wrong places.

7abdbcc4

Diff

@@ -95,7 +95,7 @@ instance LT' : LT String :=
 
 instance decidableLT : @DecidableRel String (· < ·) := by
   simp only [LT']
-  infer_instance
+  infer_instance -- short-circuit type class inference
 #align string.decidable_lt String.decidableLT
 
 /-- Induction on `String.ltb`. -/
@@ -138,7 +138,6 @@ lemma ltb.cons_add_csize (c : Char) (cs₁ cs₂ : List Char) (i₁ i₂ : ℕ)
   · rename_i h₂ h₁ hne
     simp [Iterator.curr, Iterator.hasNext.cons_add_csize, get.cons_add_csize, *] at *
 
--- short-circuit type class inference
 @[simp]
 theorem lt_iff_toList_lt : ∀ {s₁ s₂ : String}, s₁ < s₂ ↔ s₁.toList < s₂.toList
 | ⟨s₁⟩, ⟨s₂⟩ => show ltb ⟨⟨s₁⟩, 0⟩ ⟨⟨s₂⟩, 0⟩ ↔ s₁ < s₂ by
@@ -175,10 +174,9 @@ instance LE : LE String :=
 
 instance decidableLE : @DecidableRel String (· ≤ ·) := by
   simp only [LE]
-  infer_instance
+  infer_instance -- short-circuit type class inference
 #align string.decidable_le String.decidableLE
 
--- short-circuit type class inference
 @[simp]
 theorem le_iff_toList_le {s₁ s₂ : String} : s₁ ≤ s₂ ↔ s₁.toList ≤ s₂.toList :=
   (not_congr lt_iff_toList_lt).trans not_lt

d13b3a4a

chore: move List.lt_iff_lex_lt to a more logical location (#3403)

85a0b4ca

Diff

@@ -226,25 +226,6 @@ theorem popn_empty {n : ℕ} : "".popn n = "" := by
   simp [popn]
 #align string.popn_empty String.popn_empty
 
-end String
-
-theorem List.lt_iff_lex_lt [LinearOrder α] (l l' : List α) :
-    lt l l' ↔ Lex (· < ·) l l' := by
-  constructor <;>
-  intro h
-  · induction h with
-    | nil b bs => exact Lex.nil
-    | @head a as b bs hab => apply Lex.rel; assumption
-    | @tail a as b bs hab hba _ ih =>
-      have heq : a = b := _root_.le_antisymm (le_of_not_lt hba) (le_of_not_lt hab)
-      subst b; apply Lex.cons; assumption
-  · induction h with
-    | @nil a as => apply lt.nil
-    | @cons a as bs _ ih => apply lt.tail <;> simp [ih]
-    | @rel a as b bs h => apply lt.head; assumption
-
-namespace String
-
 instance : LinearOrder String where
   le_refl a := le_iff_toList_le.mpr le_rfl
   le_trans a b c := by

d13b3a4a

fix: correct String.instLinearOrderString (#3339)

Use the optimized compare function and provide a manual compare_eq_compareOfLessAndEq field.

f5645984

Diff

@@ -53,7 +53,7 @@ open private utf8GetAux from Init.Data.String.Basic
 
 private lemma utf8GetAux.add_right_cancel (i p n : ℕ) (s : List Char) :
     utf8GetAux s ⟨i + n⟩ ⟨p + n⟩ = utf8GetAux s ⟨i⟩ ⟨p⟩ := by
-  apply utf8GetAux.inductionOn s ⟨i⟩ ⟨p⟩ (motive := fun s i p ↦
+  apply inductionOn s ⟨i⟩ ⟨p⟩ (motive := fun s i p ↦
     utf8GetAux s ⟨i.byteIdx + n⟩ ⟨p.byteIdx + n⟩ = utf8GetAux s i p) <;>
   simp [utf8GetAux]
   · intro c cs ⟨i⟩ ⟨p⟩ h
@@ -120,7 +120,7 @@ def ltb.inductionOn.{u} {motive : Iterator → Iterator → Sort u} (it₁ it₂
 lemma ltb.cons_add_csize (c : Char) (cs₁ cs₂ : List Char) (i₁ i₂ : ℕ) :
     ltb ⟨⟨c :: cs₁⟩, ⟨i₁ + csize c⟩⟩ ⟨⟨c :: cs₂⟩, ⟨i₂ + csize c⟩⟩ =
     ltb ⟨⟨cs₁⟩, ⟨i₁⟩⟩ ⟨⟨cs₂⟩, ⟨i₂⟩⟩ := by
-  apply ltb.inductionOn ⟨⟨cs₁⟩, ⟨i₁⟩⟩ ⟨⟨cs₂⟩, ⟨i₂⟩⟩ (motive := fun ⟨⟨cs₁⟩, ⟨i₁⟩⟩ ⟨⟨cs₂⟩, ⟨i₂⟩⟩ ↦
+  apply inductionOn ⟨⟨cs₁⟩, ⟨i₁⟩⟩ ⟨⟨cs₂⟩, ⟨i₂⟩⟩ (motive := fun ⟨⟨cs₁⟩, ⟨i₁⟩⟩ ⟨⟨cs₂⟩, ⟨i₂⟩⟩ ↦
     ltb ⟨⟨c :: cs₁⟩, ⟨i₁ + csize c⟩⟩ ⟨⟨c :: cs₂⟩, ⟨i₂ + csize c⟩⟩ =
     ltb ⟨⟨cs₁⟩, ⟨i₁⟩⟩ ⟨⟨cs₂⟩, ⟨i₂⟩⟩) <;> simp <;>
   intro ⟨cs₁⟩ ⟨cs₂⟩ ⟨i₁⟩ ⟨i₂⟩ <;>
@@ -226,6 +226,25 @@ theorem popn_empty {n : ℕ} : "".popn n = "" := by
   simp [popn]
 #align string.popn_empty String.popn_empty
 
+end String
+
+theorem List.lt_iff_lex_lt [LinearOrder α] (l l' : List α) :
+    lt l l' ↔ Lex (· < ·) l l' := by
+  constructor <;>
+  intro h
+  · induction h with
+    | nil b bs => exact Lex.nil
+    | @head a as b bs hab => apply Lex.rel; assumption
+    | @tail a as b bs hab hba _ ih =>
+      have heq : a = b := _root_.le_antisymm (le_of_not_lt hba) (le_of_not_lt hab)
+      subst b; apply Lex.cons; assumption
+  · induction h with
+    | @nil a as => apply lt.nil
+    | @cons a as bs _ ih => apply lt.tail <;> simp [ih]
+    | @rel a as b bs h => apply lt.head; assumption
+
+namespace String
+
 instance : LinearOrder String where
   le_refl a := le_iff_toList_le.mpr le_rfl
   le_trans a b c := by
@@ -240,7 +259,11 @@ instance : LinearOrder String where
     simp only [le_iff_toList_le]
     apply le_total
   decidable_le := String.decidableLE
-  compare a b := compareOfLessAndEq a b
+  compare_eq_compareOfLessAndEq a b := by
+    simp [compare, compareOfLessAndEq, toList, instLTString, List.instLTList, List.LT']
+    split_ifs <;>
+    simp [List.lt_iff_lex_lt] at * <;>
+    contradiction
 
 end String
 
@@ -257,7 +280,7 @@ theorem List.length_asString (l : List Char) : l.asString.length = l.length :=
 
 @[simp]
 theorem List.asString_inj {l l' : List Char} : l.asString = l'.asString ↔ l = l' :=
-  ⟨fun h ↦ by rw [← List.toList_inv_asString l, ← List.toList_inv_asString l', toList_inj, h],
+  ⟨fun h ↦ by rw [← toList_inv_asString l, ← toList_inv_asString l', toList_inj, h],
    fun h ↦ h ▸ rfl⟩
 #align list.as_string_inj List.asString_inj
 
@@ -267,5 +290,5 @@ theorem String.length_toList (s : String) : s.toList.length = s.length := by
 #align string.length_to_list String.length_toList
 
 theorem List.asString_eq {l : List Char} {s : String} : l.asString = s ↔ l = s.toList := by
-  rw [← asString_inv_toList s, List.asString_inj, asString_inv_toList s]
+  rw [← asString_inv_toList s, asString_inj, asString_inv_toList s]
 #align list.as_string_eq List.asString_eq

d13b3a4a

feat: port Data.String.Basic (#1054)

mathlib3 SHA: 8a275d92

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: ChrisHughes24 <chrishughes24@gmail.com> Co-authored-by: Moritz Firsching <firsching@google.com> Co-authored-by: maxwell-thum <119913396+maxwell-thum@users.noreply.github.com> Co-authored-by: Maxwell Thum <maxwell.thum2718@gmail.com> Co-authored-by: casavaca <96765450+casavaca@users.noreply.github.com> Co-authored-by: Bulhwi Cha <chabulhwi@semmalgil.com>

0fdb96c1

`data.string.basic` ⟷ `Mathlib.Data.String.Basic`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

PR contents

Lean PRs involved in this bump

leanprover/lean4#2778

leanprover/lean4#2722

leanprover/lean4#2783

Dependencies 12

data.string.basic ⟷ Mathlib.Data.String.Basic

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

PR contents

Lean PRs involved in this bump

leanprover/lean4#2778

leanprover/lean4#2722

leanprover/lean4#2783

Dependencies 12

`data.string.basic` ⟷ `Mathlib.Data.String.Basic`