Archive for the ‘Uncategorized’ Category

Rewilding as the logical outcome of civilisation

March 18, 2018

I believe that a truly advanced civilisation should not be visible within the confines of an biosphere, at least per a modern human’s perception.

Consider human civilisation – from hominids roaming Europe, Asia and Africa hundreds of thousands of years ago, with modern-ish humans emerging about 100 thousand years ago, and modern humans about 20.  The first small agricultural communities, perhaps 10 to 15 thousand years ago.  The first cities and empires, 5 thousand years ago.  Industrialisation, about 300 years ago.

If risks are managed sensibly, I see that a logical steady state approach would be to seek not to over-extend use of resources, and restore if possible pre-existing ecosystems, or create new ones.

Likely, as with the move to cities, our descendants may likely move to city memory and only ‘avatar’ to one or multiple cyborg bodies if and when required.  Consequently, although cities may have several orders of magnitude more inhabitants, performing at a cognitive and intellectual level far beyond modern humans, their experiences and chosen interfaces will largely be virtual or simulated.  Moreover, such cities could essentially be much more compact than modern cities, as they would essentially be server farms with robotic maintenance infrastructure.  These might run on nuclear fusion or casimir pumps.

For reasons of ecotourism and keeping things tidy and ordered, such future civilisations spanning the globe and solar system may decide to let nature reclaim the large tracts of land previously given over to agriculture and more primitive infrastructure, in an ordered but apparently chaotic fashion.  This principle of ecological custodianship would possibly also seek to revive extinct species by first principles, or construct new ones if and as required to fill ecological niches and improve the aesthetic of the apparently wilder world.

Tunnels through space may well be constructed to transport the few goods and resources required for maintenance, obviating the need for traditional shipping (road, freight and rail).  Hence these could be left to decay and return to the wilds, or even deliberately dismantled.

Eventually a machine civilisation with citizens in city memory could potentially surgere off miniature pockets of reality for use, connected by one or multiple small umbilicals to base reality.  It seems likely at said point that at this stage Contact may well have been attained, and this civilisation would no longer be bound to the confines of our Solar System.  On Earth, devices to maintain said umbilicals would not need to be as large as the server farms running the prior cities.   Casimir pumps or more advanced forms of energy production would be consumed to power the civilisation.  Populations would continue to increase by several orders of magnitude over the previous machine civilisation, however the maintenance infrastructure and much of the relics of the machine civilisation would not be required.  Custodianship processes could accelerate, and managed gardening of the world by a branch of some part of the future government might pick up.  Apparent chaos would continue to increase.  Pocket universes with recreations of old cities might be generated for avatar tourism.

Miniaturisation and abstraction of umbilicals would continue.  Eventually, all interfaces between the base reality and said future civilisation would be essentially invisible to a modern human eye.  The entire planet would contain only the relics of prior settlement that the civilisation wished to leave or preserve.  Any copies for archaeological purposes would have long since been backed up at various levels of abstraction or recreated in pocket universes that might be smaller or larger than the base.  Everything else would be restored and wild.  Atmospheric gas concentrations would be carefully balanced, and ecosystems would be designed to be as stable as possible with negligible intervention.

Consequently if a modern human were to step into a time machine and emerge on Earth say at some sufficiently distant point in the future (700 years?  1500 years?) they could well see no sign of civilisation at all.  However, it would be there, running at a level of sophistication and subtlety well beyond the wildest predictions of such writers as H.G. Wells.


Various Projects, Status & Rundown

February 27, 2018

Here is a brain dump of my various projects, and progress to date on them.

Unity 3D game

  • I was enthused to learn that Unity-Technologies have taken over development of GILES as of 12 days ago (which was originally a ProCore3D project), here: .  I have updated my copy of GILES to run against Unity 2017.3.1
  • I have been furthermore encouraged to learn that per that BoltEngine is now almost up to speed with the latest Unity, and that there will be a Sample Pack released soon (which should make my job of adapting the tech to my purposes simpler).

Phoenix/Elixir app

  • I have started playing around with Phoenix.  My current goal is to build a scaffold for an app where users can submit billboards, with topics, with posts, with attachments.  The data layout for this has largely been done and instantiated via ecto/postgres.  Hopefully I can progress this further by building out the controllers and the views over the next month or two.

Facebook events app

  • I have been spending some time learning a bit about android, in particular, Facebook app development.  My goal is to build an app that can query the graph api, and only extract and present data to me that I care about from Facebook.  This will have a couple of benefits to me – 1, that Facebook will become useful to me again, and 2, it will provide me with practical knowledge in terms of building Facebook apps.
  • Currently I have built a normal Android app, as well as a Facebook app placeholder.  However I am finding that there is a namespace conflict between the two apps; likely I will need to start a new project from scratch, rather than copying and then editing the namespace by hand.  Also, I intend to remove the need to ask for permissions from the app; I dislike apps that ask for permissions they do not need.

Machine learning reading and education

  • I’m currently reading the very approachable Introduction to Statistical Learning (, and doing the exercises in R.  My goal is to work my way through this book, and make a start on Elements of Statistical Learning, before looking into potentially undertaking a microdegree or two later this year.

Language Learning

  • I’ve been trying to learn a bit of French by working my way through the Michel Thomas course on same.  I’ve worked my way through the audio course once now; I will aim to work my way through it one or two more times before the end of the year.
  • I’m thinking of learning a bit of German the same way, with the sibling Michel Thomas course.
  • My goal by the end of 2019 is to be able to read Le Monde to a degree ( as well as Der Spiegel (

Research project, arithmetic topology

  • Preliminary progress has been made.  This is largely on the backburner for now, but I should probably make a bit of an effort to properly write up what I have at some point.

Vertical farming: practical with fusion power

September 17, 2017

Vertical farming has the potential to provide a number of advantages over conventional farming:

  • Cut down on supply chain costs
  • More efficient use of land
  • Rewilding of large amounts of wilderness outside of cities
  • Fresher produce more readily available

However, there is a bit of a problem – the energy expenditure required to make it practical renders it more expensive to grow crops in skyscrapers, both economically and environmentally, than conventional farming.  Wheat requires a large amount of energy to grow, as do legumes.

However, if, with any luck, we have the ability to construct workable nuclear fusion power plants by 2030, the nature of the game changes, as we would have readily available much cheaper, cleaner energy than through other power sources (with the exception of the Sun, which is also, of course, providing energy emitted by nuclear fusion).

If such does become practicable, large amounts of existing land given over to farming could be returned to the wild, and established as national parks and nature reserves.  This would be greatly useful, as it would allow us to allow the lungs of the world to regenerate, as well as providing large areas for ecotourism for city dwellers to appreciate on a more primal level.

Management of the cutover from large scale agricultural operations to vertical farming would be likely to take decades, but I could imagine that by 2070 or 2080 it should be possible to return a fair amount of land to the wild.

Consider not what is lost, but what is GAN

July 7, 2017

A generative adversarial network is a set of two neural networks competing against one another in a zero sum game (todo: consider game theoretic implications).  Classically one is a generator, and one is a discriminator.  The generator tries to fool the discriminator.  However this situation can become unstable and the algorithm can fail to converge to interpret / generate digits, say.

There is another recent paper on cliques of neurons and their role in consciousness, a paper that draws links between algebraic topology and intelligence.  In particular, it indicates that there are stratified layers of sets of neurons that can be up to 11 strata deep.

So the question I pose is twofold: one, is there a way to avoid instability in a classical GAN and also extend it to broader classes of problems; and two, can we consider the latter paper’s analogue in AI to be stratified layers of sets of neurons in an underlying ‘space’ of potential usable neurons, that can be up to 11 strata deep, and which can be created, read, updated and destroyed, as time buckets continue?  Maybe we could implement using dind (docker in docker).  All sorts of possibilities.

I think this broader idea of ‘GAN’ would be useful, as it would allow us to remove neuron sets that are underperforming / have become unstable, and also allow for new models to arise in a Conways Game of Life fashion out of the morass.

But how do we measure, how do we update, what data are we measuring against?  All excellent questions.

Perhaps then we need to consider the set of possible usable neurons as living in a module that has an input (a set of performance measures at time step T) and an output (a set of the same performance measures at time step T+1).  Based on this difference we can apply a feedback loop to the universe of inputs.  Maybe we output the algebraic structure of the set of adversarial subnets in the universal net as a json object say (with the model parameters included eg matrix representations etc, so

{json(T)} as input, and {json(T+1)} as output

where some nodes from the json file might be removed, and others added.

eg. { {{ [network including 2 sets of 4 nodes, 2 layers deep], A_ij }, { [network including 3 sets of 3 nodes, 3 layers deep], B_ij } }, { [network with 2 x 4 nodes ], D_ij } }(T)

{ { [ network including 2 sets of 4 nodes, 2 layers deep ], A_ij }, { [network including 3 sets of 2 nodes, 3 layers deep], C_ij } }(T+1).

One could have any sort of network within the universal neural space, eg a CNN, an ordinary hidden markov model, etc.

So we have a big box, with json objects and current training parameters of same being spat in and out of the box.

The training parameters of the transient submodels could then be placed inside some form of distance measure relative to the problem we are optimising for (i.e., relative to one’s timeboxed dataset or evolving input).  It strikes me that this sort of approach, although difficult to implement, could potentially lead to applications much more wideranging than image manipulation.

A further generalisation would be to allow the model to create an output timeboxed dataset, and allow that to form an extrapolation of previous input or data.  This sort of approach might be useful, for instance, for performing fairly demanding creative work.  One would naturally of course need to seed the task with an appropriate starting point, say a collection of ‘thoughts’ (or rather their network representation) inhabiting a network of cliques in the universal neural lattice.


The current state of open source AI

July 2, 2017

I recently discovered the company OpenAI, which has a significant endowment, and has a couple of notable projects that enable work on training / testing AI algorithms.  In particular, these projects are Gym ( and Universe (  Gym is based on this paper ( which is essentially a toolkit for benchmarking the performance of various AI algorithms in reinforcement learning.  From the project page:

gym makes no assumptions about the structure of your agent, and is compatible with any numerical computation library, such as TensorFlow or Theano.

Universe fits in with Gym, in that Gym provides the interface to Universe, which provides an AI algorithm with an environment within which to train.  An example of this is given on the project page, which essentially demonstrates use of Universe and Gym to test an agent running the game DuskDrive in a Docker container:

import gym
import universe  # register the universe environments

env = gym.make('flashgames.DuskDrive-v0')
env.configure(remotes=1)  # automatically creates a local docker container
observation_n = env.reset()

while True:
  action_n = [[('KeyEvent', 'ArrowUp', True)] for ob in observation_n]  # your agent here
  observation_n, reward_n, done_n, info = env.step(action_n)

Evidently this is potentially quite powerful.  Indeed, from the main promotional page for universe (, apparently there are already more than 1000 environments to test / train learning agents against, which apparently many many more in the works.

To get started, one could use the openai code in the projects or, however, those with a more sophisticated bent might instead be interested in investigating DeepMind’s project, which makes use of Google Tensorflow and DeepMind Sonnet (  Sonnet is a Tensorflow neural network library.

Towards increasingly unorthodox approaches, I think it would be fascinating to watch the space around the development of algorithms to take advantage of the architecture of IBM’s neuromorphic chips (based I believe on Field Programmable Gate Arrays), or looking a bit further out, towards the opportunities based in machine learning associated to Topological Quantum Computers (Majorana fermion based), and possibly same with a slight Qudit boost (hybrid/pseudo tetracomputer, maybe with switches consisting up to a 100 states).

I will continue to follow developments in this area with some interest.

Cryptography in the Quantum Computing Age

June 16, 2017

There is a problem with much of modern internet communications at the moment.  The problem is that the security of same relies on factoring being hard.  And, this is the case for a conventional computing machine.  However, for a quantum computer, such as may become available to corporations and governments within the next 5 to 10 years, it will be easy.

So this necessitates the need for a ‘refresh’ of the algorithms maintaining internet security.  So, how can we do this?

How RSA works

Well, recall the following about how RSA works (from the wikipedia entry):

  • Take two very large primes (100s of digits long) and multiply them together.   (n = pq, p and q prime).
  • Compute h = lcm(p – 1, q – 1)  (this is easy via the Euclidean algorithm, as lcm(a, b) = ab/gcd(a, b) ).
  • Choose e st e < h and gcd(e, h) = 1 (again, easy via the Euclidean algorithm).
  • Determine d st ed = 1 (mod h)  [ so that d is the modular multiplicative inverse of e ]
  • e is then the public key.  n is also released as public.
  • d is the private key.

Encryption process:

  • Bob obtain’s Alice’s public key e.  With a message M, he converts it into an integer m.  Then he computes c = m^e (mod n)

Decryption process:

  • Alice obtains Bob’s message c, and decrypts it as c^d = (m^e)^d = m (mod n)
  • Then m -> M is easy if the padding scheme is known.

The Achilles heel exposed by a quantum computer

The main point about the above that makes RSA hard to break is that factorisation is hard.  But, if factorisation is easy, Jill can intercept Bob’s ciphertext c, and, given her knowledge of n and e (which are public), factor n to p and q, compute h, and then identify d as the multiplicative inverse of e mod h.

Consequent to this, she can then decrypt Alice’s message as above.

So, if factorisation is easy, RSA is in a bit of a pickle.  But is there a better way to encrypt?

RSA over an integer polynomial ring


  • Take two very large irreducible polynomials over the integer polynomial ring Z[x] (100s of tuples long) and multiply them together.   nb. for extra security, you may want to ensure that the coefficients of these polynomials are each at least 100 digits long. (n[x] = p[x]q[x], p[x] and q[x] prime).
  • Compute h[x] = lcm(p – 1, q – 1)  (this is easy via the Euclidean algorithm for integer valued polynomials, as lcm(a, b) = ab/gcd(a, b)).
  • Choose e st e < h and gcd(e, h) = 1 (again, easy via the Euclidean algorithm).
  • Determine d[x] st e[x]d[x] = 1 (mod h[x])  [ so that d is the modular multiplicative inverse of e ]
    • Note: This is hard, unless factorisation is easy.
  • e is then the public key.  n is also released as public.
  • d is the private key.

Encryption process:

  • Bob obtain’s Alice’s public key e.  With a message M, he converts it into an integer m.  Then he computes c = m^e (mod n)

Decryption process:

  • Alice obtains Bob’s message c, and decrypts it as c^d = (m^e)^d = m (mod n)
  • Then m -> M is easy if the padding scheme is known.

Is this vulnerable to attack by a Quantum Computer eavesdropping on a channel carrying an encrypted message?

I claim not, as the size of the set of irreducible (prime) polynomials over the integer ring is much bigger than the set of primes.  The cardinality might be the same, but the complexity just seems intuitively to be much greater to me.  Factorising a semi-prime polynomial, which as factors has prime polynomials with possibly 100 or 200 terms, each with coefficients up to 150 digits in length, is, I suspect, much much more difficult than factorising a semi-prime integer.

If one had a tetra-computer (“hyper-computer”), the story might be different, but I suspect we will not have sufficiently powerful variants of those until 2050.

Towards zero latency – improved communications, coming soon to you

June 16, 2017

This recent press release got me thinking about how a quantum internet might work.  In particular, one question an observer might ask is, why do we need entanglement to transmit information?

The answer is that the ‘speed of entanglement’ is fast.  It is at least 10000 times faster than the speed of light.  Possibly the square of the speed of light.  It is quick.  But, you say, can’t I communicate quite rapidly anyway from one side of the world to the other?  Yes, but there is latency.

The bane of latency

Latency is a problem in internet communications today.  This problem is felt most acutely when attempting high bandwidth communications that require near instantaneous feedback.  And a key medium (and one of the first mediums to adopt the new technologies that consume all the bandwidth, like VR) is gaming.

Gaming where the data centre is located in another country can be a very frustrating experience.  That is where entangled communications excel.  Additionally, entangled communications have the promise of increasing bandwidth drastically, from megabits per second, to gigabits, or even terabits per second.

Entanglement is useful

By entangling a medium of communication, such as photons, and then separating same, it is possible to transmit data very quickly, and very rapidly.  However, there are a couple of obvious problems:

  • How does one ‘recharge’ one’s entanglement capacity at each network node to service the required / anticipated bandwidth?, and
  • How does one ensure one has enough bandwidth for these communications?

These are interesting questions.  Certainly, it seems intuitively reasonable that with a first pass quantum internet, at best the rate of recharge of entanglement would at best be limited by:

  • The speed of light for transportation of entangled pairs from a source; and
  • The amount of energy consumed in creating entangled pairs

Resolution of the problems

However, it does not seem unreasonable that the amount of energy required to create an entangled pair could be relatively low and fairly cheap, economically.  Which leads the matter of transporting this ‘data energy’ to where it needs to be consumed.  This is a problem that would necessitate not just distributing data energy to a single point, but rather a 2-tuple of points.  But this should be possible eg with photons, as one could use optimal waveguides to transmit them to storage at particular centres, to administer 2 to 3 times the anticipated capacity in time bucket N say between nodes K1 and K2, with redundancy a function of the amount of funding the market between K1 and K2 is willing to pay, and reliability – that is, the duration of the entanglement – also a function of same.

Ensuring duration of reservoir of entangled pairs between nodes K1 and K2

Assuming that one has transmitted entangled information between nodes K1 and K2 to said nodes respectively, it should be possible to have error correction operating at both ends to ensure the integrity of the entangled state of the ‘data energy’.  This will require an input of first order energy in order to do this, at both nodes K1 and K2.  As to details of implementation, I am not sure, but I do know that this is likely something that has likely been already subject to exhaustive study (integrity of entangled information, that is).

Concluding thoughts

This theorycraft sketch of a quantum internet still necessitates that ‘data energy’, the backbone of same, be limited in terms of transmission by the speed of light.  But this is not such a bad thing, as long as one can anticipate demand in advance.  For example, in the energy markets, one often has to plan in advance how much energy people in a particular location at a particular time will want to use.  If there is not enough, there will be blackouts.  The equivalent in the quantum internet could be fallback to the regular internet.  But, hey.  At least things would still work.  Sort of.

Experiments with APIs: a CFA fire alerts app

March 13, 2017


Over the last couple of days I thought it might be interesting to investigate writing a prototype CFA fire alerts app.  The key motivation of this was essentially the pursuit of simplicity.  Emergency Victoria do happen to have an alerts app, but it contains a plethora of different calls to various different RSS feeds and other APIs, and is not just a way for people to be notified regarding CFA fire alerts.

The CFA used to have an older app, in fact, but it was decommissioned in favour of the “improved” and more general app.

So I decided to look into trying to build my own over the last couple of days, this Labour Day weekend.

Ultimately, I was successful in my goal of building a prototype.  Essentially I built an app in Unity that I was able to compile and deploy to my android phone.  It displays a map centered on hard-coded latitude and longitude coordinates, and places a black pin anywhere on that map corresponding to a flammables related incident that the app considers to be interesting.  Also it only does this once; there is no refresh option, no buttons to push.  Very simple and utilitarian.  But a good proof of concept.


Getting the data

So how did I go about building the app?  Well, first I worked out how to get the xml file located here:, by making a C# request using Unity libraries.

Processing the data

Secondly, I deserialised that xml object into a list of incidents.

Next, I extracted all of the information from the description attribute: an additional 13 fields.

Obtaining the interesting information within the data

Consequent to this, I used my google and script-kiddie abilities to graft on some code to my project that could convert two pairs of (latitude, longitude) coordinates into a relative distance.

After that, I wrote a filter to determine what constituted an “interesting” fire: that being sufficiently close to a particular pair of hard-coded coordinates, and also with the additional qualities that the fire was not small, and not under control.

Debugging statements and breakpoints helped tremendously throughout this process.

Displaying the information to the user

So that allowed me to determine what was interesting.  But that left one final thing, figuring out how to display that to the user.

Fortunately, there was a plugin on the Unity App Store I was able to download for free, for the google static maps api.  With additional code-kinder knowhow, I was able to adapt the out of date code therein.

With further chicanery and trial and error, I was able to then graft my hard-coded lat,long coordinates to center the map about my location of interest, then push through the interesting incidents into a list of markers which would then be placed on the map as black pins.  This relied entirely upon the features of the google static maps API.

Deploying to Android

Finally I investigated deploying and building the project to android.  I found that I needed to do a number of things:

  • Install Android Studio 2.3.1.
  • Install the Android SDK for Android 6.0
  • Install the JDK from the Oracle website for Java SE 8.
  • Alter the Unity settings to point to this new JDK rather than for Java SE 7.
  • Alter the player settings within the Unity build settings so that the 32 bit display buffer was unchecked.
  • Alter the player settings within the Unity build settings so that the project had an appropriate name (com.spinningcatstudios.ChrisCFAApp)
  • Create an android manifest at ProjectRoot/Assets/Plugins/Android/manifest.xml with an appropriate format, so that I could select the appropriate Android SDK
  • Finally, in Settings/Security, I needed to allow untrusted code to run in order to install my app.

After this I was able to build the project, and debug it while connected to my development computer.  However I found that Astro File Manager could not install apk files with Android OS 6, so I needed to switch to a more modern file manager.

Future features

Various additional features that come to mind are:

  • Configurability of what constitutes an interesting event.
  • Ability to alter the zoom and focused location of the map, to see more or less.
  • Add additional data feeds (eg traffic incidents etc) with other additional filters.
  • Move from the google static maps api to the google dynamic maps api 3.0
  • Notifications for when alerts occur

Bug fixes

  • Make the map look less stretched.

Parting thoughts

All in all, this was an interesting experience.  The end result is that I have a working prototype, which I can certainly at least deploy to Android, and hopefully should be less painful to deploy to iOS.  Anyway, here’s hoping!

Mechanised farming in desert areas

January 25, 2017

I’ve been thinking recently about an engineering problem that I started considering a number of years back.  The challenge is fairly straightforward; in various parts of the world, such as Australia, there are large desert wildernesses that are essentially unlivable, but which contain vast amounts of sunlight, and land.

This suggests that one should theoretically be able to set up a series of solar energy plants to power, say, one or several massive mechanised agricultural operations.  There are certain small pilot examples where this model has already been demonstrated to work.  For instance, Sundrop Farms at Port Augusta in South Australia.  Their operation relies on solar power, proximity to the ocean, and is partly though not completely automated.

Ultimately, however, it could well be a good goal to aim to pipe water from the sea to support intensive agriculture in greenhouses many miles from open water.  This could be achieved through using solar power and batteries in many areas.  Such operations could be monitored, maintained, and harvested by drones operated by artificial intelligence.  The logistics of transporting goods to ports or highways could also be managed by autonomous machines, potentially with refrigerated interiors.  Container vessels could then transport produce as trade to regions that required such.

There are many small problems that need to be solved here though in order for something like this to be practicable at large scale.  In particular it needs to be possible to build and maintain such infrastructure autonomously.  This will require advances not only in renewable energy (which we largely already have in wind, solar, and lithium batteries), but also in robotics and artificial intelligence.  I suspect that the latter two technological categories mentioned will largely be mature enough for this sort of operation by 2030.

I think that it would be worthwhile to try to build small first and then expand, though – with potentially many, many ventures in different arid regions or locations – rather than waiting for things to become completely mature.  Although I dare say that that is where the commercial reality is, regardless.

Notes from a machine learning unconference

December 5, 2016

Here are a few dot points I took from a machine learning unconference I went to recently.

  • The STAN programming language.  You can declare variables without giving them values and then use them in calculations.  Outcomes are determined probabilistically.
  • Andrew Gellman at NYU apparently knows things about multi level models (beyond Bayesianism).
  • GAN (generative adversarial networks/models) are powerful.  Tension between minimising one thing and maximising another.  Made me think about Akaike information for the ‘max’ of an algorithm and Fisher information for the ‘min’.  Might be able to render these stable that way.
  • Kicad electronics CAD tool for microcircuits
  • Ionic transfer desalination
  • Super resolution is amazing (more GAN)
  • InfoGAN
  • LIME GAN super-resolution local to global (a model explaining a model).  See .  Might be the next step for this sort of thing (testing machine learning models)
  • Electronic frontiers Australia, citizen 4
  • Simulation to generate data, unreal CV, unity3d to train machines
  • Parseymcparseface and inception Google pretrained models
  • Imagenet