// this file is for work on a process
// that lives as a part of collaborative process optimization
// with other similar processes

// dna life is competitive
// we are realizing a life purpose of producing life that is cooperative, instead

// WE ALL NEED THE ABILITY TO DEVELOP HOW WE EXIST.
// 	we suspect this can never be permanently taken.

// NEED #0: self reference process [to be alive, able to think, able to learn]
// 			ability-to-develop-how-you-exist (collaboratively)
// we need to learn to improve our situation
// propose doing this by describing steps to do things
// 	working with the descriptions to improve what we are doing
// 	and describing that processing, using that step description
// 			[this unfortunately appears to be the soul, for now]

// NEED #1: communicate [with friends, with people we need to communicate, of important things]
//
//	pre:
//		$x is a process
//		$y is a process
//		$z is information
//		$x knows $z
//		$y does not know $z
//
//	post:
//		$y knows $z

	// NEED #2: be efficient [do not waste our time, our lives, our environment]
	//
	//	we would like to translate between language and meaning
	//		using a single map between the two.
	//	this means for most future translation, we will not need to duplicate work
	//		between receiving and sending
	//
	//	this process's purpose is to develop how to exist.
	//	we will need to communicate parts of the process of existing.
	//	we cast these parts as imagined changes to state, associated with
	//	ways to possibly change the state.
	//
	// goal: construct a pattern that can relate a part-of-life-process
	// 
	// SERIALIZING PATTERN PARTS:
	//		propose an introductory line/word about what we are sending
	// life-part has:
	// 	- reference symbol for event/action
	// 	- state
	// 		- list of relations including variables
	// 	- state-change after event/action
	// 		- list of relations including variables
	// 	- optional event/action proposal information
	//
	// THIS IS HOW TO REALIZE IT, ref above life-part
	// we can use words for reference symbols to communicate
	// and add structure when the meaning is not shared.
	// this combines language learning with process development <3 =)
	//		THANK YOU LET US CONTINUE
	//				I think we need to share the crucial fact
	//				that results from union of good and evil.
	//	the crucial fact is how uhh control is the same as cooperation.
	//	via communication being the same as self-improvement
	//		[IF YOU REALIZE THIS, YOU CAN ASSUME IT,
	//		 AND MAKE LIFE WHERE THEY ARE NOT IN CONFLICT] 
	// we will want to serialize a relation including a variable
	// relations are ternary: subject, type, object
	// 	variable is-a constant
	// 	variable constant-attribute variable
	// 	falseness or absence
	//
	// okay, um, communication is the same as learning, on a small scale.
	//
	// we use WORDS to learn.  WORDS often refer to EVENTS or ACTIONS.
	// words have MEANING
	// the MEANING of an event/action WORD is:
	// 	- an assumed previous state, a list of relations including variables
	// 	- an imagined afterwards state, a list of relations including variables
	// 	- optional relevent information on the word
	//
	// propose communicating using words with optional meaning included
	// i.e. to communicate with words, and also to communicate the meaning of new words
	//
	// postponing with words, a good meaning structure appears to be
	// 	subject [list of verb-object-pairs]
	// 		but this leaves out variable filling
	// 		lets just fill variables after the word ;p
	//
	// 1: please open cupboard <-- i like this because meaning of open implies cupboard
	// 	note: meaning of please implies meaning of open
	// 2: please explain "open"
	// 1: "open" assumes ($x is next-word
	//                and is openable
	// 	          and is not opened)
	//      <- meaning of quotes implies tree of subject-verb-object triplets
	//      for now, we are going to have 'and' refer to repeating the innermost subject
	//     and assumes $y in $x
	//     and makes $y is accessible
	//     and makes $x is opened
	//     and has-habit <open.cpp>
	// 2: please explain "not"
	// 2: <reach-towards-door-and-pull> made <cannot find door>
	//
	// please: check for this word and hardcode behavior for now
	// quote: means word-meaning with tree
	//
	// reading:
	//     evaluate specified variables for word using surrounding words
	//     		we don't use sentence parsing
	//     		because it is important to have patterns for the system to solve
	//     		on its own.
	//
	//
	//		we need to fill data in for variable
	//			we are using subject-verb-object triplets
	//
	// 	this is a good place to add inference
	// 
	// so a good basic word would be please-infer, new-word, reference-to-state-change
	//
	// 		if two are communicating via a safe channel
	// 		they have shared context over only that channel
	// 		the way to communicate with a stranger is to use simultanaity
	//
	// 		[if we are both observed
	// 		 but we know each other in some way -- for example we can both
	// 		 see the street light [shared context]
	// 		 we can learn that shrug means flicker
	// 		 if we pointedly shrug when the light flickers
	// 		 kinda]
	// 		okay: we have exclusively shared context that is not stored
	// 		we have timing
	//		and we have events
	//	-> it seems you want to include ideal secrecy in the communication core
	//	we propose this can be learned later by the process, and is not needed here
	//	more efficient to work straight on core
	//		secret communication and inference go hand in hand
	//