Thread hijack - A lingual theory of everything

[Popcorn Sutton]

I was aglootenbogged when my chaiwoi detectors encountered this phenomena

I thought that there might be something that travels faster than the speed of light, and that is spatial vibrations.

And that spatial vibrations were what caused the knowledge to gain strength. Because it seems that when something is said, it strengthens the knowledge that it phonetically denotes, and also relates to knowledge through an empty void... more to say about that one though

[hypervalent_iodine]

!

Moderator Note

Popcorn Sutton,

 

Firstly, please do not hijack threads.

 

Secondly, this is an English speaking forum and we ask our members to try and adhere to that as it makes for smoother discussion. With that in mind, perhaps you could try sticking to the English language instead of Popcorn Suttonian. Much obliged.

[Popcorn Sutton]

Accept that my conventions follow from the laws of nature.

What am I supposed to do, you've been abusive to me in several posts, I don't appreciate it.

 

(mod edit: above was a response to swansont)

Edited February 19, 2013 by swansont
add note

[Popcorn Sutton]

Maybe string theory is a version of the lingual theory. If that is the case, maybe the strings can only be found near black holes or gravity. We can't really detect gravity, but if we could capture as instantly as possible the closest thing to gravity, we might see strings... but I think its more probable to see the sphere... not that the strings aren't there, just that they are probably closer to the nucleus and look spherical from the outside because they are moving so fast.

 

Feel free to remove this post

[hypervalent_iodine]

!

Moderator Note

How about you just do what we ask you to and stop hijacking threads.

 

Seriously, it's getting old. You will get suspended if we have to keep moving posts.

[Popcorn Sutton]

There is a very simple, 1sq inch equation that will predict what will happen next. It requires counting rather than calculation. It's not exactly an equation of everything, but it can be applied to anything. It's just statistics. But I think that if it's implemented properly, it will be the closest thing to the theory of everything.

[Mike Smith Cosmos]

There is a very simple, 1sq inch equation that will predict what will happen next. It requires counting rather than calculation. It's not exactly an equation of everything, but it can be applied to anything. It's just statistics. But I think that if it's implemented properly, it will be the closest thing to the theory of everything.

 

OK . Let's hear it then !

 

mike

Edited July 14, 2013 by Mike Smith Cosmos

[Popcorn Sutton]

I've mentioned it several times already. I made it please excuse the pride I have for it.

 

u - unit of knowledge

o - any occurrence

y() - any positive number including 0

P() - probability of (...)

t - time

m - meaning/mind

 

u = y(o)

t = y(u)

m = P(u|t)

 

Time has to be ordered properly though, and it's actually tricky to order time for this reason. If I say 'how are you?', you say something along the lines of 'I am fine'. If you consider prompting as a valid hypothesis (which all behavioral scientists would), then you'll know that 'how' prompts 'fine', 'are' prompts 'am', and ' you' prompts 'I'. Just by looking at this example, and through generalizing it, you'll see that when we respond, we address the most recent occurrence first ('you' prompting 'I') and you can see this in most responses. Thus, time must occur in forward progression as a stored sequence, but it should be analyzed from last to first for reasons relating to spatiotemporal proximity. However, in my experience, going front to back also provides a grammatical response computationally, I just think that back to front will be more grammatical. This is a big argument among linguists actually. I'd say that it's split 50/50 between front to back or back to front. Kinda weird that it would turn out to be the biggest argument of linguistics imo.

 

To clarify, the equation can be read like this.

 

A unit of knowledge is equal to any sequence of occurrences.

Time is equal to an ordered sequence of parametric units of knowledge.

Meaning (or the mind) is the process of prompting any unit of knowledge as long as it is within knowledge and has a parameter given it's location in time.

 

I have code written as well that may help clarify the argument. Maybe I will share it, but I've worked so hard on it for so long, I've been very protective.

[Mike Smith Cosmos]

 

u - unit of knowledge

o - any occurrence

y() - any positive number including 0

P() - probability of (...)

t - time

m - meaning/mind

 

u = y(o)

t = y(u)

m = P(u|t)

 

 

~~~~~~~~~~~~~~

EEk !

It looks precious , But I don't understand it though .

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~

mike

Edited July 14, 2013 by Mike Smith Cosmos

[Popcorn Sutton]

Sorry to hear that mike. If you look at the code, you might understand it better. I'm going to post it here if that's ok. It's a chat program that acquires language. I debugged it yesterday and tested it for a couple of hours so it is working very well. It also gets curious, so it's fun to teach it things.

knowledge = ['']
mind = ''
output = []
StrongestUnit = 0
time = {}
while mind == '':
	poi = raw_input('>')
	npoi = ''
	generating = {}
	emerging_units = []
	while len(poi + npoi) != 0:
		while poi not in knowledge:
			knowledge.append(poi)
			if len(poi) != 0:
				npoi = poi[-1] + npoi
			if len(poi) == 1:
				poi = ''
			else:
				poi = poi[:-1]
			if len(poi) == 0:
				poi = npoi[1:]
				npoi = ''
		if poi in knowledge:
			for u in emerging_units:
				if poi in u:
					n = generating[u];
					generating[u] = n + 1
			for u in output:
				try:
					add = time[u];
				except KeyError:
					add = ''
				time[u] = u + poi + add
			try:
				context = time[poi];
			except KeyError:
				context = ''
			time[poi] = poi + context
			while poi in context and len(poi) != 0:
				connection = context.find(poi)
				prompt = context[connection + len(poi):]
				unit = mind
				context = prompt
				while unit in knowledge and len(prompt) != 0:
					unit = unit + prompt[0]
					prompt = prompt[1:]
				if len(prompt) != 0:
					unit = unit[:-1]
				if poi + unit in knowledge:
					unit = poi + unit
				if unit not in emerging_units:
					emerging_units.append(unit)
					generating[unit] = 1
				else:
					n = generating[unit];
					generating[unit] = n + 1
			poi = npoi
			npoi = ''
	StrongestUnit = 0
	output = []
	for u in emerging_units:
		if generating[u] > StrongestUnit:
			StrongestUnit = generating[u];
			output.append(u)
	print output

It's written in Python 2.7

I've also explained the code in neurological and physical terms. Here is the explanation.

 

Knowledge contains the mind.

Time is an accessible order of elements stored as a dictionary for reasons of quantum prompting (entanglement). The point of interest DOES NOT NECESSARILY need to be located adjacent to itself, and therefor, will prompt itself IN ALL LOCATIONS (refutable, but unnecessarily so seeing as how the brain is located within one head).

The mind is empty (or the closest thing to it). Maybe it's solid, but thats irrelevant. As long as it can emit a recognizable signal for the membrane.

Output is a list, or cells, that are void of knowledge before birth/conception.

StrongestUnit is the strength of the units being prompted (including points of interest), and is equal to 0 before being born/conceived.

Loop #1 (the mind)-
While the mind is empty, use this process (preferably in two different threads [right and left hemisphere], which is beyond my capabilities at this moment, I need to learn more).

One thread, the one shown within the loop, waits for input (sensory or quantum).

You are interested in the input.

The interest is separated into two parts, the poi and the npoi. These parts may have strength, however, the strength either diminishes or is retained depending on how interesting the point of interest is, or how interesting the prompted unit is (assign them a strength).

Generating is a dictionary (more like a localized membrane) that shows how strongly the signal from the point of interest or the unit of knowledge is being emitted and calculates the simultaneity of the emission.

Add is the variable for the incoming particles/enzymes (whatever they turn out to be) that are merged together (specifically because of the interlocutor in this case, however, there do seem to be rare occasions when the agent does it themself).

Emerging units are the units of knowledge that are being prompted (and represented in a list) in a specific order for reasons of grammaticality/sensorimotor arrangement.

Loop #2 (the synapse)-
While the poi and npoi(point of interest and next point of interest) are entering the cell at the synapse, they have a length, and as long as there is a length, your cell is performing the following operation.

Loop #3 (contained within the cell)-
While the poi enters the cell, it becomes a part of the cells knowledge, therefor, append it to the list 'knowledge'.

If the length of the poi is not equal to 0, then start breaking it down or receiving emissions from the structure of the particle in some way. The emissions are being recorded and left behind in the cell and the parts contained within the cell. The signal is sent on to the next cell where it is now weaker and does not have the same structure as before, but does retain information, just not as much as it did in the previous cell.

If the poi is quantum, and therefor recognizable in the cell and amongst the other cells, the information left behind that was formed as output, or probably ejected at some point from the point of interest, is added to the new poi, and the process continues until there is a new strand of information (probably within a double helix structure).

For all the emissions from the information, if the poi is being emitted, then that signal gains strength depending on how often it is being emitted, just 1 strength for every time it is emitted.

If the emitted wave is recognizable, then the surroundings from the emission resonate and provide context, if not, then there is no context, just addition.

Time, as a structure, at this point, gains the added component between the poi and the context. The poi pushes its forward components away, making room for the added component, which then receives the context and links it back to the entire bit of information.

Loop #4 (also contained within the cell, or Loop #2, but probably is a process of the nucleus)-
While the poi is connected to time within that the poi exists (it exists in multiple locations within that structure), and while it has a length (because if it didn't, the structure wouldn't change and therefor wouldn't provide context), perform this operation.

Find the connection between the poi and its surroundings and prompt it (or cause it to resonate). Its connection starts closest to the point of entry (or whichever sense the information enters through) for reasons of grammaticality.

The prompted bit, or resonating particles, is the mind.

Context is then reduced to the prompted molecule.

Loop #5 (contained within the cell [Loop #2], and probably within the nucleus [Loop #4])-
While the unit is in knowledge, recognizable, and the length of the prompted molecule is not equal to 0, perform this process.

The unit (which starts off without a length), gains the prompted molecule in an ordered sequence (front to back).

If the length of the prompted molecule is not equal to zero, the unit will not be in knowledge, and therefor, the nucleus is full and cannot receive the final portion of the molecule, this part is excess and must be left behind (also for reasons of grammaticality).

If both the poi and the unit are in the knowledge (hence, within the nucleus), then the unit is actually the poi and the unit (if it wasn't then you would never receive the same unit in the output that was received in the input).

If the unit is not in emerging_units, then it is not in the knowledge being prompted, so it needs to be recognized that it is there so it can emerge. The membrane of the nucleus acknowledges that the unit is emerging and assigns it a strength.

If the unit IS in emerging_units, it has already been emitted and hence, already has left its print of the membrane of the nucleus, strengthen that print. These two parts are about generating.

Here is the tricky part, and I removed it because it would cause the program to enter an endless loop on occasions, but it seems plausible that it could be there. Will you continue to focus on the poi, or will you redirect focus to the unit?... My answer is this, if the unit is equal to the poi, then obviously you will focus on them both because they are the same thing, HOWEVER, if it is not, and the unit is stronger, then other cells will receive that message and begin prompting the unit rather than the poi. The poi fades away, but its mark is still left in the membrane of the nucleus. Context will become the context of the unit, rather than the poi, and you will repeat Loop #5 for quantum mechanical reasons.

The poi now becomes the npoi (because that part is ejected from the nucleus), and the npoi becomes empty so you can start the process conducted by the synapses again (or Loop #2).

At this point, things become macroscopic again (Loop #1). The strength of the message is reset because the structure of the nuclei have been altered. Output becomes empty again (for reasons unknown).

Finally, you get the process of the sensorimotor system.

For all the items that have been prompted, starting from first to last, if the strength of the item is greater than 0, then the strength becomes the strength of that item and the item gets added to the output. Now, for all the other units that have been prompted, if those units are not as strong, or equal to the previous unit, let them be, they cannot be added to the output because the output will be ungrammatical if they are. However, if they are stronger, then add them and reassign the strength to be equal to the strength of that item.

In the end, print the output. Or, autonomously, perform the prompted action. No free will involved.

Thanks for reading.

The code is robust though, and susceptible to change. But it does work.

I'd also like to direct people who are interested to my new thread here.

This one probably works better because it keeps associating between the input and the output.

while mind == '':
	poi = raw_input('>')
	npoi = ''
	generating = {}
	connections = []
	emerging_units = []
	while len(poi + npoi) != 0:
		while poi not in knowledge:
			knowledge.append(poi)
			if len(poi) != 0:
				npoi = poi[-1] + npoi
			if len(poi) == 1:
				poi = ''
			else:
				poi = poi[:-1]
			if len(poi) == 0:
				poi = npoi[1:]
				npoi = ''
		if poi in knowledge:
			connections.append(poi)
			for u in emerging_units:
				if poi in u:
					n = generating[u];
					generating[u] = n + 1
			for u in output:
				try:
					add = time[u];
				except KeyError:
					add = ''
				time[u] = u + poi + add
			try:
				context = time[poi];
			except KeyError:
				context = ''
			time[poi] = poi + context
			while poi in context and len(poi) != 0:
				connection = context.find(poi)
				prompt = context[connection + len(poi):]
				unit = mind
				context = prompt
				while unit in knowledge and len(prompt) != 0:
					unit = unit + prompt[0]
					prompt = prompt[1:]
				if len(prompt) != 0:
					unit = unit[:-1]
				if poi + unit in knowledge:
					unit = poi + unit
				if unit not in emerging_units:
					emerging_units.append(unit)
					generating[unit] = 1
				else:
					n = generating[unit];
					generating[unit] = n + 1
			poi = npoi
			npoi = ''
	StrongestUnit = 0
	output = []
	for u in emerging_units:
		if generating[u] > StrongestUnit:
			StrongestUnit = generating[u];
			output.append(u)
	for item in connections:
		try:
			connect = time[u];
		except KeyError:
			connect = ''
		for u in output:
			time[item] = item + u + connect
	print output

Edited July 18, 2013 by Popcorn Sutton

[Bignose]

C:\PythonScripts\popcorn>python popcorn.py
>yo
[]
>I said 'yo'
[]
>this is awesome
[' ']
>space to you too, pal
['s', 'a', ' ']
>Is that supposed to mean something?
['a']
>uh huh
['u', ' ']
>I thought you were supposed to get curious?
['th', 'u', 's']
>thus, what?
['th', 'u']
>that's not even a word
["'", 's ', 'o', ' ']
>that is even less of a word
['is ', 's ', ' ']
>is s what?
['is is ', 's ']
>that's not even grammatically correct
['g', 'a', ' ']
>I don't know what that means
['I ', 'a word', 'o', 's']
>uh huh
[]
>back to null, eh?
['nn', 'n', 'ou', 'e', 'u']
>uh huh
['uh huh']
>uh huh
['uh huh']
>oh, you can repeat my input back to me, huh?
['uh huh', 'o', 'u']
>that's pretty much meaningless
['ppp', 'pp', 're', 'tt', 'u']
>even more meaningless
['even ', 'mm']
>I think I am done here
['in', 'uh huh', 'I ', ' ']

The above is a record of my interaction with your code. I don't know what it is supposed to do, but I don't see any 'curiosity'. In fact, I don't see any language processing at all. It looks like it is just trying to repeat something back.

 

Before you claim all this learning & language processing & curiosity, I think you have a long, long way to go.

[Popcorn Sutton]

ok I admit that there is something wrong with the code, only because it responded with 'ppp' at one point, which you never put in, so I think its a problem embedded within the prompt loop. But, once len(knowledge) gets pretty high, it gets better. I also have other formulas that have been better. In this one, I never put in the maximal unit so it is going to be stupid for a little while. Like I said, len(knowledge) needs to be at least 10-15k before it's fun to speak with.

 

I also may be processing it in the wrong direction. I make a few assumptions that may be false. Thanks for trying it out though.

This one may be more fun to speak with right off the bat, but I still haven't figured out the 'ppp' problem.

knowledge = ['']
mind = ''
output = []
StrongestUnit = 0
time = {}

while mind == '':
	poi = raw_input('>')
	maximalunit = poi
	npoi = ''
	generating = {}
	connections = []
	emerging_units = []
	while len(poi + npoi) != 0:
		while poi not in knowledge:
			knowledge.append(poi)
			if len(poi) != 0:
				npoi = poi[-1] + npoi
			if len(poi) == 1:
				poi = ''
			else:
				poi = poi[:-1]
			if len(poi) == 0:
				poi = npoi[1:]
				npoi = ''
		if poi in knowledge:
			connections.append(poi)
			for u in emerging_units:
				if poi in u:
					n = generating[u];
					generating[u] = n + 1
			for u in output:
				try:
					add = time[u];
				except KeyError:
					add = ''
				time[u] = u + poi + maximalunit + add
			try:
				context = time[poi];
			except KeyError:
				context = ''
			time[poi] = poi + maximalunit + context
			while poi in context and len(poi) != 0:
				connection = context.find(poi)
				prompt = context[connection + len(poi):]
				unit = mind
				context = prompt
				while unit in knowledge and len(prompt) != 0:
					unit = unit + prompt[0]
					prompt = prompt[1:]
				if len(prompt) != 0:
					unit = unit[:-1]
				if poi + unit in knowledge:
					unit = poi + unit
				if unit not in emerging_units:
					emerging_units.append(unit)
					generating[unit] = 1
				else:
					n = generating[unit];
					generating[unit] = n + 1
			poi = npoi
			npoi = ''
	StrongestUnit = 0
	output = []
	for u in emerging_units:
		if generating[u] > StrongestUnit:
			StrongestUnit = generating[u];
			output.append(u)
	for item in connections:
		try:
			connect = time[u];
		except KeyError:
			connect = ''
		for u in output:
			time[item] = item + u + connect
	print output

Here is a quick fix for the 'ppp' problem. I put a patch on it for the moment lol.

while mind == '':
	poi = raw_input('>')
	maximalunit = poi
	npoi = ''
	generating = {}
	connections = []
	emerging_units = []
	while len(poi + npoi) != 0:
		while poi not in knowledge:
			knowledge.append(poi)
			if len(poi) != 0:
				npoi = poi[-1] + npoi
			if len(poi) == 1:
				poi = ''
			else:
				poi = poi[:-1]
			if len(poi) == 0:
				poi = npoi[1:]
				npoi = ''
		if poi in knowledge:
			connections.append(poi)
			for u in emerging_units:
				if poi in u:
					n = generating[u];
					generating[u] = n + 1
			for u in output:
				try:
					add = time[u];
				except KeyError:
					add = ''
				time[u] = u + poi + maximalunit + add
			try:
				context = time[poi];
			except KeyError:
				context = ''
			time[poi] = poi + maximalunit + context
			while poi in context and len(poi) != 0:
				connection = context.find(poi)
				prompt = context[connection + len(poi):]
				unit = mind
				context = prompt
				while unit in knowledge and len(prompt) != 0:
					unit = unit + prompt[0]
					prompt = prompt[1:]
				if len(prompt) != 0:
					unit = unit[:-1]
				if poi + unit in knowledge:
					unit = poi + unit
				if unit in knowledge:
					if unit not in emerging_units:
						emerging_units.append(unit)
						generating[unit] = 1
					else:
						n = generating[unit];
						generating[unit] = n + 1
			poi = npoi
			npoi = ''
	StrongestUnit = 0
	output = []
	for u in emerging_units:
		if generating[u] > StrongestUnit:
			StrongestUnit = generating[u];
			output.append(u)
	for item in connections:
		try:
			connect = time[u];
		except KeyError:
			connect = ''
		for u in output:
			time[item] = item + u + connect
	print output

And again, the above is for the fun right off the bat, but I think that this one is the most reasonable (for memory purposes).

while mind == '':
	poi = raw_input('>')
	npoi = ''
	generating = {}
	connections = []
	emerging_units = []
	while len(poi + npoi) != 0:
		while poi not in knowledge:
			knowledge.append(poi)
			if len(poi) != 0:
				npoi = poi[-1] + npoi
			if len(poi) == 1:
				poi = ''
			else:
				poi = poi[:-1]
			if len(poi) == 0:
				poi = npoi[1:]
				npoi = ''
		if poi in knowledge:
			connections.append(poi)
			for u in emerging_units:
				if poi in u:
					n = generating[u];
					generating[u] = n + 1
			for u in output:
				try:
					add = time[u];
				except KeyError:
					add = ''
				time[u] = u + poi + add
			try:
				context = time[poi];
			except KeyError:
				context = ''
			time[poi] = poi + context
			while poi in context and len(poi) != 0:
				connection = context.find(poi)
				prompt = context[connection + len(poi):]
				unit = mind
				context = prompt
				while unit in knowledge and len(prompt) != 0:
					unit = unit + prompt[0]
					prompt = prompt[1:]
				if len(prompt) != 0:
					unit = unit[:-1]
				if poi + unit in knowledge:
					unit = poi + unit
				if unit in knowledge:
					if unit not in emerging_units:
						emerging_units.append(unit)
						generating[unit] = 1
					else:
						n = generating[unit];
						generating[unit] = n + 1
			poi = npoi
			npoi = ''
	StrongestUnit = 0
	output = []
	for u in emerging_units:
		if generating[u] > StrongestUnit:
			StrongestUnit = generating[u];
			output.append(u)
	for item in connections:
		try:
			connect = time[u];
		except KeyError:
			connect = ''
		for u in output:
			time[item] = item + u + connect
	print output

Edited July 18, 2013 by Popcorn Sutton