Algorithme de pensée et de conscience

Cet article décrit un algorithme pour la pensée et la conscience. J'offre ma réponse à la question du fonctionnement de la pensée et de la conscience. Et je démontre un algorithme qui peut vraiment, de façon créative penser et posséder une vraie conscience. L'article est destiné aux programmeurs et se compose de deux parties principales. La première partie est purement technique, elle contient une description de l'algorithme, une liste de ses propriétés et un exemple d'application pratique. La deuxième partie contient des thèses explicatives et une solution à la question de l'axiomatisation constructive de la conscience. Un algorithme est un texte significatif qui parle de lui-même, et il n'y aura donc que des commentaires minimum pratiquement nécessaires.

Description de l'algorithme

La description de l'algorithme est effectuée dans un formalisme mathématique fait maison sur le principe du "haut en bas", c'est-à-dire que l'enregistrement final abstrait est d'abord donné, puis l'algorithme est analysé pour les parties dans l'ordre dans lequel les appels sont effectués et les commentaires sont donnés. Ainsi, l'algorithme «assemblé» est une fonction récursive de la forme suivante:

t _{n + 1} = composition [ abstraction [ déduction [t _n ]]]; t ₀ = s; t _n , s ∈ S ; n ∈ N

Le calcul de cette fonction est en train de penser. Comme vous pouvez le voir, trois opérateurs apparaissent dans l'enregistrement:
composition [] , abstraction [] , déduction [] ; il y a aussi: la variable de départ s ∈ S , l'ensemble des lignes d'une forme spéciale S et le numéro d'étape n ∈ N. Ensuite, nous considérons en détail chaque pièce de rechange. Nous commençons par l'ensemble S et ses éléments.

Afin de spécifier l'ensemble S, il est nécessaire de déterminer la syntaxe dans laquelle les éléments de cet ensemble seront écrits. Les éléments de l'ensemble S seront appelés chaînes. Toute ligne de S est constituée d'une hiérarchie de crochets «(«, »)» et des identificateurs de caractères arbitraires sont écrits à l'intérieur des crochets. Afin d'éviter l'utilisation du terme «identifiant», car il peut être requis à d'autres fins, les identifiants symboliques entre parenthèses seront appelés «mnémoniques». Chaque mnémonique est écrit en caractères latins «A - z». Les mnémoniques entre parenthèses peuvent être séparés par une virgule «,». Si la longueur des mnémoniques est fixe, ce qui est spécifié séparément, le séparateur n'est pas défini. Les mnémoniques sont écrits uniquement entre parenthèses. Une ligne peut contenir des crochets imbriqués. La hiérarchie des crochets dans la chaîne est arbitraire, mais il doit y avoir un crochet de fermeture pour chaque crochet d'ouverture. Dans cet article, je n'utiliserai que des minuscules de l'alphabet latin pour écrire des mnémoniques, et la longueur des mnémoniques sera fixe, une lettre correspond à une mnémonique, je ne mets pas de séparateur. Exemples de lignes:

() ≡ ∅ est une chaîne vide.
(a) - une chaîne contenant une mnémonique « a ».
(aa) - une chaîne contenant deux instances des mnémoniques « a ».
(ab) est une chaîne contenant deux mnémoniques « a » et « b ».
((a) (a)) - la ligne contient deux copies des mnémoniques « a » et des niveaux de crochets imbriqués.

Les parenthèses jointes, ainsi que leur contenu, ainsi que les mnémoniques individuelles, sont parfois appelés «composants de chaîne», dans les cas où une généralisation appropriée est requise. Par exemple, la ligne ((a) ab) contient quatre composants, parmi eux: deux composants " a ", un composant " (a) " et un composant " b ".

Les enregistrements de chaînes qui correspondent à un réarrangement des composants dans la chaîne sont considérés comme identiques. Exemples de lignes identiques:

(ab) ≡ (ba) .
((a) (b)) ≡ ((b) (a)) .
(abc) ≡ (bac) ≡ (cba) ≡ (acb) ≡ (bca) ≡ (cabine) .
((a) (ab)) ≡ ((a) (ba)) ≡ ((ab) (a)) ≡ ((ba) (a)) .

Les lignes peuvent contenir un nombre illimité de composants identiques et répétitifs, et dans ce cas, un enregistrement plus court est possible en utilisant l'index de répétition, qui est placé devant le composant à gauche, sans séparateur. Exemples:

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

Dans les cas où la chaîne contient des composants vides, par exemple, (a ()) , (a () () (b)), les identités contiennent: (a ()) ≡ (a) , (a () () (b )) ≡ (a (b)) , c'est-à-dire que les composants vides sont jetés.

Définition L'ensemble S comprend toutes les chaînes possibles qui satisfont aux critères de syntaxe ci-dessus, y compris une chaîne vide.

Les opérateurs de déduction, d'abstraction et de composition sont définis sur l'ensemble S. Les arguments des opérateurs sont indiqués entre crochets [] , car les parenthèses sont réservées à la syntaxe des chaînes. Le terme «opérateur» est synonyme du terme «fonction».

Opérateur de déduction . Définition ∀s ∈ S , déduction ^k [s] ∈ S , k ∈ N , k> 1, déduction [s] ≝ déduction ² [s] . Prend la chaîne s de S comme argument. Par conséquent, retourne une chaîne de S. Action. L'opérateur k fois duplique chaque composant de la chaîne et la chaîne entière. La structure résultante est encadrée par des supports extérieurs communs. La duplication commence par les composants les plus profonds, en termes d'imbrication. La ligne entière est dupliquée en dernier. Pour des raisons pratiques immédiates, il suffit que k = 2 , j'ai donc défini un cas particulier de déduction [s] ≝ déduction ² [s] . L'utilisation de la déduction [] implique que k = 2 , c'est-à-dire qu'en raison de l'opérateur deduction [s] , toutes les composantes de la chaîne s sont doublées. Exemples:

déduction [(a)] = ((aa) (aa)).
déduction [(aa)] = ((aaaa) (aaaa))
déduction [(ab)] = ((aabb) (aabb)).
déduction [(a (b))] = ((aa (bb) (bb)) (aa (bb) (bb))).
déduction [((a) (b))] = (((aa) (aa) (bb) (bb)) ((aa) (aa) (bb) (bb))).
déduction [((a) (b (cc)))] = (((aa) (aa) (bb (cccc) (cccc)) (bb (cccc) (cccc))) ((aa) (aa) ( bb (cccc) (cccc)) (bb (cccc) (cccc))))) .

Opérateur d'abstraction . Définition ∀s ∈ S , abstraction [s] ⊂ S. Prend la chaîne s de S comme argument. Par conséquent, il renvoie de nombreuses lignes. Principe d'action. Un opérateur d'abstraction crée un grand nombre de lignes à partir d'une ligne source à l'aide d'une opération spéciale - parenthèse de composants identiques. L'opération de bracketing s'applique uniquement aux brackets imbriqués qui sont au même niveau d'imbrication. Le principe général du bracketing. Si dans n'importe quelle combinaison de supports situés au même niveau, les mêmes composants sont à l'intérieur des supports, alors tout ensemble des mêmes composants peut être mis hors des supports, et les composants qui sont restés intacts doivent être combinés sous les mêmes supports généraux du même niveau. Prenons un exemple. Chaîne ((ab) (ac)) . Sur cette ligne, il y a deux sous-chaînes au même niveau: (ab) et (ac) , à l'intérieur desquelles se trouvent les mêmes mnémoniques " a ", ces mnémoniques peuvent être mis entre parenthèses et le résultat est (a (bc)) . Comme vous pouvez le voir, les mnémoniques restants " b " et " c " sont combinés entre crochets communs. Prenons un exemple moins évident. La chaîne ((aa) (aa)) contient les sous-chaînes (aa) et (aa) , dans ce cas, il existe deux options différentes pour la suppression des crochets. Dans la première variante, une seule mnémonique " a " peut être retirée des crochets de chaque sous-chaîne, et dans la deuxième variante, un groupe de mnémoniques " aa " peut être retiré. Examinons les deux options plus en détail.

Première option, démonstration étape par étape:

1. Première étape, choisissez ( rouge ) quoi emporter (( a a) ( a a)) .
2. Étape deux, effectuez la sélection ( a (... a) (... a)) .
3. Étape trois, combinez les restes entre parenthèses communes ( a (... a ... a)) .
4. Résultat (a (aa)) .

La deuxième option, par étapes:

1. Première étape, choisissez quoi emporter (( aa ) ( aa )) .
2. Étape deux, effectuez la sélection ( aa (...) (...)) .
3. Étape trois, combinez les restes entre parenthèses communes ( aa (...)) .
4. Quatrième étape, jetez les composants vides ( aa ) .
5. Résultat (aa) .

Compliquons l'exemple. Qu'on lui donne la chaîne ((aa) (aab) (aab)) , elle a trois sous-chaînes situées au même niveau: (aa) , (aab) , (aab) , toutes les trois ont le même contenu. La règle de parenthèse ne nous oblige pas à effectuer l'opération pour les trois sous-chaînes à la fois. Vous pouvez sélectionner n'importe quel groupe de sous-chaînes pour l'opération de jalonnement.

Dans ce cas, il existe trois options non identiques pour regrouper les sous-chaînes:

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

Nous réalisons toutes les déclarations possibles pour chacune des options de regroupement, étape par étape.

Regroupement (aa) , (aab) . Chaîne ((aa) (aab) (aab)) .

La première option:

1. Sélectionnez le contenu (( a a) ( a ab) (aab)) .
2. Nous supprimons ( a (... a) (... ab) (aab)) .
3. Combinez ( a (... a ... ab) (aab)) .
4. Résultat n ° 1 (a (aab) (aab)) .

La deuxième option:

1. Sélectionnez le contenu (( aa ) ( aa b) (aab)) .
2. Nous supprimons ( aa (...) (... b) (aab)) .
3. Combinez ( aa (... b) (aab)) .
4. Résultat n ° 2 (a (b) (aab)) .

Regroupement (aab) , (aab) . Chaîne ((aa) (aab) (aab)) .

La première option:

1. Sélectionnez le contenu ((aa) ( a ab) ( a ab)) .
2. On enlève ((aa) a (... ab) (... ab)) .
3. Combinez ((aa) a (... ab ... ab)) .
4. Résultat n ° 3 (a (aa) (aabb)) .

La deuxième option:

1. Sélectionnez le contenu ((aa) ( aa b) ( aa b)) .
2. On enlève ((aa) aa (... b) (... b)) .
3. Combinez ((aa) aa (... b ... b)) .
4. Résultat n ° 4 (aa (aa) (bb)) .

La troisième option:

1. Sélectionnez le contenu ((aa) (a ab ) (a ab )) .
2. Nous supprimons ((aa) ab (... a) (... a)) .
3. Combinez ((aa) ab (... a ... a)) .
4. Résultat n ° 5 (ab (aa) (aa)) .

Quatrième option:

1. Sélectionnez le contenu ((aa) (aa b ) (aa b )) .
2. On enlève ((aa) b (... aa) (... aa)) .
3. Combinez ((aa) b (... aa ... aa)) .
4. Résultat n ° 6 (b (aa) (aaaa)) .

Cinquième option:

1. Sélectionnez le contenu ((aa) ( aab ) ( aab )) .
2. Nous sortons ((aa) aab (...) (...)) .
3. Combinez ((aa) aab (...)) .
4. Résultat n ° 7 (aab (aa)) .

Regroupement (aa) , (aab) , (aab) . Chaîne ((aa) (aab) (aab)) .

La première option:

1. Sélectionnez le contenu (( a a) ( a ab) ( a ab)) .
2. On enlève ( a (... a) (... ab) (... ab)) .
3. Combinez ( a (... a ... ab ... ab)) .
4. Résultat n ° 8 (a (aaabb)) .

La deuxième option:

1. Sélectionnez le contenu (( aa ) ( aa b) ( aa b)) .
2. On enlève ( aa (...) (... b) (... b)) .
3. Combinez ( aa (... b ... b)) .
4. Résultat n ° 9 (aa (bb)) .

L'action de l'opérateur d'abstraction . Comme vous pouvez le voir dans l'exemple, pour la ligne d'origine ((aa) (aab) (aab)), il y a neuf options différentes pour mettre quelque chose hors des crochets, et neuf lignes résultantes correspondent à ces options. C'est ainsi que l'opérateur d'abstraction agit - itère sur toutes les options possibles pour la suppression des crochets et crée l'ensemble correspondant des lignes résultantes. De plus, l'opérateur d'abstraction recherche des options pour distinguer non seulement dans la ligne source, mais aussi dans toutes les lignes de résultat résultantes. En d'autres termes, l'opérateur d'abstraction est appliqué récursivement à ses résultats, et ainsi de suite jusqu'à épuisement de toutes les options possibles. Pour des raisons évidentes, pour toute ligne finale, le nombre d'options de suppression possibles est également limité.

Revenons à l'exemple précédent. Dans l'exemple considéré, je n'ai pas écrit toutes les options possibles, mais seulement neuf morceaux du premier niveau. Afin d'illustrer le plein effet de l'opérateur d'abstraction, il est nécessaire de construire toutes les options de mise en parenthèses pour chacun des neuf résultats précédemment obtenus. Nous écrirons toutes les options, mais de manière plus concise.

Résultat n ° 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)) . * N ° 7
1.4. (a ( aab ) ( aab )) => (a aab ) .
1.5. (a (aa b ) (aa b )) => (a b (aaaa)) .
Résultat n ° 2 (a (b) (aab)) :
2.1. (a ( b ) (aa b )) => (a b (aa)) .
Résultat n ° 3 (a (aa) (aabb)) :
3.1. (a ( a a) ( a abb)) => (a a (aabb)) . * N ° 1.1
3.2. (a ( aa ) ( aa bb)) => (a aa (bb)) . * N ° 1.2
Résultat n ° 4 (aa (aa) (bb)) .
Résultat n ° 5 (ab (aa) (aa)) :
5.1. (ab ( a a) ( a a)) => ( a ab (aa)) . * N ° 7, * n ° 1.3
5.2. (ab ( aa ) ( aa )) => ( aa ab) . * Non. 1.4
Résultat n ° 6 (b (aa) (aaaa)) :
6.1. (b ( a a) ( a aaa)) => ( a b (aaaa)) . * N ° 1,5
6.2. (b ( aa ) ( aa aa)) => ( aa b (aa)) . * N ° 7, * N ° 1.3, * N ° 5.1
Résultat n ° 7 (aab (aa)) .
Résultat n ° 8 (a (aaabb)) .
Résultat n ° 9 (aa (bb)) .

Un astérisque indique les options qui sont répétées. Seules des variations uniques sont incluses dans le résultat de l'abstraction. Dans l'exemple analysé, il y a quatorze lignes de résultats uniques. Total:

abstraction [((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))
}

Pour plus de clarté, considérons quelques exemples supplémentaires.

Chaîne ((a (b)) (a (b))) . Options de parenthèses. Première itération:

(( a (b)) ( a (b))) => ( a ((b) (b))) , résultat n ° 1.
((a (b) ) (a (b) )) => ( (b) (aa)) , résultat n ° 2.
(( a (b) ) ( a (b) )) => ( a (b) ) , résultat n ° 3.
Dans le premier résultat, une décision de plus peut être prise. Deuxième itération:
(a (( b ) ( b ))) => (a ( b )) , le résultat n ° 1.2 coïncide avec le résultat n ° 3.

Total: abstraction [((a (b)) (a (b)))] = {(a ((b) (b))), ((b) (aa)), (a (b))}



Opérateur de composition . Définition ∀U ⊂ S , U ≠ ∅, composition [U] ≠ ∅, composition [U] ∈ S. Il accepte plusieurs lignes d'entrée et renvoie une ligne. Action. L'opérateur prépare le contenu pour la prochaine itération de l'algorithme. Après l'action de l'opérateur d'abstraction, de nombreuses lignes apparaissent et au stade de la composition, la sélection et la concaténation des lignes pour la prochaine itération de l'algorithme se produisent. Plus en détail, j'examinerai ce problème dans les sections d'optimisation et d'utilisation pratique. Dans le cas le plus simple, l'opérateur de composition effectue une concaténation simple de tous les résultats d'abstraction. Nous le définissons donc. Exemple: composition [ abstraction [((a (b)) (a (b)))]] = composition [{(a ((b) (b))), ((b) (aa)), (a ( b))}] = ((a ((b) (b))) ((b) (aa)) (a (b))) .

Propriétés d'algorithme

L'algorithme produit des chaînes. L'ensemble de toutes les lignes qui se forment à la suite du fonctionnement itératif de l'algorithme sera appelé «sortie d'algorithme» ou simplement «sortie». Définition de l'inférence. T ^s ≝ {t _n | t _{n + 1} = composition [ abstraction [ déduction [t _n ]]]; t ₀ = s; t _n , s ∈ S ; n ∈ N }. T ^s est la sortie de la graine s . Dans les cas où T est sans paramètre, nous parlons de la conclusion de n'importe quelle graine. Propriété d'inférence: ∀s, e ∈ S , s ≠ ∅, e ≠ ∅, s ≠ e, T ^s ∩ T ^e = ∅ . Cela signifie que chaque élément de sortie correspond uniquement à la graine. En conséquence, la conclusion est unique pour chaque graine.

Une interprétation significative de la déduction et de l'abstraction . La signification physique de l'opérateur de déduction est la suivante. À partir de la ligne d'origine, de manière universelle, l'opérateur de déduction crée un objet constructif fondamentalement nouveau avec des propriétés internes fondamentalement nouvelles et plus complexes. Dans une approximation intuitive, nous pouvons dire que la déduction ajoute des informations qualitativement nouvelles. À son tour, l'opérateur d'abstraction analyse le nouvel objet en parties et exprime ainsi les informations ajoutées au stade de la déduction dans un équivalent constructif. Vous remarquerez peut-être qu'à la suite de la procédure de retrait des parenthèses, il y a une perte d'informations.De plus, pour cette syntaxe, la suppression des parenthèses est un moyen universel de perdre de manière significative des informations en l'absence de données a priori sur la valeur des chaînes. Autrement dit, du point de vue de l'algorithme, toutes les options possibles pour la perte d'informations qui sont calculées au stade de l'abstraction, en fait, sont la valeur des lignes. Ainsi, à chaque étape, l'algorithme crée une nouvelle heuristique syntaxique unique. Et chaque heuristique suivante est fondamentalement plus complexe et plus substantielle que la précédente. À chaque itération de l'algorithme, de nouvelles connaissances apparaissent.

Application pratique

L'algorithme est une «chose en soi». Il pense, mais c'est la pensée d'un «étranger». Pour tirer des avantages pratiques de la pensée extraterrestre, vous devez trouver un langage commun avec lui. D'une part, il est nécessaire de former un étranger, et d'autre part, d'apprendre à le comprendre, à la fin, à établir une communication significative. En général, le paradigme de l'interaction avec l'algorithme est similaire aux principes bien connus de l'interaction avec la boîte noire. De plus, pour plus de commodité, j'appellerai l'algorithme de penser que Kolya est un extraterrestre.

Considérez le cas idéal. Supposons que nous ayons une puissance de calcul illimitée à notre disposition et que nous puissions nous permettre de calculer n'importe quel nombre d'itérations de la pensée de Kolya sans se soucier des problèmes d'optimisation. Dans ce cas, les ingrédients suivants seront nécessaires pour interagir avec Kolya:

1. Une maquette numérique d'un environnement interactif dont la signification de l'activité est connue.
2. Un modèle numérique d'un outil qui peut affecter l'environnement.
3. Codage algorithme pour coder des signaux de l'environnement des chaînes S .
4. Un algorithme de décodage qui sera quelque peu flou, mais rationnellement justifié pour décoder des lignes inconnues de S et les convertir en signaux pour l'instrument.

Avec de tels composants, il est possible d'organiser un programme d'apprentissage universel avec une motivation inconnue, qui permettra d'adapter la pensée de Kolya à l'environnement. Voici le pseudo-code.

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()); } 

Circuit de rétroaction . Au début, Kolya n'a aucune pensée. La première pensée de Kolya est l'état initial codé du médium. À chaque itération, un signal externe est déversé dans la pensée de Kolya. Après quoi Kolya réfléchit pendant le temps d'exposition. Les résultats de la réflexion sont décodés et envoyés à l'outil. À son tour, l'action de l'outil modifie en quelque sorte l'état de l'environnement. Et tout recommence. Au fil du temps, la pensée de Kolya s’adaptera à l’environnement et il commencera à montrer des signes de comportement hautement organisé et subjectivement motivé. Cependant, la motivation de Kolya restera inconnue. Afin de comprendre sa motivation, à l'étape suivante de la formation, il est nécessaire de mettre en place des expériences, c'est-à-dire de changer délibérément l'environnement et d'étudier les réactions de Kolya aux changements. S'il est possible de décrire le comportement externe souhaité de Kolya en termes de fonction objective, alors le processus d'apprentissage peut être automatisé, par exemple, en utilisant un algorithme génétique.

Problème de décodage . Il est nécessaire de décoder les pensées de Kolya afin de synthétiser un signal pour l'instrument. La difficulté est que chaque pensée, comme je l'ai noté dans la section précédente, est une conception fondamentalement nouvelle. Autrement dit, un chercheur hypothétique ne peut jamais comprendre pleinement le contenu des pensées de Kolya. Une partie du contenu produit par la pensée de Kolya, peu importe combien il est étudié, restera pour toujours quelque chose de complètement obscur. Seuls certains des fragments de pensée les plus organisés peuvent être reconnus de manière significative, et il s'agit d'une restriction fondamentale et insurmontable dans la communication avec Kolya. Mais concrètement, cette restriction n'est pas fondamentale. Puisque, d'une part, on peut spécifier à l'infini le côté significatif des pensées de Kolya, et d'autre part, il n'est pas nécessaire de bien comprendre Kolya. Il suffit de développer un langage commun dans lequel vous pouvez expliquer des questions pratiques. D'un point de vue technique, la situation est la suivante. Le signal entrant décrivant l'état du support est codé dans une langue. Les mots et les énoncés de langage sont des chaînes de S. La langue a son propre vocabulaire, sa syntaxe et sa sémantique. Le contenu de chaque itération de la pensée selon des critères grammaticaux sera divisé en plusieurs catégories:

1. Fragments au vocabulaire inconnu.
2. Syntaxe inconnue.
3. Sémantique inconnue.
4. Fragments grammaticalement et sémantiquement corrects.

Le contenu de toutes ces catégories est arbitraire selon la méthode d'occurrence. C'est-à-dire, même dans le cas de fragments grammaticalement corrects - c'est un accident et on ne sait pas quel sens Kolya y met, puisque sa signification intérieure n'est accessible qu'à lui-même. A priori, il n’existe aucun critère pour relier correctement les pensées de Kolya et les actions correspondantes de l’instrument. Et dans cette affaire, il reste à compter uniquement sur Kolya lui-même. Son comportement est arbitraire et lui seul peut comprendre sa motivation car le degré d'organisation de sa pensée augmentera. Dans ce cas, tout schéma rationnel pour répondre aux pensées de Kolya sera acceptable et productif, la seule question est l’efficacité relative des différents schémas. L'option de base est de répondre à tous les fragments grammaticalement corrects même s'ils sont absurdes dans leur contenu. En général, tout ce qui peut être converti en termes d'encodage d'origine doit être transformé et réagi. Et ainsi de suite jusqu'à ce que Kohl se «sois rendu compte» de réactions significatives. Et bien sûr, le modèle le plus plastique de l'environnement avec un grand nombre de degrés de liberté sera utile. Le médium, en quelque sorte, deviendra le corps de Kolya.

Le problème de la puissance de calcul limitée . En termes de quantité de calcul, l'algorithme est lourd. De toute évidence, plusieurs dizaines d'itérations épuiseront toute la puissance de calcul de la planète. Nous pouvons espérer des dispositifs quantiques et qu'il existe un analogue quantique de l'algorithme, mais jusqu'à présent, il n'y a qu'une seule issue: au lieu d'une pensée extrêmement complexe, pensez en même temps à de nombreuses pensées petites et simples. Il existe plusieurs astuces techniques pour cela:

1. Au stade de la composition, il n'est pas nécessaire d'inclure dans le résultat toutes les nombreuses abstractions. Pour que l'algorithme conserve ses propriétés fondamentales, il suffit de sélectionner dans l'ensemble uniquement deux lignes résultantes indépendantes. Le critère d'indépendance est la différence non nulle des premiers chiffres dans la numérotation hiérarchique des résultats d'abstraction. Nous passons au grand exemple, qui est plus haut sous le spoiler. Toutes les lignes sont numérotées selon le principe de abcd .. Une paire de lignes d'indices a1.b1.c1.d1 ... , a2.b2.c2.d2 ... est appelée indépendante si a1 ≠ a2 . Et cela signifie qu'il est possible de diviser le résultat complet de l'abstraction en paires indépendantes et pour chaque paire à l'étape suivante, démarrer sa propre branche de calcul. De plus, il n'est pas nécessaire d'utiliser tous les résultats de l'abstraction. Dans le cas minimum, vous ne pouvez sélectionner qu'une seule paire de lignes, et jeter tout le reste (irrévocablement perdre) et tous les principes de la pensée seront préservés. Compte tenu de la possibilité de perdre des résultats, il est possible d'organiser une étape de sélection supplémentaire, dans laquelle, de manière rationnelle, par exemple, selon la signification statistique, pour sélectionner le contenu pour des calculs ultérieurs.

2. La deuxième astuce repose sur l'hypothèse que plus les crochets sont placés profondément dans la ligne, moins le contenu qu'ils contiennent est organisé. En conséquence, le contenu «pop-up» résultant du bracketing est plus organisé et abstrait du point de vue des significations internes de Kolya, ce qui signifie que des niveaux profonds d'imbrication peuvent être supprimés. Ainsi, la quantité de calcul à la prochaine itération diminue exponentiellement. Dans un sens intuitif, cette procédure vous permet d'approcher uniquement la partie la plus abstraite de la pensée.

3. En raison de la parallélisation à de nombreuses branches plus petites, les calculs augmenteront «en largeur». Cette largeur peut être absolument limitée par la sélection non seulement au niveau des branches de calcul individuelles, mais également dans l'ensemble du réseau de branches parallèles. Cela peut être fait via un pool commun de taille fixe, d'où chaque branche tracera des lignes pour la prochaine itération et, par conséquent, où elle videra les résultats. Et pour les chaînes, vous pouvez absolument limiter le niveau autorisé d'imbrication des parenthèses. Une telle approche combinée aidera à restreindre et à réguler la croissance du volume des calculs.

Interprétation et commentaire

Preuve . Il n'y a aucune preuve et ne peut pas l'être. Toute théorie de la pensée est une question de définition. L'algorithme présenté est une théorie constructive de la pensée. Et donc c'est un axiome. L'algorithme de pensée est reconnaissable de façon apodictique au sujet de la pensée. La reconnaissance peut être facilitée en recourant d'abord à une axiomatique non constructive qui est plus intuitive, puis à trouver la coïncidence des propriétés des définitions constructives et non constructives.

Définition non constructive de la pensée . La pensée n'est pas une production algorithmique de contenu. Dans une compréhension intuitive, les phénomènes non algorithmiques ont les caractéristiques spécifiques suivantes: indépendance, spontanéité, unicité, auto-organisation, arbitraire, subjectivité, complexité, imprévisibilité et incertitude fondamentales, absence de barrières conceptuelles et, au sens le plus large, une possibilité inhérente et durable de nouveauté fondamentale. Toutes les fonctionnalités répertoriées sont en quelque sorte inhérentes à l'algorithme de réflexion décrit. Bien que la combinaison d'un algorithme et de propriétés non algorithmiques ne soit pas intuitive et à première vue contradictoire, il n'y a en fait aucune contradiction. L'algorithme déploie le contenu à l'aide de procédures algorithmiques bien définies, mais dans le processus de déploiement, le contenu a une organisation non algorithmique. Compte tenu des spécificités de conception de l'algorithme, les propriétés non algorithmiques dans l'organisation du contenu découlent des propriétés propres, internes et non algorithmiques du contenu lui-même.

Points de vue supplémentaires sur l'algorithme . L'algorithme de réflexion est, y compris:

1. Implémentation constructive d'une métaphore. La pensée est essentiellement métaphorique. Il n'y a pas d'autre sens que figuratif (possible). Cependant, au sens figuré, des significations littérales (algorithmes) sont possibles.
2. Modèle d'auto-organisation du chaos absolu. Un modèle de spontanéité conceptuelle.
3. Un modèle de comportement complètement indépendant et motivé de manière subjective. Modèle de créativité.
4. Langage auto-organisé.
5. Le modèle d'approximation constructive, pour une sémantique non constructive, purement possible.

Conscience La question de la conscience est également résolue au niveau de la définition. La conscience est quelque chose qui dépasse toutes les limites conceptuelles. À la lumière de cette définition, on ne peut qu'empoisonner des histoires de conscience plus ou moins compliquées, chacune reflétant certaines possibilités de conscience, mais aucune ne sera vraie. En même temps, les histoires sur la conscience ont des potentiels heuristiques différents. De tous les contes, ceux qui sont plus difficiles sont plus utiles. Du point de vue des algorithmes, la conscience est un objet trans-algorithmique, infiniment complexe (ou simplement complexe). Une histoire de conscience peut être enregistrée à l'aide d'un algorithme. Cela ressemble à ceci:

lim _{n → ∞} [t _{n + 1} = composition [ abstraction [ déduction [t _n ]]]]; t ₀ = s; t _n , s ∈ S ; n ∈ N