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.

theorem remove_length_le {α : Type u} [DecidableEq α] (a : α) (l : List α) : List.length (List.remove a l) ≤ List.length l

Removing an element from a list does not increase length

theorem remove_mem_length {α : Type u} [DecidableEq α] {a : α} {l : List α} (hyp : a ∈ l) : List.length (List.remove a l) < List.length l

Removing a member from a list shortens the list

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.

def IO.randFin (n : ℕ) (h : 0 < n) : IO (Fin n)

A random number in Fin n

def pickElemIO {α : Type} [DecidableEq α] (l : List α) (p : α → Bool) (h : ∃ t, t ∈ l ∧ p t = true) : IO { t // t ∈ l ∧ p t = true }

A random element with a given property from a list, within IO

Equations

• One or more equations did not get rendered due to their size.

def pickElemD {α : Type} [DecidableEq α] (l : List α) (p : α → Bool) (default : α) (h₁ : default ∈ l) (h₂ : p default = true) : { t // t ∈ l ∧ p t = true }

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

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.

def RandomM (α : Type u_1) : Type u_1

def RandomM.rand (lo : ℕ) (hi : ℕ) : RandomM ℕ

def RandomM.run {α : Type u_1} (x : RandomM α) : StdGen → α × StdGen

def RandomM.run' {α : Type u_1} (x : RandomM α) (gen : optParam StdGen default) : α

instance RandomM.instMonadRandomM : Monad RandomM

def RandomM.randBool : RandomM Bool

def RandomM.randList (lo : ℕ) (hi : ℕ) (n : ℕ) : RandomM (List ℕ)

Equations

• RandomM.randList lo hi 0 = pure []
• RandomM.randList lo hi (Nat.succ k) = do let x ← RandomM.rand lo hi let xs ← RandomM.randList lo hi k pure (x :: xs)

def RandomM.setSeed (n : ℕ) : RandomM Unit

def RandomM.withSeed {α : Type} (n : ℕ) (c : RandomM α) : RandomM α

def StateM' (σ : Type u_1) (α : Type u_2) : Type (max u_1 u_2)

instance instMonadStateM' {σ : Type u_1} : Monad (StateM' σ)

def StateM'.run {σ : Type u_1} {α : Type u_2} (x : StateM' σ α) : σ → α × σ

def StateM'.run' {σ : Type u_1} {α : Type u_2} [Inhabited σ] (x : StateM' σ α) (s : optParam σ default) : α

def StateM'.setState {σ : Type u_1} (s : σ) : StateM' σ Unit

def StateM'.getState {σ : Type u_1} : StateM' σ σ

def StateM'.withState {σ : Type u_1} {α : Type} (s : σ) (c : StateM' σ α) : StateM' σ α

def RandomM' (α : Type u_1) : Type u_1