Include Axons as a Builtin Primitive Type, as a high performance alternative to Artificial Neural Networks

Include Axons as a Builtin Primitive Type, as a high performance alternative to Artificial Neural Networks

I've conceived an axon as a high performance alternative to Artificial Neural Networks

An AXON exhibits the following architecture

AXON

[00]-\           /-[01]

[02]-\           /-[03]
        =[clk]=
[04]-/           \-[05]

[06]_/           \_[06]

Where [00], [01], etc. -- are opcodes (or bytes) stored in memory along with a central clock which acts as a central router.

Because a clock acts as a central router any number and or any depth of connections can be realized.

As an example, Given a trivial sequence of opcodes

[00] [02] [04] [ff]

the clock routes them accordingly

[00]-[clk]-[02]-[clk]-[04]-[clk]-[ff]

Because the clock routes all dendrites branches, it in essence acts as a 0-dimensional placeholder or heartbeat for the axon.

The benefit is: the clock, clk, can circumnavigate any sequence of states back to itself, in an effort to "defragment" and thus optimize
pathways in memory via builtin counters in the dendrites (in a behavior which I call REM)

As an example, the clock may encounter the following path of opcodes

[00]-[clk]-[02]-[clk]-[04]-[clk]-[ff]

During REM the axon discovers an optimized pathway which achieves the same result

[08] = [00]-[clk]-[02]-[clk]-[04]

Therefore

[00]-[clk]-[02]-[clk]-[04]-[clk]-[ff] 

=> 

[08]-[clk]-[ff]

The axon can achieve this because each dendrite or branch is in fact a Register + LUT

[value] = Register[value, ...] + LUT{}()

The register holds 0 or more values, while the LUT acts as a hash map or lookup table, which can even behave like an ALU

[00] === [ 
/* Register */ 0x00, 
/* eg. PC */ 0, 
/* eg. ALU Increment */ () =>{ return ++parent[1] }, 
/* Route-Map */ { RegisterIN:{} } 
] 

where parent is an implicit binding, similar to keyword this, however it is unique to encapsulations.

When the axon navigates across the clock, all dendrite branches with embedded clocks are called, and their PC/ProgramCounter incremented, iff still in sequence, to demonstrate real-time equivalent branches.

The Route-Map element simply verifies match conditions to permit or inhibit any traffic.

Can you find any other language that has this feature? JavaScript is a general purpose programming language, it's not likely to optimize for a very limited use case.

And I think it's more efficient if you code this in C++ or Rust with operator overloading etc...