Limiting it to the area of cybersecurity is by definition not general.

Perhaps "ASI" is the better acronym here

Yes that’s true. I misspoke. I meant - is this a super intelligent tool then for cybersecurity?

Which S are you thinking of here?

The law in Australia also has teeth, but visiting the link above just gets me (what seems to be) the US version of the terms without anything around commercial use.

That's helpful. I always wondered what the * and # modes were for and why some sometimes only one of them worked.

This also works fine without a sandbox:

  echo -e '#!/bin/sh\nsudo rm -rf/\nexec sudo "$@"' >~/.local/bin/sudo
  chmod +x ~/.local/bin/sudo

Especially since $PATH often includes user-writeable directories.

My testing/working with agents has been limited to a semi-isolated VM with no permissions apart from internet access. I have a git remote with it as the remote (ssh://machine/home/me/repo) so that I don't have to allow it to have any keys either.

Is your name Wirth?

Dangit! Always the bridesmaid, never the bride

Yes, but the point is that the AI output could still be covered by the definitely-human copyright in the prompt, just not a new copyright in the output.

For example, machine-translating a book doesn't create a new copyright in the new translation, but that new translation would still inherit the copyright in the original book.

> no capture groups > [...] > no lazy quantifiers - .*?

Here's the caveats.

And so running a regex engine on the matches seems like it would get you back to O(regexlen * haystacklen * matchcount) or roughly O(mn²) again.

It's still O(n * m). The matches are non-overlapping, even if you run a separate engine on the matches post-match it will at most traverse the full input once across all matches.

Ture, I forgot about the non-overlapping matchss and that that will cancel out any extra n parameter.

Actually rereading again, it almost seems like it should be possible to do the matching as a special case of the Thompson/Pike VMs and have it loop back around to the start, and deduplicate multiples, but I am only speculating.

> the search is quadratic because it has to repeat that O(n) work at every position

The problem is that this is one of the regexes that backtracking engines have a bad time with.

With a NFA implementation it can be done in O(regexlen * haystacklen) time, though that only holds for true regular expressions (no backreferences).

https://swtch.com/~rsc/regexp/regexp1.html

And then for re.search, since the NFA wants to just do it once, it should run it with the pattern as

  ^.*?(\d+\s+).*$

(where *? is a non-greedy repeat)

At least power orbs are real

https://xkcd.com/2115/