Algorithm of Thinking and Consciousness, Part 2
This text contains explanations for the algorithm from my first article “Algorithm of Thinking and Consciousness” . Theses of the first article:
Author's view in general . First of all, I proceed from the assumption that rationality and complexity are one and the same. As a result, the logic of complexity, whatever it may be in essence, precedes any other kind of logic and is therefore absolute. It is from this point of view that my proposed algorithm is reasonable, since it can achieve any structural complexity in a formal computing process.
The thinking algorithm is based on the formal logic of complexity with the following properties:
The transition from a simple theory to a more complex one, with many substantial theories, intuitively corresponds to the concept of ideal thinking. The constructive implementation of such logic will be, among other things, the constructive theory of thinking.
More about abstract theories . Abstract theories are any thing about which it is known only that they are inherent in constructive complexity, because this complexity can be clearly verified. And it is also known that from any such thing a constructive transition to other, more complex pieces is possible and this can also be checked.
Informally about constructive complexity . A complex object is something that can be uniquely decomposed into simple objects. The more simple objects contained in a complex object, the more complex this object. Simple objects cannot be made out in a unique way. The complexity of all simple objects is the same.
Accordingly, abstract theories are divided into two types: simple and complex. A theory is called complex if, using some procedure, a unique set of simple theories can be derived from it. In turn, for all simple theories, the same procedure returns a constant result, and thus the complexity of simple theories is the same. Due to the fact that the complexity in the logic under consideration is determined constructively, it can be calculated and compared. Two theories have the same complexity if they can be decomposed into the same number of simple theories. The more simple theories you can get, the more complicated the original theory.
Formal definition of complexity . On the set of theories S = P ∪ C , where P = {s ∈ S | A [s] = ∅} is a subset of simple theories, C = {s ∈ S | A [s] ≠ ∅} is a subset of complex theories, the operator A: S → 2 P defines complexity if ∀ (c 1 , c 2 ) ∈ C , c 1 ≠ c 2 , A [c 1 ] ≠ A [c 2 ] ; that is, for any complex theory there is a unique decomposition into simple ones. In turn, | A [s] |: a numerical measure of complexity s.
The logic of complexity . The set of theories S , the operator A, and the operator D: S → S such that ∀s ∈ S , | A [s] | <| A [D [s]] |, and ∀ (s 1 , s 2 ) ∈ S , s 1 ≠ s 2 , D [s 1 ] ≠ D [s 2 ], define the logic of complexity. The operator D from any given theory deduces a new, guaranteed more complicated one.
The implementation of the logic of complexity . The logic described above can be expressed in formal operations on strings of a special kind. Please see the first article for a detailed description of the implementation. Below is just a simplified, schematic description of the implementation.
Many theories . To represent theories, strings are used that consist of an arbitrary sequence of parentheses '(', ')' and any graphic identifiers inside the brackets. For brevity, each letter is considered a separate identifier. The entire contents of the string must be enclosed in common outer brackets. For each opening bracket in the line should be closing. Example: line ((b) a (e)) is correct, while lines (b) a (e) , (a (b (e) are incorrect.
Many S theories consist of all possible correct strings.
Two lines are equal if they coincide up to a permutation of indivisible elements in substrings. An example of how you can rearrange the elements: (ab (cd)) ≡ ((cd) ab) ≡ (b (dc) a) ≡ ... ≡ ((dc) ba). Empty substrings are not significant and are thrown away, for example, (a ()) ≡ (a).
Withdrawal rules . Three rules of inference are given on the set S.
Rule of abstraction . Applies to substrings of a given string. Allows you to bracket the same content. From any group of brackets at the same level, any identical substrings can be taken out of brackets, according to the following principle:
By the rule of abstraction, results are always simpler than the original string. In the case of simple strings, for example, ((a) (b)), the result of applying the abstraction rule is empty. The recursive application of the abstraction rule allows you to decompose any complex string into simple ones.
The rule of deduction . According to this rule, you can get as many new lines as you like from the original row, by duplicating all the elements in the original row any given number of times, according to the following principle:
Composition rule Any set of lines from S can be combined into one line. For example: (a), (b), (e) ⇒ ((a) (b) (e)).
Operator A. The result of the operator is a unique set of simple strings. The recursive application of the rule of abstraction to a given line, until it stops when all possible decomposition options are exhausted, corresponds to the action of operator A.
I want to draw attention to the fact that in the main article, the abstraction operator, unlike the A operator, in the result of its work includes not only simple, but in general all lines that can be deduced according to the rule of abstraction.
Operator D. A deduction rule with a given duplication parameter corresponds to the action of the operator D. From any given line, a more complex line can be deduced from the deduction rule, and this fact can be checked using operator A.
Composition Operator (). Corresponds to the action of the composition rule.
Thus, a formal system is obtained which satisfies the definition of complexity logic.
The content of theories . In the logic of complexity, every theory is meaningful. Since ∀s ∈ S there is a unique chain of conclusions t n = (A [D [t n-1 ]]) of increasing and potentially infinite complexity.
The unsolvability hypothesis . Sets of the general form T s = {p ∈ S | ∀n ∈ N , p ∈ A [D [t n ]]; t n = (A [D [t n-1 ]]); t 0 = s} I consider unsolvable. The set T s contains all simple strings that are derived by the recursive function t n from the start line s. Given the unsolvability of T s , the output t n is algorithmically random. There is no evidence.
Thinking t n has the character of complexity as in ideal thinking and on this basis is a form of ideal thinking. At each iteration t n, there is a clear transition from a less complex theory to a new, more complex theory, each such transition is unique and this process is potentially endless.
Thinking realizes consciousness in an asymptotic form. Roughly speaking, “consciousness of the theory” is the ultimate, infinitely complex content that t n aspires to in the process of computing.
Subjective experience . Subjective experiences are the prerogative of consciousness. Consciousness is not constructive.
Will the computer survive during computing? No. But in the results of the calculations, there may be experiences at the expense of the computer.
Conclusion I believe everyone knows how much imagination it takes to build something truly complex. Not just big, but complex. And for infinite complexity, you need endless fantasy. Where does the algorithm get so much imagination from? Unless the fantasy itself is an algorithm.
- The phenomenon of subjective thinking can be algorithmized.
- The algorithm presented in the article thinks and this can be used practically.
- Using the thinking algorithm, we can define consciousness in an asymptotic form.
Author's view in general . First of all, I proceed from the assumption that rationality and complexity are one and the same. As a result, the logic of complexity, whatever it may be in essence, precedes any other kind of logic and is therefore absolute. It is from this point of view that my proposed algorithm is reasonable, since it can achieve any structural complexity in a formal computing process.
The thinking algorithm is based on the formal logic of complexity with the following properties:
- The objects of logic are abstract theories.
- Any theory has complexity, and this complexity can be clearly verified.
- From any theory, a more complex theory can be deduced.
- From any complex theory, a simple theory can be derived.
- There will be different conclusions from two different theories.
- Any theory is meaningful. A theory is called meaningful if it is unique and infinitely complex. In practice, this means that a potentially infinite chain of conclusions can be constructed from a meaningful theory, such that all conclusions in the chain are unique and each subsequent conclusion is more complicated than the previous one.
The transition from a simple theory to a more complex one, with many substantial theories, intuitively corresponds to the concept of ideal thinking. The constructive implementation of such logic will be, among other things, the constructive theory of thinking.
More about abstract theories . Abstract theories are any thing about which it is known only that they are inherent in constructive complexity, because this complexity can be clearly verified. And it is also known that from any such thing a constructive transition to other, more complex pieces is possible and this can also be checked.
Informally about constructive complexity . A complex object is something that can be uniquely decomposed into simple objects. The more simple objects contained in a complex object, the more complex this object. Simple objects cannot be made out in a unique way. The complexity of all simple objects is the same.
Accordingly, abstract theories are divided into two types: simple and complex. A theory is called complex if, using some procedure, a unique set of simple theories can be derived from it. In turn, for all simple theories, the same procedure returns a constant result, and thus the complexity of simple theories is the same. Due to the fact that the complexity in the logic under consideration is determined constructively, it can be calculated and compared. Two theories have the same complexity if they can be decomposed into the same number of simple theories. The more simple theories you can get, the more complicated the original theory.
Formal definition of complexity . On the set of theories S = P ∪ C , where P = {s ∈ S | A [s] = ∅} is a subset of simple theories, C = {s ∈ S | A [s] ≠ ∅} is a subset of complex theories, the operator A: S → 2 P defines complexity if ∀ (c 1 , c 2 ) ∈ C , c 1 ≠ c 2 , A [c 1 ] ≠ A [c 2 ] ; that is, for any complex theory there is a unique decomposition into simple ones. In turn, | A [s] |: a numerical measure of complexity s.
The logic of complexity . The set of theories S , the operator A, and the operator D: S → S such that ∀s ∈ S , | A [s] | <| A [D [s]] |, and ∀ (s 1 , s 2 ) ∈ S , s 1 ≠ s 2 , D [s 1 ] ≠ D [s 2 ], define the logic of complexity. The operator D from any given theory deduces a new, guaranteed more complicated one.
The implementation of the logic of complexity . The logic described above can be expressed in formal operations on strings of a special kind. Please see the first article for a detailed description of the implementation. Below is just a simplified, schematic description of the implementation.
Many theories . To represent theories, strings are used that consist of an arbitrary sequence of parentheses '(', ')' and any graphic identifiers inside the brackets. For brevity, each letter is considered a separate identifier. The entire contents of the string must be enclosed in common outer brackets. For each opening bracket in the line should be closing. Example: line ((b) a (e)) is correct, while lines (b) a (e) , (a (b (e) are incorrect.
Many S theories consist of all possible correct strings.
Two lines are equal if they coincide up to a permutation of indivisible elements in substrings. An example of how you can rearrange the elements: (ab (cd)) ≡ ((cd) ab) ≡ (b (dc) a) ≡ ... ≡ ((dc) ba). Empty substrings are not significant and are thrown away, for example, (a ()) ≡ (a).
Withdrawal rules . Three rules of inference are given on the set S.
Rule of abstraction . Applies to substrings of a given string. Allows you to bracket the same content. From any group of brackets at the same level, any identical substrings can be taken out of brackets, according to the following principle:
((ab)(ac)) ⇒ (a(bc));
((ab)(abc)) ⇒ { (a(bbc)), (b(aac)), (ab(c )) };
((ab)(ac)(ae)) ⇒ { (a(bce)), (a(bc)(ae)), (a(ab)(ce)) };
By the rule of abstraction, results are always simpler than the original string. In the case of simple strings, for example, ((a) (b)), the result of applying the abstraction rule is empty. The recursive application of the abstraction rule allows you to decompose any complex string into simple ones.
The rule of deduction . According to this rule, you can get as many new lines as you like from the original row, by duplicating all the elements in the original row any given number of times, according to the following principle:
(a) ⇒ { ((aa)(aa)), ((aaa)(aaa)(aaa)), ((aaaa)(aaaa)(aaaa)(aaaa)), …};
(a(b)) ⇒ { ((aa(bb)(bb))(aa(bb)(bb))), ((aaa(bbb)(bbb)(bbb))(aaa(bbb)(bbb)(bbb))(aaa(bbb)(bbb)(bbb))), …};
(a(b(cc))) ⇒ { (aa(bb(cccc)(cccc))(bb(cccc)(cccc)))(aa(bb(cccc)(cccc))(bb(cccc)(cccc))), …};
Composition rule Any set of lines from S can be combined into one line. For example: (a), (b), (e) ⇒ ((a) (b) (e)).
Operator A. The result of the operator is a unique set of simple strings. The recursive application of the rule of abstraction to a given line, until it stops when all possible decomposition options are exhausted, corresponds to the action of operator A.
I want to draw attention to the fact that in the main article, the abstraction operator, unlike the A operator, in the result of its work includes not only simple, but in general all lines that can be deduced according to the rule of abstraction.
Operator D. A deduction rule with a given duplication parameter corresponds to the action of the operator D. From any given line, a more complex line can be deduced from the deduction rule, and this fact can be checked using operator A.
Composition Operator (). Corresponds to the action of the composition rule.
Thus, a formal system is obtained which satisfies the definition of complexity logic.
The content of theories . In the logic of complexity, every theory is meaningful. Since ∀s ∈ S there is a unique chain of conclusions t n = (A [D [t n-1 ]]) of increasing and potentially infinite complexity.
The unsolvability hypothesis . Sets of the general form T s = {p ∈ S | ∀n ∈ N , p ∈ A [D [t n ]]; t n = (A [D [t n-1 ]]); t 0 = s} I consider unsolvable. The set T s contains all simple strings that are derived by the recursive function t n from the start line s. Given the unsolvability of T s , the output t n is algorithmically random. There is no evidence.
Thinking t n has the character of complexity as in ideal thinking and on this basis is a form of ideal thinking. At each iteration t n, there is a clear transition from a less complex theory to a new, more complex theory, each such transition is unique and this process is potentially endless.
Thinking realizes consciousness in an asymptotic form. Roughly speaking, “consciousness of the theory” is the ultimate, infinitely complex content that t n aspires to in the process of computing.
Subjective experience . Subjective experiences are the prerogative of consciousness. Consciousness is not constructive.
Will the computer survive during computing? No. But in the results of the calculations, there may be experiences at the expense of the computer.
Conclusion I believe everyone knows how much imagination it takes to build something truly complex. Not just big, but complex. And for infinite complexity, you need endless fantasy. Where does the algorithm get so much imagination from? Unless the fantasy itself is an algorithm.
All Articles