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: α

nil
List.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

cons
List.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

cons
List.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

cons
List.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.inl
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.inr
List.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

cons
List.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.inl
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.inr
List.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.h
List.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.inl
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.inr
List.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

cons
List.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.inr
List.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.inr
List.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.inr
Nat.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.inr
Nat.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.inr
List.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.a
List.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.inr
List.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 ∈ []

nil
List.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

cons
List.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

cons
List.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

cons
List.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.inl
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.inr
List.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

cons
List.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.inl
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.inr
List.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.a
List.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.inl
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.inr
List.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

cons
List.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.inr
List.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.inr
List.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.inr
Nat.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.inr
Nat.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.inr
List.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.a
List.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.inr
List.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.a
List.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.inr
List.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⟩

#check
List.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
#check
List.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
#check
List.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

hyp
a ∈ 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.
-/