dtgp aaip11

Verified Stack-based Genetic Programming via Dependent Types

by Larry Diehl

Tuesday, July 19, 2011

Motivation

• avoid searching space of stack under/overflowing programs

• use strongly typed genetic operators

• avoid logic and runtime errors due to increasingly complex genetic operators

• use a total and dependently typed language


Dependent Types

• Agda programming language

• purely functional (like Haskell)

• total (coverage/termination/positivity)

• types can encode any intuitionistic logic formula

• e.g. proof theory judgement “Even 6”


Genetic Programming

• representation

• genetic operators

• evaluation function

• initialization procedure


“Forth” operations

and1

consumes0true 1

word

1

produces

12not


“Forth” terms

truenot

andnot

0 → 36 → 4and

and

1 → 1 3 → 1

nottrue

trueand

true

not7 → 70 → 1


append (ill)

0truetruenot2 3

andand1

≠


append (ill)

0truetruenot2 3

and2

≠


append (well)

0truetruenot2 2

and1

=1

0truetruenotand

⇒Tuesday, July 19, 2011

split

0truetruenot22

and1

=1

0truetruenotand


split

0true11

truenotand1

=

2

0truetruenotand


Agda Crash Course


data Bool : Set where true false : Bool

data ℕ : Set where zero : ℕ suc : ℕ ! ℕ

one : ℕone = suc zero

two : ℕ two = suc one

three : ℕthree = suc two


data List (A : Set) : Set where [] : List A _∷_ : A ! List A ! List A

false∷[] : List Boolfalse∷[] = false ∷ []

true∷false∷[] : List Booltrue∷false∷[] = true ∷ false∷[]


data Vec (A : Set) : ℕ ! Set where [] : Vec A zero _∷_ : {n : ℕ} ! A ! Vec A n ! Vec A (suc n)

false∷[]1 : Vec Bool onefalse∷[]1 = false ∷ []

true∷false∷[]2 : Vec Bool twotrue∷false∷[]2 = true ∷ false∷[]1


_+_ : ℕ ! ℕ ! ℕzero + n = nsuc m + n = suc (m + n)

_++_ : {A : Set} {m n : ℕ} ! Vec A m ! Vec A n ! Vec A (m + n)[] ++ ys = ys(x ∷ xs) ++ ys = x ∷ (xs ++ ys)

true∷false∷true∷[]3 : Vec Bool threetrue∷false∷true∷[]3 = (true ∷ false ∷ []) ++ (true ∷ [])


Representation


data Word : Set where true not and : Word

data List (A : Set) : Set where [] : List A

_∷_ : A ! List A ! List A

Term = List Word


bc : Term -- 2 1bc = and ∷ []

ab : Term -- 0 2ab = not ∷ true ∷ true ∷ []

ac : Term -- 0 1ac = and ∷ not ∷ true ∷ true ∷ []


bc : Term 2 1bc = and []

ab : Term 0 2ab = not (true (true []))

ac : Term 0 1ac = and (not (true (true [])))


data Term (inp : ℕ) : ℕ ! Set where [] : Term inp inp true : {out : ℕ} ! Term inp out ! Term inp (1 + out) not : {out : ℕ} ! Term inp (1 + out) ! Term inp (1 + out) and : {out : ℕ} ! Term inp (2 + out) ! Term inp (1 + out)


module DTGP {Word : Set} (pre post : Word ! ℕ ! ℕ)where

data Term (inp : ℕ) : ℕ ! Set where [] : Term inp inp

_∷_ : ∀ {n} (w : Word) ! Term inp (pre w n) ! Term inp (post w n)


data Word : Set where true not and : Word

pre : Word ! ℕ ! ℕpre true n = npre not n = 1 + npre and n = 2 + n

post : Word ! ℕ ! ℕpost true n = 1 + npost not n = 1 + npost and n = 1 + n

open import DTGP pre post


bc : Term 2 1bc = and ∷ []

ab : Term 0 2ab = not ∷ true ∷ true ∷ []

ac : Term 0 1ac = and ∷ not ∷ true ∷ true ∷ []


Genetic Operators


crossover : {inp out : ℕ} (female male : Term inp out) (randF randM : ℕ) ! Term inp out × Term inp out



ab : Term 0 2ab = not ∷ true ∷ true ∷ []

ac : Term 0 1ac = bc ++ ab


_++_ : ∀ {inp mid out} ! Term mid out ! Term inp mid ! Term inp out[] ++ ys = ys(x ∷ xs) ++ ys = x ∷ (xs ++ ys)


split

0truetruenot22

and1

=1

0truetruenotand



bc++ab : Split 2 acbc++ab = bc ++' ab


data Split {inp out} mid : Term inp out ! Set where _++'_ : (xs : Term mid out) (ys : Term inp mid) ! Split mid (xs ++ ys)



bc++ab : Split 2 acbc++ab = proj₂ (split 1 ac)



bc++ab : Σ ℕ λ mid ! Split mid acbc++ab = split 1 ac


split : ∀ {inp out} (n : ℕ) (xs : Term inp out) ! Σ ℕ λ mid ! Split mid xssplit zero xs = _ , [] ++' xssplit (suc n) [] = _ , [] ++' []split (suc n) (x ∷ xs) with split n xssplit (suc n) (x ∷ .(xs ++ ys)) | _ , xs ++' ys = _ , (x ∷ xs) ++' ys


Evaluation Function



eval-bc : Vec Bool 1eval-bc = eval bc (true ∷ false ∷ [])


eval-ac : Vec Bool 1eval-ac = eval ac []


eval : {inp out : ℕ} ! Term inp out ! Vec Bool inp ! Vec Bool outeval [] is = iseval (true ∷ xs) is = true ∷ eval xs iseval (not ∷ xs) is with eval xs is... | o ∷ os = ¬ o ∷ oseval (and ∷ xs) is with eval xs is... | o₂ ∷ o₁ ∷ os = (o₁ ∧ o₂) ∷ os


score : Term 0 1 ! ℕscore xs with eval xs []... | true ∷ [] = 0... | false ∷ [] = 1

open Evolution score


Initialization Procedure


choices : List Wordchoices = true ∷ not ∷ and ∷ []

population : List (Term 0 1)population = init 2 0 1 choices -- (and ∷ true ∷ true ∷ []) ∷ -- (not ∷ not ∷ true ∷ []) ∷ -- (not ∷ true ∷ []) ∷ -- (true ∷ []) ∷ -- []


-- data Term (inp : ℕ) : ℕ ! Set where-- _∷_ : ∀ {n} (w : Word) !-- Term inp (pre w n) !-- Term inp (post w n)-- pre : Word ! ℕ ! ℕ-- pre and n = 2 + n

true∷true : Term 0 2true∷true = true ∷ true ∷ []

and∷and∷true : Term 0 1and∷and∷true = _∷_ {n = 0} and true∷true


match : (w : Word) (out : ℕ) ! Dec (Σ ℕ λ n ! out ≡ pre w n)match true n = yes (n , refl)match not zero = no ¬p where ¬p : Σ ℕ (λ n ! 0 ≡ suc n) ! ⊥ ¬p (_ , ())match not (suc n) = yes (n , refl)


match and zero = no ¬p where ¬p : Σ ℕ (λ n ! 0 ≡ suc (suc n)) ! ⊥ ¬p (_ , ())match and (suc zero) = no ¬p where ¬p : Σ ℕ (λ n ! 1 ≡ suc (suc n)) ! ⊥ ¬p (_ , ())match and (suc (suc n)) = yes (n , refl)

open Initialization match


Generalization


module DTGP {Domain Word : Set} (pre post : Word ! Domain ! Domain) (_≟_ : (x y : Domain) ! Dec (x ≡ y))where

data Term (inp : Domain) : Domain ! Set where [] : Term inp inp

_∷_ : ∀ {d} (w : Word) ! Term inp (pre w d) ! Term inp (post w d)


data Word : Set where not gt : Word num : ℕ ! Word

record Domain : Set where constructor _,_ field bools : ℕ nats : ℕ

postulate _≟_ : (x y : Domain) ! Dec (x ≡ y)


pre : Word ! Domain ! Domainpre not (m , n) = 1 + m , npre (num _) (m , n) = m , npre gt (m , n) = m , 2 + n

post : Word ! Domain ! Domainpost not (m , n) = 1 + m , npost (num _) (m , n) = m , 1 + npost gt (m , n) = 1 + m , n

open DTGP pre post _≟_


bc : Term (0 , 2) (1 , 0)bc = not ∷ gt ∷ []

ab : Term (0 , 0) (0 , 2)ab = num 3 ∷ num 5 ∷ []

ac : Term (0 , 0) (1 , 0)ac = bc ++ ab


FINgithub.com/larrytheliquid/dtgp/tree/aaip11

questions?


dtgp aaip11

Technology