Re: GETF Speedup?

So, 

1) Physics says we don’t get infinitely fast processing or internal memory or pretty much anything else. Ever. (Only politicians ignore this.) If anything, such a machine would
    require infinite energy.

    Wherever you draw the line, there’s going to be some tradeoff on how best to use whatever resources you have, which invariably will be less than what you wish you had,
    unless you are dealing with something susceptible to static analysis. You can’t design for all possible futures, so instead allow artifacts to adapt to the future they are in (to
    the extent possible; I’m not suggesting a raven can become a writing desk even if Poe wrote on both). 

2) There is a lot of work that has been done on reconfigurable robots built out of homogeneous modules that can attach to each-other in a variety of ways. These configurations 
     then learn to move efficiently in their configuration, but computation is decentralized: individual modules have their own autonomy and cooperate with other modules. See, for example
     https://robots.isi.edu/ though there is a lot of other relevant work in this area (I just happen to personally know Wei Min). 

3) Yes, the question is does the cost of morphing outweigh a less efficient configuration. The point of the research is to build a system that can do this analysis for itself. 
     Consider choices we make all the time: is it better to keep using the screwdriver in your swiss army knife, or trod over to your workshop and get the electric screwdriver which
     may or may not be charged? And if not, do you wait until it gets charged, or get a bigger (more torque) screwdriver out of your toolbox. Which you can’t find because you left it somewhere.
     So now you’re looking for your toolbox. Or you go back and finish the job with your swiss army knife while your arm is ready to fall off from the effort. And remember that the reasoning
     itself is costing you resources. 

     Work along these lines is many. Shlomo Zilberstein (Umass Amherst) has done yeoman’s work on anytime algorithms 
     (trade off between doing your plan now, vs thinking more about it and possibly getting a better plan)
     (google “Using Anytime Algorithms in Intelligent Systems” AI Magazine V17N3 1996, since I can’t find a clean link). 

     There has been a lot of work on various kinds of planners, I’m a particular fan of HTN planning such as Dana Nau’s SHOP planner (see https://www.cs.umd.edu/projects/shop/description.html)
     mainly because it’s easier to incorporate “advice” to such a planner.

     And of course planning and decision making can be accelerated with an appropriate SAT-solver. Here’s a recent contribution in that area: https://dl.acm.org/doi/10.1145/3706628.3708869 
     (I haven’t read this myself yet, but it does cite earlier work I’m more familiar with).

4)  I think your last paragraph is asking if the system is necessarily a case-based reasoning system, limited to known cases. Since research in CBR has already shown that cases can be used
     as priors, and be adapted to fit a given situation better (possibly by blending cases), I would say no. Of course, it is certainly possible to set up scenarios for which any system (including
     humans) cannot possibly adapt fast enough to preserve their own functionality, or make errors in judgement that allows use of underperforming tools in situations where casualties may 
     occur but with low enough likelihood (in the agent’s estimate) that the risk is worthwhile. Consider human brains and driving. But the work on modular robotics also indicates there are 
     non-CBR approaches that may be more appropriate, where one would only use CBR to either preprogram some known solutions or approaches (the moral equivalent of education).

At any rate, this is getting far afield of list-appropriate common-lisp discussion, so it may be best for interested parties to take this discussion to private email.

> On Oct 17, 2025, at 4:12 AM, Yuri Davidovsky <[email protected]> wrote:
> 
> 
> 
>> On 16 Oct 2025, at 23:42, Bradford Miller <[email protected]> wrote:
>> 
>> Back to GETF: all software, but the Symbolics approach I previously referenced is related to the "self-reconfiguration depending on your data", problem.
> 
> This looks like an interesting undertaking, which is essentially designing cyborgs, or to be precise, mechanisms that can adapt to their environment, and rewire themselves to it: much like we do in various settings, at work we behave a certain way, with our families we behave in another way, that would look very weird in a work setting. I understand it, the main drive for it is essentially a search for performance — we want to use the most out of our computing hardware, so we can reconfigure it to be better at certain tasks when needed.
> 
> However, per se it is not different to a conventional machine that runs different code branches depending on the inputs, in this way adapting to the problem, like OpenSSL can produce a pair of private/public keys, or encrypting a block of data depending on the parameters it was called with. Only in our cyborg case we not only choose a different part of code to run, we also modify the hardware to run this part of code on more efficiently. It follows that there is nothing special about hardware morphing — if we had an infinitely fast ARM64 processor, we could just run whatever code we need in a given situation, even though if it would be more “verbose” than may be needed in theory.
> 
> We are not overcoming drawbacks of von Neumann’s architecture per se, but the limitations of our current computational hardware implementations. The problem becomes, does the cost of hardware morphing outweigh overhead costs of running code “redundant” for this particular configuration.
> 
> This approach is not wrong, of course, given that our current hardware does have certain limitation (CPU vs RAM speed disparity, that is), however the main challenge that I am seeing is not in morphing hardware per se, but the choice of input parameters that decide what configuration to be used. It does not appear to be possible to do it fully automatically: a system cannot do anything it wasn’t programmed to, someone has to look into it at the design stage and say “when the input combination from sensors is similar to this, switch into this mode, or when the set of inputs is this, use that mode”.
> 
> That means that behind all this T-1000 morphing machinery will be a single point of control (possibly running on a raspberry pi), that monitors the sensor inputs and decides which branch of code to take, so to speak, and morph accordingly. It appears that morphing hardware is an optimisation facade behind something that essentially remains a code branch selector and their follower based on specific rules and conditions. It does not matter how these rules were created, by hand, or by aggregated data analysis (machine learning, that is), it will still remain a more or less static algorithm.
> 
> This is not to take away from your work, which I do find very curious as just recently I was reading about how FPGAs work, but the question arises: do you think that the morphing hardware concept is more or less a hack that won’t be needed if suddenly the speed of common computational hardware suddenly stops being a limiting factor (say, atom based transistors, or something, magic hyperspace RAM access protocols maybe)? 
> 
> Does you research show that such adaptable systems will inevitably boil down to a set of if-then-else constructs tailored to respond to a preselected set of input parameters (note that machine learning does not change anything here in principle, we just have a bigger selection of input combinations we can respond to), or do you have reasons to believe that such systems have a potential to respond adequately to genuinely novel situations?
> 
> <latest.webp>