Author Archives: ob08

22 July 2014


Lee, Thom, Bill, Karthik, Tim, Wren, Omri (scribe)


New CS hire for grant administration stuff: Lisa Karlin (things that used to go to Jean should go to Lisa)

Dartmouth trip next Monday, involves

  • A PhD defense that has to do with evolution and networks, public defense 10-11AM
  • A possible meeting with Jason Moore’s research group (studying GP and genetics, among other things), sometime between 1-3PM
  • Lee is giving a seminar from 3-4PM (“Expressive Program Evolution”)

Currently this week, Lee is participating in a(n awesome) workshop on open-ended evolutionary computation with Wolfgang Banzhaf and Susan Stepny (in Newfoundland, via Skype)

Plush woes

Plush programs are getting really big. Why? We don’t know, and it’s quite a problem.

Lexicase paper

Due August 6th

Thom will be back from Florida August 1s with revisions

Lee will have time to review and write a letter

Semantic distance

Karthik queries: how do you measure semantic distance in GP?

Maybe base it off of constraints?

Hard problem!

Next week

Meeting at regular time and place, i.e. ASH Conference Room 9:15-10:30AM (Tues July 29th)

People planning to go to Dartmouth

Get to Lee’s house at 7:30 on Monday (July 28)!

17 June 2014


Lance, Lee, Thom, Bill, Tim, Omri (scribe)


August 12 & 19 no meetings

Lee will be submitting to Templeton for a grant (origins of life, adaptive complexity stuff)

Lee: contact Bill Tozier about visit

Dartmouth trip–anybody who wants to go is welcome


  • Bill and Lee have to make posters
  • Practice presentations
    • July 1 for Thom
    • Frode? (somebody should email him)
      • should send us his slides by July 1
      • maybe he could record a video that we could watch?


Lance is here for the year!

He’s very interested in the origins of adaptive complexity, and specifically finds reified autoconstruction a promising line

We discussed VM resource management and arbitrary code generation


Is anybody willing to maintain/re-build the lab website?

  • Add python push link
  • Include more publications
  • Fix things (such as broken link to my own paper)

Apparently it’s Omri’s job now (despite his rejection of it)!

27 May 2014


Lee, Thom, Bill, George, Karthik, Omri (scribe)


Less than 2000 problem is important–why isn’t it easy?

Thom has no time


Bill has set up lexicase in his system

Quantum stuff

George to work on minimal evoluationary loop:
1. Get comfortable with ClojureScript workflow
2. Manually try out some qgame programs
3. Generate random qgame programs
4. Very simple selection/reproduction

TDS paper discussion

  • Can solve some pretty hard problems, but runs into an “exponential wall”–maybe GP could be really useful here
  • Perhaps we should we write to the authors about non-binary test cases in GP (something they seem to have overlooked)
  • Case order is manually optimized, whereas in lexicase order is randomized for each evaluation
  • Raises the question: how do we deal with large numbers–potentially infinite–test cases?
  • Their method has difficulty with arbitrary structure and instructions


There may be a workshop in Newfoundland with Wolfgang

16 April 2014


Lee, Thom, Karthik, Bill, Jake, Frode, Kwaku, Omri (scribe)


Lee, Thom, Karthik, and Bill are going. They will be collaborating with Moshe.

A little unsure what we’re doing with the Analyzing HUMIEs paper.


Frode got his paper accepted to the Undergraduate Workshop at GECCO (yay!), with a revision suggestion that he do runs on additional problems.

Moshe will not be going but someone in his lab will be. So we will use GECCO for collaboration.


We discussed Bill’s PhD application, and the arguments around its significance.

19 February 2014


Lee, Thom, Bill, Jake, Frode, Omri (scribe)


We should reconsider meeting time. Lee, send out an email about this.

Next Friday is international Moshe Sipper Day. Possibly no meeting Wednesday, to be replaced by the Friday meeting with Moshe.

Homework: review the past winners of the humies, prior to the Friday meeting.

Maybe Omri will try to digitize the Koza GP VHSs.

Frode: NOOP experiments

  • Is this a good idea in the first place?
  • How to decide when to remove an instruction that NOOPs?
  • How to remove an instruction that NOOPs?
  • Maybe think in terms of simplification in general, instead of NOOP removal in particular?

Omri: qgame and qromp

  • qgame exists as a ClojureScript library now
  • What about Clojure integration (in addition to ClojureScript)?
  • Possible demo of ClojureScript usage in general, as well as qromp, next meeting

Thom’s stuff

  • ‘ultra-padding’ and ‘()’ padding seem to have the same effects
  • Problems with git and Windows line endings

Bill’s stuff

  • Working on python stuff
  • Read an interesting article about ALPS
  • Giving a talk tomorrow

Jake: Push visualizer

  • Getting back into the swing of things
  • Push program visualizer webapp is coming along
  • Possible demo next meeting

Linear push discussion

  • Baked-in metadata or ‘end’s as code?
    • Baked-in metadata: how to evolve where/how ends/starts exist?
    • ‘end’s as code: how to deal with nesting? How to deal with tagging?
  • Compile to parens program or parse at runtime?
    • Compile to parens: speed for multiple evaluations of a program, separation of genome from execution, minimal changes to existing Push interpreter
    • Parse at runtime: only one Push program representation

15 January 2014


Tom, Omri, Bill, Karthik (scribe)

Administrative stuff

Meeting times – Wednesdays 10-12 Starting 22nd January 2014
29th – GECCO deadline.

ULTRA stuff

Bug with ULTRA-padding and push simplification fixed.
Single symbol program issues.
Potentially solve with making all programs sequences.
Single instruction to ULTRA where ULTRA does nothing. #New issue

Push Licensing

Push licensing currently unresolved.
The Eclipse Public License ? The one Clojure uses for now.

GECCO paper stuff

– Differential equations
– Word count
– Push simplification
– (Abstract on calc)
– Finite algebras
Random stuff : Source code addition to GECCO ? Anonymous everything – tricky.
Fischer’s exact test – potential statistical significance test.
Justifications for why some particular statistics were used.
Program self reference interference with simplification.


Searching for Quantum algorithms to use GP on. Qgame used? Possibly depends on the need for complex numbers.


Lexicase + GSX. Lexicase currently done without push. Possible extension of some GSX stuff to also use Lexicase.

Calc problem updates

Complimentary mate selection.
Reversed lexicase selection.
Errors, Pass/Fail, and Novelty
The Genetics : Recombination for correct functionality.
Tag modifications for combining functionality correctly ?
Small deviations vs Large deviations with ULTRA.
ULTRA causing program size to increase because of the program size average

Clojush simplifcation

Simplifcation at the end of the run
Simplification for reporting
Simplification during run – where simplification is a genetic operator. (Messy courtesy fitness evaluation being built IN to a genetic operator)


Different differential equation models.
“Non inheritable epigenesis”
Hill climbing and improvement.
Eventual plan to shift away from MATLAB to write code.

More random stuff

Turing completeness vs non turing complete languages for evolution.
Generative testing + Lexicase selection.

8 January 2014


Lee, Thom, Bill, Karthik, Omri (scribe)

Spring meeting time

Provisionally Wednesdays 10-12am (Karthik will vid-chat in for half of it)

Starting with January 22nd


Abstract deadline January 15th

Paper deadline January 29th

Workshop paper deadline sometime in March maybe

Finite algebra paper

Lee is working on this with David Clark and Maarten Keijzer

Maarten has come up with an awesome algorithm, but it is domain specific

On the calculator problem

Lee has been trying or thinking about a bunch of new things…

  • Augmentive test cases
  • Complementary lexicase selection (opposites attract)
  • Concatenative tagging
  • Maybe pass/fail?
  • Maybe novelty search?
  • How do we ensure generalization?

…But nothing seems to be working

Thom’s update

On the word count problem paper…

  • General solutions greater than 0 and less than 10 percent of the time, independent of parameters
  • What statistics to use? Maybe Fisher’s Exact Test? Maybe look at Luke’s Meta-heuristics book, the chapter on stats?

On the auto-simplification paper…

  • To what extent does is hill-climbing program simplification effective?
  • Which problems: Pagie-1? Digital multiplier? WC? Odd?

Karthik’s update

He’s very interested in satisfiability module theory

Looking into Z3 (from Microsoft)

Thinking about combining GSX and lexicase

Next meeting

Friday January 17th 10-12am

11 December 2013


Lee, Tom, Frode, Kwaku, Karthik, Eddie, Omri (scribe)


Lee: send out a CI Lab email about Zeke’s webgp thing

GECCO deadlines: Jan. 15th for abstracts, 29th for papers, and they seem very serious about sticking to these deadlines

Administrative stuff

There will probably be a meeting next Wednesday, regular time, last of the semester

Proposed Clojush changes

All println calls to prn

Option to report percent of parens in a given program or population

Separate out “report-best”, so that it can be independent from “fitness”


It works (yay!)

Some of the syntax is different

Next steps are to include tags and/or any kind of genetic programming functionality

Lee recommends aiming to make it usable for next semester’s Genetic Programming students

Clojush documentation

Frode has been working on this, with a lot of good documentation and tutorials that can be seen in the Clojush wiki

Lee is unsure where we should go from here: where to host documentation and tutorials of Clojush and/or of Push in general

Evolving GUIs and “reactive” Push REPL

Frode has been thinking about doing experiments related to both of these

Lee pointed out that these are separable projects, and that one possible off-shoot is to look into some Excel/Clojush integration

Parameter tweaking in evolutionary runs

Bill has been trying to solve a harmonic oscillation problem

He has a number of interesting non-standard genetic operators that he’s been working with, and is having difficulty knowing/finding the right parameters

Lee suggested taking a step back and trying more standard genetic operators, and also just “seeing what works”


Karthik would like to do some experiments here, possibly related to the calculator problem

Lee described a lot of recent efforts around automatic modularity, and the various issues surrounding modularity in general

Kwaku has been working on identifying modularity at run-time, hoping to find good metrics for modularity in arbitrary programs (which reminds Lee of some old experiments testing the “compressibility” of execution traces in Push programs)

Word count problem

Thom thinks he’s recently come upon some general solutions to the word count problem (yay!)

Training cases and test cases

Tom’s using training AND test cases, where training cases are seen during evolution, and test cases are only used to test the generality of solutions that arise from the evolutionary loop

Lee has a sort of rotating-auto-generation training case thing, but notes that he doesn’t know what’s going on between generations because of the set of cases shifting under his feet

Tom suggests making one large auto-generated list of cases, choosing a random subset for evolutionary selection, and using the whole thing for comparing different generations

Non-elite lexicase

Lexicase seems to have issues with errors measured in floating point, because selection here will be too elite

So Tom has been experimenting with a non-elite lexicase based on relative ranking (“ranked lexicase”): notably, on the bioavailability problem, it was better than normal lexicase, but equal to standard tournament selection


There is now a working qgame API, and a GUI in the works

13 November 2013


Lee, Tom, Frode, Kwaku, Karthik, Omri (scribe)

Events & news

New web framework for Clojure, Caribou, may be exciting.

We have missing notes from October 23rd…anybody have those to post?

The standalone counterclockwise is weird but still maybe what we should generally use by default.

Biomath event next Wednesday, November 20th. Among others, Lee and Omri will be presenting.


Multiplicative (as opposed to additive) fitness is an interesting idea! It is widely used in biological evolutionary simulations, and it could have useful implications for our problems.

On Push forth, Kwaku and Omri defended some of its virtues, while Lee and Tom took more neutral or critical stances. Ultimately, we decided that although it may have interesting features that are of potential use, none of them have any meaningful bearing on current projects, so it makes no sense to shift gears at this point.

We had a productive start of a discussion on linear GP and more specifically linear Push. The only opinions voiced were in favor. So while it looks promising, we will need to continue this discussion next week.

25 September 2013


Lee, Tom, Bill, Omri (scribe), Kwaku, Jake, George

Grants, collaborations, visits

We have funding for collaborative projects aiming at human-competitive GP with Moshe Sipper (and his group) over at Ben-Gurion University. The funding alots for travel expenses for quite a few round trips to Israel. We should keep this opportunity in mind.

Lee will also be applying for Templeton funding for looking at “big” questions about life and its origins. Ventpods may come into play here.

Chris and Conner will be coming to visit sometime in the upcoming weeks. They will join for a research group meeting, and Lee may also try to set up a time and place for them to give a talk.

Status updates and such

Tom’s been working with the coin problem, and clojush doesn’t require anything beyond integer instructions to find a solution. So, it may not be quite the right problem for trying to get at “replacing the programmer”. Either way, now it’s an example problem in clojush.

Tom has also done some tests with “bagging” (ensemble voting) and it doesn’t look promising.

Jake’s been working on brevis with Kyle, and there will be a demo next week!

Omri has been looking into SIMD integer factorization algorithms.

Lee has been doing experimenting with “bushy” or “deep” program generation, and also experimenting with increasing no-op usage in the calculator problem.

Possible threads to follow

Evolving SIMD parallel algorithms.

Analyzing why no-ops seem to help the evolutionary dynamics in the calculator problem. More generally, considering experiments with adaptive representations.

Generating random code shapes.

Linear Push, some ideas for how to maintain recursion and expressive “chunking of stuff”:

  • instructions with “baked-in” arguments
  • instructions with structural taken from the stack like regular arguments
  • some instructions scan for keywords like “end”
  • some instructions scan for patterns
  • make the execution environment dense with tags
  • revisit tag space machines
  • incorporate GOTOs
  • recursion through environments

New ways to deal with parentheses and mutation in ULTRA:

  • no mutation
  • no mutation of parentheses (including no ability for things to mutate into parentheses)

Reading for next week

Maarten Keijzer’s Push-forth paper.

Library of Babel by Borges.