Algoritmo de Pensamiento y Conciencia

Este art铆culo describe un algoritmo para el pensamiento y la conciencia. Ofrezco mi respuesta a la pregunta de c贸mo funcionan el pensamiento y la conciencia. Y demuestro un algoritmo que puede pensar de manera creativa y verdadera y poseer conciencia real. El art铆culo est谩 destinado a programadores y consta de dos partes principales. La primera parte es puramente t茅cnica, contiene una descripci贸n del algoritmo, una lista de sus propiedades y un ejemplo de aplicaci贸n pr谩ctica. La segunda parte contiene tesis explicativas y una soluci贸n a la cuesti贸n de la axiomatizaci贸n constructiva de la conciencia. Un algoritmo es un texto significativo que habla por s铆 mismo y, por lo tanto, solo habr谩 comentarios m铆nimos pr谩cticamente necesarios.

Descripci贸n del algoritmo


La descripci贸n del algoritmo se realiza en un formalismo matem谩tico hecho a s铆 mismo de acuerdo con el principio "de arriba hacia abajo", es decir, primero se proporciona un registro abstracto y final, y luego se analiza el algoritmo por partes en el orden en que se realizan las llamadas y se hacen comentarios. Entonces, el algoritmo "ensamblado" es una funci贸n recursiva de la siguiente forma:

t n + 1 = composici贸n [ abstracci贸n [ deducci贸n [t n ]]]; t 0 = s; t n , s 鈭 S ; n 鈭 N

El c谩lculo de esta funci贸n es pensar. Como puede ver, aparecen tres operadores en el registro:
composici贸n [] , abstracci贸n [] , deducci贸n [] ; tambi茅n hay: la variable semilla s 鈭 S , el conjunto de filas de una forma especial S y el n煤mero de paso n 鈭 N. A continuaci贸n, consideramos en detalle cada pieza de repuesto. Comenzamos con el conjunto S y sus elementos.

Para especificar el conjunto S, es necesario determinar la sintaxis en la que se escribir谩n los elementos de este conjunto. Los elementos del conjunto S se denominar谩n cadenas. Cualquier l铆nea en S consiste en una jerarqu铆a de corchetes "(", ")", y los identificadores de caracteres arbitrarios se escriben dentro de los corchetes. Para evitar el uso del t茅rmino "identificador", ya que puede ser necesario para otros fines, los identificadores simb贸licos entre par茅ntesis se denominar谩n "mnemot茅cnicos". Cada mnemotecnia est谩 escrita en caracteres latinos "A - z". Los mnem贸nicos entre par茅ntesis pueden estar separados por una coma ",". Si la longitud de la mnemotecnia es fija, que se especifica por separado, el separador no se establece. Los mnem贸nicos se escriben solo entre par茅ntesis. Una l铆nea puede contener corchetes anidados. La jerarqu铆a de corchetes en la cadena es arbitraria, pero debe haber un corchete de cierre para cada corchete de apertura. En este art铆culo, usar茅 solo letras peque帽as del alfabeto latino para escribir mnem贸nicos, y la longitud de los mnem贸nicos ser谩 fija, una letra corresponde a una mnem贸nica, no pongo un car谩cter separador. Ejemplos de l铆neas:

() 鈮 鈭 es una cadena vac铆a.
(a) - una cadena que contiene una mnemotecnia " a ".
(aa) : una cadena que contiene dos instancias de la mnemotecnia " a ".
(ab) es una cadena que contiene dos mnemot茅cnicos " a " y " b ".
((a) (a)) : la l铆nea contiene dos copias de la mnemotecnia " a " y niveles anidados de corchetes.

Los corchetes adjuntos, junto con su contenido, as铆 como los mnemot茅cnicos individuales, a veces se denominar谩n "componentes de cadena", en los casos en que se requiera una generalizaci贸n adecuada. Por ejemplo, la l铆nea ((a) ab) contiene cuatro componentes, entre ellos: dos componentes " a ", un componente " (a) " y un componente " b ".

Los registros de cadenas que coinciden con una permutaci贸n de los componentes dentro de la cadena se consideran id茅nticos. Ejemplos de l铆neas id茅nticas:

(ab) 鈮 (ba) .
((a) (b)) 鈮 ((b) (a)) .
(abc) 鈮 (bac) 鈮 (cba) 鈮 (acb) 鈮 (bca) 鈮 (cabina) .
((a) (ab)) 鈮 ((a) (ba)) 鈮 ((ab) (a)) 鈮 ((ba) (a)) .

Las l铆neas pueden contener cualquier n煤mero de componentes id茅nticos y repetidos, y en este caso, es posible un registro m谩s corto utilizando el 铆ndice de repetici贸n, que se coloca antes del componente a la izquierda, sin un separador. Ejemplos:

(aa) 鈮 (2a) .
(aabb) 鈮 (2a2b) .
((a) (a)) 鈮 (2 (a)) .
((aa) (aa)) 鈮 (2 (2a)) .
(aa (bb) (bb) (ccc) (ccc) (ccc)) 鈮 (2a2 (2b) 3 (3c)) .

En aquellos casos donde la cadena contiene componentes vac铆os, por ejemplo, (a ()) , (a () () (b)), las identidades contienen: (a ()) 鈮 (a) , (a () () (b )) 鈮 (a (b)) , es decir, los componentes vac铆os se desechan.

Definici贸n El conjunto S consta de todas las cadenas posibles que satisfacen los criterios de sintaxis anteriores, incluida una cadena vac铆a.

Los operadores de deducci贸n, abstracci贸n y composici贸n se definen en el conjunto S. Los argumentos del operador se indican entre corchetes [] , porque los par茅ntesis est谩n reservados para la sintaxis de cadenas. El t茅rmino "operador" es sin贸nimo del t茅rmino "funci贸n".

Operador de deducci贸n . Definici贸n 鈭s 鈭 S , deducci贸n k [s] 鈭 S , k 鈭 N , k> 1, deducci贸n [s] 鈮 deducci贸n 2 [s] . Toma la cadena s de S como argumento. Como resultado, devuelve una cadena de S. Acci贸n. El operador k multiplica por dos cada componente de la cadena y toda la cadena. La estructura resultante est谩 enmarcada por corchetes externos comunes. La duplicaci贸n comienza con los componentes m谩s profundos, en t茅rminos de anidamiento. La fila completa se duplica al final. Para prop贸sitos pr谩cticos inmediatos, es suficiente que k = 2 , as铆 que defin铆 un caso especial de deducci贸n [s] 鈮 deducci贸n 2 [s] . El uso de la deducci贸n [] implica que k = 2 , es decir, como resultado del operador de deducci贸n [s] , todos los componentes de la cadena s se duplican. Ejemplos:

deducci贸n [(a)] = ((aa) (aa)).
deducci贸n [(aa)] = ((aaaa) (aaaa))
deducci贸n [(ab)] = ((aabb) (aabb)).
deducci贸n [(a (b))] = ((aa (bb) (bb)) (aa (bb) (bb))).
deducci贸n [((a) (b))] = (((aa) (aa) (bb) (bb)) ((aa) (aa) (bb) (bb))).
deducci贸n [((a) (b (cc)))] = (((aa) (aa) (bb (cccc) (cccc)) (bb (cccc) (cccc))) ((aa) (aa) ( bb (cccc) (cccc)) (bb (cccc) (cccc)))) .

Operador de abstracci贸n . Definici贸n 鈭s 鈭 S , abstracci贸n [s] 鈯 S. Toma la cadena s de S como argumento. Como resultado, devuelve muchas filas. Principio de acci贸n. Un operador de abstracci贸n crea muchas l铆neas a partir de una l铆nea fuente utilizando una operaci贸n especial: par茅ntesis de componentes id茅nticos. La operaci贸n de horquillado se aplica solo a los corchetes anidados que est谩n en el mismo nivel de anidamiento. El principio general del horquillado. Si en cualquier combinaci贸n de corchetes ubicados en el mismo nivel, los mismos componentes est谩n dentro de los corchetes, entonces cualquier conjunto de los mismos componentes se puede poner entre corchetes, y los componentes que permanecieron intactos deben combinarse bajo los mismos corchetes generales del mismo nivel. Considera un ejemplo. Cadena ((ab) (ac)) . En esta l铆nea, hay dos subcadenas en el mismo nivel: (ab) y (ac) , dentro de las cuales hay la misma mnemotecnia " a ", esta mnem贸nica se puede poner entre par茅ntesis y el resultado es (a (bc)) . Como puede ver, los mnem贸nicos restantes " b " y " c " se combinan entre par茅ntesis comunes. Considere un ejemplo menos obvio. La cadena ((aa) (aa)) contiene las subcadenas (aa) y (aa) , en este caso hay dos opciones diferentes para poner entre par茅ntesis. En la primera variante, solo se puede sacar una mnemotecnia " a " de los corchetes de cada subcadena, y en la segunda variante, se puede sacar un grupo de mnemotecnias " aa ". Consideremos ambas opciones con m谩s detalle.

Primera opci贸n, demostraci贸n paso a paso:

  1. Paso uno, elige ( rojo ) qu茅 sacar (( a a) ( a a)) .
  2. Paso dos, haga el seleccionado ( a (... a) (... a)) .
  3. Paso tres, combine los restos entre par茅ntesis comunes ( a (... a ... a)) .
  4. Resultado (a (aa)) .

La segunda opci贸n, en pasos:

  1. Paso uno, elige qu茅 sacar (( aa ) ( aa )) .
  2. Paso dos, haga el seleccionado ( aa (...) (...)) .
  3. Paso tres, combine los restos entre par茅ntesis comunes ( aa (...)) .
  4. Cuarto paso, deseche los componentes vac铆os ( aa ) .
  5. Resultado (aa) .

Vamos a complicar el ejemplo. Deje que se le d茅 la cadena ((aa) (aab) (aab)) , tiene tres subcadenas ubicadas en el mismo nivel: (aa) , (aab) , (aab) , las tres tienen el mismo contenido. La regla de par茅ntesis no nos obliga a realizar la operaci贸n para las tres subcadenas a la vez. Para la operaci贸n de replanteo, puede seleccionar cualquier grupo de subcadenas.

En este caso, hay tres opciones no id茅nticas para agrupar subcadenas:

  1. (aa), (aab) .
  2. (aab), (aab) .
  3. (aa), (aab), (aab) .

Realizamos todas las declaraciones posibles para cada una de las opciones de agrupaci贸n, paso a paso.

Agrupaci贸n (aa) , (aab) . Cadena ((aa) (aab) (aab)) .

La primera opcion:

  1. Seleccione el contenido (( a a) ( a ab) (aab)) .
  2. Sacamos ( a (... a) (... ab) (aab)) .
  3. Combinar ( a (... a ... ab) (aab)) .
  4. Resultado No. 1 (a (aab) (aab)) .

La segunda opci贸n:

  1. Seleccione el contenido (( aa ) ( aa b) (aab)) .
  2. Sacamos ( aa (...) (... b) (aab)) .
  3. Combinar ( aa (... b) (aab)) .
  4. Resultado No. 2 (a (b) (aab)) .

Agrupaci贸n (aab) , (aab) . Cadena ((aa) (aab) (aab)) .

La primera opcion:

  1. Seleccione el contenido ((aa) ( a ab) ( a ab)) .
  2. Sacamos ((aa) a (... ab) (... ab)) .
  3. Combina ((aa) a (... ab ... ab)) .
  4. Resultado No. 3 (a (aa) (aabb)) .

La segunda opci贸n:

  1. Seleccione el contenido ((aa) ( aa b) ( aa b)) .
  2. Sacamos ((aa) aa (... b) (... b)) .
  3. Combina ((aa) aa (... b ... b)) .
  4. Resultado No. 4 (aa (aa) (bb)) .

La tercera opci贸n:

  1. Seleccione el contenido ((aa) (a ab ) (a ab )) .
  2. Sacamos ((aa) ab (... a) (... a)) .
  3. Combina ((aa) ab (... a ... a)) .
  4. Resultado No. 5 (ab (aa) (aa)) .

Cuarta opci贸n:

  1. Seleccione el contenido ((aa) (aa b ) (aa b )) .
  2. Sacamos ((aa) b (... aa) (... aa)) .
  3. Combina ((aa) b (... aa ... aa)) .
  4. Resultado No. 6 (b (aa) (aaaa)) .

Quinta opci贸n:

  1. Seleccione el contenido ((aa) ( aab ) ( aab )) .
  2. Sacamos ((aa) aab (...) (...)) .
  3. Combina ((aa) aab (...)) .
  4. Resultado No. 7 (aab (aa)) .

Agrupaci贸n (aa) , (aab) , (aab) . Cadena ((aa) (aab) (aab)) .

La primera opcion:

  1. Seleccione el contenido (( a a) ( a ab) ( a ab)) .
  2. Sacamos ( a (... a) (... ab) (... ab)) .
  3. Combinar ( a (... a ... ab ... ab)) .
  4. Resultado No. 8 (a (aaabb)) .

La segunda opci贸n:

  1. Seleccione el contenido (( aa ) ( aa b) ( aa b)) .
  2. Sacamos ( aa (...) (... b) (... b)) .
  3. Combinar ( aa (... b ... b)) .
  4. Resultado No. 9 (aa (bb)) .

La acci贸n del operador de abstracci贸n . Como puede ver en el ejemplo, para la fila original ((aa) (aab) (aab)), hay nueve opciones diferentes para poner algo fuera de los corchetes, y nueve l铆neas resultantes corresponden a estas opciones. As铆 es como act煤a el operador de abstracci贸n: itera sobre todas las opciones posibles para poner entre corchetes y crea el conjunto correspondiente de filas resultantes. Adem谩s, el operador de abstracci贸n est谩 buscando opciones para distinguir no solo en la l铆nea de origen, sino tambi茅n en todas las l铆neas de resultado resultantes. En otras palabras, el operador de abstracci贸n se aplica de forma recursiva a sus resultados, y as铆 sucesivamente hasta que se agoten todas las opciones posibles. Por razones obvias, para cualquier l铆nea final, el n煤mero de posibles opciones de eliminaci贸n tambi茅n es limitado.

Volvamos al ejemplo anterior. En el ejemplo considerado, no escrib铆 todas las opciones posibles, sino solo nueve piezas del primer nivel. Para ilustrar el efecto completo del operador de abstracci贸n, es necesario construir todas las opciones para poner entre par茅ntesis para cada uno de los nueve resultados obtenidos previamente. Vamos a escribir todas las opciones, pero de una manera m谩s concisa.

Resultado No. 1 (a (aab) (aab)) :

1.1. (a ( a ab) ( a ab)) => (a a (aabb)) .
1.2. (a ( aa b) ( aa b)) => (a aa (bb)) .
1.3. (a (a ab ) (a ab )) => (a ab (aa)) . * No. 7
1.4. (a ( aab ) ( aab )) => ( aab ) .
1.5. (a (aa b ) (aa b )) => (a b (aaaa)) .
Resultado No. 2 (a (b) (aab)) :
2.1. (a ( b ) (aa b )) => (a b (aa)) .
Resultado No. 3 (a (aa) (aabb)) :
3.1. (a ( a a) ( a abb)) => (a a (aabb)) . * No. 1.1
3.2. (a ( aa ) ( aa bb)) => (a aa (bb)) . * No. 1.2
Resultado No. 4 (aa (aa) (bb)) .
Resultado No. 5 (ab (aa) (aa)) :
5.1. (ab ( a a) ( a a)) => ( a ab (aa)) . * No. 7, * No. 1.3
5.2. (ab ( aa ) ( aa )) => ( aa ab) . * No. 1.4
Resultado no 6 (b (aa) (aaaa)) :
6.1. (b ( a a) ( a aaa)) => ( a b (aaaa)) . * No. 1.5
6.2. (b ( aa ) ( aa aa)) => ( aa b (aa)) . * No. 7, * No. 1.3, * No. 5.1
Resultado No. 7 (aab (aa)) .
Resultado No. 8 (a (aaabb)) .
Resultado No. 9 (aa (bb)) .

Un asterisco indica opciones que se repiten. Solo se incluyen variaciones 煤nicas en el resultado de la abstracci贸n. En el ejemplo analizado, hay catorce l铆neas de resultados 煤nicas. Total:

abstracci贸n [((aa) (aab) (aab))] =
{
(a (aab) (aab)), (aa (aabb)), (aaa (bb)), (aaab), (a (b) (aab)), (ab (aa)), (a (aa) (aabb)), (aa (aa) (bb)), (ab (aa) (aa)), (b (aa) (aaaa)), (ab (aaaa)), (aab (aa)), ( a (aaabb)), (aa (bb))
}

Para mayor claridad, considere un par de ejemplos m谩s.

Cadena ((a (b)) (a (b))) . Opciones de par茅ntesis. Primera iteraci贸n:

(( a (b)) ( a (b))) => ( a ((b) (b))) , resultado No. 1.
((a (b) ) (a (b) )) => ( (b) (aa)) , resultado No. 2.
(( a (b) ) ( a (b) )) => ( a (b) ) , resultado No. 3.
En el primer resultado, se puede tomar una decisi贸n m谩s. Segunda iteraci贸n:
(a (( b ) ( b ))) => (a ( b )) , el resultado No. 1.2 coincide con el resultado No. 3.

Total: abstracci贸n [((a (b)) (a (b)))] = {(a ((b) (b))), ((b) (aa)), (a (b))}

Gran ejemplo:
abstracci贸n [ deducci贸n [(a (b))]] = abstracci贸n [((aa (bb) (bb)) (aa (bb) (bb)))] =>
1. ((aa ( b b) ( b b)) (aa (bb) (bb))) => ((aa b (b)) (aa (bb) (bb))) .
1.1. (( a ab (b)) ( a a (bb) (bb))) => ( a (aab (b) (bb) (bb))) .
1.1.1. (a (aab ( b ) ( b b) (bb))) => (a (aab b (b) (bb))) .
1.1.1.1. (a (aabb ( b ) ( b b))) => (a (aabb b (b))) .
1.1.2. (a (aab ( b ) ( b b) ( b b))) => (a (aab b (bb))) .
1.1.3. (a (aab (b) ( b b) ( b b))) => (a (aab b (b) (bb))) .
1.1.3.1. (a (aabb ( b ) ( b b))) => (a (aabb b (b))) .
1.1.4. (a (aab (b) ( bb ) ( bb ))) => (a (aab bb (b))) .
1.2. (( aa b (b)) ( aa (bb) (bb))) => ( aa (b (b) (bb) (bb))) .
1.2.1 (aa (b ( b ) ( b b) (bb))) => (aa (b b (b) (bb))) .
1.2.1.1. (aa (bb ( b ) ( b b))) => (aa (bb b (b))) .
1.2.2. (aa (b ( b ) ( b b) ( b b))) => (aa (b b (bb))) .
1.2.3 (aa (b (b) ( b b) ( b b))) => (aa (b b (b) (bb))) .
1.2.3.1. (aa (bb ( b ) ( b b))) => (aa (bb b (b))) .
1.2.4. (aa (b (b) ( bb ) ( bb ))) => (aa (b bb (b))) .
1.3. ((aab (b)) (aa ( b b) ( b b))) => ((aab (b)) (aa b (bb))) .
1.3.1. (( a ab (b)) ( a ab (bb))) => ( a (aabb (b) (bb))) .
1.3.1.1. (a (aabb ( b ) ( b b))) => (a (aabb b (b))) .
1.3.2. (( aa b (b)) ( aa b (bb))) => ( aa (bb (b) (bb))) .
1.3.2.1. (aa (bb ( b ) ( b b))) => (aa (bb b (b))) .
1.3.3. (( aab (b)) ( aab (bb))) => ( aab ((b) (bb))) .
1.3.3.1. (aab (( b ) ( b b))) => (aab ( b (b))) .
1.3.4. ((a ab (b)) (a ab (bb))) => ( ab (aa (b) (bb))) .
1.3.4.1. (ab (aa ( b ) ( b b))) => (ab (aa b (b))) .
1.3.5. ((aa b (b)) (aa b (bb))) => ( b (aaaa (b) (bb))) .
1.3.5.1. (b (aaaa ( b ) ( b b))) => (b (aaaa b (b))) .
1.4. ((aab (b)) (aa ( bb ) ( bb ))) => ((aab (b)) (aa bb )) .
1.4.1. (( a ab (b)) ( a abb)) => ( a (aabbb (b))) .
1.4.2. (( aa b (b)) ( aa bb)) => ( aa (bbb (b))) .
1.4.3. (( aab (b)) ( aab b)) => ( aab (b (b))) .
1.4.4. ((a ab (b)) (a ab b)) => ( ab (aab (b))) .
1.4.5. ((aa b (b)) (aa b b)) => ( b (aaaab (b))) .
2. ((aa ( bb ) ( bb )) (aa (bb) (bb))) => ((aa bb ) (aa (bb) (bb))) .
2.1. ((aabb) (aa ( b b) ( b b))) => ((aabb) (aa b (bb))) .
2.1.1 (( a abb) ( a ab (bb))) => ( a (aabbb (bb))) .
2.1.2. (( aa bb) ( aa b (bb))) => ( aa (bbb (bb))) .
2.1.3. (( aab b) ( aab (bb))) => ( aab (b (bb))) .
2.1.4. ((a ab b) (a ab (bb))) => ( ab (aab (bb))) .
2.1.5. ((aa b b) (aa b (bb))) => ( b (aaaab (bb))) .
2.2. ((aabb) (aa ( bb ) ( bb ))) => ((aabb) (aa bb )) .
2.2.1. (( a abb) ( a abb)) => ( a (aabbbb)) .
2.2.2. (( aa bb) ( aa bb)) => ( aa (bbbb)) .
2.2.3. (( aab b) ( aab b)) => ( aab (bb)) .
2.2.4. ((a abb ) (a abb )) => ( abb (aa)) .
2.2.5. (( aabb ) ( aabb )) => ( aabb ) .
2.2.6. ((a ab b) (a ab b)) => ( ab (aabb)) .
2.2.7. ((aa b b) (aa b b)) => ( b (aaaabb)) .
2.2.8. ((aa bb ) (aa bb )) => ( bb (aaaa)) .
2.3. (( a abb) ( a a (bb) (bb))) => ( a (aabb (bb) (bb))) .
2.3.1. (a (aabb ( b b) ( b b))) => (a (aabb b (bb))) .
2.3.2. (a (aabb ( bb ) ( bb ))) => (a (aabb bb )) .
2.4. (( aa bb) ( aa (bb) (bb))) => ( aa (bb (bb) (bb))) .
2.4.1 (aa (bb ( b b) ( b b))) => (aa (bb b (bb))) .
2.4.2 (aa (bb ( bb ) ( bb ))) => (aa (bb bb )) .
3. (( a a (bb) (bb)) ( a a (bb) (bb))) => ( a (aa (bb) (bb) (bb) (bb))) .
3.1. (a (aa ( b b) ( b b) (bb) (bb))) => (a (aa b (bb) (bb) (bb))) .
3.1.1. (a (aab ( b b) ( b b) (bb))) => (a (aab b (bb) (bb))) .
3.1.1.1. (a (aabb ( b b) ( b b))) => (a (aabb b (bb))) .
3.1.1.2. (a (aabb ( bb ) ( bb ))) => (a (aabb bb )) .
3.1.2. (a (aab ( b b) ( b b) ( b b))) => (a (aab b (bbb))) .
3.1.3. (a (aab ( bb ) ( bb ) (bb))) => (a (aab bb (bb))) .
3.1.4. (a (aab ( bb ) ( bb ) ( bb ))) => (a (aab bb )) .
3.2. (a (aa ( bb ) ( bb ) (bb) (bb))) => (a (aa bb (bb) (bb))) .
3.2.1. (a (aabb ( b b) ( b b))) => (a (aabb b (bb))) .
3.2.2. (a (aabb ( bb ) ( bb ))) => (a (aabb bb )) .
3.3. (a (aa ( b b) ( b b) ( b b) (bb))) => (a (aa b (bbb) (bb))) .
3.3.1 (a (aab ( b bb) ( b b))) => (a (aab b (bbb))) .
3.3.2. (a (aab ( bb b) ( bb ))) => (a (aab bb (b))) .
3.4. (a (aa ( b b) ( b b) ( b b) ( b b))) >> (a (aa b (bbbb))) .
3.5. (a (aa ( bb ) ( bb ) ( bb ) (bb))) => (a (aa bb (bb))) .
3.6. (a (aa ( bb ) ( bb ) ( bb ) ( bb ))) => (a (aa bb )) .
4. (( aa (bb) (bb)) ( aa (bb) (bb))) >> ( aa ((bb) (bb) (bb) (bb))) .
4.1. (aa (( b b) ( b b) (bb) (bb))) => (aa ( b (bb) (bb) (bb))) .
4.1.1 (aa (b ( b b) ( b b) (bb))) => (aa (b b (bb) (bb))) .
4.1.1.1. (aa (bb ( b b) ( b b))) => (aa (bb b (bb))) .
4.1.1.2. (aa (bb ( bb ) ( bb ))) => (aa (bb bb )) .
4.1.2. (aa (b ( b b) ( b b) ( b b))) => (aa (b b (bbb))) .
4.1.3. (aa (b ( bb ) ( bb ) (bb))) => (aa (b bb (bb))) .
4.1.4. (aa (b ( bb ) ( bb ) ( bb ))) => (aa (b bb )) .
4.2. (aa (( bb ) ( bb ) (bb) (bb))) => (aa ( bb (bb) (bb))) .
4.2.1 (aa (bb ( b b) ( b b))) => (aa (bb b (bb))) .
4.2.2 (aa (bb ( bb ) ( bb ))) => (aa (bb bb )) .
4.3. (aa (( b b) ( b b) ( b b) (bb))) => (aa ( b (bbb) (bb))) .
4.3.1. (aa (b ( b bb) ( b b))) => (aa (b b (bbb))) .
4.3.2. (aa (b ( bb b) ( bb ))) => (aa (b bb (b))) .
4.4. (aa (( b b) ( b b) ( b b) ( b b))) >> (aa ( b (bbbb))) .
4.5. (aa (( bb ) ( bb ) ( bb ) (bb))) => (aa ( bb (bb))) .
4.6. (aa (( bb ) ( bb ) ( bb ) ( bb ))) => (aa ( bb )) .
5. ((aa (bb) (bb)) (aa (bb) (bb))) => ( (bb) (aaaa (bb) (bb))) .
5.1. ((bb) (aaaa ( b b) ( b b))) => ((bb) (aaaa b (bb))) .
5.1.1 (( b b) (aaaa b (bb))) => ( b (aaaab (bb))) .
5.2. ((bb) (aaaa ( bb ) ( bb ))) => ((bb) (aaaa bb )) .
5.2.1. (( b b) (aaaa b b)) => ( b (aaaabb)) .
5.2.2. (( bb ) (aaaa bb )) => ( bb (aaaa)) .
6. ((aa (bb) (bb) ) (aa (bb) (bb) )) => ( (bb) (bb) (aaaa)) .
6.1. (( b b) ( b b) (aaaa)) => ( b (bb) (aaaa)) .
6.2. (( bb ) ( bb ) (aaaa)) => ( bb (aaaa)) .
7. ((a a (bb) (bb)) (a a (bb) (bb))) => ( a (bb) (aa (bb) (bb))) .
7.1. (a (bb) (aa ( b b) ( b b))) => (a (bb) (aa b (bb))) .
7.1.1 (a ( b b) (aa b (bb))) => (a b (aab (bb))) .
7.2. (a (bb) (aa ( bb ) ( bb ))) => (a (bb) (aa bb )) .
7.2.1 (a ( b b) (aa b b)) => (a b (aabb)) .
7.2.2 (a ( bb ) (aa bb )) => (a bb (aa)) .
8. (( aa (bb) (bb)) ( aa (bb) (bb))) => ( aa (bb) ((bb) (bb))) .
8.1. (aa (bb) (( b b) ( b b))) => (aa (bb) ( b (bb))) .
8.1.1 (aa ( b b) ( b (bb))) => (aa b (b (bb))) .
8.2. (aa (bb) (( bb ) ( bb ))) => (aa (bb) ( bb )) .
8.2.1. (aa ( b b) ( b b)) => (aa b (bb)) .
8.2.2. (aa ( bb ) ( bb )) => (aa bb ) .
9. ((a a (bb) (bb) ) (a a (bb) (bb) )) => ( a (bb) (bb) (aa)) .
9.1. (a (aa) ( b b) ( b b)) => (a b (aa) (bb)) .
9.2. (a (aa) ( bb ) ( bb )) => (a bb (aa)) .
10. (( aa (bb) (bb) ) ( aa (bb) (bb) )) => ( a (bb) (bb) ) .
10.1 (a ( b b) ( b b)) => (a b (bb)) .
10.2 (a ( bb ) ( bb )) => (a bb ) .

De la lista anterior de filas resultantes (a la derecha de la flecha), debe seleccionar todas las 煤nicas, y este conjunto de filas 煤nicas ser谩 el resultado de la abstracci贸n [((aa (bb) (bb)) (aa (bb) (bb))]] . No escribir茅 l铆neas 煤nicas, ya que esto no agregar谩 nada a la explicaci贸n. A continuaci贸n, al considerar la optimizaci贸n y el uso pr谩ctico del algoritmo, me referir茅 a este ejemplo.


Operador de composici贸n . Definici贸n 鈭U 鈯 S , U 鈮 鈭, composici贸n [U] 鈮 鈭, composici贸n [U] 鈭 S. Acepta muchas l铆neas de entrada y devuelve una l铆nea. Acci贸n. El operador prepara el contenido para la pr贸xima iteraci贸n del algoritmo. Despu茅s de la acci贸n del operador de abstracci贸n, aparecen muchas l铆neas, y en la etapa de composici贸n, se produce la selecci贸n y concatenaci贸n de l铆neas para la pr贸xima iteraci贸n del algoritmo. Con m谩s detalle considerar茅 este tema en las secciones de optimizaci贸n y uso pr谩ctico. En el caso m谩s simple, el operador de composici贸n realiza una concatenaci贸n simple de todos los resultados de abstracci贸n. Entonces lo definimos. Ejemplo: composici贸n [ abstracci贸n [((a (b)) (a (b)))]] = composici贸n [{(a ((b) (b))), ((b) (aa)), (a ( b))}] = ((a ((b) (b))) ((b) (aa)) (a (b))) .

Propiedades del algoritmo


El algoritmo produce cadenas. El conjunto de todas las l铆neas que se forman como resultado de la operaci贸n iterativa del algoritmo se denominar谩 "salida del algoritmo" o simplemente "salida". Definici贸n de inferencia. T s 鈮 {t n | t n + 1 = composici贸n [ abstracci贸n [ deducci贸n [t n ]]]; t 0 = s; t n , s 鈭 S ; n 鈭 N }. T s es la salida para la semilla s . En aquellos casos en los que T no tiene un par谩metro, estamos hablando de la conclusi贸n de cualquier semilla. Propiedad de inferencia: 鈭s, e 鈭 S , s 鈮 鈭, e 鈮 鈭, s 鈮 e, T sT e = 鈭 . Esto significa que cada elemento de salida corresponde 煤nicamente a la semilla. Como resultado, la conclusi贸n es 煤nica para cada semilla.

Una interpretaci贸n significativa de la deducci贸n y la abstracci贸n . El significado f铆sico del operador de deducci贸n es el siguiente. A partir de la l铆nea original, de manera universal, el operador de deducci贸n crea un objeto constructivo fundamentalmente nuevo con propiedades internas fundamentalmente nuevas y m谩s complejas. En una aproximaci贸n intuitiva, podemos decir que la deducci贸n agrega informaci贸n cualitativamente nueva. A su vez, el operador de abstracci贸n analiza el nuevo objeto en partes y, por lo tanto, expresa la informaci贸n agregada en la etapa de deducci贸n en un equivalente constructivo. Puede notar que como resultado del procedimiento de eliminaci贸n de par茅ntesis hay una p茅rdida de informaci贸n. Adem谩s, para esta sintaxis, poner entre par茅ntesis es una forma universal de perder informaci贸n de manera significativa en ausencia de datos a priori sobre el valor de las cadenas. Es decir, desde el punto de vista del algoritmo, todas las opciones posibles para la p茅rdida de informaci贸n que se calculan en la etapa de abstracci贸n, de hecho, son el valor de las l铆neas. Por lo tanto, en cada paso, el algoritmo crea una nueva heur铆stica sint谩ctica 煤nica. Y cada heur铆stica posterior es fundamentalmente m谩s compleja y m谩s sustancial que la anterior. En cada iteraci贸n del algoritmo, aparece un nuevo conocimiento.

Aplicaci贸n pr谩ctica


El algoritmo es una "cosa en s铆 misma".脡l piensa, pero este es el pensamiento de un "extraterrestre". Para obtener beneficios pr谩cticos del pensamiento extraterrestre, debes encontrar un lenguaje com煤n con 茅l. Por un lado, se requiere entrenar a un extraterrestre y, por otro lado, aprender a entenderlo, al final, para establecer una comunicaci贸n significativa. En general, el paradigma de interacci贸n con el algoritmo es similar a los conocidos principios de interacci贸n con la "caja negra". Adem谩s, para mayor comodidad, llamar茅 al algoritmo de pensamiento el alien Kohl.

Considere el caso ideal. Supongamos que tenemos un poder de c贸mputo ilimitado a nuestra disposici贸n y podemos permitirnos calcular cualquier n煤mero de iteraciones del pensamiento de Kolya sin preocuparnos por los problemas de optimizaci贸n. En este caso, se requerir谩n los siguientes ingredientes para interactuar con Kolya:

  1. Un modelo digital de un entorno interactivo cuyo significado de actividad es conocido.
  2. Un modelo digital de una herramienta que puede afectar el medio ambiente.
  3. Codificaci贸n de algoritmo para se帽ales codifican desde el entorno de cadenas S .
  4. Un algoritmo de decodificaci贸n que ser谩 de alguna manera difuso, pero racionalmente justificado para decodificar l铆neas previamente desconocidas de S y convertirlas en se帽ales para el instrumento.

Con tales componentes, es posible organizar un esquema de aprendizaje universal con una motivaci贸n desconocida, que permitir谩 adaptar el pensamiento de Kolya al entorno. A continuaci贸n se muestra el pseudoc贸digo.

S NextThought(S prevThought, S ExternalSignal, int exposure = 1) { S t = composition[prevThought, ExternalSignal]; for (int i = 0; i < exposure; i++) t = composition[abstraction[deduction[t]]]; return t; } EnvironmentModel e; S s = encode(e.GetState()); S o = 鈭; while (0) { S o = NextThought(o, s); e.ImpactTool.perform(decode(o)); s = encode(e.GetState()); } 

Circuito de retroalimentaci贸n . Al principio, Kolya no tiene pensamientos. El primer pensamiento de Kolya es el estado inicial codificado del medio. En cada iteraci贸n, una se帽al externa se vierte en el pensamiento de Kolya. Despu茅s de lo cual Kolya piensa durante el tiempo de exposici贸n. Los resultados del pensamiento son decodificados y enviados a la herramienta. A su vez, la acci贸n de la herramienta de alguna manera cambia el estado del entorno. Y todo se repite de nuevo. Con el tiempo, el pensamiento de Kolya se adaptar谩 al entorno y comenzar谩 a mostrar signos de comportamiento altamente organizado y motivado subjetivamente. Sin embargo, la motivaci贸n de Kolya seguir谩 siendo desconocida. Para comprender su motivaci贸n, en la siguiente etapa del entrenamiento, es necesario realizar experimentos, es decir, cambiar a prop贸sito el entorno y estudiar las reacciones de Kolya a los cambios. Si es posible describir el comportamiento externo deseado de Kolya en t茅rminos de alguna funci贸n objetivo, entonces el proceso de aprendizaje puede automatizarse, por ejemplo, utilizando un algoritmo gen茅tico.

Problema de decodificaci贸n . Es necesario decodificar los pensamientos de Kolya para sintetizar una se帽al para el instrumento. La dificultad es que cada pensamiento, como se帽al茅 en la secci贸n anterior, es un dise帽o fundamentalmente nuevo. Es decir, un investigador hipot茅tico nunca puede comprender completamente el contenido de los pensamientos de Kolya. Parte del contenido producido por el pensamiento de Kolya, no importa cu谩nto se estudie, siempre ser谩 algo completamente oscuro. Solo algunos de los fragmentos de pensamiento m谩s altamente organizados pueden ser reconocidos de manera significativa, y esta es una restricci贸n fundamental e insuperable en la comunicaci贸n con Kolya. Pero en t茅rminos pr谩cticos, esta restricci贸n no es fundamental. Dado que, en primer lugar, se puede especificar infinitamente el lado significativo de los pensamientos de Kolya, y en segundo lugar, no hay necesidad de comprender completamente a Kolya. Es suficiente desarrollar un lenguaje com煤n dentro del cual pueda explicar sobre cuestiones pr谩cticas. Desde un punto de vista t茅cnico, la situaci贸n es la siguiente. La se帽al entrante que describe el estado del medio est谩 codificada en alg煤n idioma. Las palabras y las declaraciones del lenguaje son cadenas de S. El lenguaje tiene su propio vocabulario, sintaxis y sem谩ntica. El contenido de cada iteraci贸n de pensamiento de acuerdo con criterios gramaticales se dividir谩 en varias categor铆as:

1. Fragmentos con vocabulario desconocido.
2. Sintaxis desconocida.
3. Sem谩ntica desconocida.
4. Fragmentos gramatical y sem谩nticamente correctos.

El contenido de todas estas categor铆as es arbitrario seg煤n el m茅todo de ocurrencia. Es decir, incluso en el caso de fragmentos gramaticalmente correctos, esto es un accidente y no se sabe qu茅 significado les da Kolya, ya que su significado interno es accesible solo para 茅l. A priori, no hay criterios para conectar correctamente los pensamientos de Kolya y las acciones correspondientes del instrumento. Y en este asunto queda depender 煤nicamente del propio Kolya. Su comportamiento es arbitrario y solo 茅l puede comprender su motivaci贸n a medida que aumenta el grado de organizaci贸n de su pensamiento. En este caso, cualquier esquema racional para responder a los pensamientos de Kolya ser谩 aceptable y productivo, la 煤nica pregunta es la efectividad relativa de los diversos esquemas. La opci贸n b谩sica es responder a todos los fragmentos gramaticalmente correctos, incluso si su contenido es absurdo. En general, todo lo que se puede convertir en t茅rminos de la codificaci贸n original debe transformarse y reaccionar. Y as铆 sucesivamente hasta que Kohl "se dio cuenta" de reacciones significativas. Y, por supuesto, ser谩 煤til el modelo m谩s pl谩stico del entorno con un gran n煤mero de grados de libertad. El medio, de alguna manera, se convertir谩 en el cuerpo de Kolya.

El problema de la potencia inform谩tica limitada . En t茅rminos de la cantidad de c谩lculo, el algoritmo es pesado. Claramente, varias docenas de iteraciones agotar谩n toda la potencia inform谩tica del planeta. Podemos confiar en dispositivos cu谩nticos y en el hecho de que existe un an谩logo cu谩ntico del algoritmo, pero hasta ahora solo ha habido una salida: en lugar de un pensamiento enormemente complejo, piense muchos pensamientos peque帽os y simples en paralelo. Hay varios trucos t茅cnicos para esto:

1. En la etapa de composici贸n, no es necesario incluir en el resultado todas las muchas abstracciones. Para que el algoritmo conserve sus propiedades fundamentales, es suficiente seleccionar del conjunto solo dos filas resultantes independientes. El criterio de independencia es la diferencia distinta de cero de los primeros d铆gitos en la numeraci贸n jer谩rquica de los resultados de la abstracci贸n. Pasamos al gran ejemplo, que es m谩s alto bajo el spoiler. Todas las l铆neas est谩n numeradas seg煤n el principio de abcd. Un par de l铆neas con 铆ndices a1.b1.c1.d1 ... , a2.b2.c2.d2 ... se llama independiente si a1 鈮 a2 . Y esto significa que es posible dividir todo el resultado de la abstracci贸n en pares independientes y para cada par en el siguiente paso, comenzar su propia rama computacional. Adem谩s, no es necesario utilizar todos los resultados de la abstracci贸n. En el caso m铆nimo, puede seleccionar solo un par de l铆neas y descartar todo el resto (perder irrevocablemente) y se conservar谩n todos los principios de pensamiento. Dada la capacidad de perder resultados, es posible organizar una etapa de selecci贸n adicional, en la cual, de alguna manera racional, por ejemplo, de acuerdo con la significaci贸n estad铆stica, seleccionar contenido para c谩lculos posteriores.

2. El segundo truco se basa en el supuesto de que cuanto m谩s se colocan los corchetes en la l铆nea, menos organizado es el contenido que contienen. En consecuencia, el contenido "emergente" como resultado de los corchetes es m谩s organizado y abstracto desde el punto de vista de los significados internos de Kolya, lo que significa que se pueden eliminar los niveles profundos de anidaci贸n. Por lo tanto, la cantidad de c谩lculo en la siguiente iteraci贸n disminuye exponencialmente. En un sentido intuitivo, este procedimiento le permite aproximar solo la parte m谩s abstracta del pensamiento.

3. Como resultado de la paralelizaci贸n a muchas ramas m谩s peque帽as, los c谩lculos crecer谩n "en ancho". Este ancho puede estar absolutamente limitado por la selecci贸n no solo a nivel de ramas de computaci贸n individuales, sino tambi茅n en toda la gama de ramas paralelas. Esto se puede hacer a trav茅s de un grupo com煤n de un tama帽o fijo, desde donde cada rama dibujar谩 l铆neas para la pr贸xima iteraci贸n y, en consecuencia, donde volcar谩 los resultados. Y para las cadenas, puede limitar absolutamente el nivel permitido de anidamiento de corchetes. Tal enfoque combinado ayudar谩 a frenar y regular el crecimiento del volumen de c谩lculos.

Interpretaci贸n y comentario


Evidencia No hay evidencia y no puede ser. Cualquier teor铆a del pensamiento es una cuesti贸n de definici贸n. El algoritmo presentado es una teor铆a constructiva del pensamiento. Y por lo tanto 茅l es un axioma. El algoritmo de pensamiento es apod铆cticamente reconocible para el sujeto del pensamiento. El reconocimiento se puede facilitar recurriendo primero a una axiom谩tica no constructiva que sea m谩s intuitiva, y luego encuentre la coincidencia de las propiedades de las definiciones constructivas y no constructivas.

Definici贸n no constructiva del pensamiento . Pensar no es una producci贸n algor铆tmica de contenido. En una comprensi贸n intuitiva, los fen贸menos no algor铆tmicos tienen las siguientes caracter铆sticas espec铆ficas: independencia, espontaneidad, singularidad, autoorganizaci贸n, arbitrariedad, subjetividad, complejidad, imprevisibilidad fundamental e incertidumbre, la ausencia de barreras conceptuales y, en el sentido m谩s amplio, una posibilidad inherente y duradera de novedad fundamental. Todas las caracter铆sticas enumeradas son de alguna manera inherentes al algoritmo de pensamiento descrito. Aunque la combinaci贸n de un algoritmo y propiedades no algor铆tmicas no es intuitiva y a primera vista es contradictoria, de hecho no hay contradicci贸n. El algoritmo despliega contenido utilizando procedimientos algor铆tmicos bien definidos, pero en el proceso de implementaci贸n, el contenido tiene una organizaci贸n no algor铆tmica. Dados los detalles de dise帽o del algoritmo, las propiedades no alerg铆tmicas en la organizaci贸n del contenido se derivan de las propiedades propias, internas y no algor铆tmicas del contenido mismo.

Puntos de vista adicionales sobre el algoritmo . El algoritmo de pensamiento es, que incluye:

1. Implementaci贸n constructiva de una met谩fora. Pensar es esencialmente metaf贸rico. No hay otros significados adem谩s de figurativo (posible). Sin embargo, en sentido figurado, son posibles los significados literales (algoritmos).
2. Modelo de autoorganizaci贸n del caos absoluto. Un modelo de espontaneidad conceptual.
3. Un modelo de comportamiento completamente independiente, subjetivamente motivado. Modelo de creatividad.
4. Lenguaje autoorganizado.
5. El modelo de aproximaci贸n constructiva, para la sem谩ntica no constructiva, puramente posible.

Conciencia La cuesti贸n de la conciencia tambi茅n se resuelve a nivel de definici贸n. La conciencia es algo que se encuentra m谩s all谩 de cualquier limitaci贸n conceptual. A la luz de tal definici贸n, uno solo puede envenenar historias m谩s o menos complicadas sobre la conciencia, cada una de las cuales reflejar谩 algunas posibilidades de conciencia, pero ninguna de ellas ser谩 verdadera. Al mismo tiempo, las historias sobre la conciencia tienen potenciales heur铆sticos diferentes. De todos los cuentos, los que son m谩s dif铆ciles son m谩s 煤tiles. Desde el punto de vista de los algoritmos, la conciencia es un objeto trans-algor铆tmico, infinitamente complejo (o simplemente complejo). Un cuento de conciencia se puede grabar usando un algoritmo. Suena as铆:

lim n 鈫 鈭 [t n + 1 = composici贸n [ abstracci贸n [ deducci贸n [t n ]]]]; t 0 = s; t n , s 鈭 S ; n 鈭 N

Source: https://habr.com/ru/post/440424/


All Articles