思维与意识算法

本文概述了一种思考和意识的算法。 我对思考和意识如何运作的问题提供答案。 我演示了一种可以真正，创造性地思考并拥有真实意识的算法。 本文面向程序员，由两个主要部分组成。 第一部分纯粹是技术性的，其中包含对算法的描述，其属性列表以及实际应用示例。 第二部分包含解释性论文和建设性意识公理化问题的解决方案。 算法是一个有意义的文本，可以说明一切，因此，实际上只有必要的最少注释。

算法说明

根据“自上而下”的原则，以自制的数学形式主义对算法进行描述，即首先给出最终的抽象记录，然后按调用和给出注释的顺序分析算法的各个部分。 因此，“组合”算法是以下形式的递归函数：

t _{n +1} = 组成 [ 抽象 [ 推论 [t _n ]]]； t ₀ = s; t _n ，s∈S; n∈N

该函数的计算正在思考中。 如您所见，记录中出现了三个运算符：
组成 [] ， 抽象 [] ， 演绎 [] ； 还有：种子变量s∈S ，特殊形式S的行集和步数n∈N 。 接下来，我们详细考虑每个备件。 我们从集合S及其元素开始。

为了指定集合S，有必要确定将写入该集合的元素的语法。 集S的元素称为字符串。 S中的任何行都由括号“（”，“）”的层次结构组成，并且任意字符标识符都写在括号内。 为了避免使用术语“标识符”，由于可能出于其他目的而需要使用它，因此括号内的符号标识符将称为“助记符”。 每个助记符都用拉丁字符“ A-z”编写。 括号内的助记符可以用逗号“，”分隔。 如果助记符的长度是固定的（单独指定），则不会设置分隔符。 助记符仅写在括号内。 一行可能包含嵌套的括号。 字符串中括号的层次结构是任意的，但每个开头括号必须有一个结尾括号。 在本文中，我将仅使用拉丁字母的小写字母来编写助记符，并且助记符的长度将是固定的，一个字母对应一个助记符，我不放置分隔符。 线路示例：

（）∅是一个空字符串。
（a） -包含一个助记符“ a ”的字符串。
（aa） -包含助记符“ a ”的两个实例的字符串。
（ab）是包含两个助记符“ a ”和“ b ”的字符串。
（（a）（a）） -该行包含助记符“ a ”的两个副本和括号的嵌套级别。

在需要适当概括的情况下，有时将括号括起来的括号及其内容以及个别的助记符称为“字符串组件”。 例如，行（（a）ab）包含四个成分，其中：两个成分“ a ”，一个成分“ （a） ”和一个成分“ b ”。

与字符串中各组成部分的重新排列相匹配的字符串记录被视为相同。 相同行的示例：

（ab）≡（ba） 。
（（a）（b））≡（（b）（a）） 。
（abc）≡（bac）≡（cba）≡（acb）≡（bca）≡（cab） 。
（（a）（ab））≡（（a）（ba））≡（（ab）（a））≡（（ba）（a）） 。

行可以包含任意数量的相同的重复组件，在这种情况下，使用重复索引可以缩短记录的时间，该索引位于左边组件的前面，而没有分隔符。 范例：

（aa）≡（2a） 。
（aabb）≡（2a2b） 。
（（a）（a））≡（2（a）） 。
（（aa）（aa））≡（2（2a）） 。
（aa（bb）（bb）（ccc）（ccc）（ccc））≡（2a2（2b）3（3c）） 。

在字符串包含空成分的情况下，例如（a（）） ， （a（）（）（b）），标识保持： （a（））≡（a） ， （a（）（）（b ））≡（a（b）） ，即将空的组件丢弃。

定义 集S由满足以上语法标准的所有可能的字符串组成，包括一个空字符串。

推导，抽象和组合运算符在集合S上定义。 运算符自变量用方括号[]表示 ，因为括号保留给字符串语法使用。 术语“操作者”与术语“功能”同义。

演算者 。 定义 ∀s∈S， 推导 ^k [s]∈S，k∈N，k> 1， 推导 [s]≝ 推导 ² [s] 。 将S中的字符串s作为参数。 结果，从S返回一个字符串。 行动 运算符k次复制字符串的每个部分和整个字符串。 最终的结构由通用的外部支架框住。 复制从嵌套最深的组件开始。 整个行最后重复。 出于即时实际目的， k = 2就足够了，因此我定义了一种特殊情况，即推导 [s]≝ 推导 ² [s] 。 使用deduction []意味着k = 2 ，也就是说，作为deduction [s]运算符的结果，字符串s的所有分量都加倍了。 范例：

推导 [（a）] =（（aa）（aa））。
扣减 [（aa）] =（（aaaa）（aaaa））
推导 [（ab）] =（（aabb）（aabb））。
推导 [（a（b））] =（（aa（bb）（bb））（aa（bb）（bb）））。
推导 [[（（a）（b））] =（（（（aa）（aa）（bb）（bb））（（aa）（aa）（bb）（bb）））。
扣减 [[（（a）（b（cc）））] =（（（（aa）（aa）（bb（cccc）（cccc））（bb（cccc）（cccc））））（（aa）（aa）（ bb（cccc）（cccc））（bb（cccc）（cccc）））） 。

抽象运算符 。 定义 ∀s∈S， 抽象 [s]⊂S 。 将S中的字符串s作为参数。 结果，它返回许多行。 行动原则。 抽象运算符使用特殊操作-相同组件的括号从源代码行创建许多行。 包围操作仅适用于处于相同嵌套级别的嵌套括号。 包围的一般原则。 如果位于同一级别的括号的任何组合中，相同的组件位于括号内，则可以将任何一组相同的组件放在括号之外，并且保持完整的组件应在同一级别的相同通用括号下进行组合。 考虑一个例子。 字符串（（ab）（ac）） 。 在此行上，有两个处于相同级别的子字符串： （ab）和（ac） ，其中有相同的助记符“ a ”，该助记符可以放在方括号中，结果为（a（bc）） 。 如您所见，其余的助记符“ b ”和“ c ”被合并在共同的括号中。 考虑一个不太明显的例子。 字符串（（aa）（aa））包含子字符串（aa）和（aa） ，在这种情况下，有两个不同的选项可以放在括号中。 在第一个变体中，只能从每个子字符串的括号中取出一个助记符“ a ”，在第二个变体中，可以取出一组助记符“ aa ”。 让我们更详细地考虑这两个选项。

第一种选择，逐步演示：

1. 第一步，选择（ 红色 ）取出（（ a a）（ a a）） 。
2. 第二步，选择（ a （... a）（... a）） 。
3. 第三步，将余数合并在公共括号（ a （... a ... a））中 。
4. 结果（a（aa）） 。

第二个选项，步骤如下：

1. 第一步，选择要取出的东西（（ aa ）（ aa ）） 。
2. 第二步，选择（ aa （...）（...）） 。
3. 第三步，将余数合并在公共括号（ aa （...））中 。
4. 第四步，丢弃空的组件（ aa ） 。
5. 结果（aa） 。

让我们使这个例子复杂化。 假设给定字符串（（aa）（aab）（aab）） ，它具有三个位于相同级别的子字符串： （aa） ， （aab） ， （aab） ，所有三个子字符串具有相同的内容。 括号规则并不要求我们立即对所有三个子字符串执行操作。 对于放样操作，可以选择任何子串组。

在这种情况下，可以使用三种不同的方式对子字符串进行分组：

1. （aa），（aab） 。
2. （aab），（aab） 。
3. （aa），（aab），（aab） 。

我们将逐步为每个分组选项执行所有可能的声明。

分组（aa） ， （aab） 。 字符串（（aa）（aab）（aab）） 。

第一种选择：

1. 选择内容（（ a a）（ a ab）（aab）） 。
2. 我们取出（ a （... a）（... ab）（aab）） 。
3. 合并（ a （... a ... ab）（aab）） 。
4. 结果1 （a（aab）（aab）） 。

第二种选择：

1. 选择内容（（ aa ）（ aa b）（aab）） 。
2. 我们取出（ aa （...）（... b）（aab）） 。
3. 合并（ aa （... b）（aab）） 。
4. 结果2 （a（b）（aab）） 。

分组（aab） ， （aab） 。 字符串（（aa）（aab）（aab）） 。

第一种选择：

1. 选择内容（（aa）（ a ab）（ a ab）） 。
2. 我们取出（（aa） a （... ab）（... ab）） 。
3. 合并（（aa） a （... ab ... ab）） 。
4. 结果3 （a（aa）（aabb）） 。

第二种选择：

1. 选择内容（（aa）（ aa b）（ aa b）） 。
2. 我们取出（（aa） aa （... b）（... b）） 。
3. 合并（（aa） aa （... b ... b）） 。
4. 结果4 （aa（aa）（bb）） 。

第三种选择：

1. 选择内容（（aa）（a ab ）（a ab ）） 。
2. 我们取出（（aa） ab （... a）（... a）） 。
3. 合并（（aa） ab （... a ... a）） 。
4. 结果5 （ab（aa）（aa）） 。

第四种选择：

1. 选择内容（（aa）（aa b ）（aa b ）） 。
2. 我们取出（（aa） b （... aa）（... aaa）） 。
3. 合并（（aa） b （... aa ... aa）） 。
4. 结果6 （b（aa）（aaaa）） 。

第五种选择：

1. 选择内容（（aa）（ aab ）（ aab ）） 。
2. 我们取出（（aa） aab （...）（...）） 。
3. 合并（（aa） aab （...）） 。
4. 结果7 （aab（aa）） 。

分组（aa） ， （aab） ， （aab） 。 字符串（（aa）（aab）（aab）） 。

第一种选择：

1. 选择内容（（ a a）（ a ab）（ a ab）） 。
2. 我们取出（ a （... a）（... ab）（... ab）） 。
3. 合并（ a （... a ... ab ... ab）） 。
4. 结果8 （a（aaabb）） 。

第二种选择：

1. 选择内容（（ aa ）（ aa b）（ aa b）） 。
2. 我们取出（ aa （...）（... b）（... b）） 。
3. 合并（ aa （... b ... b）） 。
4. 结果9 （aa（bb）） 。

抽象运算符的作用 。 从示例中可以看到，对于原始行（（aa）（aab）（aab）），有9种不同的选项可以将某些内容放在方括号中，并且有9条结果行与这些选项相对应。 这就是抽象运算符的操作方式-遍历所有可能的选项以放入括号并构建相应的结果行集。 此外，抽象运算符不仅在源代码行中寻找选项，而且还在所有结果行中寻找选项。 换句话说，将抽象运算符递归应用于其结果，依此类推，直到用尽所有可能的选项。 出于明显的原因，对于任何最后一行，可能的删除选项的数量也是有限的。

让我们回到前面的示例。 在所考虑的示例中，我没有写出所有可能的选项，而只写了第一级的九个选项。 为了说明抽象运算符的全部效果，有必要为所有九个先前获得的结果构造所有用于括号的选项。 我们将以更简洁的方式列出所有选项。

结果1 （a（aab）（aab）） ：

1.1。 （a（ab）（ a ab））=>（a a （aabb）） 。
1.2。 （a（ aa b）（ aa b））=>（ aa a （bb）） 。
1.3。 （a（a ab ）（a ab ））=>（a ab （aa）） 。 * 7号
1.4。 （a（ aab ）（ aab ））=>（a aab ） 。
1.5。 （a（aa b ）（aa b ））=>（a b （aaaa）） 。
结果2 （a（b）（aab）） ：
2.1。 （a（ b ）（aa b ））=>（a b （aa）） 。
结果3 （a（aa）（aabb）） ：
3.1。 （a（ a a）（abb））=>（a a （aabb）） 。 * 1.1号
3.2。 （a（ aa ）（ aa bb））=>（ aa （bb）） *第1.2号
结果4 （aa（aa）（bb）） 。
结果5 （ab（aa）（aa）） ：
5.1。 （ab（ a a）（ a a））=>（ a a b（aa）） 。 * 7号* 1.3号
5.2。 （ab（ aa ）（ aa ））=>（ aa ab） 。 *第1.4号
结果6 （b（aa）（aaaa）） ：
6.1。 （b（ a a）（aaaa））=>（ a b（aaaa）） 。 * 1.5
6.2。 （b（ aa ）（ aa aa））=>（ aa b（aa）） 。 * 7号* 1.3号* 5.1号
结果7 （aab（aa）） 。
结果8 （a（aaabb）） 。
结果9 （aa（bb）） 。

星号表示重复的选项。 抽象结果中仅包含唯一的变体。 在解析的示例中，有十四个唯一的结果行。 总计：

抽象 [[（（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））
}

为了清楚起见，请考虑另外两个示例。

字符串（（a（b））（a（b））） 。 括号选项。 第一次迭代：

（（（ a （b））（ a （b））））=>（ a （（b）（b））） ，结果1
（（a （b） ）（a （b） ））=>（ （b） （aa）） ，结果2
（（（ a（b） ）（ a（b） ））=>（ a（b） ） ，结果3
在第一个结果中，可以做出另一个决定。 第二次迭代：
（a（（ b ）（ b ）））=>（a（ b ）） ，结果1.2与结果3一致。

总计： 抽象 [[（（a（b））（a（b）））] = {（a（（b）（b））），（（b）（aa）），（a（b））}



合成运算符 。 定义 ∀U⊂S，U≠∅， 成分 [U]≠∅， 成分 [U]∈S 。 它接受多行输入，并返回一行。 行动 操作员为算法的下一次迭代准备内容。 在抽象运算符的作用之后，出现了许多行，并且在合成阶段，发生了用于算法的下一次迭代的行的选择和连接。 我将在优化和实际使用部分中更详细地讨论此问题。 在最简单的情况下，组合运算符对所有抽象结果执行简单的串联。 所以我们定义它。 示例： composition [ 抽象 [（（（a（b））（a（b）））]] = 成分 [{（a（（b）（b））），（（b）（aa）），（a（ b））}] =（（（a（（b）（b）））（（b）（aa））（a（b））） 。

算法属性

该算法产生字符串。 由于算法的迭代操作而形成的所有行的集合将被称为“算法输出”或简称为“输出”。 推断的定义。 T ^s {{ _n | t _{n + 1} = 组成 [ 抽象 [ 推论 [t _n ]]]]； t ₀ = s; t _n ，s∈S; n∈N}。 T ^s是种子s的输出。 在那些T没有参数的情况下，我们谈论的是任何种子的结论。 推论性质： ∀s，e∈S，s≠∅，e≠∅，s≠e， T s∩T ^e =∅ 。 这意味着每个输出元素唯一地对应于种子。 结果，每个种子的结论都是唯一的。

对演绎和抽象的有意义的解释 。 推导算子的物理含义如下。 从原始行开始，演绎运算符以通用的方式创建一个具有根本上新的更复杂内部属性的根本上新的构造对象。 用直觉上的近似，我们可以说推论从质上增加了新的信息。 反过来，抽象运算符将新对象分解为多个部分，从而以推论性的等效方式表示在推导阶段添加的信息。 您可能会注意到，由于括号中的步骤导致信息丢失。 此外，对于此语法，在没有任何有关字符串值的先验数据的情况下，放在方括号中是有意义地丢失信息的通用方法。 即，从算法的角度来看，在抽象阶段计算出的所有可能的信息丢失选项实际上都是行的值。 因此，在每个步骤中，该算法都会创建一个新的独特的语法启发式算法。 而且，每一次后续的启发式搜索都比上一次更复杂，更实质。 在算法的每次迭代中，都会出现新知识。

实际应用

该算法本身就是“事物”。他认为，但这是“外国人”的想法。为了从外星人思维中获得实际利益，您需要与他一起找到一种共同语言。一方面，需要训练外星人，另一方面，要学会了解他，最终建立有意义的交流。通常，与算法交互的范例类似于与“黑匣子”交互的众所周知的原理。此外，为了更大的方便，我将思维算法称为外星人科尔。

考虑理想情况。假设我们拥有无限的计算能力，并且我们有能力计算Kolya思想的任何迭代次数，而不必担心优化问题。在这种情况下，与Kolya相互作用需要以下成分：

1. .
2. .
3. , S .
4. , - , S .

, . .

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

反馈电路 。 刚开始，Kolya没有任何想法。 Kolya的第一个想法是媒体的编码初始状态。 每次迭代时，外部信号都会注入Kolya的思想中。 之后，Kolya会在曝光时间内进行思考。 思考的结果被解码并发送到工具。 反过来，工具的操作会以某种方式改变环境的状态。 一切再次重复。 随着时间的流逝，科里亚的思维将适应环境，并且他将开始表现出高度组织化，主观动机的行为的迹象。 但是，科里亚的动机仍然未知。 为了了解他的动机，在下一阶段的培训中，有必要进行实验，即有目的地改变环境并研究Kolya对变化的反应。 如果有可能通过某种目标函数来描述Kolya的期望外部行为，那么学习过程可以自动化，例如使用遗传算法。

解码问题 。 有必要对Kolya的思想进行解码，以便为乐器合成信号。 困难在于，正如我在上一节中提到的那样，每一个想法都是一个全新的设计。 也就是说，假设的研究人员永远无法完全理解科里亚思想的内容。 无论研究了多少内容，由Kolya思维产生的部分内容将永远永远是完全晦涩的。 只有一些最高度组织化的思维碎片才能得到有意义的识别，这是与Kolya进行交流时的根本性和不可克服的限制。 但实际上，这种限制不是根本的。 因为，首先，可以无限地说明科里亚思想的有意义的一面，其次，不需要完全理解科里亚。 开发一种通用语言就足够了，您可以用它来解释实际问题。 从技术角度来看，情况如下。 描述介质状态的输入信号以某种语言编码。 单词和语言陈述是S的字符串。 该语言具有自己的词汇，语法和语义。 根据语法标准进行的每一次思维重复的内容将分为几类：

1.词汇不明的片段。
2.未知语法。
3.未知语义。
4.语法和语义上正确的片段。

根据出现的方法，所有这些类别的内容都是任意的。 也就是说，即使在语法上正确的片段的情况下，这也是偶然的，并且不知道Kolya赋予它们的含义是什么，因为Kolya的内部含义只能由他自己访问。 先验地，没有标准可以正确地将科里亚的思想与乐器的相应动作联系起来。 在这件事上，仍然只能依靠科里亚自己。 他的行为是随心所欲的，只有他能理解他的动机，因为他思维的组织程度会提高。 在这种情况下，任何回应科里亚思想的合理方案都是可以接受和富有成效的，唯一的问题是各种方案的相对有效性。 基本选项是响应所有语法正确的片段，即使它们的内容是荒谬的。 通常，所有可以转换为原始编码形式的内容都必须进行转换和作出反应。 依此类推，直到科尔“明智地”做出有意义的反应。 当然，具有大量自由度的最具塑性的环境模型将很有用。 该介质将以某种方式成为Kolya的身体。

计算能力有限的问题 。 就计算量而言，该算法很繁琐。 显然，数十次迭代将耗尽地球的全部计算能力。 我们可以希望有量子设备，并且算法可以有一个量子类似物，但是到目前为止，只有一种出路：代替一个极其复杂的思想，同时思考许多小而简单的思想。 为此有几种技术技巧：

1.在组合阶段，不必在结果中包含所有许多抽象。 为了使算法保留其基本属性，仅从集合中选择两个独立的结果行就足够了。 独立性标准是抽象结果的分层编号中前几位的非零差。 我们来看一个很好的例子，在扰流器下更高。 所有行均根据abcd的原则进行编号。如果a1≠a2 ， 则一对具有索引a1.b1.c1.d1 ... ， a2.b2.c2.d2 ...的行将被称为独立行。 这意味着可以将整个抽象结果分成独立的对，并在下一步中为每个对开始其自己的计算分支。 而且，不需要使用所有抽象结果。 在最小的情况下，您只能选择一对线，而舍弃所有其余的线（不可挽回的输掉），所有的思维原理都会保留下来。 给定失去结果的能力，可以组织一个附加的选择阶段，在该阶段中，以某种合理的方式，例如根据统计意义，选择要进行进一步计算的内容。

2.第二个技巧是基于这样的假设，即括号放在行中的位置越深，它们包含的内容就越没有组织性。 因此，从Kolya的内部含义来看，由于包围而导致的“弹出”内容更加有条理和抽象，这意味着可以消除深层次的嵌套。 因此，在下一次迭代时的计算量呈指数下降。 从直观的角度来看，此过程仅允许您近似思考的最抽象部分。

3.由于并行化到许多较小的分支，计算将“沿宽度”增长。 不仅可以在单个计算分支的级别进行选择，而且可以在整个并行分支的数组中进行选择，从而完全限制此宽度。 这可以通过一个固定大小的公用池来完成，从该池中每个分支将为下一次迭代绘制线条，并因此从该分支中​​转储结果。 对于字符串，您可以绝对限制括号嵌套的允许级别。 这种结合的方法将有助于限制和调节计算量的增长。

口译和评论

证据 。 没有证据，也没有。 任何思维理论都是定义问题。 提出的算法是一种建设性的思维理论。 因此，他是一个公理。 思维算法在思维上是可以识别的。 可以通过首先采用更直观的非构造公理来促进识别，然后找到构造和非构造定义的性质的重合。

思维的非确定性定义 。 思考不是内容的算法产生。 在直觉上理解，非算法现象具有以下特定特征：独立性，自发性，唯一性，自组织性，任意性，主观性，复杂性，根本的不可预测性和不确定性，没有概念上的障碍以及从最广泛的意义上说，根本的新颖性具有内在和持久的可能性。 列出的所有功能都是所描述的思维算法固有的。 尽管算法和非算法属性的组合不直观，乍看之下是矛盾的，但实际上并没有矛盾。 该算法使用定义明确的算法过程来部署内容，但是在部署过程中，内容具有非算法组织。 给定算法的设计细节，内容组织中的非算法属性源于内容本身的内部，非算法属性。

关于算法的其他观点 。 思维算法包括：

1.隐喻的建设性实施。 思考本质上是隐喻的。 除了象征性（可能）之外，没有其他含义。 但是，从象征意义上讲，字面意义（算法）是可能的。
2.绝对混乱的自组织模型。 概念自发性模型。
3.完全独立的，主观动机的行为模型。 创造力模型。
4.自组织语言。
5.用于非构造性，纯粹可能的语义的构造性近似模型。

意识 意识问题也在定义级别得到解决。 意识超出了任何概念上的限制。 根据这一定义，一个人只能毒害或多或少地涉及到意识的复杂故事，每个故事都将反映出意识的一些可能性，但没有一个是真实的。 同时，关于意识的故事具有不同的启发潜能。 在所有的故事中，难度更大的故事更有用。 从算法的角度来看，意识是一种跨算法的，无限复杂（或简单地-复杂）的对象。 意识故事可以使用算法记录。 听起来像这样：

lim _n→∞ [t _{n + 1} = 组成 [ 抽象 [ 推论 [t _n ]]]]； t ₀ = s; t _n ，s∈S; n∈N