It doesn’t seem like a good idea to (in effect) bet against you when you’ve been thinking about this a lot longer than I have and seem to know something that I don’t.
It would certainly be best to just talk through it and agree if possible. Hopefully we can end up in a state where we either agree about what is feasible in the long term or disagree about what is feasible in the short term.
As a stepping stone, it would also be useful to have an example of a concrete experiment which you expect to fail, so that I can understand more precisely where the differing intuitions are and what I should be arguing for. I’m going to write a long/sloppy description of how this might work in the programming case to get the ball rolling.
To be concrete about the programming case, let’s assume that A is just another copy of me (it seems like that simplification is orthogonal to your question), that each of us has 1 minute to think, that the language is Fortran (about which I know almost nothing but can read the docs), and the task is determining whether an integer is prime (in sqrt(N) time).
[Doing this with actual humans is going to be extra inefficient because we can’t reuse their intermediate state, but the number of people involved also seems orthogonal to your question.
Expensive amplification would take place over many consecutive steps. That is, A+ could effectively do things that would take 100 queries to A, and A++ can effectively do things that would take 100 queries to A+, and so on. Your incredulity seems to only carry weight if you are incredulous about accomplishing the task with any number of copies.]
I would probably start by asking one copy of A: “break down the process of writing a root(N) time primality test in Fortran into a sequence of significantly simpler steps.” I expect that copy of A would return something like:
- Figure out how to write a function which takes an input and returns a constant output.
- Figure out how to write Fortran code to test if one integer divides another.
- Figure out how to writer Fortran code to take the square root of an integer.
- Figure out how to transform the Fortran code which performs some operation into code which performs that operation for each integer in a contiguous range.
- Put together those pieces in order to compute primality.
(We could break down the act of decomposition further. But if we were actually doing this with humans-like-me and actually had 1 minute each, I’d expect a breakdown at least as good as that one.)
I wouldn’t literally see this list, I would see something like “The sequence of steps [X].” I would then spin up another copy of A and say “Execute each step in [X] in order to implement [a sqrt(N) time primality test].”
That copy of A would then spin up subcopies for each step, who would address that step (being given a term encoding the results of the previous steps).
The steps are pretty repetitive, but we can just talk about the “Figure out how to write Fortran code to test if one integer divides another” step since it seems representative. If I were A, I would first ask a copy for “Give me the ten quotes from the documentation that seem most relevant to writing code which [tests if one integer divides another].” I would expect to get back a list like “The most relevant pieces of documentation are in this list [X].” We could talk about how to assemble that list using a bunch of copies of A.
I’d then ask another copy of A to attempt to break down the process of testing if one integer divides another into a series of simpler steps, using the available documentation. At this point I’d have to actually start digging into the documentation to figure out what they’d say, but I expect they’d give a breakdown which involves finding the syntax of a line of code which computes the remainder of two values stored in local variables, and finding out how to set the value of a variable to an operation, and finding out how to test equality, and so on. Then I’d hand off that sequence of instructions to another copy of A, who would spawn up sub-copies for each instruction in the sequence, and consult the docs in order to accomplish each of them.
Anyway, we could go into arbitrary amounts of detail about this process but it seems unlikely to be where you are skeptical. The main step where I can understand skepticism is the “Put together those pieces,” so I’ll talk about that briefly. (Though I still don’t expect to be addressing what you are skeptical about.)
So imagine I’m a copy of A, and I’ve been given the question “Combine the results in [X] in order to write Fortran code that implements [Y].” So I continue the trend, and ask “Break down the process of [combining the results in [X] in order to write Fortran code that implements [Y]] into steps.” I hand that to another copy in A.
That copy of A then first asks why we think that it is possible to combine the results in [X] to implement [Y].
They get back an answer like “There is a simple algorithm [Z] which can be implemented using those results and which would achieve [Y],” where Z is a representation of the standard algorithm for testing primality.
They then punt to “Break down using the results in [X] to implement the algorithm [Z] into a series of steps.”
They get a sequence like:
- First compose a function that takes an integer input and returns a constant.
- Then modify that function so that it tests divisibility by a variable x, and stores the result in y, before returning a result.
- Then modify that function so that it loops…
- And so on, I don’t want to go through it.
They return that sequence of steps. That sequence of steps then gets implemented by another copy of A. It performs each step in turn (each with a separate copy), and now is actually performing manipulations on a string which represents the function (probably also with some other information, like the set of variables in scope at each line in the program and semantic information about those variables and so on, which depend on how the language actually works). Each step of the manipulation is performed by consulting the results of “Figuring out how to do <blah>” which were produced by consulting the docs (the output of “figuring out” includes instructions like “Insert the character % in between tokens which represent the two variables,” which was itself produced by a collaboration of many copies of A scanning the documentation.)
The output is a string which implements the desired function. Probably we then go through an entire separate exercise to test that the function works correctly and debug it if not.
Anyway, we can flesh out any part of this in more detail if there is something in particular that seems dubious or unclear. Fleshing it all out all of the way would involve about as much work as actually implementing it, which would itself involve more work than learning Fortran. I’m happy to do that at some point, but would prefer do it once we’ve agreed to disagree about the outcome. I currently believe that this would work after a few tries to iron out rough patches, and I’d guess that with Paul-level implementers it would take 2–4 hours of total time to write a correct Fortran program to test primality. A problem with implementing is that the results may not be believable if one person implements the whole thing, since they may be using information from one part of the tree when answering other parts of the tree.
