data.pnat.find | Mathlib porting status

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

207cfac9

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

c3291da4

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2022 Yakov Pechersky. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yakov Pechersky, Floris van Doorn
 -/
-import Data.Pnat.Basic
+import Data.PNat.Basic
 
 #align_import data.pnat.find from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"

c3291da4

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -156,7 +156,7 @@ theorem find_comp_succ (h : ∃ n, p n) (h₂ : ∃ n, p (n + 1)) (h1 : ¬p 1) :
   refine' (find_eq_iff _).2 ⟨PNat.find_spec h₂, fun n => PNat.recOn n _ _⟩
   · simp [h1]
   intro m IH hm
-  simp only [add_lt_add_iff_right, lt_find_iff] at hm 
+  simp only [add_lt_add_iff_right, lt_find_iff] at hm
   exact hm _ le_rfl
 #align pnat.find_comp_succ PNat.find_comp_succ
 -/

c3291da4

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2022 Yakov Pechersky. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yakov Pechersky, Floris van Doorn
 -/
-import Mathbin.Data.Pnat.Basic
+import Data.Pnat.Basic
 
 #align_import data.pnat.find from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"

c3291da4

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2022 Yakov Pechersky. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yakov Pechersky, Floris van Doorn
-
-! This file was ported from Lean 3 source module data.pnat.find
-! leanprover-community/mathlib commit c3291da49cfa65f0d43b094750541c0731edc932
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Pnat.Basic
 
+#align_import data.pnat.find from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
+
 /-!
 # Explicit least witnesses to existentials on positive natural numbers

c3291da4

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -34,8 +34,6 @@ instance decidablePredExistsNat : DecidablePred fun n' : ℕ => ∃ (n : ℕ+) (
 #align pnat.decidable_pred_exists_nat PNat.decidablePredExistsNat
 -/
 
-include h
-
 #print PNat.findX /-
 /-- The `pnat` version of `nat.find_x` -/
 protected def findX : { n // p n ∧ ∀ m : ℕ+, m < n → ¬p m } :=
@@ -99,16 +97,20 @@ theorem find_eq_iff : PNat.find h = m ↔ p m ∧ ∀ n < m, ¬p n :=
 #align pnat.find_eq_iff PNat.find_eq_iff
 -/
 
+#print PNat.find_lt_iff /-
 @[simp]
 theorem find_lt_iff (n : ℕ+) : PNat.find h < n ↔ ∃ m < n, p m :=
   ⟨fun h2 => ⟨PNat.find h, h2, PNat.find_spec h⟩, fun ⟨m, hmn, hm⟩ =>
     (PNat.find_min' h hm).trans_lt hmn⟩
 #align pnat.find_lt_iff PNat.find_lt_iff
+-/
 
+#print PNat.find_le_iff /-
 @[simp]
 theorem find_le_iff (n : ℕ+) : PNat.find h ≤ n ↔ ∃ m ≤ n, p m := by
   simp only [exists_prop, ← lt_add_one_iff, find_lt_iff]
 #align pnat.find_le_iff PNat.find_le_iff
+-/
 
 #print PNat.le_find_iff /-
 @[simp]
@@ -150,6 +152,7 @@ theorem find_le {h : ∃ n, p n} (hn : p n) : PNat.find h ≤ n :=
 #align pnat.find_le PNat.find_le
 -/
 
+#print PNat.find_comp_succ /-
 theorem find_comp_succ (h : ∃ n, p n) (h₂ : ∃ n, p (n + 1)) (h1 : ¬p 1) :
     PNat.find h = PNat.find h₂ + 1 :=
   by
@@ -159,6 +162,7 @@ theorem find_comp_succ (h : ∃ n, p n) (h₂ : ∃ n, p (n + 1)) (h1 : ¬p 1) :
   simp only [add_lt_add_iff_right, lt_find_iff] at hm 
   exact hm _ le_rfl
 #align pnat.find_comp_succ PNat.find_comp_succ
+-/
 
 end PNat

c3291da4

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -26,7 +26,7 @@ namespace PNat
 variable {p q : ℕ+ → Prop} [DecidablePred p] [DecidablePred q] (h : ∃ n, p n)
 
 #print PNat.decidablePredExistsNat /-
-instance decidablePredExistsNat : DecidablePred fun n' : ℕ => ∃ (n : ℕ+)(hn : n' = n), p n :=
+instance decidablePredExistsNat : DecidablePred fun n' : ℕ => ∃ (n : ℕ+) (hn : n' = n), p n :=
   fun n' =>
   decidable_of_iff' (∃ h : 0 < n', p ⟨n', h⟩) <|
     Subtype.exists.trans <| by
@@ -40,7 +40,7 @@ include h
 /-- The `pnat` version of `nat.find_x` -/
 protected def findX : { n // p n ∧ ∀ m : ℕ+, m < n → ¬p m } :=
   by
-  have : ∃ (n' : ℕ)(n : ℕ+)(hn' : n' = n), p n := Exists.elim h fun n hn => ⟨n, n, rfl, hn⟩
+  have : ∃ (n' : ℕ) (n : ℕ+) (hn' : n' = n), p n := Exists.elim h fun n hn => ⟨n, n, rfl, hn⟩
   have n := Nat.findX this
   refine' ⟨⟨n, _⟩, _, fun m hm pm => _⟩
   · obtain ⟨n', hn', -⟩ := n.prop.1
@@ -156,7 +156,7 @@ theorem find_comp_succ (h : ∃ n, p n) (h₂ : ∃ n, p (n + 1)) (h1 : ¬p 1) :
   refine' (find_eq_iff _).2 ⟨PNat.find_spec h₂, fun n => PNat.recOn n _ _⟩
   · simp [h1]
   intro m IH hm
-  simp only [add_lt_add_iff_right, lt_find_iff] at hm
+  simp only [add_lt_add_iff_right, lt_find_iff] at hm 
   exact hm _ le_rfl
 #align pnat.find_comp_succ PNat.find_comp_succ

c3291da4

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -36,6 +36,7 @@ instance decidablePredExistsNat : DecidablePred fun n' : ℕ => ∃ (n : ℕ+)(h
 
 include h
 
+#print PNat.findX /-
 /-- The `pnat` version of `nat.find_x` -/
 protected def findX : { n // p n ∧ ∀ m : ℕ+, m < n → ¬p m } :=
   by
@@ -49,6 +50,7 @@ protected def findX : { n // p n ∧ ∀ m : ℕ+, m < n → ¬p m } :=
     simpa [hn', Subtype.coe_eta] using pn'
   · exact n.prop.2 m hm ⟨m, rfl, pm⟩
 #align pnat.find_x PNat.findX
+-/
 
 #print PNat.find /-
 /-- If `p` is a (decidable) predicate on `ℕ+` and `hp : ∃ (n : ℕ+), p n` is a proof that
@@ -73,16 +75,21 @@ protected theorem find_spec : p (PNat.find h) :=
 #align pnat.find_spec PNat.find_spec
 -/
 
+#print PNat.find_min /-
 protected theorem find_min : ∀ {m : ℕ+}, m < PNat.find h → ¬p m :=
   (PNat.findX h).Prop.right
 #align pnat.find_min PNat.find_min
+-/
 
+#print PNat.find_min' /-
 protected theorem find_min' {m : ℕ+} (hm : p m) : PNat.find h ≤ m :=
   le_of_not_lt fun l => PNat.find_min h l hm
 #align pnat.find_min' PNat.find_min'
+-/
 
 variable {n m : ℕ+}
 
+#print PNat.find_eq_iff /-
 theorem find_eq_iff : PNat.find h = m ↔ p m ∧ ∀ n < m, ¬p n :=
   by
   constructor
@@ -90,6 +97,7 @@ theorem find_eq_iff : PNat.find h = m ↔ p m ∧ ∀ n < m, ¬p n :=
   · rintro ⟨hm, hlt⟩
     exact le_antisymm (PNat.find_min' h hm) (not_lt.1 <| imp_not_comm.1 (hlt _) <| PNat.find_spec h)
 #align pnat.find_eq_iff PNat.find_eq_iff
+-/
 
 @[simp]
 theorem find_lt_iff (n : ℕ+) : PNat.find h < n ↔ ∃ m < n, p m :=
@@ -102,15 +110,19 @@ theorem find_le_iff (n : ℕ+) : PNat.find h ≤ n ↔ ∃ m ≤ n, p m := by
   simp only [exists_prop, ← lt_add_one_iff, find_lt_iff]
 #align pnat.find_le_iff PNat.find_le_iff
 
+#print PNat.le_find_iff /-
 @[simp]
 theorem le_find_iff (n : ℕ+) : n ≤ PNat.find h ↔ ∀ m < n, ¬p m := by
   simp_rw [← not_lt, find_lt_iff, not_exists]
 #align pnat.le_find_iff PNat.le_find_iff
+-/
 
+#print PNat.lt_find_iff /-
 @[simp]
 theorem lt_find_iff (n : ℕ+) : n < PNat.find h ↔ ∀ m ≤ n, ¬p m := by
   simp only [← add_one_le_iff, le_find_iff, add_le_add_iff_right]
 #align pnat.lt_find_iff PNat.lt_find_iff
+-/
 
 #print PNat.find_eq_one /-
 @[simp]
@@ -118,19 +130,25 @@ theorem find_eq_one : PNat.find h = 1 ↔ p 1 := by simp [find_eq_iff]
 #align pnat.find_eq_one PNat.find_eq_one
 -/
 
+#print PNat.one_le_find /-
 @[simp]
 theorem one_le_find : 1 < PNat.find h ↔ ¬p 1 :=
   not_iff_not.mp <| by simp
 #align pnat.one_le_find PNat.one_le_find
+-/
 
+#print PNat.find_mono /-
 theorem find_mono (h : ∀ n, q n → p n) {hp : ∃ n, p n} {hq : ∃ n, q n} :
     PNat.find hp ≤ PNat.find hq :=
   PNat.find_min' _ (h _ (PNat.find_spec hq))
 #align pnat.find_mono PNat.find_mono
+-/
 
+#print PNat.find_le /-
 theorem find_le {h : ∃ n, p n} (hn : p n) : PNat.find h ≤ n :=
   (PNat.find_le_iff _ _).2 ⟨n, le_rfl, hn⟩
 #align pnat.find_le PNat.find_le
+-/
 
 theorem find_comp_succ (h : ∃ n, p n) (h₂ : ∃ n, p (n + 1)) (h1 : ¬p 1) :
     PNat.find h = PNat.find h₂ + 1 :=

c3291da4

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -36,12 +36,6 @@ instance decidablePredExistsNat : DecidablePred fun n' : ℕ => ∃ (n : ℕ+)(h
 
 include h
 
-/- warning: pnat.find_x -> PNat.findX is a dubious translation:
-lean 3 declaration is
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p], (Exists.{1} PNat (fun (n : PNat) => p n)) -> (Subtype.{1} PNat (fun (n : PNat) => And (p n) (forall (m : PNat), (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) -> (Not (p m)))))
-but is expected to have type
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p], (Exists.{1} PNat (fun (n : PNat) => p n)) -> (Subtype.{1} PNat (fun (n : PNat) => And (p n) (forall (m : PNat), (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) m n) -> (Not (p m)))))
-Case conversion may be inaccurate. Consider using '#align pnat.find_x PNat.findXₓ'. -/
 /-- The `pnat` version of `nat.find_x` -/
 protected def findX : { n // p n ∧ ∀ m : ℕ+, m < n → ¬p m } :=
   by
@@ -79,34 +73,16 @@ protected theorem find_spec : p (PNat.find h) :=
 #align pnat.find_spec PNat.find_spec
 -/
 
-/- warning: pnat.find_min -> PNat.find_min is a dubious translation:
-lean 3 declaration is
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) {m : PNat}, (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) -> (Not (p m))
-but is expected to have type
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) {m : PNat}, (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) m (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) -> (Not (p m))
-Case conversion may be inaccurate. Consider using '#align pnat.find_min PNat.find_minₓ'. -/
 protected theorem find_min : ∀ {m : ℕ+}, m < PNat.find h → ¬p m :=
   (PNat.findX h).Prop.right
 #align pnat.find_min PNat.find_min
 
-/- warning: pnat.find_min' -> PNat.find_min' is a dubious translation:
-lean 3 declaration is
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) {m : PNat}, (p m) -> (LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) m)
-but is expected to have type
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) {m : PNat}, (p m) -> (LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) m)
-Case conversion may be inaccurate. Consider using '#align pnat.find_min' PNat.find_min'ₓ'. -/
 protected theorem find_min' {m : ℕ+} (hm : p m) : PNat.find h ≤ m :=
   le_of_not_lt fun l => PNat.find_min h l hm
 #align pnat.find_min' PNat.find_min'
 
 variable {n m : ℕ+}
 
-/- warning: pnat.find_eq_iff -> PNat.find_eq_iff is a dubious translation:
-lean 3 declaration is
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) {m : PNat}, Iff (Eq.{1} PNat (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) m) (And (p m) (forall (n : PNat), (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) n m) -> (Not (p n))))
-but is expected to have type
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) {m : PNat}, Iff (Eq.{1} PNat (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) m) (And (p m) (forall (n : PNat), (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) n m) -> (Not (p n))))
-Case conversion may be inaccurate. Consider using '#align pnat.find_eq_iff PNat.find_eq_iffₓ'. -/
 theorem find_eq_iff : PNat.find h = m ↔ p m ∧ ∀ n < m, ¬p n :=
   by
   constructor
@@ -115,46 +91,22 @@ theorem find_eq_iff : PNat.find h = m ↔ p m ∧ ∀ n < m, ¬p n :=
     exact le_antisymm (PNat.find_min' h hm) (not_lt.1 <| imp_not_comm.1 (hlt _) <| PNat.find_spec h)
 #align pnat.find_eq_iff PNat.find_eq_iff
 
-/- warning: pnat.find_lt_iff -> PNat.find_lt_iff is a dubious translation:
-lean 3 declaration is
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) n) (Exists.{1} PNat (fun (m : PNat) => Exists.{0} (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) (fun (H : LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) => p m)))
-but is expected to have type
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) n) (Exists.{1} PNat (fun (m : PNat) => And (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) m n) (p m)))
-Case conversion may be inaccurate. Consider using '#align pnat.find_lt_iff PNat.find_lt_iffₓ'. -/
 @[simp]
 theorem find_lt_iff (n : ℕ+) : PNat.find h < n ↔ ∃ m < n, p m :=
   ⟨fun h2 => ⟨PNat.find h, h2, PNat.find_spec h⟩, fun ⟨m, hmn, hm⟩ =>
     (PNat.find_min' h hm).trans_lt hmn⟩
 #align pnat.find_lt_iff PNat.find_lt_iff
 
-/- warning: pnat.find_le_iff -> PNat.find_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) n) (Exists.{1} PNat (fun (m : PNat) => Exists.{0} (LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) (fun (H : LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) => p m)))
-but is expected to have type
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) n) (Exists.{1} PNat (fun (m : PNat) => And (LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) m n) (p m)))
-Case conversion may be inaccurate. Consider using '#align pnat.find_le_iff PNat.find_le_iffₓ'. -/
 @[simp]
 theorem find_le_iff (n : ℕ+) : PNat.find h ≤ n ↔ ∃ m ≤ n, p m := by
   simp only [exists_prop, ← lt_add_one_iff, find_lt_iff]
 #align pnat.find_le_iff PNat.find_le_iff
 
-/- warning: pnat.le_find_iff -> PNat.le_find_iff is a dubious translation:
-lean 3 declaration is
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) n (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) (forall (m : PNat), (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) -> (Not (p m)))
-but is expected to have type
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) n (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) (forall (m : PNat), (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) m n) -> (Not (p m)))
-Case conversion may be inaccurate. Consider using '#align pnat.le_find_iff PNat.le_find_iffₓ'. -/
 @[simp]
 theorem le_find_iff (n : ℕ+) : n ≤ PNat.find h ↔ ∀ m < n, ¬p m := by
   simp_rw [← not_lt, find_lt_iff, not_exists]
 #align pnat.le_find_iff PNat.le_find_iff
 
-/- warning: pnat.lt_find_iff -> PNat.lt_find_iff is a dubious translation:
-lean 3 declaration is
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) n (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) (forall (m : PNat), (LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) -> (Not (p m)))
-but is expected to have type
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) n (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) (forall (m : PNat), (LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) m n) -> (Not (p m)))
-Case conversion may be inaccurate. Consider using '#align pnat.lt_find_iff PNat.lt_find_iffₓ'. -/
 @[simp]
 theorem lt_find_iff (n : ℕ+) : n < PNat.find h ↔ ∀ m ≤ n, ¬p m := by
   simp only [← add_one_le_iff, le_find_iff, add_le_add_iff_right]
@@ -166,44 +118,20 @@ theorem find_eq_one : PNat.find h = 1 ↔ p 1 := by simp [find_eq_iff]
 #align pnat.find_eq_one PNat.find_eq_one
 -/
 
-/- warning: pnat.one_le_find -> PNat.one_le_find is a dubious translation:
-lean 3 declaration is
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)), Iff (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) (OfNat.ofNat.{0} PNat 1 (OfNat.mk.{0} PNat 1 (One.one.{0} PNat PNat.hasOne))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) (Not (p (OfNat.ofNat.{0} PNat 1 (OfNat.mk.{0} PNat 1 (One.one.{0} PNat PNat.hasOne)))))
-but is expected to have type
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)), Iff (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) (OfNat.ofNat.{0} PNat 1 (instOfNatPNatHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) (Not (p (OfNat.ofNat.{0} PNat 1 (instOfNatPNatHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))
-Case conversion may be inaccurate. Consider using '#align pnat.one_le_find PNat.one_le_findₓ'. -/
 @[simp]
 theorem one_le_find : 1 < PNat.find h ↔ ¬p 1 :=
   not_iff_not.mp <| by simp
 #align pnat.one_le_find PNat.one_le_find
 
-/- warning: pnat.find_mono -> PNat.find_mono is a dubious translation:
-lean 3 declaration is
-  forall {p : PNat -> Prop} {q : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] [_inst_2 : DecidablePred.{1} PNat q], (forall (n : PNat), (q n) -> (p n)) -> (forall {hp : Exists.{1} PNat (fun (n : PNat) => p n)} {hq : Exists.{1} PNat (fun (n : PNat) => q n)}, LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) hp) (PNat.find (fun (n : PNat) => q n) (fun (a : PNat) => _inst_2 a) hq))
-but is expected to have type
-  forall {p : PNat -> Prop} {q : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] [_inst_2 : DecidablePred.{1} PNat q], (forall (n : PNat), (q n) -> (p n)) -> (forall {hp : Exists.{1} PNat (fun (n : PNat) => p n)} {hq : Exists.{1} PNat (fun (n : PNat) => q n)}, LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) hp) (PNat.find (fun (n : PNat) => q n) (fun (a : PNat) => _inst_2 a) hq))
-Case conversion may be inaccurate. Consider using '#align pnat.find_mono PNat.find_monoₓ'. -/
 theorem find_mono (h : ∀ n, q n → p n) {hp : ∃ n, p n} {hq : ∃ n, q n} :
     PNat.find hp ≤ PNat.find hq :=
   PNat.find_min' _ (h _ (PNat.find_spec hq))
 #align pnat.find_mono PNat.find_mono
 
-/- warning: pnat.find_le -> PNat.find_le is a dubious translation:
-lean 3 declaration is
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] {n : PNat} {h : Exists.{1} PNat (fun (n : PNat) => p n)}, (p n) -> (LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) n)
-but is expected to have type
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] {n : PNat} {h : Exists.{1} PNat (fun (n : PNat) => p n)}, (p n) -> (LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) n)
-Case conversion may be inaccurate. Consider using '#align pnat.find_le PNat.find_leₓ'. -/
 theorem find_le {h : ∃ n, p n} (hn : p n) : PNat.find h ≤ n :=
   (PNat.find_le_iff _ _).2 ⟨n, le_rfl, hn⟩
 #align pnat.find_le PNat.find_le
 
-/- warning: pnat.find_comp_succ -> PNat.find_comp_succ is a dubious translation:
-lean 3 declaration is
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (h₂ : Exists.{1} PNat (fun (n : PNat) => p (HAdd.hAdd.{0, 0, 0} PNat PNat PNat (instHAdd.{0} PNat PNat.hasAdd) n (OfNat.ofNat.{0} PNat 1 (OfNat.mk.{0} PNat 1 (One.one.{0} PNat PNat.hasOne)))))), (Not (p (OfNat.ofNat.{0} PNat 1 (OfNat.mk.{0} PNat 1 (One.one.{0} PNat PNat.hasOne))))) -> (Eq.{1} PNat (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) (HAdd.hAdd.{0, 0, 0} PNat PNat PNat (instHAdd.{0} PNat PNat.hasAdd) (PNat.find (fun (n : PNat) => p (HAdd.hAdd.{0, 0, 0} PNat PNat PNat (instHAdd.{0} PNat PNat.hasAdd) n (OfNat.ofNat.{0} PNat 1 (OfNat.mk.{0} PNat 1 (One.one.{0} PNat PNat.hasOne))))) (fun (a : PNat) => _inst_1 (HAdd.hAdd.{0, 0, 0} PNat PNat PNat (instHAdd.{0} PNat PNat.hasAdd) a (OfNat.ofNat.{0} PNat 1 (OfNat.mk.{0} PNat 1 (One.one.{0} PNat PNat.hasOne))))) h₂) (OfNat.ofNat.{0} PNat 1 (OfNat.mk.{0} PNat 1 (One.one.{0} PNat PNat.hasOne)))))
-but is expected to have type
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (h₂ : Exists.{1} PNat (fun (n : PNat) => p (HAdd.hAdd.{0, 0, 0} PNat PNat PNat (instHAdd.{0} PNat instPNatAdd) n (OfNat.ofNat.{0} PNat 1 (instOfNatPNatHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))), (Not (p (OfNat.ofNat.{0} PNat 1 (instOfNatPNatHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) -> (Eq.{1} PNat (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) (HAdd.hAdd.{0, 0, 0} PNat PNat PNat (instHAdd.{0} PNat instPNatAdd) (PNat.find (fun (n : PNat) => p (HAdd.hAdd.{0, 0, 0} PNat PNat PNat (instHAdd.{0} PNat instPNatAdd) n (OfNat.ofNat.{0} PNat 1 (instOfNatPNatHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (fun (a : PNat) => _inst_1 (HAdd.hAdd.{0, 0, 0} PNat PNat PNat (instHAdd.{0} PNat instPNatAdd) a (OfNat.ofNat.{0} PNat 1 (instOfNatPNatHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) h₂) (OfNat.ofNat.{0} PNat 1 (instOfNatPNatHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))
-Case conversion may be inaccurate. Consider using '#align pnat.find_comp_succ PNat.find_comp_succₓ'. -/
 theorem find_comp_succ (h : ∃ n, p n) (h₂ : ∃ n, p (n + 1)) (h1 : ¬p 1) :
     PNat.find h = PNat.find h₂ + 1 :=
   by

c3291da4

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -110,8 +110,7 @@ Case conversion may be inaccurate. Consider using '#align pnat.find_eq_iff PNat.
 theorem find_eq_iff : PNat.find h = m ↔ p m ∧ ∀ n < m, ¬p n :=
   by
   constructor
-  · rintro rfl
-    exact ⟨PNat.find_spec h, fun _ => PNat.find_min h⟩
+  · rintro rfl; exact ⟨PNat.find_spec h, fun _ => PNat.find_min h⟩
   · rintro ⟨hm, hlt⟩
     exact le_antisymm (PNat.find_min' h hm) (not_lt.1 <| imp_not_comm.1 (hlt _) <| PNat.find_spec h)
 #align pnat.find_eq_iff PNat.find_eq_iff

c3291da4

bump to nightly-2023-05-16-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

9cb92e8c

Diff

@@ -36,7 +36,12 @@ instance decidablePredExistsNat : DecidablePred fun n' : ℕ => ∃ (n : ℕ+)(h
 
 include h
 
-#print PNat.findX /-
+/- warning: pnat.find_x -> PNat.findX is a dubious translation:
+lean 3 declaration is
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p], (Exists.{1} PNat (fun (n : PNat) => p n)) -> (Subtype.{1} PNat (fun (n : PNat) => And (p n) (forall (m : PNat), (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) -> (Not (p m)))))
+but is expected to have type
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p], (Exists.{1} PNat (fun (n : PNat) => p n)) -> (Subtype.{1} PNat (fun (n : PNat) => And (p n) (forall (m : PNat), (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) m n) -> (Not (p m)))))
+Case conversion may be inaccurate. Consider using '#align pnat.find_x PNat.findXₓ'. -/
 /-- The `pnat` version of `nat.find_x` -/
 protected def findX : { n // p n ∧ ∀ m : ℕ+, m < n → ¬p m } :=
   by
@@ -50,7 +55,6 @@ protected def findX : { n // p n ∧ ∀ m : ℕ+, m < n → ¬p m } :=
     simpa [hn', Subtype.coe_eta] using pn'
   · exact n.prop.2 m hm ⟨m, rfl, pm⟩
 #align pnat.find_x PNat.findX
--/
 
 #print PNat.find /-
 /-- If `p` is a (decidable) predicate on `ℕ+` and `hp : ∃ (n : ℕ+), p n` is a proof that
@@ -75,21 +79,34 @@ protected theorem find_spec : p (PNat.find h) :=
 #align pnat.find_spec PNat.find_spec
 -/
 
-#print PNat.find_min /-
+/- warning: pnat.find_min -> PNat.find_min is a dubious translation:
+lean 3 declaration is
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) {m : PNat}, (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) -> (Not (p m))
+but is expected to have type
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) {m : PNat}, (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) m (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) -> (Not (p m))
+Case conversion may be inaccurate. Consider using '#align pnat.find_min PNat.find_minₓ'. -/
 protected theorem find_min : ∀ {m : ℕ+}, m < PNat.find h → ¬p m :=
   (PNat.findX h).Prop.right
 #align pnat.find_min PNat.find_min
--/
 
-#print PNat.find_min' /-
+/- warning: pnat.find_min' -> PNat.find_min' is a dubious translation:
+lean 3 declaration is
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) {m : PNat}, (p m) -> (LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) m)
+but is expected to have type
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) {m : PNat}, (p m) -> (LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) m)
+Case conversion may be inaccurate. Consider using '#align pnat.find_min' PNat.find_min'ₓ'. -/
 protected theorem find_min' {m : ℕ+} (hm : p m) : PNat.find h ≤ m :=
   le_of_not_lt fun l => PNat.find_min h l hm
 #align pnat.find_min' PNat.find_min'
--/
 
 variable {n m : ℕ+}
 
-#print PNat.find_eq_iff /-
+/- warning: pnat.find_eq_iff -> PNat.find_eq_iff is a dubious translation:
+lean 3 declaration is
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) {m : PNat}, Iff (Eq.{1} PNat (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) m) (And (p m) (forall (n : PNat), (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) n m) -> (Not (p n))))
+but is expected to have type
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) {m : PNat}, Iff (Eq.{1} PNat (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) m) (And (p m) (forall (n : PNat), (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) n m) -> (Not (p n))))
+Case conversion may be inaccurate. Consider using '#align pnat.find_eq_iff PNat.find_eq_iffₓ'. -/
 theorem find_eq_iff : PNat.find h = m ↔ p m ∧ ∀ n < m, ¬p n :=
   by
   constructor
@@ -98,11 +115,10 @@ theorem find_eq_iff : PNat.find h = m ↔ p m ∧ ∀ n < m, ¬p n :=
   · rintro ⟨hm, hlt⟩
     exact le_antisymm (PNat.find_min' h hm) (not_lt.1 <| imp_not_comm.1 (hlt _) <| PNat.find_spec h)
 #align pnat.find_eq_iff PNat.find_eq_iff
--/
 
 /- warning: pnat.find_lt_iff -> PNat.find_lt_iff is a dubious translation:
 lean 3 declaration is
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) n) (Exists.{1} PNat (fun (m : PNat) => Exists.{0} (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) (fun (H : LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) => p m)))
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) n) (Exists.{1} PNat (fun (m : PNat) => Exists.{0} (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) (fun (H : LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) => p m)))
 but is expected to have type
   forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) n) (Exists.{1} PNat (fun (m : PNat) => And (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) m n) (p m)))
 Case conversion may be inaccurate. Consider using '#align pnat.find_lt_iff PNat.find_lt_iffₓ'. -/
@@ -114,7 +130,7 @@ theorem find_lt_iff (n : ℕ+) : PNat.find h < n ↔ ∃ m < n, p m :=
 
 /- warning: pnat.find_le_iff -> PNat.find_le_iff is a dubious translation:
 lean 3 declaration is
-  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) n) (Exists.{1} PNat (fun (m : PNat) => Exists.{0} (LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) (fun (H : LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) => p m)))
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) n) (Exists.{1} PNat (fun (m : PNat) => Exists.{0} (LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) (fun (H : LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) => p m)))
 but is expected to have type
   forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) n) (Exists.{1} PNat (fun (m : PNat) => And (LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) m n) (p m)))
 Case conversion may be inaccurate. Consider using '#align pnat.find_le_iff PNat.find_le_iffₓ'. -/
@@ -123,19 +139,27 @@ theorem find_le_iff (n : ℕ+) : PNat.find h ≤ n ↔ ∃ m ≤ n, p m := by
   simp only [exists_prop, ← lt_add_one_iff, find_lt_iff]
 #align pnat.find_le_iff PNat.find_le_iff
 
-#print PNat.le_find_iff /-
+/- warning: pnat.le_find_iff -> PNat.le_find_iff is a dubious translation:
+lean 3 declaration is
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) n (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) (forall (m : PNat), (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) -> (Not (p m)))
+but is expected to have type
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) n (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) (forall (m : PNat), (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) m n) -> (Not (p m)))
+Case conversion may be inaccurate. Consider using '#align pnat.le_find_iff PNat.le_find_iffₓ'. -/
 @[simp]
 theorem le_find_iff (n : ℕ+) : n ≤ PNat.find h ↔ ∀ m < n, ¬p m := by
   simp_rw [← not_lt, find_lt_iff, not_exists]
 #align pnat.le_find_iff PNat.le_find_iff
--/
 
-#print PNat.lt_find_iff /-
+/- warning: pnat.lt_find_iff -> PNat.lt_find_iff is a dubious translation:
+lean 3 declaration is
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) n (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) (forall (m : PNat), (LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) m n) -> (Not (p m)))
+but is expected to have type
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)) (n : PNat), Iff (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) n (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) (forall (m : PNat), (LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) m n) -> (Not (p m)))
+Case conversion may be inaccurate. Consider using '#align pnat.lt_find_iff PNat.lt_find_iffₓ'. -/
 @[simp]
 theorem lt_find_iff (n : ℕ+) : n < PNat.find h ↔ ∀ m ≤ n, ¬p m := by
   simp only [← add_one_le_iff, le_find_iff, add_le_add_iff_right]
 #align pnat.lt_find_iff PNat.lt_find_iff
--/
 
 #print PNat.find_eq_one /-
 @[simp]
@@ -143,25 +167,37 @@ theorem find_eq_one : PNat.find h = 1 ↔ p 1 := by simp [find_eq_iff]
 #align pnat.find_eq_one PNat.find_eq_one
 -/
 
-#print PNat.one_le_find /-
+/- warning: pnat.one_le_find -> PNat.one_le_find is a dubious translation:
+lean 3 declaration is
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)), Iff (LT.lt.{0} PNat (Preorder.toHasLt.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) (OfNat.ofNat.{0} PNat 1 (OfNat.mk.{0} PNat 1 (One.one.{0} PNat PNat.hasOne))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) (Not (p (OfNat.ofNat.{0} PNat 1 (OfNat.mk.{0} PNat 1 (One.one.{0} PNat PNat.hasOne)))))
+but is expected to have type
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] (h : Exists.{1} PNat (fun (n : PNat) => p n)), Iff (LT.lt.{0} PNat (Preorder.toLT.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) (OfNat.ofNat.{0} PNat 1 (instOfNatPNatHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h)) (Not (p (OfNat.ofNat.{0} PNat 1 (instOfNatPNatHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))))
+Case conversion may be inaccurate. Consider using '#align pnat.one_le_find PNat.one_le_findₓ'. -/
 @[simp]
 theorem one_le_find : 1 < PNat.find h ↔ ¬p 1 :=
   not_iff_not.mp <| by simp
 #align pnat.one_le_find PNat.one_le_find
--/
 
-#print PNat.find_mono /-
+/- warning: pnat.find_mono -> PNat.find_mono is a dubious translation:
+lean 3 declaration is
+  forall {p : PNat -> Prop} {q : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] [_inst_2 : DecidablePred.{1} PNat q], (forall (n : PNat), (q n) -> (p n)) -> (forall {hp : Exists.{1} PNat (fun (n : PNat) => p n)} {hq : Exists.{1} PNat (fun (n : PNat) => q n)}, LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) hp) (PNat.find (fun (n : PNat) => q n) (fun (a : PNat) => _inst_2 a) hq))
+but is expected to have type
+  forall {p : PNat -> Prop} {q : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] [_inst_2 : DecidablePred.{1} PNat q], (forall (n : PNat), (q n) -> (p n)) -> (forall {hp : Exists.{1} PNat (fun (n : PNat) => p n)} {hq : Exists.{1} PNat (fun (n : PNat) => q n)}, LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) hp) (PNat.find (fun (n : PNat) => q n) (fun (a : PNat) => _inst_2 a) hq))
+Case conversion may be inaccurate. Consider using '#align pnat.find_mono PNat.find_monoₓ'. -/
 theorem find_mono (h : ∀ n, q n → p n) {hp : ∃ n, p n} {hq : ∃ n, q n} :
     PNat.find hp ≤ PNat.find hq :=
   PNat.find_min' _ (h _ (PNat.find_spec hq))
 #align pnat.find_mono PNat.find_mono
--/
 
-#print PNat.find_le /-
+/- warning: pnat.find_le -> PNat.find_le is a dubious translation:
+lean 3 declaration is
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] {n : PNat} {h : Exists.{1} PNat (fun (n : PNat) => p n)}, (p n) -> (LE.le.{0} PNat (Preorder.toHasLe.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat PNat.linearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) n)
+but is expected to have type
+  forall {p : PNat -> Prop} [_inst_1 : DecidablePred.{1} PNat p] {n : PNat} {h : Exists.{1} PNat (fun (n : PNat) => p n)}, (p n) -> (LE.le.{0} PNat (Preorder.toLE.{0} PNat (PartialOrder.toPreorder.{0} PNat (OrderedCancelCommMonoid.toPartialOrder.{0} PNat (LinearOrderedCancelCommMonoid.toOrderedCancelCommMonoid.{0} PNat instPNatLinearOrderedCancelCommMonoid)))) (PNat.find (fun (n : PNat) => p n) (fun (a : PNat) => _inst_1 a) h) n)
+Case conversion may be inaccurate. Consider using '#align pnat.find_le PNat.find_leₓ'. -/
 theorem find_le {h : ∃ n, p n} (hn : p n) : PNat.find h ≤ n :=
   (PNat.find_le_iff _ _).2 ⟨n, le_rfl, hn⟩
 #align pnat.find_le PNat.find_le
--/
 
 /- warning: pnat.find_comp_succ -> PNat.find_comp_succ is a dubious translation:
 lean 3 declaration is

c3291da4

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

207cfac9

chore: change from plural to singular in porting notes (#10761)

0f21e517

Diff

@@ -101,7 +101,7 @@ theorem lt_find_iff (n : ℕ+) : n < PNat.find h ↔ ∀ m ≤ n, ¬p m := by
 theorem find_eq_one : PNat.find h = 1 ↔ p 1 := by simp [find_eq_iff]
 #align pnat.find_eq_one PNat.find_eq_one
 
--- porting notes: deleted `@[simp]` to satisfy the linter because `le_find_iff` is more general
+-- Porting note: deleted `@[simp]` to satisfy the linter because `le_find_iff` is more general
 theorem one_le_find : 1 < PNat.find h ↔ ¬p 1 :=
   not_iff_not.mp <| by simp
 #align pnat.one_le_find PNat.one_le_find

207cfac9

chore: remove include/omit porting notes (#10517)

See this Zulip discussion.

f499c227

Diff

@@ -26,8 +26,6 @@ instance decidablePredExistsNat : DecidablePred fun n' : ℕ => ∃ (n : ℕ+) (
       simp_rw [mk_coe, @exists_comm (_ < _) (_ = _), exists_prop, exists_eq_left']
 #align pnat.decidable_pred_exists_nat PNat.decidablePredExistsNat
 
---include h
-
 /-- The `PNat` version of `Nat.findX` -/
 protected def findX : { n // p n ∧ ∀ m : ℕ+, m < n → ¬p m } := by
   have : ∃ (n' : ℕ) (n : ℕ+) (_ : n' = n), p n := Exists.elim h fun n hn => ⟨n, n, rfl, hn⟩

207cfac9

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,14 +2,11 @@
 Copyright (c) 2022 Yakov Pechersky. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yakov Pechersky, Floris van Doorn
-
-! This file was ported from Lean 3 source module data.pnat.find
-! leanprover-community/mathlib commit 207cfac9fcd06138865b5d04f7091e46d9320432
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.PNat.Basic
 
+#align_import data.pnat.find from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
+
 /-!
 # Explicit least witnesses to existentials on positive natural numbers

207cfac9

chore: formatting issues (#4947)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

5068808d

Diff

@@ -22,7 +22,7 @@ namespace PNat
 
 variable {p q : ℕ+ → Prop} [DecidablePred p] [DecidablePred q] (h : ∃ n, p n)
 
-instance decidablePredExistsNat : DecidablePred fun n' : ℕ => ∃ (n : ℕ+)(_ : n' = n), p n :=
+instance decidablePredExistsNat : DecidablePred fun n' : ℕ => ∃ (n : ℕ+) (_ : n' = n), p n :=
   fun n' =>
   decidable_of_iff' (∃ h : 0 < n', p ⟨n', h⟩) <|
     Subtype.exists.trans <| by
@@ -33,7 +33,7 @@ instance decidablePredExistsNat : DecidablePred fun n' : ℕ => ∃ (n : ℕ+)(_
 
 /-- The `PNat` version of `Nat.findX` -/
 protected def findX : { n // p n ∧ ∀ m : ℕ+, m < n → ¬p m } := by
-  have : ∃ (n' : ℕ)(n : ℕ+)(_ : n' = n), p n := Exists.elim h fun n hn => ⟨n, n, rfl, hn⟩
+  have : ∃ (n' : ℕ) (n : ℕ+) (_ : n' = n), p n := Exists.elim h fun n hn => ⟨n, n, rfl, hn⟩
   have n := Nat.findX this
   refine' ⟨⟨n, _⟩, _, fun m hm pm => _⟩
   · obtain ⟨n', hn', -⟩ := n.prop.1

207cfac9

chore: fix typos (#4518)

I ran codespell Mathlib and got tired halfway through the suggestions.

92beef58

Diff

@@ -106,7 +106,7 @@ theorem lt_find_iff (n : ℕ+) : n < PNat.find h ↔ ∀ m ≤ n, ¬p m := by
 theorem find_eq_one : PNat.find h = 1 ↔ p 1 := by simp [find_eq_iff]
 #align pnat.find_eq_one PNat.find_eq_one
 
--- porting notes: deleted `@[simp]` to satisfy the linter becuase `le_find_iff` is more general
+-- porting notes: deleted `@[simp]` to satisfy the linter because `le_find_iff` is more general
 theorem one_le_find : 1 < PNat.find h ↔ ¬p 1 :=
   not_iff_not.mp <| by simp
 #align pnat.one_le_find PNat.one_le_find

207cfac9

feat: port CanLift instances for PNat (#1426)

depends on #1425

2ba550f7

Diff

@@ -26,7 +26,7 @@ instance decidablePredExistsNat : DecidablePred fun n' : ℕ => ∃ (n : ℕ+)(_
   fun n' =>
   decidable_of_iff' (∃ h : 0 < n', p ⟨n', h⟩) <|
     Subtype.exists.trans <| by
-      simp_rw [Subtype.coe_mk, @exists_comm (_ < _) (_ = _), exists_prop, exists_eq_left']
+      simp_rw [mk_coe, @exists_comm (_ < _) (_ = _), exists_prop, exists_eq_left']
 #align pnat.decidable_pred_exists_nat PNat.decidablePredExistsNat
 
 --include h

207cfac9

Port/data.pnat.find (#1220)

Port of data.pnat.find

Also changed Nat.find_x to Nat.findX to follow naming conventions

Co-authored-by: ChrisHughes24 <chrishughes24@gmail.com> Co-authored-by: Chris Hughes <33847686+ChrisHughes24@users.noreply.github.com>

95f15947

`data.pnat.find` ⟷ `Mathlib.Data.PNat.Find`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 1 + 88

data.pnat.find ⟷ Mathlib.Data.PNat.Find

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 1 + 88

`data.pnat.find` ⟷ `Mathlib.Data.PNat.Find`