Lamentablemente tengo que volver al asunto de las comillas.
La cuestión es que si uno intenta hacer un programa de computadora,
ya no hay signos, sino caracteres, y las comillas se usan con otro significado,
que puede llegar a ser justo el opuesto del uso gramatical dado en este hilo.
Lo cual me hace dar cuenta por qué me enredé en esa discusión.
En contextos diferentes hay que ver cómo se traducen las cosas correctamente.
Ya que hemos convenido que los signos de \(L_{arp}\) significarán 8 entidades del Universo,
voy a elegir a esas entidades como ocho fichas que tienen pintados los octetos en binario que son códigos ASCII o UNICODE de los caracteres cuyo glifo luce como los signos de \(L_{arp}\).
Además, los signos "\(\kappa\)" y "\(\rho\)" los he cambiado por sus versiones latinas "k" y "r", porque son más accesibles en ASCII, y además yo puedo elegir los elementos que yo quiera para mi conjunto.

He aquí los objetos de mi conjunto de ocho elementos:
\[
\fbox{00110000},\fbox{01010011},\fbox{01110000},\fbox{01100011},
\fbox{01101011},\fbox{01110010},\fbox{01111000},\fbox{00111101}.
\]
Podría haber elegido otros objetos, pero quiero mantener el símil con la representación en memoria, porque esa será la implementación real después de todo.
Por la manera que hemos llevado la discusión, pareciera que no puedo nunca poner explícitamente en forma escrita esos objetos, porque al ser signos,
van entre comillas, puesto que estoy hablando de ellos.
Pero bueno. No sé. No puedo poner una fotografía entre comillas, ni un audio de Beethoven entre comillas.
Acá solamente estoy ilustrando gráficamente que me estoy refiriendo
a unas supuestas fichas con octetos binarios pintados en el lomo,
y que andan por ahí.
De hecho, lo cierto es que no serán fichas, sino una configuración electrónica de una tarjeta RAM, que en ocho posiciones consecutivas adquiere un voltaje alto o bajo (los famosos bits de un byte).
Ese byte, en su forma electrónica del mundo real, digamos,
serán los signos de \(L_{arp}\).
Al mismo tiempo, son unidades de información en el
entorno de ejecución de un programa escrito en C o en C++ (a estos efectos, ambos lenguajes tienen especificaciones parecidas).
Ahora bien, en el entorno de ejecución de un programa
uno no tiene cadenas de caracteres,
sino
arrays (posiciones contiguas de memoria) de
bytes.
En tanto y en cuenta se tomen como lo que son,
a saber, bytes, o bien se amontonen como arrays de bytes sin significado alguno,
no veo necesidad de que lleven comillas, pues estoy usando las figuras en los rectángulos
para representar a esos objetos por sí mismos (serían su propio significado

).
Cuando quiera usarles para representar el número tres, ahí si los entrecomillaríamos:
El siguiente array de bytes
"\(\fbox{01010011}\fbox{01010011}\fbox{01010011}\fbox{00110000}\)"
significará el número natural tres.
Y acá es donde yo veo importante distinguir entre un signo y una cadena de signos de longitud 1.
Y es que si yo me refiero a \(\fbox{01010011}\)
como un objeto que pertenece a un conjunto,
no le veo sentido tener que ponerle comillas.
Su significado es el de un octeto de ocho bits,
y como tal no tiene sentido decir que es una cadena de signos de longitud 1.
Sólo cuando tengo la intención de usarlo como signo es que puedo
decir que tiene el atributo de longitud igual a 1.
El símil aquí sería decidir mirar un trozo de memoria RAM como una sucesión de bytes,
en cuyo caso se podría hablar de la longitud del array de bytes en cuestión.
Puede ser un poco extraño, luego,
decir que el significado de una sucesión de bytes es una entidad mental,
como el caso del número natural tres.
La computadora no tiene manera de hacer esa asociación
(aunque Elon Musk anda cerca de lograrlo).

Así que ese significado habría que dárselo, todavía, sólo desde la mente.
En cualquier caso, al menos creo haber logrado
dar con lo que sería la manera correcta de una representación
en computadora de los
signos del lenguaje formal, como se explican en el hilo.
No obstante, quiero notar acá que, cuando agrego comillas para hablar
del array de bytes per se, y sus propiedades como array (que serían equivalentes a las propiedades de una sucesión de signos),
no son comillas que pondría en la memoria RAM.
Es decir, no usaría bytes extra para representar comillas ahí.
Son comillas mentales, por decirlo así, o que podría poner acá en el texto escrito,
puesto que son comillas del lenguaje español,
y no algo que tenga sentido en la memoria RAM, ni tampoco en la sintaxis del lenguaje de programación.
_____________
Ahora bien.
En el código fuente de un programa en C o C++,
uno puede especificar arrays de bytes de varias maneras,
pero la manera más sencilla es por medio de una construcción sintáctica
denominada
cadena literal.
Aquí, llamativamente, se usan comillas dobles para denotar una cadena literal.
Estamos, pues, ahora en terreno sintáctico, vale decir,
en lo que se denomina
entorno de traducción,
que es donde se especifican las reglas del lenguaje C o C++.
Una cadena literal es una construcción sintáctica
por la cual una sucesión finita de caracteres se encierran entre comillas dobles.
Así,
"hola" es una cadena literal, y también lo es
"otro-ejemplo".
Si hablo de la cadena literal
"hola", estoy refiriéndome a un objeto
del lado sintáctico del lenguaje de programación que esté usando.
Lo que me llama la atención es que puedo hablar de ella,
al igual que Carlos dice que uno puede hablar de una palabra entrecomillada,
diciendo por ejemplo que "hola" tiene cuatro letras,
mientras en C uno diría que la cadena literal
"hola" tiene 4 caracteres.
Y al igual que "Sp" (en el idioma de Ivorra)
no es la cadena de signos formada por una ese y una pe,
la cadena literal
"Sp" en C ó C++
no es lo mismo que el array que contiene los bytes \(\fbox{01010011},\fbox{01110000}\).
Si bien la analogía parece coincidir,
creo que es pura casualidad hasta acá,
y los contextos son diferentes.
En cuanto a lo que el lenguaje C se refiere,
lo que sucede es bien concreto:
el compilador de C, al ejecutarse,
realiza una traducción del objeto sintáctico
"Sp", digamos,
y lo convierte en el array de bytes: \(\fbox{01010011},\fbox{01110000}\).
Así, una
cadena literal (que siempre va entrecomillada)
se traduce en un
array de bytes.
Y creo yo que entre ambos contextos, el idioma español y el lenguaje C,
puede mantenerse hasta aquí un paralelismo que funciona bien.
____________________________________________
Sin embargo, en la exposición de Carlos sucede algo diferente,
y es que a las
cadenas de signos se le dan nombres,
que serían palabras nuevas para nombrar entidades que serán,
después de todo,
sucesiones finitas de signos,
y que en el contexto de programación serían
arrays de bytes.
En C ó C++ también puede hacerse algo así,
mediante variables de tipo array de caracteres,
o de tipo puntero a caracteres.
Así como Carlos usa la palabra SS0 para denotar la misma sucesión de signos que denotaría con la cadena "SS0",
análogamente nosotros usaríamos una variable
SS0 para denotar el mismo array de bytes que denotaríamos con la cadena literal
"SS0":
const char SS0[] = "SS0";
Acá me siento algo confundido,
si es que quiero mantener la analogía entre lo que explica Carlos
y que hace el lenguaje C.
Para empezar, en C no es exactamente lo mismo un identificador, como
SS0,
que una cadena literal como
"SS0".
De todas maneras, al traducir al
entorno de ejecución,
ambos objetos sintácticos serán traducidos
al array de bytes \(\fbox{01010011} \fbox{01010011} \fbox{00110000}\).
Sin embargo Carlos diría que SS0 (en español) "es" el array de bytes \(\fbox{01010011} \fbox{01010011} \fbox{00110000}\)
mientras que "SS0" es una palabra de tres letras que, de paso,
se usará para representar un array de tres bytes, digamos.
En el lenguaje C, tanto
SS0 como
"SS0" son objetos sintácticos,
y que lleven comillas o no sólo indica que son objetos de clasificación sintáctica diferente
(un identificador y una cadena literal, respectivamente),
que luego tendrán la virtud de traducirse a la misma cosa.
Pero, por ejemplo, en C sería falso argumentar que el significado de
"SS0" es
SS0.
En cambio, el significado (la semántica en tiempo de ejecución del programa en C),
tanto de
"SS0" como de
SS0, es el mismo:
\(\fbox{01010011} \fbox{01010011} \fbox{00110000}\).
______________________
Para peor, el lenguaje C contiene en su especificación
un metalenguaje, que se llama
preprocesador de C,
el cual tiene sus propias reglas,
y se usa para traducir un cierto código fuente a lenguaje C puro.
En este preprocesador uno puede estipular clásulas de sustitución, en forma de macros,
como las siguientes:
#define SSSS0 "SSSS0"
En este caso, el identificador
SSSS0 se estaría usando,
en la etapa del procesador,
como una manera de expresar, como sinónimo, a la cadena literal
"SSSS0".
Se podría decir que la semántica del indentificador
SSSS0 es el objeto sintáctico
"SSSS0".
Aquí estamos en una situación opuesta a la que se tiene en el hilo principal,
porque allí SSSS0 (en español) no es capaz de sustituir a la cadena entrecomillada "SSSS0",
ya que en realidad "es lo mismo que" (hablando español)
\(\fbox{01010011} \fbox{01010011} \fbox{01010011} \fbox{01010011}\fbox{00110000}\).
_______________________
Lo que me chirría o preocupa en todo esto son aquellas ocasiones
en que Carlos afirma que todo esto se puede llevar a cabo en un ordenador.
En rigor, no es cierto.
Y me parece que hay que establecer claramente cómo se traduce de un contexto al otro.