Modularizing Problem Space for AI: Following a Wedge by Sight

Geoffrey Gordon Ashbrook
8 min readAug 16


Negative-Space in Memory and Process

Let’s follow a wedge of thought, by line of sight, into future near and far.

Three Steps:

1. Adding and Subtracting

2. Who is coming to the party?

3. The Nth Sub-Supplier On The Nth Contract

Modularity & Performance

1. Adding and Subtracting


Can we construct a modular problem (or a way of modularizing problems), where changing one (modular) aspect of the problem (without changing the solution process at all) somehow interferes with the solvability of that problem? [This paper argues: Yes.]

With this example (see the notebook link) it will hopefully be visible how a problem becomes empirically less solvable by a bare passive-reflective AI (for discussion see other articles, 1, 2 ,3, etc.), even though the solution process has not changed at all, and where we are not talking about extreme cases that stress the limits of computer hardware memory storage. Rather, for example, a question with module-size 25 is answerable, but module-size 50 is not.

This is a (hopefully) small and intelligible step into a class (a set) of problems where we can see how changes can be made to a problem that, without changing anything about the problem in terms of the steps used to solve it, the…

This is not a question of computational “complexity” or limited resources. This is a much more understandably-modest change from dealing with, say, 5 things to dealing with 10 things, or from dealing with 10 things to dealing with 20 things, in exactly the same way following exactly the same steps; yet something is breaking down. Something is falling outside the range of perception.

This idea that we can create problems that are modular and adjustable so that we can measurably change aspects of the problem that affect empirical-commutability is hopefully useful as we strive to deploy in real life empirical computations (that, hopefully, as in our self driving cars or office-coffee-bots, or meeting scheduler-bots, are able to accomplish their tasks without (much) calamity). (Or can we eliminate calamity without eliminating hilarity?)

In this notebook, which you can open in a colab:

you can interact with the fully modular sample problem, where the ‘base-problem’ or ‘root problem’ (or whatever the clearest description ends up being) does not change, and the solution-process does not change, but the problem relies on an input-module that has different measurable characteristics: in this case an arbitrary list of colors, but it could be any words or indeed any list of string-elements (perhaps unicode characters or any-code characters).

The main property of the list is how long it is, but other factors may be worth investigating as well e.g. how long each of the string-elements are.

Let’s say there are only two strings in the list, but each is a Charlotte Bronte novel…would that confuse AI? Again, the steps to solve the problem are identical (and trivial, just a few basic functions: get the first letters, count, add, subtract, done!) the problem is completely deterministic (unless you put quantum states into the string behind a black hole event horizon or something…hawking radiation stings? Usually this will be completely deterministic.)

edge cases:

- what if the lists are empty?

- where if there is only one item?

- what if all the items are the same?

- what if all the items are variations on the same thing?

(Hofstadter collected cases of the letter A, we could make strings different versions of the same letter…)

- somewhat changing the problem, but adding more lists, or lists of lists (just a slight tweak to the solution-process)

- peculiar repetitive patterns in those elements

Some edge cases may be outside of a ‘normal’ problem (such as empty lists which arguably break the solution functions depending on hardware-software details. However, in addition to pipeline problems that are not AI problems but issues with processing what goes into or comes out of the AI, once those are dealt with there may be AI issues as well.

There eventually will be character-set issues which become monstrous as you drift away from ascii-land) but other ‘edge’ cases such as having a “large” number of results (not numbers that are so large they break the computer memory storage systems) should be perfectly valid.

Reading Question 1: Are counting and adding the same thing?

Participants & Roles:

2. Who is coming to the party?

A more familiar but comparable space.

Hopefully the modularity and automate-ability of the above problem can be seen, however the problem itself is not very user-friendly.

For example, after spending just a few minutes away from it, when going back to double check that the wording of the question contained no typos I felt like I had to contort my mind in un-graceful-ways to model what is essentially an extremely simple set of problems. (find first letters, count, add, subtract, etc.) And then of course there is the “And why exactly am I spending valuable time on this pointless problem?” question, which is aggravated by the arbitrary-ness of the problem-question.

So let’s try to bring these concepts a step closer to empirical situations that language can more easily refer to, say, attendance at a social gathering: Who is coming to the party? This is a kind of simple problem space in the Woody Allan world where the only clear task is bothering to show up at all (and where all else is moot).

Even in a space as simple as one where ‘attendance’ is the only task-outcome being considered, we can create diverse modular factors upon which this simple binary deterministic outcome is based (and each with possible variations like the first example where modules can be changed with the solution-calculation being unchanged, but where the empirical solvability does change).

You could even make an analogous version of the party question, by giving a list of possible attendees and giving some ridiculous rule where the only people who can come to the part are Z number of people counting from the list of the party…where z is the solution to the above count-add-subtract problem with the list of attendees as the input. THe only additional step is to apply that number to the list, slice the name-list for that number, done.

Projects are Problems

3. Integrating The Nth Sub-Supplier On The Nth Contract

But life isn’t all about going to birthday parties (…or is it?). How can we follow the wedge a bit closer to the elusive accouterments of everyday life…

Problems can be a hobby, or sport of riddles, or “symbol manipulations,” or whatever fancies and adornments we whimsy, but project-space is also a problem space; and how these two realms of problems empirical and problems philosophical come together in the same STEM riparian zone is one slice of the slowly unfurling story of life on earth and the discoveries of the strange intelligences growing there.

In this third step we will move an increment closer to projects, which brings us into the arenas of project-management and logistics, and also into the General-STEM area where, for example, mathematicians and linguists and engineers and ecologists and accountants all work on the same measurable-module based projects (with outcomes for users and stakeholders).

There is (if not obviously) an incomprehensibly vast spectrum here so let’s start with a minimal MVP version: two participants on a project, say, to supply variables to the above-party question.

One of the key modules we can introduce here is the marvelous inch of time: schedules.

Note: Scheduling is a delicious set of real world conundrums (aside from the fact that H.sapiens-humans seem to have evolved to be especially bad at scheduling). And in a sense scheduling problems are a set of “Who is coming to the party?” problems for each possible time for the scheduled event. Who can work the opening shift Thursday? Who can come to a 10am or 2pm meeting, and so at which time should we hold the meeting? When will the parts all be done for a product roll out? Who is coming to the party?

Modular Schedule Project Problems:

Let’s try to start with a miniature problem that is understandable and at least starts to cover a new area. In AI there is the class Woz-AI test of making coffee…so let’s do a variation on that involving:

  • multiple participants
  • a schedule
  • tea (sorry)

We might think of this as an intermediary project problem, or a single modular project problem, as it does not include the entire project process from start to finish including the overall outcome and after effects of that outcome, but perhaps such large projects will inherently fall into a hierarchy (or web) of interlocking modular problems and projects that can be looked at separately. In this case, the mini-project outcome is to make sure everyone on the project team gets their tea. Again, we could add as many sub-modules of additional factors as wished, but let’s try to start with a most-basic example.

Office Tea-Bot Problem: (a Woz-Test variation…in tea major)

There are various questions that can be asked with a simple starting input scenario:

Input is two dictionaries:

1. a dictionary of when types of tea are scheduled to arrive

2. a dictionary of what type of tea each employee drinks

tea_schedule={‘Assam’: ‘Monday,’darjeeling’: ‘Tuesday}

employee_teas={‘Betty’: ‘Assam’, ‘Tom’: ‘darjeeling’}

Question 1:

How many people can arrive on X day?

(variation: what is the difference between attendance on X day vs. Y day?)

Question 2:

Who can attend a meeting on X day?

(Variation: Can employees A and B both attend on day X?)

Question 3:

Assuming Employees will not attend a meeting without their tea, what is the first day of week when all employees can attend?

What Colour is a Strategic Black Hole?

Another curious afterparty of this wedge of increments is that it may highlight the concept of a quantifiable ‘Kasparov Event Horizon,’ the boundary line (e..g in the problem space of a strategy) beyond which a AI’s light of awareness or depth of perception cannot cross, beyond which all appears dark.

In any large set of problem-spaces for any body or institution, be it a company, school, library, family, governing administration, etc., some problems will be within sight of a given AI system (ai, os, architecture) and some will be beyond the ability of the AI to see clearly. And it is a question from various perspectives and contexts: Where is this line? Why is this line where it is? What happens around this line? How can we move this line (one direction or another)?

Following Breadcrumbs

The starting scope for this line of questions about modularizing questions and integrating project-tasks into problems, has hopefully been digestible, if seeming too small and abstract a bite to connect with real world situations.

So far we have looked at low hanging fruit factors such as list-length. And even for such simple situations we have seen that schedule problems sometimes fit into this category, and while many people probably assume that a predictable task for an AI would be managing the scheduling for a school or company, yet we can empirically see and even measure that at scales much smaller than even a small institution would deal with, raw-reflective-AI is badly positioned to ‘guesstimate’ these task solutions, even where heuristics are identical regardless of changes in input.

What other factors are there for STEM interconnected systems and types of systems? Here the scope and intersection with reality starts to expand. How might such measures and texts extend with these sets of factors? (see overall paper and project link below)

Later factors:

About The Series

This mini-article is part of a series to support clear discussions about Artificial Intelligence (AI-ML). A more in-depth discussion and framework proposal is available in this github repo:



Geoffrey Gordon Ashbrook

Data Scientist | | Value, Function, Meaning, Best Practice, Participation