• 1 Post
  • 166 Comments
Joined 3 years ago
cake
Cake day: June 18th, 2023

help-circle




  • I absolutely agree with your point here. I think part of the problem is probably the system/law. When you go for literal years without any action from the local government, there need to be laws/channels that you can use to escalate the issue.

    Basically, a clean and safe environment should be mandated by law. If the local government doesn’t uphold that law, the issue should be raised to higher levels (and the individuals responsible for the local government breaking the law should be punished accordingly). If higher levels don’t resolve it, your division of power is broken, since the government is blatantly violating rulings from the judiciary. If the division of power is broken… revolt?


  • But you said the counter didn’t reset? If it grants 2 in the “second loop”, that implies 1 was granted (since we didn’t invert 2), but you can’t grant 2 (uninverted) and also grant 1.

    If you’re operating with a time-loop recursion, you run into the problem of my initial comment. If you try to grant all three wishes simultaneously, you run into the obvious contradiction. The only way you get out is if you allow a time-loop recursion, but for some reason count the ignored guess as a granted guess in the inner loop(s).


  • Well if the counter doesn’t reset (because the genie exists outside of time and therefore grants all the wishes “simultaneously” from its own perspective) we definitely get a problem, because granting 3 makes it impossible for 3 to be granted, and we get the paradox implied by the comic

    1. Do the opposite of next
    2. Do not grant 3
    3. Ignore 1

    If you grant 1 and 2, then you cannot grant 3 (since 3 implies not granting 1). If you grant 3, then 2 cannot be granted (since it implies not granting 3). This is the simple form of the paradox.


  • I’m gonna lean on another commenter who made me realise the legitimate reasoning behind something like this (disregarding the fact that two years is absurdly high): If we permit anyone to do whatever “cleaning” they themselves deem reasonable without approval, we risk that unknowledgable people with good intentions cause serious damage. One reason could be that they create an acute flood risk (you’re right: garbage shouldn’t be flood protection, but the actual flood protection is built around existing circumstances, and if removing the garbage causes a major risk to people losing their homes, the correct approach is to first prepare the flood protection, then remove the garbage). Another is that people can unknowingly or unintentionally destroy habitats or otherwise damage the environment.

    The point is: We have some very competent people that are capable of assessing the impact of various cleaning operations. We need to let those people do their job. There can be very complex interactions in play, that turn your good intentions into catastrophic consequences. Therefore, we cannot allow laymen to judge how large cleaning operations should be conducted.

    Full disclaimer: While I think the above reasoning is sound, I think we should be very careful regarding how unauthorised cleaning operations are punished. For example, it seems absurd to me to give jail time for it. When the person in question is obviously acting with good intentions, it’s much more reasonable to sentence them to take some course where they can learn about why what they were doing was potentially harmful, and perhaps sentence them to community service working on some authorised project. That way, you help them learn, let them work on something they want to contribute to, and get more resources for the authorised projects.


  • You could argue that there is though, since the genie will grant three wishes. In that case, it operates like

    granted_wishes = 0
    while granted_wishes < 3:
        wish = receive_wish()
        granted = grant_wish(wish)  # True if wish is granted, false otherwise (invalid wish etc)
        if granted:
            granted_wishes += 1
    

    So we get

    1. Do opposite of next -> granted_wishes = 1
    2. Complete 3 -> granted_wishes = 2
    3. Ignore 1 -> Enter time loop (recurse)

    -inner loop-

    1. Do opposite of next (ignored due to outer loop) -> granted_wishes = 0
    2. Ignore 3 -> granted_wishes = 1
    3. Ignore 1 -> enter time loop (recurse)

    -inner loop 2-

    1. Do opposite of next (ignored due to outer loop) -> granted_wishes = 0
    2. Ignore 3 -> granted_wishes = 1
    3. Ignore 1 -> enter time loop (recurse)

    … etc.

    We get an infinite time-loop recursion, because we never reach the third guess in the inner loops.



  • While I see what you’re getting at, I still like this XKCD. I work as a developer, and have also worked in more “handy” fields. The thing with planes, elevators, and basically all other physical things is that they’re limited by physics. A steel beam can’t suddenly decide to spontaneously fail or disappear.

    With code, that can feel pretty different. With experience, I’ve basically learned to assume that there is always some edge-case I haven’t considered, that could trigger a bug. In a building, you can have redundant bolts, and over-dimensioned supports. A small mistake somewhere, a single missing bolt, won’t cause a catastrophic failure. With code, it’s different: A tiny, hard to notice mistake, can bring the whole think crashing down. Imagine if a plane could crash because the paint had a slightly non-uniform thickness…


  • This is the issue you’ll never get completely around with autonomous systems. A soldier can always figure something out, whether that is simply clearing their weapon, completely disassembling it to repair it, finding a new weapon on the battlefield or getting a buddies side-arm. An autonomous system will never be as versatile and capable of adapting to stuff breaking as a human soldier.

    The major advantage with autonomous systems is that you can accept that they break and become dysfunctional in the field. You can always manufacture more, and none of your guys die when one of these fails.

    With all that said, I would think you could get pretty far by just adding some arm that can slide back the bolt to clear/reload the weapon when you get a jam. Like 90+ % of the jams I experienced with the MG3 and HK416 were cleared by just doing that.






  • My point is that we’ve built our model on top of these “generalist” models. You hook it up to an API and then let Claude, Mistral, etc. (I try to avoid GPT and some other) do the generalist job of translating human language into actionable tasks. You give it tools to parse documentation and actually do the tasks.

    The generalist models are fairly good at taking a set of instructions and translating that to the correct tool calls, then our tools enforce correctness on the final output. Building an agent like the one we have would be nearly impossible without having some generalist model to do the “translation” step.

    I think we’ll see two major changes going forward in how LLM’s are used: 1) they’ll become much more expensive and less widely used, since today they’re run at a loss. 2) they’ll be integrated into larger systems where they can do what they’re good at (parsing and outputting natural language), while offloading technical tasks to other tools that are actually built for technical tasks where formal correctness is paramount.


  • I don’t think they will. I’m the first to be massively sceptical of LLMs, but that doesn’t mean they can’t be used to build good tools. The key is recognising that tasks where correctness is vital should not be solved by the LLM directly. At my job, we’ve built an LLM-agent that’s very useful (internal use). What we’ve done is build essentially a Python library that this LLM uses to interact with our data. That way, we ensure that a query like “set up a skeleton for X” will be done correctly, while we save a bunch of time that would have otherwise been spent doing boilerplate work.

    Basically: Enforce correctness by constraining how the LLM can interact with your data, and use the LLM to translate short natural-language queries into actions that otherwise would have taken 30 min of click-ops or write-run-toss scripting.



  • aren’t bound to Evolutionary advantage to survive.

    That’s not how evolution works though. Evolution is a process that works a the gene-level. A gene that makes its carrier more likely to reproduce and keep its offspring alive will over time propagate and replace genes that are less likely to do so. This is a simple game of statistics that works regardless of whether the organism that carries the gene is a human or not.

    Basically, evolution isn’t about survival. It’s about what genes are more likely to propagate to the next generation. You can simulate this fairly easily: If you have a completely stable population (the average person produces one offspring), and a gene that makes e.g. 10 % of the population produce on average 0.99 offspring, you’ll see that after a certain number of generations that gene is drowned out and eventually extinguished. Any gene that isn’t extinguished has survived because it doesn’t put its carrier at a big enough disadvantage to be extinguished.