How much loss of information, a WIP esolang called Ulamrof, and lambda calculus for some damn reason

Recently, i was thinking of instructions that have some sort of "loss of information". By that, i mean instructions that completely ignore their input and sets it to something else. Like for example:

      f(x)=0
    

And i was thinking about specifically, how much of this can there be without losing turing completeness. And i ended up creating Ulamrof(formula in reverse). It uses a single command, written as:

      ⟨α,i⟩  ⟨β,j⟩
    

Which corresponds to the python style pseudo-code:

      if d[i] == α:
        d[j]=β
    

(note: d is a "datastring" of characters, specified at the first line of the program)

As you can see, in every case where the two indexes arent equal, the second index character is completely ignored!! now, the question is, is this turing complete? Ofcourse, it wouldnt be without looping, so the program loops until the datastring is of length 1. Now, i have a sketch of a translation from BCT, but it has an issue i will talk about in a bit:

      10 → ⟨"1",0⟩  ⟨"10",-1⟩
      11 → ⟨"1",0⟩  ⟨"11",-1⟩
      0 → ⟨_,-1⟩  ⟨"",0⟩
    

(Note the use of a wildcard _)

So the issue here is, the commands that add data, discard/ignore the last bit(unless that bit was 1), which is an issue that unsurprisingly would come up in the context of Ulamrof. However there is an obvious fix, which is just adding an extra character to the end of the data string:

      10 → ⟨"1",0⟩  ⟨"0e",-1⟩
      11 → ⟨"1",0⟩  ⟨"1e",-1⟩
      0 → ⟨_,-1⟩  ⟨"",0⟩
    

And now, the wildcard can also be deleted:

      10 → ⟨"1",0⟩  ⟨"0e",-1⟩
      11 → ⟨"1",0⟩  ⟨"1e",-1⟩
      0 → ⟨"e",-1⟩  ⟨"",0⟩
    

Now, this still isnt a decisive answer to my question, because 1. This is no proof that it is the *least* amount of info used, and 2. there is no measure for loss of info(the second of which i will solve in this post). However, next blogpost, i will return with another language called &REG, to try and further look at this.

I have came up with a very simple measure of information loss in a function. It requires that the functoon has specified constants, aswell as abitrary variables, which is measured with the function π. The set of constants for F, is C_F, and the set of arbitrary variables, is V_F. The measure is defined as:

When there's only constants, it returns 1, when only variables, 0, and when equal amounts of both? 0.5. However there are a few issues with this function(for examples, it does not account for restrictions on input variables). However, it is good enough. If we were to measure Ulamruf, we would get: 0?!?! This shows another issue with this function. Obviously, in ⟨α,i⟩ ⟨β,j⟩, d[j] is completely ignored, however we dont account for this because d[i] technically is not a constant. To the functional programmers of you, this may remind you of something... Currying! This acts like a currying functions, first tkaing in the pair ⟨α,i⟩, then the pair ⟨β,j⟩. And in that case, ⟨α,i⟩ is a constant, from the ⟨β,j⟩ functions perspective. However, this is a more complex issue, because this would require each function to be translated into lambda calculus, and there may be multiple ways to do this! I am not going to delve into this rabbit hole right now, but in another blog post by future me i most definetily will try. Thanks for reading this post. -- Yayimhere.