§

§code is neither like instruction code nor Unicode; it is an infinitely extensible serial ID. Global §ID is issued starting with the birth of the first § in the world, and new global § are constantly being born every time, everywhere. Upon the death of a §, its ID will be permanently invalidated, and no § will ever use that serial ID again.

( A , B ) means both of A and B will be made true, and also means both will be allocated to operate. 

( A ; B ) means only one of A or B will be made true randomly, and also means only one will be allocated to operate. 

Before 

( ) express senses in a container associate in priority 

[ ] express a container for collection 

{ } express a container for classification 

After 

There is only one kind of bracket, and all kinds of containers are expressed by ( ) .

[ ] { } are turned to operators:  

A [ B expersses A is an element of collection B 

A ] B expersses A is a collection of element B 

A { B expersses A is an instance of class B 

A } B expersses A is a class of instance B

Dynamic object system

It can be called the dynamic object system only if it can perform this operation: (A∈B) ⊧ (C∈D) . 

Sense

A most basic sense unit is a reference point as entrance on an one-dimensional linear memory array, two directions from this point: one side is value array; the other side is linkage array. Use this particle to organize the Sense graph.

Dynamic behavior

The abstract behavior table of each object is not fixed, the behavior reference registration can be dynamically moved among objects, classes, and parent classes. When a behavior is not found in an object, it will jump to its class to find; if it is not found in a class, it will jump to its parent class to find. The behavior references placed in the object spend the most memory space, placed in the parent class spend the most travel time, and the ability to evaluate and adjust the placement according to the situation during runtime is a way of dynamic balance. In this way, the dynamic abstract behavior table can also directly implement dynamic addition and deletion of behaviors. The old static object system lacked a dynamic addition and deletion mechanism, so an extra Component Object Model was defined on it. The new dynamic object system has a more direct and better way.

The dynamic logic model

The basis of an operation system is the connection among operands and operators. The connection state is specified sequentially by instruction codes, it is called control-driven. The next connection state is generated by the result of the operation, it is called reaction-driven. The operation starts when the operands change, it is called data/event-driven. The operation including connection changing for the formula automatically solving starts when any operand is unknown, it is called goal-driven. Reaction-driven is also data/event-driven and goal-driven, but control-driven is not. 

The dynamic logic model is reaction-driven instead of control-driven. 

Could the operands, virtual operators, and virtual wires be uniformed to be only one kind of unit?

In the traditional processor, the function is a program counter assignment to jump to the function body and return with the parameters pushed in and popped out the stack.

In the sense graph processor, regard the traditional function declaration and definition as the same type of interreplaceable sentence, use the symbol ≡ to link all interreplaceable sentences, and choose the suitable one according to the configurable situation on site, so the function can be redefined during runtime.

Subgraph = class

There are several the same subgraphs in a large graph can be overlapped to be only one in the memory as a class, and then the boundaries between the overlapped subgraph and the large graph holes formed after the subgraphs cutted can be regarded as the instances of this class.

There may also be several the same subgraphs in a subgraph. Travelers remember one more boundary each time crossing a boundary into a subgraph, and forget the last added boundary when exiting a subgraph. Via these remembered boundaries, the travelers from different instances can go back where they came after they leave the class traveling. 

It is possible to have different subgraph within an overlapped graph, in this condition, there are several different boundaries at the same place.

Graph machine & Replacement machine

Graph machine 是模拟人在阅读或算式的过程是先同时看到几个重要关键的字符再系结旁边的字符组成认知图而理解一段文式然后进行思考。

Replacement machine 是模拟人在阅读或算式的过程会逐步将文式片段转换成自己已理解的片段，多次返复代换到最后其实就是结果与答案了。

Graph machine & Replacement machine

Graph machine 基本是依结合优先顺序透过 comparation gate array 同时并行位移比对将 match 到多个 Sense 中取左边第一个连接到动态配置的 virtual wire 上，之后 sense 欲变更 virtual wire 的连接状态亦是相同的方式输出 senses 到 comparation gate array 上。

Replacement machine 基本透过 comparation gate array 与 replacement table 做同时并行位移比对将 match 到的片段 replace，返复进行至没有任何 match 了即为运算完成。排在 table 前面的优先 replace 即达 graph machine 中结合力较强的 operator 优先结合的效果，过程中遇到 definition keyword 就将片段加入 table 或从其刪除。

两者对括号的处理方式都是在比对到左括号时都暂不 connect 或 replace ，后面再一并进行消括号的动作，自多个左括号处同时并行向右位移比对出右括号，左右括号间仅存在一 Sense 即消掉左右括号，接着再重复前面的动作 loop 至不再比对出任何括号，若自左括号处向右位移比对到左括号则什么都不做、等待下一 loop 后面再重复进行一次。

Graph machine 是接线生的角色，接完线后 graph 自己是线路、自己在动；Replacement machine 的 senses 则完全是被动处理，纯粹是 data。

Can these two machines be combined to be one machine?

Distributing Sense

operators + operands = operation

sensed operator = sense
sensed operand = sense
sensed operation = sense

operators and operands distributing on different hardwares
= distributing operation = distributing sense

Distributed Operation

host#1'operand#1 + host#2'operand#2

+ 是1号机1号元的 operator 与其同在一号机，所以现在有2个 senses 在1号机、1个 sense 在2号机，要怎么执行这个跨机的 distributed operation ？

在2号机对1号机使用 WCF service 下这道式子会先把1号机1号元下载到2号机然后才和2号机2号元一起当作远端呼叫1号机 operator + 的 parameters 上传到1号机，1号机1号元被下载了又上传多此一举白费流量，你会说还不如传 request 给 1号机的 Web server 呼叫 Servlet 在1号机执行。但若2号机2号元的 size 大于1号机1号元与 operator + 是否就不如将 operator + 下载到2号机执行？如 Applet 的做法 ( 把 Applet 看作是一个大 operator ) 。三种架构分别，但软件在跑一下是这情况一下是那情况，这就是为何要丢掉传统架构全面采用 DDA 架构。

operator ≡

The operator ≡ is used to define the replaceable linking state of the operators and operands dynamically like the function definition. If the operator can not be found in the hardware when it is asked to be allocated, it can be replaced with the other linking graph defined by the operator ≡. If the allocated graph is already in usage, it clones the other one for new usage.

operator ∏ ∑ ∫

Change the script style of the operator ∏ ∑ ∫ to be as the operator ∀.

Ex:

( ( ∀ ( x + y = x * y ) ) ( ( x ^ 2 + 2 * x * y + y ^ 2 ) / ∂ x * ∂ y ) )
just produce a collection of ( ( x ^ 2 + 2 * x * y + y ^ 2 ) / ∂ x * ∂ y ) by ( x + y = x * y )

( ( ∫ ( x + y = x * y ) ) ( ( x ^ 2 + 2 * x * y + y ^ 2 ) / ∂ x * ∂ y ) )
the same as ∑
get the sum of a collection of ( ( x ^ 2 + 2 * x * y + y ^ 2 ) / ∂ x * ∂ y ) by ( x + y = x * y )

( ( ∏ ( x + y = x * y ) ) ( ( x ^ 2 + 2 * x * y + y ^ 2 ) / ∂ x * ∂ y ) )
get the product of a collection of ( ( x ^ 2 + 2 * x * y + y ^ 2 ) / ∂ x * ∂ y ) by ( x + y = x * y )

Dynamic operators

The operators in the static language system only access the operands; the operators in the dynamic language system also access the formula.

∀

∀ ... 🔲 ......

其实 🔲 处不用填介系词

( ∀ ... ) ......

括号內让∀优先结合得到collection'#(1~collection'#)再后接 ......

所以就用括号就行了

不用再伤脑筋这个介糸词要用何operator才不会与其它别的用途相冲突

operand operand

I would like to change my mathematic script custom that two operands side by side will be inserted an operator * in default. Restrict the operator * must be written or it will not be inserted automatically. Because it is needed to allow two noun operands side by side automatically inserted by the operator ' for compound noun. For this, I am also willing to change my English script custom about ' such as not writing "I'm", "I'd", "I'll", "I've", "It's", "isn't", "don't"...... and just writing "I m", "I d", "I ll", "I ve", "It s", "isnt", "dont" ......

operand _

An unknown object is an object without any sub-objects meaning no content. An operand _ is an unknown object without symbol as no name. In the same expression within "(" and ")", different operand _ is different unknown object. After the expression including operand _ resolving, there is a collection of possible satisfied combinations of operand _ s gotten. If more than one operand _ are needed to appoint to the same unknown object, the only way is using the named unknown object assigned with ∅ to replace the operand _ s. If there is no space among the operand _ and another characters, what matched is not an object, it is the object symbol characters match. However, each symbol and character is an object too.