import Mathlib

/-!
# Random sampling for an element

We implement sampling to find an element with a given property, for instance being prime or being coprime to a given number. For this we need a hypothesis that such an element exists. 

We use the `IO` monad to generate random numbers. This is because a random number is not a function, in the sense of having value determined by arguments.
-/

/-!
The basic way we sample is to choose an element at random from the list, and then check if it satisfies the property. If it does, we return it. If not, we remove it from the list and try again. To show termination we see (following a lab) that the length of the list decreases by at least one each time.
-/

universe u
/-- Removing an element from a list does not increase length -/
theorem remove_length_le: ∀ {α : Type u} [inst : DecidableEq α] (a : α) (l : List α), List.length (List.remove a l) ≤ List.length l
remove_length_le {α: Type u
α :  Type u: Type (u+1)
Type u} [DecidableEq: Sort ?u.4 → Sort (max1?u.4)
DecidableEq α: Type u
α](a: α
a : α: Type u
α) (l: List α
l : List: Type ?u.15 → Type ?u.15
List α: Type u
α) : (List.remove: {α : Type ?u.19} → [inst : DecidableEq α] → α → List α → List α
List.remove a: α
a l: List α
l).length: {α : Type ?u.61} → List α → ℕ
length ≤ l: List α
l.length: {α : Type ?u.65} → List α → ℕ
length := by
Goals accomplished! 🐙 
  α: Type u

inst✝: DecidableEq α

a: α

l: List α

List.length (List.remove a l) ≤ List.length linduction l: List α
l with
  α: Type u

inst✝: DecidableEq α

a: α

l: List α

List.length (List.remove a l) ≤ List.length l| nil: {α : Type u} → List α
nil => 
    α: Type u

inst✝: DecidableEq α

a: α

nilList.length (List.remove a []) ≤ List.length []simp [List.remove: {α : Type ?u.114} → [inst : DecidableEq α] → α → List α → List α
List.remove]
Goals accomplished! 🐙
  α: Type u

inst✝: DecidableEq α

a: α

l: List α

List.length (List.remove a l) ≤ List.length l| cons: {α : Type u} → α → List α → List α
cons h': ?m.107
h' t: List ?m.107
t ih: ?m.108 t
ih => 
      α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

consList.length (List.remove a (h' :: t)) ≤ List.length (h' :: t)simp [List.remove: {α : Type ?u.617} → [inst : DecidableEq α] → α → List α → List α
List.remove]α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

consList.length (if a = h' then List.remove a t else h' :: List.remove a t) ≤ Nat.succ (List.length t)
      α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

consList.length (List.remove a (h' :: t)) ≤ List.length (h' :: t)splitα: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

h✝: a = h'

cons.inlList.length (List.remove a t) ≤ Nat.succ (List.length t)
α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) ≤ Nat.succ (List.length t)
      α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

consList.length (List.remove a (h' :: t)) ≤ List.length (h' :: t)· α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

h✝: a = h'

cons.inlList.length (List.remove a t) ≤ Nat.succ (List.length t)
α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) ≤ Nat.succ (List.length t)apply Nat.le_step: ∀ {n m : ℕ}, n ≤ m → n ≤ Nat.succ m
Nat.le_stepα: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

h✝: a = h'

cons.inl.hList.length (List.remove a t) ≤ List.length t
        α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

h✝: a = h'

cons.inlList.length (List.remove a t) ≤ Nat.succ (List.length t)
α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) ≤ Nat.succ (List.length t)assumption
Goals accomplished! 🐙
      α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

consList.length (List.remove a (h' :: t)) ≤ List.length (h' :: t)· α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) ≤ Nat.succ (List.length t)rw [α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) ≤ Nat.succ (List.length t)List.length_cons: ∀ {α : Type ?u.2175} (a : α) (as : List α), List.length (a :: as) = Nat.succ (List.length as)
List.length_consα: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

h✝: ¬a = h'

cons.inrNat.succ (List.length (List.remove a t)) ≤ Nat.succ (List.length t)]α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

h✝: ¬a = h'

cons.inrNat.succ (List.length (List.remove a t)) ≤ Nat.succ (List.length t)
        α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) ≤ Nat.succ (List.length t)apply Nat.succ_le_succ: ∀ {n m : ℕ}, n ≤ m → Nat.succ n ≤ Nat.succ m
Nat.succ_le_succα: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

h✝: ¬a = h'

cons.inr.aList.length (List.remove a t) ≤ List.length t
        α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: List.length (List.remove a t) ≤ List.length t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) ≤ Nat.succ (List.length t)exact ih: ?m.108 t
ih
Goals accomplished! 🐙


/-- Removing a member from a list shortens the list -/
theorem remove_mem_length: ∀ {α : Type u} [inst : DecidableEq α] {a : α} {l : List α}, a ∈ l → List.length (List.remove a l) < List.length l
remove_mem_length  {α: Type u
α :  Type u: Type (u+1)
Type u} [DecidableEq: Sort ?u.2332 → Sort (max1?u.2332)
DecidableEq α: Type u
α]{a: α
a : α: Type u
α } {l: List α
l : List: Type ?u.2343 → Type ?u.2343
List α: Type u
α} (hyp: a ∈ l
hyp : a: α
a ∈ l: List α
l) : (List.remove: {α : Type ?u.2403} → [inst : DecidableEq α] → α → List α → List α
List.remove a: α
a l: List α
l).length: {α : Type ?u.2444} → List α → ℕ
length < l: List α
l.length: {α : Type ?u.2448} → List α → ℕ
length  := by
Goals accomplished! 🐙 
  α: Type u

inst✝: DecidableEq α

a: α

l: List α

hyp: a ∈ l

List.length (List.remove a l) < List.length linduction l: List α
l with
  α: Type u

inst✝: DecidableEq α

a: α

l: List α

hyp: a ∈ l

List.length (List.remove a l) < List.length l| nil: {α : Type u} → List α
nil => 
    α: Type u

inst✝: DecidableEq α

a: α

hyp: a ∈ []

nilList.length (List.remove a []) < List.length []contradiction
Goals accomplished! 🐙
  α: Type u

inst✝: DecidableEq α

a: α

l: List α

hyp: a ∈ l

List.length (List.remove a l) < List.length l| cons: {α : Type u} → α → List α → List α
cons h': ?m.2493
h' t: List ?m.2493
t ih: ?m.2494 t
ih => 
      α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

consList.length (List.remove a (h' :: t)) < List.length (h' :: t)simp [List.remove: {α : Type ?u.2575} → [inst : DecidableEq α] → α → List α → List α
List.remove]α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

consList.length (if a = h' then List.remove a t else h' :: List.remove a t) < Nat.succ (List.length t)
      α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

consList.length (List.remove a (h' :: t)) < List.length (h' :: t)splitα: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: a = h'

cons.inlList.length (List.remove a t) < Nat.succ (List.length t)
α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) < Nat.succ (List.length t) 
      α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

consList.length (List.remove a (h' :: t)) < List.length (h' :: t)· α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: a = h'

cons.inlList.length (List.remove a t) < Nat.succ (List.length t)
α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) < Nat.succ (List.length t)apply Nat.lt_succ_of_le: ∀ {n m : ℕ}, n ≤ m → n < Nat.succ m
Nat.lt_succ_of_leα: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: a = h'

cons.inl.aList.length (List.remove a t) ≤ List.length t
        α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: a = h'

cons.inlList.length (List.remove a t) < Nat.succ (List.length t)
α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) < Nat.succ (List.length t)apply remove_length_le: ∀ {α : Type ?u.3371} [inst : DecidableEq α] (a : α) (l : List α), List.length (List.remove a l) ≤ List.length l
remove_length_le
Goals accomplished! 🐙
      α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

consList.length (List.remove a (h' :: t)) < List.length (h' :: t)· α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) < Nat.succ (List.length t)rw [α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) < Nat.succ (List.length t)List.length_cons: ∀ {α : Type ?u.3423} (a : α) (as : List α), List.length (a :: as) = Nat.succ (List.length as)
List.length_consα: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

cons.inrNat.succ (List.length (List.remove a t)) < Nat.succ (List.length t)]α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

cons.inrNat.succ (List.length (List.remove a t)) < Nat.succ (List.length t)
        α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) < Nat.succ (List.length t)apply Nat.succ_lt_succ: ∀ {n m : ℕ}, n < m → Nat.succ n < Nat.succ m
Nat.succ_lt_succα: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

cons.inr.aList.length (List.remove a t) < List.length t
        α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) < Nat.succ (List.length t)have in_tail: a ∈ t
in_tail: a: α
a ∈ t: List ?m.2493
t := α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

cons.inr.aList.length (List.remove a t) < List.length tby
Goals accomplished! 🐙 
          α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

a ∈ thave : ¬ a: α
a = h': α
h' := α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

a ∈ tby
Goals accomplished! 🐙 α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

¬a = h'assumption
Goals accomplished! 🐙
          α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

a ∈ tsimp [List.mem_cons: ∀ {α : Type ?u.3506} {a b : α} {l : List α}, a ∈ b :: l ↔ a = b ∨ a ∈ l
List.mem_cons, this: ¬a = h'
this] at hyp: a ∈ h' :: t
hypα: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

h✝, this: ¬a = h'

hyp: a ∈ t

a ∈ t
          α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

a ∈ tassumption
Goals accomplished! 🐙
        α: Type u

inst✝: DecidableEq α

a, h': α

t: List α

ih: a ∈ t → List.length (List.remove a t) < List.length t

hyp: a ∈ h' :: t

h✝: ¬a = h'

cons.inrList.length (h' :: List.remove a t) < Nat.succ (List.length t)exact ih: ?m.2494 t
ih in_tail: a ∈ t
in_tail
Goals accomplished! 🐙


/-!
We pick an index of the list `l`, which is of type `Fin l.length`. Rather than proving that the random number generator has this property we pass `mod n`.
-/

/-- A random number in `Fin n` -/
def IO.randFin: (n : ℕ) → 0 < n → IO (Fin n)
IO.randFin (n: ℕ
n : ℕ: Type
ℕ)(h: 0 < n
h : 0: ?m.6449
0 < n: ℕ
n ) : IO: Type → Type
IO <| Fin: ℕ → Type
Fin n: ℕ
n   := do
  let r: ?m.6592
r ← IO.rand: ℕ → ℕ → IO ℕ
IO.rand 0: ?m.6530
0 (n: ℕ
n - 1: ?m.6536
1)
  pure: {f : Type ?u.6595 → Type ?u.6594} → [self : Pure f] → {α : Type ?u.6595} → α → f α
pure ⟨r: ?m.6592
r % n: ℕ
n, Nat.mod_lt: ∀ (x : ℕ) {y : ℕ}, y > 0 → x % y < y
Nat.mod_lt r: ?m.6592
r h: 0 < n
h⟩

#checkList.mem_remove_iff.{u_1} {α : Type u_1} [inst✝ : DecidableEq α] {a b : α} {as : List α} :
  b ∈ List.remove a as ↔ b ∈ as ∧ b ≠ a List.mem_remove_iff: ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {as : List α}, b ∈ List.remove a as ↔ b ∈ as ∧ b ≠ a
List.mem_remove_iff -- ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {as : List α}, b ∈ List.remove a as ↔ b ∈ as ∧ b ≠ a
#checkList.length_pos_of_mem.{u_1} {α : Type u_1} {a : α} {l : List α} (a✝ : a ∈ l) : 0 < List.length l List.length_pos_of_mem: ∀ {α : Type u_1} {a : α} {l : List α}, a ∈ l → 0 < List.length l
List.length_pos_of_mem -- ∀ {α : Type u_1} {a : α} {l : List α}, a ∈ l → 0 < List.length l
#checkList.get_mem.{u_1} {α : Type u_1} (l : List α) (n : ℕ) (h : n < List.length l) : List.get l { val := n, isLt := h } ∈ l List.get_mem: ∀ {α : Type u_1} (l : List α) (n : ℕ) (h : n < List.length l), List.get l { val := n, isLt := h } ∈ l
List.get_mem -- ∀ {α : Type u_1} (l : List α) (n : ℕ) (h : n < List.length l), List.get l { val := n, isLt := h } ∈ l


/-- A random element with a given property from a list, within `IO`  -/
def pickElemIO: {α : Type} →
  [inst : DecidableEq α] → (l : List α) → (p : α → Bool) → (∃ t, t ∈ l ∧ p t = true) → IO { t // t ∈ l ∧ p t = true }
pickElemIO [DecidableEq: Sort ?u.6949 → Sort (max1?u.6949)
DecidableEq α: ?m.6946
α](l: List α
l: List: Type ?u.6958 → Type ?u.6958
List α: ?m.6946
α)(p: α → Bool
p: α: ?m.6946
α → Bool: Type
Bool)(h: ∃ t, t ∈ l ∧ p t = true
h : ∃t: α
t : α: ?m.6946
α, t: α
t ∈ l: List α
l ∧ p: α → Bool
p t: α
t = true: Bool
true) : IO: Type → Type
IO {t: α
t : α: ?m.6946
α // t: α
t ∈ l: List α
l ∧ p: α → Bool
p t: α
t = true: Bool
true} := do
  have h': 0 < List.length l
h' : 0: ?m.7049
0 < l: List α
l.length: {α : Type ?u.7064} → List α → ℕ
length := by
Goals accomplished! 🐙 
    α: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

0 < List.length lhave ⟨t: α
t, h₀: t ∈ l ∧ p t = true
h₀⟩ := h: ∃ t, t ∈ l ∧ p t = true
hα: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

t: α

h₀: t ∈ l ∧ p t = true

0 < List.length l
    α: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

0 < List.length lapply List.length_pos_of_mem: ∀ {α : Type ?u.7951} {a : α} {l : List α}, a ∈ l → 0 < List.length l
List.length_pos_of_mem h₀: t ∈ l ∧ p t = true
h₀.left: ∀ {a b : Prop}, a ∧ b → a
left
Goals accomplished! 🐙
  let index: ?m.7114
index ← IO.randFin: (n : ℕ) → 0 < n → IO (Fin n)
IO.randFin l: List α
l.length: {α : Type ?u.7106} → List α → ℕ
length h': 0 < List.length l
h' 
  let a: ?m.7117
a := l: List α
l.get: {α : Type ?u.7118} → (as : List α) → Fin (List.length as) → α
get index: ?m.7114
index
  if c: ?m.7208
c:p: α → Bool
p a: ?m.7117
a = true: Bool
true then
    return ⟨a: ?m.7117
a, by
Goals accomplished! 🐙 
      α: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h': 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: p a = true

a ∈ l ∧ p a = truesimp [c: p a = true
c]α: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h': 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: p a = true

List.get l index ∈ l
      α: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h': 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: p a = true

a ∈ l ∧ p a = trueapply List.get_mem: ∀ {α : Type ?u.8767} (l : List α) (n : ℕ) (h : n < List.length l), List.get l { val := n, isLt := h } ∈ l
List.get_mem
Goals accomplished! 🐙
      ⟩
  else
    let l': ?m.7211
l' := l: List α
l.remove: {α : Type ?u.7212} → [inst : DecidableEq α] → α → List α → List α
remove a: ?m.7117
a
    have h': ∃ t, t ∈ l' ∧ p t = true
h' : ∃t: α
t : α: Type
α, t: α
t ∈ l': ?m.7211
l' ∧ p: α → Bool
p t: α
t = true: Bool
true :=
      by
Goals accomplished! 🐙
        α: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h': 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: ¬p a = true

l':= List.remove a l: List α

∃ t, t ∈ l' ∧ p t = truehave ⟨t: α
t, h₁: t ∈ l
h₁, h₂: p t = true
h₂⟩ := h: ∃ t, t ∈ l ∧ p t = true
hα: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h': 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: ¬p a = true

l':= List.remove a l: List α

t: α

h₁: t ∈ l

h₂: p t = true

∃ t, t ∈ l' ∧ p t = true
        α: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h': 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: ¬p a = true

l':= List.remove a l: List α

∃ t, t ∈ l' ∧ p t = trueuse t: α
tα: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h': 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: ¬p a = true

l':= List.remove a l: List α

t: α

h₁: t ∈ l

h₂: p t = true

t ∈ l' ∧ p t = true
        α: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h': 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: ¬p a = true

l':= List.remove a l: List α

∃ t, t ∈ l' ∧ p t = truesimp [List.mem_remove_iff: ∀ {α : Type ?u.8938} [inst : DecidableEq α] {a b : α} {as : List α}, b ∈ List.remove a as ↔ b ∈ as ∧ b ≠ a
List.mem_remove_iff, h₁: t ∈ l
h₁, h₂: p t = true
h₂]α: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h': 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: ¬p a = true

l':= List.remove a l: List α

t: α

h₁: t ∈ l

h₂: p t = true

¬t = List.get l index
        α: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h': 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: ¬p a = true

l':= List.remove a l: List α

∃ t, t ∈ l' ∧ p t = truesimp at c: ¬p a = true
cα: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h': 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

l':= List.remove a l: List α

t: α

h₁: t ∈ l

h₂: p t = true

c: p (List.get l index) = false

¬t = List.get l index
        α: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h': 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: ¬p a = true

l':= List.remove a l: List α

∃ t, t ∈ l' ∧ p t = trueintro contra: t = List.get l index
contraα: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h': 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

l':= List.remove a l: List α

t: α

h₁: t ∈ l

h₂: p t = true

c: p (List.get l index) = false

contra: t = List.get l index

False
        α: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h': 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: ¬p a = true

l':= List.remove a l: List α

∃ t, t ∈ l' ∧ p t = truesimp [contra: t = List.get l index
contra, c: p (List.get l index) = false
c] at h₂: p t = true
h₂
Goals accomplished! 🐙
    have : l': ?m.7211
l'.length: {α : Type ?u.7390} → List α → ℕ
length < l: List α
l.length: {α : Type ?u.7394} → List α → ℕ
length := by
Goals accomplished! 🐙
      α: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h'✝: 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: ¬p a = true

l':= List.remove a l: List α

h': ∃ t, t ∈ l' ∧ p t = true

List.length l' < List.length lapply remove_mem_length: ∀ {α : Type ?u.9929} [inst : DecidableEq α] {a : α} {l : List α}, a ∈ l → List.length (List.remove a l) < List.length l
remove_mem_lengthα: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h'✝: 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: ¬p a = true

l':= List.remove a l: List α

h': ∃ t, t ∈ l' ∧ p t = true

hypa ∈ l
      α: Type

inst✝: DecidableEq α

l: List α

p: α → Bool

h: ∃ t, t ∈ l ∧ p t = true

h'✝: 0 < List.length l

index: Fin (List.length l)

a:= List.get l index: α

c: ¬p a = true

l':= List.remove a l: List α

h': ∃ t, t ∈ l' ∧ p t = true

List.length l' < List.length lapply List.get_mem: ∀ {α : Type ?u.9979} (l : List α) (n : ℕ) (h : n < List.length l), List.get l { val := n, isLt := h } ∈ l
List.get_mem
Goals accomplished! 🐙
    let ⟨t: α
t, h₁: t ∈ l'
h₁, h₂: p t = true
h₂⟩ ←  pickElemIO: {α : Type} →
  [inst : DecidableEq α] → (l : List α) → (p : α → Bool) → (∃ t, t ∈ l ∧ p t = true) → IO { t // t ∈ l ∧ p t = true }
pickElemIO l': ?m.7211
l' p: α → Bool
p h': ∃ t, t ∈ l' ∧ p t = true
h'
    have m: t ∈ l
m : t: α
t ∈ l: List α
l := 
      List.mem_of_mem_remove: ∀ {α : Type ?u.7518} [inst : DecidableEq α] {a b : α} {as : List α}, b ∈ List.remove a as → b ∈ as
List.mem_of_mem_remove h₁: t ∈ l'
h₁
    return ⟨t: α
t, m: t ∈ l
m, h₂: p t = true
h₂⟩
termination_by _ _ _ l _ _ => l: List α
l.length: {α : Type ?u.10278} → List α → ℕ
length  
    
/-- A random element with a given property from a list. As IO may in principle give an error, we specify a default to fallback and the conditions that this is in the list and has the property `p` -/
def pickElemD: {α : Type ?u.34043} →
  [inst : DecidableEq α] →
    (l : List α) → (p : α → Bool) → (default : α) → default ∈ l → p default = true → { t // t ∈ l ∧ p t = true }
pickElemD [DecidableEq: Sort ?u.34034 → Sort (max1?u.34034)
DecidableEq α: ?m.34031
α](l: List α
l: List: Type ?u.34043 → Type ?u.34043
List α: ?m.34031
α)(p: α → Bool
p: α: ?m.34031
α → Bool: Type
Bool)(default: α
default : α: ?m.34031
α)(h₁: default ∈ l
h₁ : default: α
default ∈ l: List α
l)(h₂: p default = true
h₂ : p: α → Bool
p default: α
default = true: Bool
true)
  : 
    {t: α
t : α: ?m.34031
α // t: α
t ∈ l: List α
l ∧ p: α → Bool
p t: α
t = true: Bool
true} := (pickElemIO: {α : Type} →
  [inst : DecidableEq α] → (l : List α) → (p : α → Bool) → (∃ t, t ∈ l ∧ p t = true) → IO { t // t ∈ l ∧ p t = true }
pickElemIO l: List α
l p: α → Bool
p ⟨default: α
default, h₁: default ∈ l
h₁, h₂: p default = true
h₂⟩).run': {ε σ α : Type ?u.34205} → EStateM ε σ α → σ → Option α
run' (): Unit
() |>.getD: {α : Type ?u.34217} → Option α → α → α
getD ⟨default: α
default, h₁: default ∈ l
h₁, h₂: p default = true
h₂⟩

/-!
## Random Monad

We used the IO Monad which has a lot of stuff besides randomness. We will now demistify this by constructing a Monad for randomness only.
-/
#checkStdGen : Type StdGen: Type
StdGen
#checkmkStdGen (s : ℕ := 0) : StdGen mkStdGen: optParam ℕ 0 → StdGen
mkStdGen -- mkStdGen (s : ℕ := 0) : StdGen
#checkrandNat.{u} {gen : Type u} [inst✝ : RandomGen gen] (g : gen) (lo hi : ℕ) : ℕ × gen randNat: {gen : Type u} → [inst : RandomGen gen] → gen → ℕ → ℕ → ℕ × gen
randNat -- randNat.{u} {gen : Type u} [inst✝ : RandomGen gen] (g : gen) (lo hi : ℕ) : ℕ × gen

def RandomM: (α : ?m.34437) → ?m.34441 α
RandomM α: ?m.34437
α := StdGen: Type
StdGen → α: ?m.34437
α × StdGen: Type
StdGen    

#checkIO.rand (lo hi : ℕ) : IO ℕ IO.rand: ℕ → ℕ → IO ℕ
IO.rand -- IO.rand (lo hi : ℕ) : IO ℕ
namespace RandomM

def rand: ℕ → ℕ → RandomM ℕ
rand (lo: ℕ
lo hi: ℕ
hi : ℕ: Type
ℕ): RandomM: Type ?u.34460 → Type ?u.34460
RandomM ℕ: Type
ℕ :=
  fun gen: ?m.34467
gen ↦ randNat: {gen : Type ?u.34469} → [inst : RandomGen gen] → gen → ℕ → ℕ → ℕ × gen
randNat gen: ?m.34467
gen lo: ℕ
lo hi: ℕ
hi

def run: {α : Type u_1} → RandomM α → StdGen → α × StdGen
run (x: RandomM α
x : RandomM: Type ?u.34530 → Type ?u.34530
RandomM α: ?m.34527
α) : 
  StdGen: Type
StdGen →  α: ?m.34527
α × StdGen: Type
StdGen := x: RandomM α
x

def run': {α : Type ?u.34613} → RandomM α → optParam StdGen default → α
run' (x: RandomM α
x : RandomM: Type ?u.34613 → Type ?u.34613
RandomM α: ?m.34610
α)(gen: optParam StdGen default
gen : StdGen: Type
StdGen := default: {α : Sort ?u.34617} → [self : Inhabited α] → α
default) : α: ?m.34610
α  :=
  (x: RandomM α
x gen: optParam StdGen default
gen).1: {α : Type ?u.35124} → {β : Type ?u.35123} → α × β → α
1
  
#eval3
 rand: ℕ → ℕ → RandomM ℕ
rand 0: ?m.35213
0 10: ?m.35224
10 |>.run': {α : Type ?u.35230} → RandomM α → optParam StdGen default → α
run' 

instance: Monad RandomM
instance : Monad: (Type ?u.35698 → Type ?u.35697) → Type (max(?u.35698+1)?u.35697)
Monad RandomM: Type ?u.35699 → Type ?u.35699
RandomM where
  pure := fun x: ?m.35852
x ↦ fun gen: ?m.35855
gen ↦ (x: ?m.35852
x, gen: ?m.35855
gen)
  map := fun f: ?m.35725
f x: ?m.35729
x ↦ 
    fun gen: ?m.35732
gen ↦ 
      let (a: α✝
a , gen': StdGen
gen') := x: ?m.35729
x gen: ?m.35732
gen
      (f: ?m.35725
f a: α✝
a, gen': StdGen
gen') 
  bind := fun x: ?m.35960
x b: ?m.35963
b ↦
    fun gen: ?m.35968
gen ↦
      let (a: α✝
a , gen': StdGen
gen') := x: ?m.35960
x gen: ?m.35968
gen
      b: ?m.35963
b a: α✝
a gen': StdGen
gen'

def randBool: RandomM Bool
randBool : RandomM: Type ?u.38008 → Type ?u.38008
RandomM Bool: Type
Bool := do
  let n: ?m.38067
n ← rand: ℕ → ℕ → RandomM ℕ
rand 0: ?m.38048
0 1: ?m.38059
1 
  pure: {f : Type ?u.38070 → Type ?u.38069} → [self : Pure f] → {α : Type ?u.38070} → α → f α
pure (n: ?m.38067
n == 0: ?m.38088
0)

#evalfalse
 randBool: RandomM Bool
randBool |>.run': {α : Type ?u.38302} → RandomM α → optParam StdGen default → α
run' (mkStdGen: optParam ℕ 0 → StdGen
mkStdGen 84938743: ?m.38309
84938743)

def randList: ℕ → ℕ → ℕ → RandomM (List ℕ)
randList (lo: ℕ
lo hi: ℕ
hi n: ℕ
n : ℕ: Type
ℕ) : 
  RandomM: Type ?u.38748 → Type ?u.38748
RandomM <| List: Type ?u.38749 → Type ?u.38749
List ℕ: Type
ℕ := do
  match n: ℕ
n with
  | 0: ℕ
0 => pure: {f : Type ?u.38791 → Type ?u.38790} → [self : Pure f] → {α : Type ?u.38791} → α → f α
pure []: List ?m.38808
[]
  | k: ℕ
k + 1 => do
    let x: ?m.38935
x ← rand: ℕ → ℕ → RandomM ℕ
rand lo: ℕ
lo hi: ℕ
hi
    let xs: ?m.38957
xs ← randList: ℕ → ℕ → ℕ → RandomM (List ℕ)
randList lo: ℕ
lo hi: ℕ
hi k: ℕ
k
    pure: {f : Type ?u.38960 → Type ?u.38959} → [self : Pure f] → {α : Type ?u.38960} → α → f α
pure <| x: ?m.38935
x :: xs: ?m.38957
xs

#eval[8, 7, 10, 7, 10, 9, 4]
 randList: ℕ → ℕ → ℕ → RandomM (List ℕ)
randList 1: ?m.39562
1 10: ?m.39573
10 7: ?m.39579
7 |>.run': {α : Type ?u.39585} → RandomM α → optParam StdGen default → α
run' (mkStdGen: optParam ℕ 0 → StdGen
mkStdGen 84938743: ?m.39592
84938743)

def setSeed: ℕ → RandomM Unit
setSeed (n: ℕ
n : ℕ: Type
ℕ) : RandomM: Type ?u.40051 → Type ?u.40051
RandomM Unit: Type
Unit :=
  fun _: ?m.40056
_ ↦ ((): Unit
(), mkStdGen: optParam ℕ 0 → StdGen
mkStdGen n: ℕ
n)

def withSeed: {α : Type ?u.40123} → ℕ → RandomM α → RandomM α
withSeed (n: ℕ
n: ℕ: Type
ℕ) (c: RandomM α
c : RandomM: Type ?u.40123 → Type ?u.40123
RandomM α: ?m.40118
α) : 
  RandomM: Type ?u.40126 → Type ?u.40126
RandomM α: ?m.40118
α := do
  setSeed: ℕ → RandomM Unit
setSeed n: ℕ
n
  c: RandomM α
c

#eval[9, 10, 2, 6, 9, 3, 10, 5, 4, 10, 2, 4]
 (withSeed: {α : Type} → ℕ → RandomM α → RandomM α
withSeed 376872: ?m.40340
376872 <| randList: ℕ → ℕ → ℕ → RandomM (List ℕ)
randList 1: ?m.40352
1 10: ?m.40359
10 12: ?m.40365
12) |>.run': {α : Type ?u.40372} → RandomM α → optParam StdGen default → α
run'

end RandomM

def StateM': Type u_1 → Type u_2 → Type (maxu_1u_2)
StateM' σ: ?m.40850
σ α: ?m.40857 σ
α := σ: ?m.40850
σ → α: ?m.40857 σ
α × σ: ?m.40850
σ

instance: {σ : Type u_1} → Monad (StateM' σ)
instance : Monad: (Type ?u.40891 → Type ?u.40890) → Type (max(?u.40891+1)?u.40890)
Monad <| StateM': Type ?u.40893 → Type ?u.40892 → Type (max?u.40893?u.40892)
StateM' σ: ?m.40887
σ where
  pure := fun x: ?m.41052
x ↦ fun gen: ?m.41055
gen ↦ (x: ?m.41052
x, gen: ?m.41055
gen)
  map := fun f: ?m.40922
f x: ?m.40926
x ↦ 
    fun gen: ?m.40929
gen ↦ 
      let (a: α✝
a , gen': σ
gen') := x: ?m.40926
x gen: ?m.40929
gen
      (f: ?m.40922
f a: α✝
a, gen': σ
gen') 
  bind := fun x: ?m.41160
x b: ?m.41163
b ↦
    fun gen: ?m.41168
gen ↦
      let (a: α✝
a , gen': σ
gen') := x: ?m.41160
x gen: ?m.41168
gen
      b: ?m.41163
b a: α✝
a gen': σ
gen'
namespace StateM'

def run: {σ : Type u_1} → {α : Type u_2} → StateM' σ α → σ → α × σ
run (x: StateM' σ α
x : StateM': Type ?u.42806 → Type ?u.42805 → Type (max?u.42806?u.42805)
StateM' σ: ?m.42796
σ α: ?m.42802
α) : 
  σ: ?m.42796
σ →  α: ?m.42802
α × σ: ?m.42796
σ := x: StateM' σ α
x

def run': {σ : Type ?u.42897} → {α : Type ?u.42896} → [inst : Inhabited σ] → StateM' σ α → optParam σ default → α
run' [Inhabited: Sort ?u.42884 → Sort (max1?u.42884)
Inhabited σ: ?m.42881
σ](x: StateM' σ α
x : StateM': Type ?u.42897 → Type ?u.42896 → Type (max?u.42897?u.42896)
StateM' σ: ?m.42881
σ α: ?m.42890
α)(s: optParam σ default
s : σ: ?m.42881
σ := default: {α : Sort ?u.42901} → [self : Inhabited α] → α
default) : α: ?m.42890
α  :=
  (x: StateM' σ α
x s: optParam σ default
s).1: {α : Type ?u.43410} → {β : Type ?u.43409} → α × β → α
1

def setState: {σ : Type ?u.43494} → σ → StateM' σ Unit
setState (s: σ
s : σ: ?m.43488
σ) : StateM': Type ?u.43494 → Type ?u.43493 → Type (max?u.43494?u.43493)
StateM' σ: ?m.43488
σ Unit: Type
Unit :=
  fun _: ?m.43501
_ ↦ ((): Unit
(), s: σ
s)

def getState: {σ : Type ?u.43562} → StateM' σ σ
getState : StateM': Type ?u.43562 → Type ?u.43561 → Type (max?u.43562?u.43561)
StateM' σ: ?m.43558
σ σ: ?m.43558
σ :=
  fun s: ?m.43567
s ↦ (s: ?m.43567
s, s: ?m.43567
s)

def withState: {σ : Type ?u.43626} → {α : Type ?u.43625} → σ → StateM' σ α → StateM' σ α
withState (s: σ
s: σ: ?m.43612
σ) (c: StateM' σ α
c : StateM': Type ?u.43626 → Type ?u.43625 → Type (max?u.43626?u.43625)
StateM' σ: ?m.43612
σ α: ?m.43620
α) : StateM': Type ?u.43630 → Type ?u.43629 → Type (max?u.43630?u.43629)
StateM' σ: ?m.43612
σ α: ?m.43620
α := do
  setState: {σ : Type ?u.43679} → σ → StateM' σ Unit
setState s: σ
s
  c: StateM' σ α
c

end StateM'

def RandomM': Type u_1 → Type u_1
RandomM' := StateM': Type ?u.43841 → Type ?u.43840 → Type (max?u.43841?u.43840)
StateM' StdGen: Type
StdGen

namespace RandomM'

end RandomM'