Posted: Jan 26, 2016 1:41 pm
by John Platko
As I was reading David Deutsch's paper on Constructor theory the concept of programmable constructors vs non programmable constructors got me thinking. (An example of a non programmable constructor is a catalyst of a chemical reaction.) Now from one perspective, my lick constructor, which is composed of many sub constructors is in a sense programmable- i.e. I did program all sub constructors, however from another perspective, once programed and launched they just do what they do, in that sense they are as fixed as the catalyst. All this, and the need for a good way to make a hot rhythm constructor got me thinking about self programed constructors. i.e. a constructor that learns to make transformations by observing what transformations occur.

I won't go into all the details but I built a constructor that can learn from watching trial and error mutations what transformations a given lick (or a lick with similar characteristics) can undergo. And this self learning programmable constructor, once it has learned that lick A has a mutation path : A->B->C->D also knows that A->D, and B->D. And this smart constructor can make these transformations with foreknowledge, which is very different than how my other constructors work. Also, while it was learning about possible transformations, it learns about the characteristics of the resulting lick. i.e., it's various entropy metrics, etc.. So a smart constructor like this doesn't have to just produce a random mutation but can attempt to create a mutation with certain characteristics. And it can learn other things while it's at it. For example, by collecting sets of notes used in licks and remembering how sweet and sour they are, it can fulfill a request for a lick with a certain sweet and sourness.

It's like this: at the start, LickMaker is like a child playing with blocks and by trial and error building what he can build with them. But soon the child learns what he can build and then can build some things from experience. With smart programmable constructors, LickMaker can learn from experience and acquire a lot of knowledge about how a given lick can be transformed and that gives it another level of capability.

All of this raises all kinds of interesting questions about how much time LickMaker spends learning about the transformations it makes by trial an error and how much time it spends evolving licks. And what licks does it learn about, and when does it learn about them ...

For now I'm going to keep things fairly simple and see what I can learn from my self learning, self programmed, hot rhythm constructor.