This does exist to some degree, as far as I understand, along the lines of style-transfer and ControlNet in visual domains. Anthropic has some research called "persona vectors" which effectively push generative behaviors toward or away from particular traits.
That's a fascinating paper you linked. A step further than the OP article.
Not quite a usable commercial writing tool like i want, but it shows that extracting and applying a vector of a concept to the embedding is very useful.
Its also a potentially a very effective AI alignment tool like anthropic mentioned. Steering or restricting the model embedding loop instead of convincing it with a convoluted system prompt.
The idea of using stenographic techniques to exfiltrate data is interesting, but I don't quite follow the general method outlined in the repository -- either through the generated documentation or code. The threat model and case studies seem contrived. I find it hard to believe that folks would expose data via RAG that they wouldn't want users of the underlying system to be privy to.
There's too much fluff here to be useful. I imagine having something that is concise and concrete would make it more appealing to others. But as-is, it's missing a good technical summary and demonstration.
It's less about the RAG exposing new data to a regular user, and more about using the vector pipeline as a covert channel. The idea is to sneak out data the attacker already can access, but in a way that might bypass traditional DLP looking at emails, USBs, etc.
The "fluff" is largely educational material, as the project is for research and learning. For a concrete technical demonstration, the scripts/embed.py and scripts/query.py scripts are the core, and the docs/guides/quick_start.md tries to offer a direct path to seeing it in action.
The first paragraph seems self-explanatory, and the templating language is simple enough that you can infer what it does when it runs. There's nothing about this that seems JS ecosystem specific, other than being implemented in a language that itself is implemented in javascript. I can imagine building a stamp interpreter in Python for example, it's not doing very much other than touching and catting text into files.
> Regardless if you specialize in React, Rails, Django, Next, Java, C#, or ObjectiveC, you probably use templates to start new projects.
Java, C#, or ObjectiveC devs are unlikely to want their first command at the shell to start with `npm`, or the software supply chain fiasco npm drags in.
That said, to jump in, here's a better starting point than this HN post link:
Getting an interview for global entry is actually pretty easy, you can just do it on the return leg of international travel with no appointment needed.
When you enter customs upon re-entry to the US there's a sign for a place where they'll do your interview real quick before letting you go. The downside (IIRC) is that you don't get your number for precheck either until you do this, so if you only do international travel 1-2 times per year you might want to find an interview time.
A first or second year (undergrad) student doing theoretical science to this level is astounding to me. It was an upper-division course for me, albeit a prerequisite for things like compilers and cryptography, so I'm sure it could be put earlier in the journey.
Sipser's "Introduction to the Theory of Computation" was the book I had to read, and it certainly makes this post more accessible.
I've just checked with a few math books I like, and they are using ℕ and ℕ₀ throughout. What I don't like about ℤ⁺ is that 1) it talks about integers, although negative numbers might not be relevant in the current context at all, and 2) it's not really clear if ℤ⁺ denotes ℕ or ℕ₀. Of course, you have the same ambiguity problem with ℕ.
Oh, see how I numbered this 1) and 2), not 0) and 1)?
> Oh, see how I numbered this 1) and 2), not 0) and 1)?
So what?
> 2) it's not really clear if ℤ⁺ denotes ℕ or ℕ₀.
On the contrary. ℕ is ambiguous between the positive integers and nonnegative integers, though in my experience it's usually the nonnegative integers.
But ℤ⁺ is absolutely unambiguous. It's the positive integers.
And since you frequently need to refer to the nonnegatives, it makes sense to have a symbol for them too. There's almost no benefit to having ℕ available as a synonym for ℤ⁺. There's a lot of benefit to having it available as a synonym for ℤ\ℤ⁻.
Well, it means I usually need either ℕ or ℤ, not ℕ₀.
> And since you frequently need to refer to the nonnegatives
It depends on the context. You don't use ℕ₀ much, if you agree that counting starts at 1. You then use either ℕ or ℤ, which just looks cleaner. No reason to complicate such a simple concept as {1, 2, 3, ...} with something complicated such as ℤ⁺. As I said before, to understand {1, 2, 3, ...}, you don't need the concept of negative numbers at all, so why drag it in through confusing symbols?
> But ℤ⁺ is absolutely unambiguous. It's the positive integers.
Or the non-negative integers. And that's not just my opinion. Here is what ChatGPT has to say about that:
*system*:
You are a mathematics professor, and happy to chat about mathematics and the philosophy of mathematics.
--------------------
*user*:
What would you say ℤ⁺ stands for? Are there multiple options?
--------------------
*assistant*:
ℤ⁺ typically stands for the set of positive integers. This usually includes all the whole numbers greater than zero. However, there can be some variation in its definition depending on the context.
In some contexts, ℤ⁺ might be defined to include zero, so it would represent the set of non-negative integers. This is less common, but it does occur in some areas of mathematics.
The symbol ℤ comes from the German word "Zahlen," which means "numbers." The superscript "+" is used to denote that we're only considering the positive members of this set (or non-negative, in some cases).
So, yes, there can be multiple options for what ℤ⁺ represents, but they are all closely related. It's always a good idea to clarify these kinds of notational issues when they arise, to avoid any potential confusion.
I guess it is the difference between measuring the size of a set, and labelling the elements of the set with a number. Both can be called "counting", but the meaning is different. The first of something should always be labelled 1, but obviously the empty set has size 0.
That's the main problem I have with using ℕ for {0, 1, 2, ...}. It's easy to get into the habit of writing stuff like x_0, ..., x_{n-1} for n elements, and that's just ugly. x_1, ..., x_n is much better and clearer. On the other hand, 0 is useful when it comes to measuring the size of something (an offset, for example, or age).
I think ℕ and ℕ₀ is a good way out of this dilemma. ℕ is the natural numbers, and ℕ₀ is the natural numbers with, well, 0.
The other way out of this dilemma is what most here prefer, I guess: It's to say a label is just a label, and starting with label 0 when labelling the elements of a set, is just as good as starting with label 1. Then you just need ℕ = {0, 1, ...}, and ℤ for the integers, and you will not have much use for ℕ⁺ = {1, 2, ...}, because now sizing something and labelling something is one and the same. So you will now use x_0, x_1, ..., x_{n-1}. So you start counting from 0. I don't know, I just don't like it, but in the long run, maybe it is less confusing, because you unified the concepts of sizing and labelling, and now you can call both of them just counting.
I added a bit to my previous answer before seeing your reply. But yes, it does not really matter in terms of notation if you use ℕ and ℕ₀, or ℕ⁺ and ℕ. But both ℕ₀ and ℕ⁺ are slightly annoying compared to just ℕ, and so it changes where you start counting from: 0 or 1. If you start counting from 0, you will mostly not need ℕ⁺, and mostly just use ℕ and ℤ. If you start counting from 1, you will use ℕ more than ℕ₀, but you will use ℕ₀ often enough so that you need ℕ, ℕ₀ and ℤ.
Logic likes to unify things, so formal definitions usually start with 0, and conflate sizing and labelling. Note that Peano first started counting from 1. Later on he changed it to 0. Doesn't mean that's the right thing to do, though. Maybe these two concepts should be kept separate: ℕ for (default) labelling, and ℕ₀ for sizing.
I agree, it changes the semantics of dictionaries in a way that doesn't feel right. There are several things that are off-putting, but another example in vein with the mixed key types is the implicit ordered dict.
Every dict in Python is already ordered so it doesn't change much and Python doesn't blink at something like `int | str` so you can already do something like {0: "hello", "0": "world"} if you hated your readers. The only change would be changing how ** works when used as function arguments which is already bespoke.
I was a bit suspicious of the claim, but found evidence that this might actually be the case. Here's a page focused on research related to non-native earthworms in North America that seems like a good start: https://www.nyisri.org/2016/09/underground-invaders-impacts-...
This paper looked familiar to me, and it turns out it's because it's part of the 4th edition of Readings in Database Systems (or the Red Book). The 5th edition is freely available to read online, and is worth the read/skim.
This is an interesting talk! I love reading about applications of math/computer science to ecology. The parent page has links to relevant papers that are worth reading, too. [0] The species similarity paper has some concrete examples on coral, butterflies, and gut microbiomes that I felt missing from the slides. [1]
[0] https://www.anthropic.com/research/persona-vectors [1] https://arxiv.org/abs/2507.21509