Saturday, October 19, 2019

Another idea on the previous post...

Something has occurred to me since my last post about where to implement the behaviour common to traditional neurons in the Clique Space(TM) Neuron.

Currently, no weights, activation, bias, or other well known mechanism commonly seen in traditional neurons (with the possible exception of  structure that resembles a Clique Space synapse) is currently implemented in the Client Device, or the Neuron as an extension of the Client Device. It currently seems too premature to implement any traditional neurologic within these two projects; it instead seems better to delay implementation to an extension of the Neuron that can handle specific device types and can also implement any variety of neurological mechanism chosen by the organisation that implements such an extension, or no mechanism at all.

The Client Device and Neuron projects define the purpose and structure of qualia and Elements: Connections, Participants, Identities, the Sovereign - and all of their surrogates. The base protocol for the transmission of deliberations and their enclosed signals, as well as synapse and thinker structure are also defined primarily in the Client Device, but are extended in the Neuron to define similar structures that permit the transmission of messages. The Client Device uses the structure defined within it to facilitate the transmission of challenges only.

The rationale of my conclusion is the following: a relay Neuron is a specific type of Neuron; it acts in a mere signal forwarding capacity. These Neurons don't contribute in any substantial way to cognition, and therefore don't have a need to be equipped with the mechanisms - the Connection weights, activation, bias etc. - that equip a neuron with a greater ability to participate in cognition. A relay Neuron can extend the Neuron without addition of functional structure. Relay Neurons do not inherit anything more than those mechanisms that make a relay Neuron do what it needs to do if traditional neurologic is not implemented in the Neuron.

Hence, I think details relating to traditionally defined neurological mechanism can be reasonably deferred to the more specific types of Neuron that need these mechanisms.

Friday, October 18, 2019

The exploration of a new hypothesis on or about the neurocognitive connectome.

It may all be bullshit, but thoughts over the past two days have led me down what I observe is an interesting garden path concerning the components of a Clique Space(TM) neural network and how a participating Neuron might conceive of itself and its neighbourhood.

Traditionally, a neuron shares physical connections with a subset of its neighbours. Each of these physical connections is assigned a weight and any given connection is assigned a value for its weight based on a process of "learning". That has always appeared as a reasonable if not abridged overview of the neural way things are generally known in this world.

I feel that I can give a slightly different slant on the above view. Clique Space is no different from this view in that Neurons indeed share similar physical connections (synapses) with a subset of their brethren; each connection is indeed realised through an algorithmic structure known as a synapse. However, what is slightly different is the following: weights are not assigned to synapses.

A Clique Space Client Device (a Neuron is a type of Client Device) is identified individually by a Connection. Connections are Elements which contain one or more features that are expressed by Participants (also Elements) which are members of Cliques. Cliques denote some cooperative endeavour is being undertaken. Synapses are a type of bipartite Clique which models the engagement of two Client Devices through the "this Element" feature of their individual Connections.

While a Client Device may not share a synapse with every one of its cohorts, it can still be aware of every Connection that makes up the entire population. Weights are assigned to the Connections known to a Neuron to represent other Neurons - even those Neurons with which the host Neuron doesn't share a synapse directly. Now, I think at this moment, there is an opportunity to do something rather useful with this knowledge; something that uses another structure developed over the past 11 years I have been working on my proof-of-concept. This something appears to me to advance the traditional connectionist model of neurons. Instead of assigning a weight to a synapse, weights are assigned to Connections.

A deliberator is a thinker (a type of Java thread) which is created to deliberate the arrival of a deliberation. Deliberators are associated with the Connection assigned as the first Neuron (actually Client Device but we will not split hairs here) to have entertained the topic being deliberated. Now, getting hypothetical, the wonderful thing about creating deliberators in this way is that a group of deliberators may be created to represent receipt of deliberations sent from neighbouring Neurons all of which are received at around the same time. Apart from the difference in originator, each deliberator is cogitating the same topic and hence each deliberator is constructed to have a identical parameters such as activation and bias because all deliberators are instructed by the same feature.

Accumulation of Connection weights for deliberators on this same topic may cross a threshold which when reached will cause the deliberator on which the threshold was crossed to send deliberations through synapses to its neighbours. Some neighbours may share synapses and may receive the deliberation immediately and others may only receive the deliberation through a neighbour who has faithfully passed the deliberation on.

This is all done by assigning weights to the Connections instead of to the synapses. I think that is a big deal, and an advancement in neuroscience that was published in this blog entry before anyone else in this world knew that assigning weights to representations of nodes in a Neuron's knowledge of its neural neighbourhood would be better than assigning them merely to the physical connections it would share with its neighbours.

This mechanism, and more as would answer most other questions about my concept is all there in my code. Really, it is... almost. I'm sitting on the greatest advancement in neuroscience since the perceptron!

Friday, September 20, 2019

Identity and Sovereignty

This post is more or less and addendum to my post on Sovereignty Demystified in that everything explained in this earlier post except the association between a Connection and its property of sovereignty still applies.

In Clique Space, sovereignty is a feature only of the Identity Element. Sovereignty is never communicated directly between Client Devices, but one device can work out if an Identity informed to it by a neighbouring device is indeed sovereign when it receives an Identity's key feature. The given Identity is sovereign when the Identity can be used to generate the same public key that was given as the key in the feature. In this case, the corresponding public/private key pair are stored as a CoSovereignKey in the given Identity.

A Client Device can use an Identity with a non-null CoSovereignKey (a sovereign Identity) to sign deliberations that it generates when informing other Client Devices of subscriptions. Subscriptions are associations between a given feature Element, qualia known as the sense datum and the subject, and a given subscription tag - either an Identity if the subscription is a challenge, or a belief (an association between two Identities - the claimant and the candidate) if the subscription is a message.

Because an Identity has to be sovereign to contain a private key, sovereign Identities are the only type of Identity capable of generating signatures for deliberations.

Sovereignty encompasses an individual's concept of self-hood. Identity is a projection of this self-hood within an individual's manifest Clique Space and outward to Clique Spaces that manifest other individuals.

Tuesday, July 23, 2019

How's this Clique Space(TM) thing going?

I'm still here. I'm venturing a comment that Clique Space is continuing, and it just now appears to me that I have perhaps resolved most of my concerns around the question of symmetry between challenges and messages.

Challenges - sent from initiator to respondent, represent queries asked by a specific device and on behalf of a specific Identity known as the respondent for information about quale associated with a specific resonance.

Messages - set from respondent to initiator, represent the state of a specific device which is associated with a pair of Identities (a belief - one is the claimant or the Identity making the claim, the other is the candidate or the Identity about which the claim is being made) associated with a specific resonance.

Friday, March 22, 2019

So, tell everyone what's been happening with this Clique Space(TM) thing of mine...

Well might you ask...

Neurons appear to do almost everything a Neuron of any type is supposed to do. The relay Neuron, (I used to call these naked Neurons on account of the fact that they implement nothing more than the basic Neural implementation) seem to work fine on my laptop. Instances of relay Neurons are started in separate JVM's so each Neuron exists as a separate process.

The Java sockets API regards each process as being "out there" in a world completely separate from each other. They must communicate using TCP/IP socket connections, and hence, when (or if) I do get to run Neurons (or Client Devices more generally) on separate physical devices, there should be little more work needed on the core Clique Space concept; everything should be about extending the core concept to capture the specific nature of the host device.

With my most recent commit, I think I have worked out the process that allows the life cycle of quale and other content to be managed.

Content? Other content? Well, yes, as it turns out, all content has a container, and these containers must be managed in a way that prevents deadlock. Indeed, I think I have solved this with a simple anonymous inner class (something that can perhaps be re-implemented as a lambda) called a keeper.

Content and containers are an abstraction: keepers are used to lock containers before access and ensure that any content retrieved or created is not disposed until the current thinker - instances of Java threads used throughout the Clique Space code - has finished with it. A Keeper can only be used to create or retrieve a single content instance. The keeper's container (and no other container) must be the container that is accessed.

A thinker uses a keeper to lock the container before it acquires the content, and then releases the container for the next keeper. Thinkers manage a stack of keepers. This stack allows the thinker to release content in the reverse order in which it was acquired so content can be disposed of in an orderly way. A thinker can only access a container to add or get its content when it has a keeper that is ready to acquire an instance of its container's content; a keeper cannot be used after it has already acquired content.

Quale are content to quale containers; a Neuron (a Client Device more generally) manages a single quale container. Subscribers are content to subscriptions; a subscription is also a type of quale and subscriptions are accessible from features. Deliberators are content to subscribers; apart from expressing the characteristics of both content and container, subscribers are nothing else. Deliberators are a type of thinker; they process (they deliberate) what should follow when a signal is received from another Client Device.

Deliberators behave in accordance with the instructions given in the implementation of the methods used to deliberate messages or signals internally for a given feature. Features and Connections are some of the extensible components of the Clique Space concept. These components give an individual the ability to transmit and control the state of a device within Clique Space.

I wonder if anyone else will take notice of this before I'm dead? I wonder if there indeed is anything to take notice of? I'll be pleasantly surprised if there is. I'll wait to be pleasantly surprised only until I die, and then I won't care.

Wednesday, January 2, 2019

How done might we be if the deliberator and the subscriber are combined?

The subject of this post is the consideration that marrying the subscriber and the deliberator into a single class is a good idea.

I actually think I might have stumbled upon the tail of this idea. I recall momentarily perceiving that it might be necessary a year ago. I was trying to implement the mechanism that helps a Client Device reconstitute as qualia information contained in a transmitter and I remember scaring myself with a very similar set of thoughts I am having now. It appears to me now that perhaps I just wasn't ready to follow this idea at that time; marrying the deliberator mechanism (a type of thinker - a Java thread used throughout the implementation) with the mechanism being considered looked so ambitious at the time that it induced some distraction.

However, the reconstitution mechanism has been stable for some time now, so I think it's now worth to go back and follow a garden path that earlier expediency had caused me to avoid. Hence, I should consider merging the subscriber and the deliberator; it might perhaps complete the implementation of the core concept... or it will merely open up other questions about the core concept that were off in the thicket of enquiry hitherto. In any eventuality, combining the deliberator and subscriber appears to be a very attractive proposition at this point in time.

This all looks to be quite a substantial unit of work unto itself, so I should perhaps obtain a clean working copy of my code before embarking. I'll do that later this afternoon. For now, I'll let these ideas steep for doing this might soften the trauma of implementing them.