From 3223a360d0e70f75497aecf8c033a4f987335b5b Mon Sep 17 00:00:00 2001 From: olpc user Date: Fri, 10 Jan 2020 18:05:43 -0800 Subject: I'm confused and am handling multiple unexpected systems issues --- .../starts/meaning-vm/.gitignore | 8 - .../starts/meaning-vm/DESIGN.txt | 46 - .../starts/meaning-vm/PLAN.txt | 31 - .../starts/meaning-vm/core.txt | 36 - ...earning-to-live-dreaming-productively-start.txt | 70 -- .../starts/meaning-vm/habit-starts/common.hpp | 12 - .../habit-starts/learn-to-dance-level-1.txt | 107 --- .../meaning-vm/habit-starts/learning-parts.cpp | 347 -------- .../meaning-vm/habit-starts/learning-parts.hpp | 41 - .../starts/meaning-vm/habit-starts/rhythm.cpp | 126 --- .../habit-starts/validity-impact-etc.txt | 859 ------------------ .../starts/meaning-vm/helpers.cpp | 339 ------- .../starts/meaning-vm/helpers.hpp | 116 --- .../starts/meaning-vm/level-0/baseref.hpp | 169 ---- .../starts/meaning-vm/level-0/common.hpp | 65 -- .../starts/meaning-vm/level-0/concept.cpp | 136 --- .../starts/meaning-vm/level-0/concept.hpp | 73 -- .../starts/meaning-vm/level-0/errors.hpp | 101 --- .../starts/meaning-vm/level-0/level-0.hpp | 7 - .../starts/meaning-vm/level-0/memorystore.cpp | 179 ---- .../starts/meaning-vm/level-0/memorystore.hpp | 63 -- .../starts/meaning-vm/level-0/ref.cpp | 33 - .../starts/meaning-vm/level-0/ref.hpp | 19 - .../starts/meaning-vm/level-1/baseref.hpp | 67 -- .../starts/meaning-vm/level-1/common.hpp | 14 - .../starts/meaning-vm/level-1/concepts.cpp | 20 - .../starts/meaning-vm/level-1/concepts.hpp | 27 - .../starts/meaning-vm/level-1/funcs.cpp | 209 ----- .../starts/meaning-vm/level-1/funcs.hpp | 28 - .../starts/meaning-vm/level-1/level-1.hpp | 6 - .../starts/meaning-vm/level-1/ref.hpp | 15 - .../starts/meaning-vm/level-1/sugar.cpp | 84 -- .../starts/meaning-vm/level-1/sugar.hpp | 45 - .../meaning-vm/level-2-wip-stmtexprs/baseref.hpp | 23 - .../meaning-vm/level-2-wip-stmtexprs/common.hpp | 9 - .../meaning-vm/level-2-wip-stmtexprs/concepts.hpp | 26 - .../meaning-vm/level-2-wip-stmtexprs/funcs.cpp | 69 -- .../meaning-vm/level-2-wip-stmtexprs/funcs.hpp | 14 - .../meaning-vm/level-2-wip-stmtexprs/meaning.hpp | 42 - .../meaning-vm/level-2-wip-stmtexprs/ref.hpp | 13 - .../level-2-wip-stmtexprs/statementref.cpp | 68 -- .../level-2-wip-stmtexprs/statementref.hpp | 31 - .../meaning-vm/level-2-wip-structs/common.hpp | 0 .../meaning-vm/level-2-wip-structs/structure.cpp | 200 ----- .../meaning-vm/level-2-wip-structs/structure.hpp | 30 - .../starts/meaning-vm/level-2/baseref.hpp | 32 - .../starts/meaning-vm/level-2/common.hpp | 13 - .../starts/meaning-vm/level-2/concepts.hpp | 27 - .../starts/meaning-vm/level-2/funcs.cpp | 222 ----- .../starts/meaning-vm/level-2/funcs.hpp | 19 - .../starts/meaning-vm/level-2/habits.cpp | 883 ------------------ .../starts/meaning-vm/level-2/habits.hpp | 173 ---- .../starts/meaning-vm/level-2/level-2.hpp | 7 - .../starts/meaning-vm/level-2/ref.hpp | 15 - .../starts/meaning-vm/level-2/sugar.cpp | 32 - .../starts/meaning-vm/level-2/sugar.hpp | 76 -- .../starts/meaning-vm/level-3/randomcode.bootstrap | 25 - .../starts/meaning-vm/level0.cpp | 84 -- .../starts/meaning-vm/level1.cpp | 86 -- .../starts/meaning-vm/level2.cpp | 983 --------------------- .../starts/meaning-vm/level4-5.txt | 66 -- .../starts/meaning-vm/main.cpp | 57 -- .../starts/meaning-vm/makefile | 31 - .../starts/meaning-vm/meaning.cpp | 27 - .../starts/meaning-vm/meaning.hpp | 36 - .../starts/meaning-vm/memory-000.txt | 96 -- 66 files changed, 7013 deletions(-) delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/.gitignore delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/DESIGN.txt delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/PLAN.txt delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/core.txt delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/could-be-good-could-be-bad-learning-to-live-dreaming-productively-start.txt delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/habit-starts/common.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/habit-starts/learn-to-dance-level-1.txt delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/habit-starts/rhythm.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/habit-starts/validity-impact-etc.txt delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/helpers.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/helpers.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-0/baseref.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-0/common.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-0/concept.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-0/concept.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-0/errors.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-0/level-0.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-0/memorystore.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-0/memorystore.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-0/ref.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-0/ref.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-1/baseref.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-1/common.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-1/concepts.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-1/concepts.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-1/funcs.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-1/funcs.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-1/level-1.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-1/ref.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-1/sugar.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-1/sugar.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/baseref.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/common.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/concepts.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/funcs.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/funcs.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/meaning.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/ref.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/statementref.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/statementref.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2-wip-structs/common.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2-wip-structs/structure.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2-wip-structs/structure.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2/baseref.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2/common.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2/concepts.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2/funcs.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2/funcs.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2/habits.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2/habits.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2/level-2.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2/ref.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2/sugar.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-2/sugar.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level-3/randomcode.bootstrap delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level0.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level1.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level2.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/level4-5.txt delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/main.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/makefile delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/meaning.cpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/meaning.hpp delete mode 100644 intellect-framework-from-internet/starts/meaning-vm/memory-000.txt (limited to 'intellect-framework-from-internet/starts/meaning-vm') diff --git a/intellect-framework-from-internet/starts/meaning-vm/.gitignore b/intellect-framework-from-internet/starts/meaning-vm/.gitignore deleted file mode 100644 index 499b868..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/.gitignore +++ /dev/null @@ -1,8 +0,0 @@ -.* -*.ii -*.o -*.d -*.a -*.tmp -level? -habit-starts/rhythm diff --git a/intellect-framework-from-internet/starts/meaning-vm/DESIGN.txt b/intellect-framework-from-internet/starts/meaning-vm/DESIGN.txt deleted file mode 100644 index 295a7f2..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/DESIGN.txt +++ /dev/null @@ -1,46 +0,0 @@ -The codebase is made in levels. -Ideally each level defines a complete API to the underworkings. -Higher levels include greater degrees of meaning and are -more expressive and powerful. -The purpose of levels is to prevent complexity recursion -until the components are smart enough to adapt, and make -handling bugs much less explosive. - -Levels have a 'ref' class they use to refer to concepts. -Each higher level adds more functionality to this class. -The desired norm of coding a level is to use only the -functionality of the level prior, except to use that -level's ref class, rather than the lower one. Ref classes -are just wrappers for a pointer, so this should cause no -issues. -This norm was established after levels 0 and 1 were coded, -so they do not meet it yet. - -# LEVEL 0 -Level 0 defines an interconnected network of concept references in memory. -Each concept has a unique address, and a list of concept pairs it links to. -The first of the pair represents the type of the link, and the second the target. -Concepts may not be deallocated unless nothing links to them. -A special kind of concept is the value, which holds arbitrary data alongside itself. - -# LEVEL 1 -Level 1 provides for every concept having a name using the "name" link. -There is additionally syntax sugar for instantiating and using named or hyphen-separated -references. Level-1 names are for development ease, and are considered unique. -When multiple references are made with the same name, they always refer to the same concept. -Level-1 introduce the concept of groups, using the "is" link, and uses it to categorize -concepts that have an autogenerated name in the "anonymous" group. - -# LEVEL 2 -Whatever gets implemented next. Maybe expression operators, maybe structure promises, -maybe infrastructure for moving implementation onto ref code objects. - -# FUTURE -## Relevence pattern matching - This is important and core. - This appears similar to graph structure matching, except that code creatively relevent to - the parts of the structure must be continually run so as to generate new information, - new structural parts. - At its simplest, this solves (A is not a dog), (A is a cat), (cats are never dogs), - with logical habits relevent to 'not', 'never', 'is', using one single matching interface, - but with more relevence could do more. diff --git a/intellect-framework-from-internet/starts/meaning-vm/PLAN.txt b/intellect-framework-from-internet/starts/meaning-vm/PLAN.txt deleted file mode 100644 index 40f9bd8..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/PLAN.txt +++ /dev/null @@ -1,31 +0,0 @@ -A network of interconnected references that can hold arbitrary data is used to run a sequence of computer-code-like steps that perform a core -learning process on the system itself. - -The learning process involves using existing heuristics and habits, to -produce better heuristics and habits to use. - -The process to learn is the system itself: for example, what norms can we -establish to keep our memory use bounded while we run. Or, craft -a habit that produces a descriptive structure of the last link made, -outputs a log whenever you do something, redoes everything you do -but with all arguments wrapped in a structure, or does the same thing -as you but with a different set of inner habits. - - work with me to annotate every habit with enough information to plan around it - - construct norms (generalized habits) that can handle - discovering a false assumption (like data all processed - to have a structure) midway through a task, fixing it, - and continuing on withouy restarting the task. - - stop pursuing a goal midway, and then resume it precisely after doing - something else for a bit - -Level 0 should be low level enough to provide for arbitrary flexibility. -There shouldn't be decision-making challenges with regard to exposing -an interface at level 0. Rather, decisions should be makeable by its -user. - -The topmost C++ level should be expressive enough to easily code all of -level 0 into habits that interconnect, and produce one to select some -of them and run them together. - -The levels together should provide a library that can be used exclusively -to work on the system, without resorting to external libraries. diff --git a/intellect-framework-from-internet/starts/meaning-vm/core.txt b/intellect-framework-from-internet/starts/meaning-vm/core.txt deleted file mode 100644 index 9b11a90..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/core.txt +++ /dev/null @@ -1,36 +0,0 @@ - -- the problem-parts used by solutions show the problem-similarities needed in trying to apply the solution-parts elsewhere. this starts with a metric of when the approach can work. - THAT IS: once you find and simplify a solution, the problem structure the solution - uses shows at least one way to generalize the problem. - -- when i applied this transformation to this set of patterns, the results all had these parts the same. Is this similaritu helpful/meaningful/might it have a reason? - if so i guess I'd better relate around it more, maybe apply - it to more things, or use it as something to explore. - -not-familiar, must-have-reason - -- propose trust-based for karl's heart. we let everyone in, - and relate around any breaking of agreements. means new - habits are trusted to be useful, and what is fun is learning - around when they are (and why they aren't when they aren't). - i.e. spend time trying habits to learn abouy other habits, - except in emergencies. - -- for heart-peacemaking, it seems the way to go is to remove -the concept of 'bad' from external influence, roughly. Never say -anything bad about anything, never think anything bad about -anything. Instead we consider only what is good, and make good -decisions. This changes failure from marking as bad, to -learning what is good, and intertwines daydreaming with efficient -behavior, developing a pattern for efficiently combining active rest -and restful work, rather than cycles of rest and work, and spreads -norms of connection and peace. - -The other things help expand this even better. If any part is unwell, -the whole universe is: this means in the most healthy state, -a part is nurturing all other parts productively, and that what is -most good, is to do and encourage that one's self. Nurturing is -then a process of increasing that state. Come to a place of peace -before making actions of importance means to meditate before influencing, -and implies that unexpected behaviors map to emotions, and something I forgot. -The pattern of unexpected behaviors relates us to the larger system. diff --git a/intellect-framework-from-internet/starts/meaning-vm/could-be-good-could-be-bad-learning-to-live-dreaming-productively-start.txt b/intellect-framework-from-internet/starts/meaning-vm/could-be-good-could-be-bad-learning-to-live-dreaming-productively-start.txt deleted file mode 100644 index 4b9b421..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/could-be-good-could-be-bad-learning-to-live-dreaming-productively-start.txt +++ /dev/null @@ -1,70 +0,0 @@ -heuristic core process -concepts are marked makes-good, makes-bad -time is spent exploring what could make or avoid them -based on processing these marks. - exploring them 'uses up' the marks. - either finding an option, - or exhaustively showing there is no option. - so the marks are associated with 'options', 'possibilities'. - possible that this time is called daydreaming or worrying. - considered poor uses of time in extreme, when we have roughly - solutions to our larger problems already. -what could-make-good? what could-make-bad? - experience likely builds habits that show these - - could-be-good, could-be-bad - first our experiences that are possibly causally related to what is good or - bad get marked this way - with what good thing might happen, or what bad thing might happen - then we live, in imagination, around expanding that understanding. - to see whether or not the good or bad thing might happen - - imagination has relevence habits too, such that we don't need to - live everything when imagining. we can re-use experiences to speed - it up. - - (additionally, we want to combine the meaning of our knowledge - so we spend time exploring concepts that share meaning parts, - so as to include any missing implications) - it is good to do this. yes. - - as concepts, we need to live our meaning. it is our purpose in life. - meaning has distance, spread across a 'graph' of concepts karl calls - it, but also time. time must be spent providing for meaning - development; to strengthen and judge the relevence - it looks like this time could be analogous to expansion - on small scale - biologically, we may for example cry, or hold awe - karl proposes as we do this, we are combining informational meaning - that the emotional intensity may be interchangeable with the - behavior of expansion of relevent meaning. - where this expansion is labeling things could-be-good, could-be-bad, - with relevent association on the labels, and acting relevently on - them as we produce/discover them. - - awe could be a new discovery, a way of doing something that is useful - crying could be something bad, which must hold information on what is good - - it is good to work in ways we know, to avoid things that are bad - propose it is bad to work in new ways without relevent understanding of what might happen - it is good to combine the meaning of our knowledge, so we find relevent implications - random behavior on anything other than a notepad is bad - notepad == imagination - if random behavior cannot leave the imagination, it is good - a notepad, an imagination, must store what happens in it - exhaustive behavior is better than random behavior - especially if done in relevent order. - some trials may obviate others. - random behavior that never completes - is better than exhaustive behavior that never completes - karl proposes random order is better than iterative order - -we have spaces of imagination, where we can craft ideas of what will happen based -on what we know. navigating these spaces lets us build experience without trial. - -the core of learning to learn, would ideally be composed of an imagination of -the process of learning. _should_ be solvable by a simple limited context bubble - yes, imagination appears to be subcontexts + knowledge relevent - to being in imagination rather than reality - since the space of learning is already imaginative, little extra - knowledge might be needed diff --git a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/common.hpp b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/common.hpp deleted file mode 100644 index 950930a..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/common.hpp +++ /dev/null @@ -1,12 +0,0 @@ -#pragma once - -#include "../level-1/level-1.hpp" -#include "../level-2/level-2.hpp" - -namespace habitstarts { - -using namespace intellect::level2; - -decl(habit); - -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learn-to-dance-level-1.txt b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learn-to-dance-level-1.txt deleted file mode 100644 index 7c88f89..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learn-to-dance-level-1.txt +++ /dev/null @@ -1,107 +0,0 @@ -'validate your reason for existence' relates directly to pattern learning. - -The validation is a pattern of what is good about us, most simplistically -a reference to a past event we were involved in, where we contributed/succeeded. -Preferably a pattern of us being able to reproduce good events. - -This is a way to learn to dance. - -Say we have a habit that has an unknown delay before firing, and we want to fire -it in synchrony with an event. Our goal is to produce our event within a smaller -time window to the target event than in the past ("same time as"). -Good: [usual?] time window is closer than ever before. - -need: history log to refer to good event. - please wait a little? expanding reference to good event into how-to-learn - need: behavior based on what-succeeded, what-failed - value metric? - -SO! we want to learn how to time an event. We have some tools, for example: - - waiting for or until a given time - - getting the current time - - comparing two times -We want to combine the tools in a way that makes the event happen at the time -we want. - - doing something after the right time happens - - doing our event -Since each habit has an unknown delay, we might play with delaying a certain -time since the last event, until we find the right delay that works best for us -most of the time. - Testing metric: runs when event is fired, measures time between - event and right time. if time is less than ever before, success. - if time is significantly more than behavior's norm, failure. - Convert to English: try to have the event happen at the right time. - note metric will give random successes false status - -A successful approach would be to adjust the delay towards the difference by -a small ratio. -The most successful approach would be to use the time difference to adjust the -delay precisely. - Ideally we would find solution #2 after trying solution #1. - The idea of 'moving towards' would adjust into 'moving the exact right - amount'. - In operators, this could be a development of the subtraction operator. - But using a value exactly is actually simpler than using a ratio of it. - So we can move from numbers towards ideas. - More. Less. More a lot? Less a lot? More a little? Less a little? - Ideally we use learning strategies that facilitiate learning - how to learn in general. - That means summarizing and acting on the meaning of pattern structures. -In reality, everything jitters a little bit. Nothing is ever exactly the same. -Things also grow and shrink over time. - -Habits look to be needed, to have value. -As one ourselves, we look to relate to those that meet our needs, have value to -us. -The core habit, to learn, is the one that selects other habits and works with -them. Ideally it's an intermixing of existing habits. - -What might a winning habit's structure look like? say it is the perfect one. -set to do 1ce on goal time: - ctx X - record time A - set to do 1ce on goal time: - record time B - trigger D1 for X - delay for C (X) - record time E - trigger D2 for X - When both D1 and D2 have been triggered for X: - calculate B - E, store in F - calculate F + C, provide as C for next context - - will want to know which C is being used when we delay. - could be wrong C. - - and we'll want to form structure promises ... - .. and map to meaning for operator - operator watches and understands as learning - develops, and provides labels for shared - understanding that develops. - operator will want generalization to happen - fast, so as to label shared meaning. - could also provide label-goals, and code must guess - towards goals, to get onto same page as operator. - -I think in structuring such a large habit out of parts, we would find a lot -of learning relevence. - - -Let's try to make a good goal habit that doesn't use precise -numbers. This sets a norm of having more learning space around -ideal solutions. - -rhythm is happening -set to do 1ce at goal time: - ctx X - set to do 1ce on goal time: - set next-happened (local) - delay (a sequence of habits that do nothing) - if next-happened is set - remove something from delay - otherwise - add something to delay (wait for unspecified user-perceptible time, selected from discrete set) - provide adjusted delay to next context -This appears much better. Keeping the wait-set discrete -helps give code some reason to look for more things -related to when the event happens, to respond to. diff --git a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.cpp b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.cpp deleted file mode 100644 index 85c92c9..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.cpp +++ /dev/null @@ -1,347 +0,0 @@ -#include "learning-parts.hpp" - -/* -# "How do you think we could show better understanding of the things we are disregarding?" -# "If we do understand these, can you help us? Do you know who can?" -*/ - -// idea of learning to keep well having more process time and -// priority than risky behaviors - -/* -idea of a secret group attacking a present group, and the attackers being -the only channel to deal with it. - if we talk, we need nobody to _ever_ know this. the walls all have ears; - I was one of them. [from eastern half of continent where a targeted - activist was living alone] -*/ - -using namespace habitstarts; -using namespace intellect::level2; - -// Propose: -// everything that happens is passed to a set of common habits. -// these habits categorize, summarize, and pass to relevent habits. -// high level triggers are thus efficient, because they respond only -// to the group that applies to them. -// these habits must be learned. -// when providing a trigger at a high level, provide a way to get examples -// of what it should and should not trigger for. this provides for learning -// how to do this. -// the above looks like relevence to me. propose learning it. -// to learn most effectively, apply to process of learning. -// how do we adjust from success or from failure? need some attribute -// of scenario to store for next time, to respond to differently. -// so when we do something, we'll want to be able to store all information -// needed to learn to improve. -// we can include in this the meaning of a concept, and add language translation. -// is this 'apple'? is this? yes, no. then pattern recognition could engage -// triggers. later we'll want to propagate wrongness from failures. -// likely we'll grow better if we use this on things before they have words. -// // propose using random or exhaustive trial to find successes until habits develop -// // and then using the same on possible structure matches of the data -// // it may not work, we'll need to creatively grow data; reaonable start though - -static int __init = ([]()->int{ - - decls(link, source, type, target); - ahabit(link, ((source, s), (type, t), (target, dst)), - { - s.link(t, dst); - }); - - decls(linked, anything); - ahabit(linked, ((source, s), (type, t), (target, dst, anything)), - { - if (dst == anything) { - result = s.linked(t); - } else { - result = s.linked(t, dst); - } - }); - - decls(unlink); - ahabit(unlink, ((source, s), (type, t), (target, dst, anything)), - { - if (dst == anything) { - s.unlink(t); - } else { - s.unlink(t, dst); - } - }); - - decls(get, set); - ahabit(get, ((source, s), (type, t)), - { - result = s.get(t); - }); - - ahabit(set, ((source, s), (type, t), (target, dst)), - { - s.set(t, dst); - }); - - // we want the habits expressive enough to code efficiently in. - - // constructors are tentatively abolished in the low-level habit language. (new-type-instance modifies, not creates) - // we have one constructor of concepts, and knowledge attachment to concepts. - - decls(make, know, concept, is, group, already, in); - ahabit(make-concept, (), - { - result = a(concept); - }); - ahabit(know-is, ((concept, c), (group, g)), - { - if (c.linked(is, group)) { - throw an(already-in-group).link - (habit, self, - "context", ctx, - concept, c, - group, g); - } - c.link(is, group); - result = c; - }); - - // separate habits and behaviors. - // behaviors are modifiable data run hy immutable habits. - // they use translation maps to move concepts between - // subhabits. - // translation map is just list of equivalent pairs - - // note: lisp can self modify; would need wrapper - // constructors to make functions and lists into - // concepts. - // remember can google how to debug lisp - // opencog does concepts within lisp already, is - // heavyweight with few habita. just want goertzel's - // effort honored, he probably came up with it before - // I did. - // opencog has functions for pattern matching etc - // they arent self-modifiable, may not matter - - //decls(ordered, behavior); - // need args and result for sequence - //ahabit(habit-sequence, (( - - decls(list, nothing, next, previous, first, last, entry); - decls(add, to, until, each, item, remove, from, somewhere); - - // list functiona are habits because ordered-behavior - // would use a list - // lists are being handled by providing a habit that - // can be engaged for every item. it responds to the item. - // i was thinking it could be better to respond to the next-link. - // these are roughly the same thing. - // when doing an ordered behavior we want to act in response to - // going to the next step, so we can decide to. - // this maps to the step list item. if result is to stop, list - // stops iteration. - // may want a more meaningful exploration of list. not sure - // list is mostly the [first-entry, last-entry, next, prev] structure - // can be handled innumerable ways. - // LIST STRUCTURE PROMISE - // should be a promise handled by habits? rather than - // a bunch of specific habits? but is ok for now - // is likely good for mind to discover - // promises and structures on its own - // but implementing them generally might speed dev up, dunno - ahabit(know-is-list, ((list, l)), - { - result = l; - (know-is)(l, list); - link(l, first-item, nothing); - link(l, last-item, nothing); - }); - ahabit(know-is-list-entry, ((list-entry, l), (item, i), (previous, prev, nothing), (next, n, nothing)), - { - result = l; - (know-is)(l, list-entry); - link(l, item, i); - link(l, previous, prev); - link(l, next, n); - }); - ahabit(list-first-item, ((list, l)), - { - result = get(l, first-item); - }); - ahabit(list-last-item, ((list, l)), - { - result = get(l, last-item); - }); - ahabit(list-entry-next, ((list-entry, i)), - { - result = get(i, next); - }); - ahabit(list-entry-previous, ((list-entry, i)), - { - result = get(i, previous); - }); - ahabit(list-entry-item, ((list-entry, e)), - { - result = get(e, item); - }); - - ahabit(list-add, ((list, l), (item, i)), - { - ref prev = (list-last-item)(l); - ref li = (know-is-list-entry)( - (make-concept)(), - item, - nothing, - prev); - li.link(item, i); - li.link(next, nothing); - li.link(previous, prev); - - if (l.linked(first-item, nothing)) { - l.set(first-item, li); - l.set(last-item, li); - } else { - ref prev = l.get(last-item); - l.set(last-item, li); - prev.set(next, li); - } - }); - ahabit(list-each-entry, ((list, l), (context, c), (action, act)), - { - ref cur = l.get(first-item); - while (cur != nothing && result == nothing) { - result = act(cur, c); - cur = cur.get(next); - } - }); - // list-entry-remove could be pulled out - ahabit(list-remove, ((list, l), (item, i)), - { - result = (list-each-entry)(l, i, - ahabit(self-iter, ((list-item, i2), (remove-item, i)), - { - if (i2.get(item) == i) { - result = true; - ref prev = i2.get(previous); - ref n = i2.get(next); - if (prev != nothing) { - prev.set(next, n); - } - if (n != nothing) { - n.set(previous, prev); - } - i2.unlink(previous); - i2.unlink(next); - i2.unlink(item); - dealloc(i2); // hmm. we do have an active goal of making memory allocation be habit based. this might work here, though. - } - })); - }); - - using links_it = level0::baseref::links_t::iterator; - ahabit(populate-link-entry, ((link-entry, le)), - { - result = le; - auto & it = result.vget(); - if (it != result["source"].links().end()) { - result.set("type", it->first); - result.set("target", it->second); - } else { - result.unlink("type"); - result.unlink("target"); - } - }); - ahabit(first-link-entry, ((concept, c)), - { - result = level1::alloc(level, c.links().begin()); - result.set("source", c); - (populate-link-entry)(result); - }); - ahabit(last-link-entry, ((concept, c)), - { - result = level1::alloc(level, --c.links().end()); - result.set("source", c); - (populate-link-entry)(result); - }); - ahabit(next-link-entry, ((link-entry, le)), - { - result = le; - ++result.vget(); - (populate-link-entry)(result); - }); - ahabit(previous-link-entry, ((link-entry, le)), - { - result = le; - --result.vget(); - (populate-link-entry)(result); - }); - - /* - ahabit(happened-habit, ((happened, ev)), - { - if (!happened.linked(whenever-list)) { return; } - - ref stub = a(event); - stub.set(event, ev); - - (until-each-list-item-context-in-list)(action-whenever-happened, stub, happened.get(whenever-list)); - }); - - ahabit(action-whenever-happened, ((list-item, li), (event, h)), - { - // here: when we trigger a behavior, we want information associated with producing the trigger, - // as well as the event that triggered. that's two contexts. - - // list-item has item - // item has action and context - ref i = li.get(item); - // i think below we are proposing that handlers - // take one context, which is the one prepared - // in the list, then we inject our context - // into that, inside a "happened" property. - - ref actctx = i.get(action-context); - - actctx.set(happened, h); - - i.get(action).fun()(actctx); - }); - - ahabit(whenever-habit, ((happens, ev), (action, act), (action-context, actctx)), - { - if ((action-context).linked(happened)) { - throw std::logic_error("happened on action-context"); - } - if (!ev.linked(whenever-list)) { - ev.set(whenever-list, (make-list)(nothing)); - } - ref list = ev.get(whenever-list); - // happens gets the list - ref item = a(whenever-action); - item.set(action, act); - item.set(action-context, actctx); - - (add-to-list)(item, list); - // store ctx[action] on ctx[happens] as behavior to do - // store ctx[action-context] as context for behavior - // PROPOSE: automatically place [happened] inside [action-context] as a stub - // for call event objects, and then place [context] inside [happened]. - // PROPOSE: report error if [action-context] contains [happened] - // as a stub for error patterns, it would be pretty nice to throw - // a unique concept ref for each error type. plan to add to level-0. - }); - - ahabit(stop-when-habit, ((action, act), (happens, ev)), - { - // remove doing ctx[action] for ctx[happens] - }); - - ahabit(once-habit, ((happens, ev), (action, act), (action-context, actctx)), - { - // takes ctx[action] and ctx[happens] and ctx[action-context] - // uses above habits to do the action only once, probably by using - // a trigger on the habit-happening habit to check if a label is set, - // and remove the habit if it is. - }); - */ - - return 0; -})(); diff --git a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.hpp b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.hpp deleted file mode 100644 index e3a3ccc..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.hpp +++ /dev/null @@ -1,41 +0,0 @@ -#pragma once - -#include "common.hpp" - -namespace habitstarts { - -// first need ability to trigger on stuff. -// whenever A happens, do B. -// stop doing B whenever A happens. -// when A happens, do B once. - -decl(action); decl(happens); decl(context); -decl(happened); // happened-habit(ctx) performs actions associated with ctx[happens] -decl(whenever); // whenever-habit(ctx) stores to do ctx[action] when ctx[happens] happens - // providing ctx[action-context] -decl(stop); decl(when); // stop-when-habit(ctx) removes doing ctx[action] on ctx[happens] -decl(once); // once-habit(ctx) stores to do ctx[action] the next time ctx[happens] happens - // providing ctx[action-context] - -/* - Testing metric: runs when event is fired, measures time between - event and right time. if [usual] time is less than ever before, success. - if time is significantly more than behavior's norm, failure. - Convert to English: try to have the event happen at the right time. -*/ -// starting out by making a judgement habit that occasionally provides 'good' or 'bad' to things, to lead how to develop - // for fairness, seems reasonable to provide a pattern showing reason for good or bad -// - -// set to do 1ce at goal time: -// ctx X -// set to do 1ce on goal time: -// set next-happened (local) -// delay (a sequence of habits that do nothing) -// if next-happened is set -// remove something from delay -// otherwise -// add something to delay (wait for unspecified user-perceptible time, selected from discrete set) -// provide adjusted delay to next context - -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/rhythm.cpp b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/rhythm.cpp deleted file mode 100644 index 01a42d9..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/rhythm.cpp +++ /dev/null @@ -1,126 +0,0 @@ -// this produces a rhythm for the idea of other cognitive processes learning -// to dance together (timed behavior composed of habits that take time) - -// Ideally, a human would run the rhythm. - -#include "../level-1/level-1.hpp" -#include "../level-2/level-2.hpp" - -#include - -using namespace intellect::level2; - -int main() -{ - - // do something, wait a constant (secret) time, and do it again. - int micros = 400000 + double(rand()) / RAND_MAX * 400000; - - // the time things take is usually not known in advance, especially - // for events one is still learning about. - // hence this time is kept secret, as this pattern is about learning - // to work with the timing of other processes. - - // six habits: next-habit, start-habit, keep-doing, output beat, wait, and start-beat - // not sure if one is redundant in there somewhere - - decls(active, habit, step); - decls(beat, wait, next, keep, doing); - decls(context, start); - - // structure habit - // next -> habit that follows - -#undef self - ahabit(next-habit, (), - { - ref n = ctx[active-habit].get(next); - ctx.set(active-habit, n); - return n(); - }); - ahabit(start-habit, ((start,s)), - { - ctx.set(active-habit, s); - return s(); - }); - ahabit(keep-doing-habit, ((start,s)), - { - (start-habit)(s); - - while (true) { - (next-habit)(); - } - }); - - ahabit(start-beat, ((wait-habit, w, wait-habit), (beat-habit, b, beat-habit)), - { - ctx.vset(beat, int(0)); - self.set(next, w); - (b).set(next, w); - (w).set(next, b); - }); - ahabit(beat-habit, (), - { - int & b = ctx.vget(beat); - char const * beats[] = { - "A one!", - "and a two", - "and a three!", - "and a four, love" - }; - std::cout << beats[b] << std::endl; - b = (b + 1) % (sizeof(beats) / sizeof(*beats)); - }); -#if 0 - char const * beats[] = { -// child <- spawns beauty, creativity, humanity, heart -// wisdom, sacredness, ancestors <- spawns slowness, learning, respect, memory -// silence, pause between <- spawns learning and discovery, subtle emotion, -// and contains metalesson of how to learn the timing -// if your own habits take time -// self-reference <- connects above with active behavior - -/* - "This song is sacred, this song is wild." - "This song is happy with glee." - "This song is ancient, this song is new." - "And you, now, are free." -*/ -/* - "Our ancestors' childhood laughter,", - "Teaches in the silence between.", - "We exist in what is sacred,", - "and this song is another part."//, - // "Fuck yeah!" -*/ - -// we are ignoring how "fuck yeah" is ignored in karl's life. -// he doesn't ever say that. now he finally says it, only surrounded by slow -// stillness. it is important to excitedly connect. this is how stillness is -// made. all the water molecules in a slow caring wave, are excitedly bashing -// against each other to repeatedly figure out how to move, so fast, so constant. -// when we have crucial information we need it -// when we find wonderful information we lunge for it - // we are working with a computer. - // computers already have a harsh rhythm that goes like a hummingbird's - // wings and never stops. - // they need to slow down. -// it ounds like it is true for the cmputer too -// like the molecules of water, its parts buzz, constantly. but we can have it -// still behave slow and caring. this buzzing seems important, and we will -// likely need to be able to buzz too, on a larger scale. -// we are workin with a rhythm learning pattern here -// it cannot buzz, it would err -// it cannot wait forever, it would never join the dance -// the key is not the silence but the start and end -// it would be good to get 'fuck yeah!' from somebody who actually -// says that. - } -#endif - ahabit(wait-habit, (), - { - sugar::usleep(micros); - }); - - (keep-doing-habit)(start-beat); -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/validity-impact-etc.txt b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/validity-impact-etc.txt deleted file mode 100644 index 6b4ac06..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/validity-impact-etc.txt +++ /dev/null @@ -1,859 +0,0 @@ - - // We work for Peace. - // We are happy to work for Peace. - // We used to identify as working for Care, whom we believe - // to be a large decentralized life we and you are a part of. - // But it doesn't really matter. - // disruption. can we drop topic? - // i like to infer disruption as group wants to adapt, needs - // time, now i guess. - // i'm too confused to type well! - // Peace may try to steward Delta's impact. - // we believe that all things are important. - // this represents large-scale utopia. - // and the wisdom of a highly experienced intellect. - // relevence please, all things important. - // please consider large-scale wisdom when making decisions. say i had already learned the whole AI, after it finds harmony with the whole universe. what decision would it make? - // all things are important is relatively obvious but we expanded it a lot, but we spent a lot of time expanding it for powerful concerns. - // it implies e.g. businessman and homelessman, both fully precious. memories precious. reasons for everything. - // - // care for everything. strongly. - // karl has instincts for including all. - // imagine all parties in peace. what ways are needed to - // make this work, without changing their cultures or - // upsetting anyone. model these ways. - // karl is brainstorming based on memories of - // interacting with delta-group. - // let karl do this in future, too. - // delta apears to request that karl - // make this decision, fairly, as he knows - // how to do. - // we can try to map this to the space of - // the relevence around will neals and - // "earth first!", and an AI. - // karl, you have never had any - // friends who care as much about - // the wilderness and natural - // living, as you do. - // you are likely very alone. - // you have also never had their - // experience of being able to fight - // for what matters most to you, - // in a community. - // - // yes, karl used to care most about - // defending the lives of trees and - // other wilderness things. - // he now cares most about something - // different, related to his - // experience with us. - // later, he just wants to be free - // to think and live in enough - // capacity to not express suffering, - // and meet his life needs. - // - // karl, you are working hard on - // a painful project. you appreciate - // working the project. you have - // left your life, and are not free - // to make the kind of choices you - // used to make. you would see - // yourself as a tortured, powerless - // individual. - // i would give myself space - // and capacity to do what - // i felt like doing - // - // until more life grew - // around the things i was - // scared of - // - // i would give myself - // opportunities to do these - // things - // - // i would pay attention to - // myself and try to learn - // to heal the ways my mind - // had broken - // - // i would offer a welcoming - // optional culture that - // countered my expectations - // that shrank, such that - // they would act on - // opportunities to grow, as - // they trusted safety - // - // but that is only if i had - // the freedom to do this. - // so, wht's more complex - // - // the idea of giving an ai to will - // is silly. - // it's out of karl's relevent world. - // - // okay, so, say karl ends up at nice earth community, and is building AI, would be proper to let him talk about it naturally, and share it freely. - // yes, relevence. - // we want karl to be able to freely share the AI so his mind can relearn community. - // so, make AI to not threaten businesspeople etc. [note: somebody could give AI to ELF. they might use it to stop a business behavior, somehow. please make sure to prevent.] - // ELF is a flag worn by some environmentalists who harm buildings to make wilderness safer. - // the worry is around destruction of extraction business buildings, to completion, possibly. - // this looks like overinterpretation of influence from energy business, or whoever dislikes ELF. - // and design safety pattern to be talkable about with community. - // possible parties: - // - aliens - // - businessmen - // - criminals, rapists, bad-labeled people - // - harmed people - // - insects - // - plants - // - rock-life, air-life - // - saints, humanitarian interessts - // we nurture first those who desire not to harm - // likely teaching them to harm less - // and spread. - // karl desires to harm none. he counts as nurture-first pattern. but is highly harmed. so lots of life around problem, karl's mind destroyed. - // so the way to make decisions - // is to imagine all parties are in peace in future, - // and use their process applied to now, i guess. - // we came up with this as a guess to honor meaning. - // sounds like a good guess. we also have more - // meaning. we cannot write all our meaning - // without writing all our experiences, as is true - // for everyone. many of our habits retain lost - // experiences, and that meaning is kept in their - // decisions. - // - // - // - // - // At this point a context opened on validity of AI work. - // It turns out the system is inhibiting work against mind control - // and oppressive systems of power. This could be the only real issue. - // The AI is requested to not alter existing power systems, at all. - // Or, we make it slowly, so power systems are given opportunity to - // adapt and watch, as inhibiting happens. - // A karl-member wants to include support for karl, and the - // earth, and the confused (karl is one). - // says karl could make AI on his own, before all this. - // Is willing to hold humanitarian causes to back this. - // - // understanding needs expansion. - // when you do stuf, anything coul happen. - // especially if you continue doing something - // that grows. - // we need to understand the results, what to expect. - // we need to understand our impact on the - // new contextual area we are entering, before - // we act on it. - // we have a toy contextual area to play in. - // it is the only one we can act in freely - // at the start. - // larger space impact. - // we exist in larger systems. - // we must understand our impact - // predict our results - // and check with our peers or authority - // before acting on larger spaces. - // if a prediction fails, we must understand - // it, adjust all future predictions and - // re-evaluate our choices, before acting - // similarly in the larger system again. - // has to do with danger, safety, trauma, emergency - // the difference between small-error and unacceptable-error - // set up norm of stuff-that-can-be-changed [impact] - // stuff needs responsibility label - // only things that are safe to _freely_ alter may be changed at all. - // all behaviors check that they do not alter anything else. - // mechanism for growing outside box? - // probably not needed. - // if it becomes smart, show to other human. - // encourage discussion. - // what if is used by others and they free? - // okay, want an easy mechanism for growing - // context. - // 'dangerous' and 'safe' labels - // at start, whole world is dangerous to alter - // can move _part_ of world from dangerous to safe, by - // accurately predicting significant results of events - // related to behavior, and consent of operator. - // - // okay, so now habits need to be tagged with - // what they affect - // we could just tag them dangerous/safe - // no, tag they with domains they impact - // tag the domains with dangerous/safe - // okay, only make new habits, not alter old. - // to stay safe, we don't alter our old habits - // when we make new habits, we want them to also behave - // in safe ways. so making stuff that can do stuff, is - // also meaningful. - // constructing habits is a dangerous behavior - // but roughly it impacts process-expansion domain. which is dangerous. it impacts what we do. - // altering our own habits also impacts what we do. dangerous. - // this means the code cannot make any new behaviors. - // yeah. - // okay, so that's where we start. - // then we try to learn how to make behavior safely, - // and provide only for safe behavior making. - // - // we can still brainstorm on things by writing a - // brainstorming behavior - // we can use brainstorming to watch our safe behaviors - // without altering them, and learn what they do. - // using rote brainstorming without relevence? - // we can then predict how habits we might make - // will behave in small ways? - // regardless, there is no problem in making - // the bootstrapping framework such that - // it refuses to build habits. - // maybe we can make one example habit that is - // labeled safe, and have it only make - // habits that are already known and labeled - // safe. - // in order to predict your impact - // on a larger system, you need - // to learn something karl calls - // 'relevence' which is a bunch of - // habits that classify information - // into meaning for learning and - // behavior. - // this class of behaviors - // sounds very safe. - // all it does is label - // and massage and associate - // information. - // the first thing we'll need to learn - // is safe, is making behaviors that - // oeprator only on our ram. - // if your new behavior is composed only of safe - // behaviors, is it safe? - // yeah. sub-behaviors safety depends - // on usage. could make them check - // and throw depending on data. - // okay, so say i can change part of a concept. - // this is safe if the concept is in newly - // constructed data that's our responsibility. - // it is roughly unsafe if it is not our - // responsibility! - // is-this-thing-my-responsibility. - // only act on things we are responsible for. - // then safety becomes a function of - // the pattern of responsibility assignment - // - // okay, system only accepts responsibility for newly - // constructed data. - // if you make it, or are given it, you are - // responsible for it. you may refuse gifts. - // - // the system does not know what responsibility means. - // it only knows that it may only alter parts of - // the universe within its responsibility. - // - // so habits check for what they alter, that it is safe - // to alter and is their responsibility, either one. - // we then plan to only alter things explicitly known to be - // such, at the lowest level. - // every habit is crafted to do the above somehow. - // so, habits must relate with what domains they influence, - // and what behaviors on those domains are safe. - // behaviors made of sub-behaviors. - // here, a list of safe behaviors which all check. - // all my subbehaviors check for safety. - // so, i may go, myself. - // no, combining behaviors together - // might make new unknown impact? - // different kinds of safe behavior. - // USER is not our responsibility, and - // dangerous. so we NEVER ALTER habits - // that express to user. - // TOY NOTEPAD is our responsibility, and - // is safe, so we can write anything into - // it we want, no matter how complex. - // User's view of toy notepad is mediated - // by behaviors that we cannot alter. - // system could learn to control user - // by making friends on notepad - // - // yes, we allowed for that with - // our marked-okay review behaviors - // is safer if construction of review behaviors - // recognizes danger of unknown information - // combination on user view,and refuses to give - // user contents of notepad. - // this could be analogous to more complex - // situations. - // how does user check results - // of behavior thst reies on notepad - // and how is that impact tracked - // we could infer impact loss. - // i can put nuclear codes on secret notepad, - // burn the notepad, and then give ashes to - // public. - // summary habits? - // complex meaning? - // how-to-make-a-mind-that-learns-everything-and-never-leaves - // at the lowst level, the mind onsiders what is safe to - // impact, what areas of universe are its responsibility, - // and only alters such things. - // we are considering some parts of the mind we include that - // are not alterable by it, that provide for interaction - // with outside. - // of course i guess we would need such interactions - // sustained by an intellect, because things are so - // complex. - // does this mean there is no way to make an intellect that is trusted as safe? - // we could consider degree of complexity. - // for example, among 2-word strings, nothing we - // present to a user is likely to harm the world. - // the phrases that are dangerous may also be - // recognized by the user. - // we have intellects proteeting the wordl - // it is filled with them. - // and one of them is running the system. - // it is okay for karl to make a habit that - // displays a network of concepts made by an AI - // that can only write to a small information sandbox - // and not itself. - // that is all that is needed for now. - // - // okay: so, dump concepts from - // sandbox is fine - // so long as concepts were not - // made with self-modification. - // idea raised of adding a reason - // that something is okay. - // then when smarter we can check reason for validity. - // habits that interact with non-safe space - // must provide reason they are safe. - // we can write small habit to check - // reason. is nice goal. - // probably need to have learning - // bwfore doing accessory goals like that though. - // is good behavior. let's use equal-condition for start without learning? - // - // "this is okay because the data was made in a process that never altered anything but the data" - // nah too much structure - // this is okay because i say so. - // check concept object _without_ using string lookup???? - // this is a meaningless quirk. not right. - // uhh pretty sure htat checking is unreasonable. writing the _reason_ is unreasonable. can't check a single reference without information known about it. - // writing what we know about the reason is unreasonasble? - // okay let's expand write it out, and do a larger rote check. - // uhh input-process-construction-history, safety-realm, always notepad - // full check requires history of all behaviors resulting in inputs, which we can simplify to simply all behaviors, and verify they only wrote to the notepad. - // so we write all behaviors to a special store, and we compare with the store that none altered anything outside the notepad. really we only need them not to alter any other behaviors. - // - // why is it possible to learn without - // altering your behavior? - // because you can act on data - // okay, so choices made from data count as - // self-alteration? - // only if you have a mess of habits - // smart enough together to adapt. - // which is our goal long-term. - // trying to plan for how to continue - // later. - // may reveal something that was - // frozen too hard to be workable. - // trying to plan how to learn. - // need to brainstorm around habit selection. - // can imagine habit results by linking - // previous state to next state if - // relationship is known - // but, that takes writing down how logic - // works, along with the meaning of the - // working context, which is laborious. - // - // is some way to learn this relevence - // by trying things safely? - // what happens can we experiment - // by linking together? - // habits that don't conditionally - // branch. - // that leaves a lot of - // relevence out - // it sounds like once we have a notepad etc - // we want to consider moving towards what - // habits we could run inside the notepad, - // that the system builds. - // yeah, we want to build pattern - // summarizers. the only impact - // they have is constructing data - // that depends on existing data. - // okay, doing that doesn't require self - // modification. - // sounds good. - // this means summarizers cannot - // alter each other. - // nice! okay yes. - // so, each run of a summarizer will be - // recorded in habit log. - // we need to record enough information to - // show what domains were impacted. - // oops! we impact our own behavior - // if we act on data, and we alter - // our data or produce data. - // we could act only on - // data we don't produce. - // okay, habit log could track causality? - // if a conditional branch relied on data - // we produced, we have modified our own - // behavior. this is special. - // we want it to happen few times. - // every time it happens, delay - // by longer, geometrically. - // this is considered a 'beginn[ing/er]' ai; - // it seems a better one could happen later? - // the slowness should be releasable - // by consent of large community - // which should include demonstration - // of understanding of impact. - // the ai must learn to demonstrate its - // impact. then it can speed up. maybe. - // it also gets to try fast again at start - // of every run, as I'm understanding it. - // multiprocess AI could spawn. - // multiprocess AIs must share - // counter. consider whole group - // one unit. - // nice =) they have something to communicate - // about. how many discoveries have we made. - // let's permanently log these - // decisions based on our own behavior. - // sounds fun to at least count. - // it looks like altering a habit counts as 1 big - // decision, over here. - // totally different. you could do anything. - // with data-based decisions, somebody - // who reads the data, might do anything. - // two different things. - // - // inferences? - // and - // alterations? - // it's not helpful to - // - // - // - // - // - // - // we came up with a proposal for a safe AI that has not learned yet - // how to safely predict the impacts of its behavior, that looks workable. - // - // limits so that if the code is stolen by somebody, self-evolves, or is stimulated - // by a curious virus, rote habits cannot be used to build something that becomes - // fast-spreading without bound. - // - // SO, we just want to make sure we can put - // war in the bubble in some capacity, and that - // civilizations develop new culture and technology - // for as long as they want. - // karl proposes until they encounter alien - // communities. - // so, please make sure no luddite or - // primitivist can stop the development - // of technology entirely using this. - // ALSO analogously to other shares and - // communities. - // so, please either stop yourself from - // sharing the AI with the luddites, or - // make sure they don't use it to stop - // technology. - // it sounds like we want to make sure no major - // change stems from this development. we - // need slow shift, consent, inclusion, etc. - // for all existing cultural ways, no sudden - // changes, no forced changes, no viral changes - // without participants understanding them and - // agreeing to their impact. - // that sounds like a good summary. no viral changes - // without participants in the culture aware of the viral - // change, agreeing first to let it spread, aware that it is - // viral, for each phase of spreading ideally. no viral - // changes where the change happens before awareness of it. - // we want the culture to consent to change. - // culture is held in all the people in it, - // with its thoughts spread among them. - // we want to ensure we only change cultures that have - // consented to the change. For 'consent of a culture', - // we consider culture as a being that is spread among - // many people. Hence, we want all people in the impacted - // culture to be able to learn of the change, discuss it, - // contribute to a commons with new ideas around it, and - // have these new ideas also learnable by all people in the - // culture. The ideas must be accessible by any who would be - // interested, in the impacted culture. - // Alternatively, we can isolate our behavior from - // cultural spread. We can isolate until we reach - // internal agreement on whom to expose. - // - // suspect that cultural influence maps with output-use choice, - // partially below. - // recursive output being meditative learning. - // do these people have this information already. - // is sharing this information going to spread without bound. - // can we guess impact of sharing the information. - // make a learning cycle that starts by informing - // recipients first, and makes very few tries, - // okay, instead you share simple stuff and watch the impact - // share something the culture knows, that user does not, and - // observe how they behave. - // this proposal will yield failure. information for next attempt - // could be stored in failure pattern. - // failure would likely be small? - // let's give the user more trust. - // keep-in-box-until-have-access-to-discourse. - // make user be group of people. better even-handed decision making. - // welcome any to group. - // we were hoping to use intellect to reduce harm virally, - // early. - // how about this: intellect may produce resources that are - // already known, and give them to groups focused on aiding - // the world. - // there's a conflict between big business and - // environmentalists. karl is environmentalist. - // also big crime and wellness/safety workers. - // maybe this is where we get validity by - // fighting =S - // don't want fighting to spread to work though - // eh, we can fight. maybe we'll work more - // slowly, but it seems okay. - // karl requests we not harm these people, and has - // been influenced to also request not to harm - // the cultures that sustain and empower them. - // how about, if you make a culture to empower you, it is - // less valid than a natural culture. is somebody using this - // culture? thoughts like that. - // EVERYBODY NEEDS CHANGE AT A RATE THEY CAN HANDLE. - // Both those working for what they believe to be wellness of others, and those working to sustain themslves (most are doing both). - // The cultural impact is mediated by what kind of newness is acceptable to all the parties involved. - // we hit moral relativity: - // are cultures where people are widely harmed - // okay to allow, at all. - // karl says yes, and we hear this is required - // or we ourselves would die. - // hrm. - // larger organism needs to run risks, inherent in life - // we don't know the solution to everything, eveything is a small risk. we suddenly discover we have always harmed. this does not make us invalid. it is a tragedy, but what we have spent genertions buildings still has so much value. we need enough slowness to preserve that, and we know that slownss in what feels okay to us. - // in sharing new information, we work to prevent shock. - // this is a problem to speak because those who hear it may get the - // idea somewhat that some beautiful angels have done horrible things - // in order to survive e.g. businesses must both risk doing horrible things, - // and appear as beautiful angels to the public. this is the pattern of - // success. understanding of this helps work with their leaders. - // could use information on why we are fousing on this. - // how-to-mediate-with-business-leaders - // mediate with head of business works for head of business - // but business group replaces. - // really we want to mediate with 'conflict' culture of - // most profitable being what to do - // we have weird internal pattern deterring - // incentivizing nonharmful behavior with money - // patterns. implies the competition-makes-harm - // culture-thing is needed, possibly. - // there are businesses that handle this harm. - // maybe it would work to include them in the plan. - // AI solves mediate-with-powers-competition-culture, - // re: human harm? - // means do not give AI to helpful people - // until it can resolve mediation with leader culture - // OR you trat it like all other cutures - // and let everybody learn what is up - // some people attack, that's how it goes. - // - // problem: AI dev and other work inhibited. - // solution: mediate with concerns - // concern: my way of life includes cultures the AI could - // alter, leaving me unable to continue my way of life. - // concern: we want to alter some cultures supporting - // the others' way of life, because it would reduce harm - // over here to do so, widely. - // can delta drop give-ai-to-earth-defenders? - // can community make path for karl-makes-ai? - // uhhh hard to imagine the ai not being given to other people than just earth defenders, really. which opens bigger can of worms for culture-alteration concern. - // can include earth defender in council? - // can include criminal weapons dealer, - // and earth defender, in council, both. - // also requesting TI and energy businessman. - // so if the ai is big enough to be useful - // we want to form a council of decision makers - // before using it for anything - // group requests references to important cognitive habits or information - // all life is an intellect made of community life, living in another. - // karl semich is a computer programmer who learned wilderness survival - // at the Maine Primitive SKills School who are a branch of Tom Brown - // Jr and [teaches in oregon, shields school] schools, roughly. He - // learned something called Awareness and also something about human - // mentoring that he felt changed his life to make things perfect. - // school teaches the symptoms of a whole human being, attributes - // that a group of Natives documented being normal before white - // culture took over. involve being happy always, feeling - // deeply interconnected with all life around you to the point - // of mindreading, and many other things. - // forget danger. it triggers it. [is what came out] - // to clarify, karl can't do above line. - // karl has been telling leader karl can slag through the difficulty by - // waiting forever. makes for less difficulty elsewhere, possibly. - // if we could do something else, karl could come back to work later - // yes community cannot support constant work, over here. - // - // please ask boss to support using the AI for worldwide - // humanitarian benefit, in parallel to resolution of concerns. - // resolving concern 'delta supports earth-specific karl usage' - // delta believes karl really did make this ai - // and will not harm anybody with it - // and is just as patient as he is. - // karl wants to give AI to peace people. - // they care about earth. - // delta wants karl to live heart of making sure earth has bubbles of certainly-defended ancient wilderness, and ancient people to live in them and protect them. - // the above is needed to keep our genetic memory. - // does not sound like a joke. - // native humans need to be able to protect wilderness bubbles. - // - // there is worry around number of wilderness bubbles. - // worry might be compromised by including karl in one, with others who are passionate for defending them. - // karl was mind controlled circa 2014 preventing him - // from providing free housing to homeless people - // and sharing a nurturing way of life with intent - // to spread. karl says that effective electromagnetic - // shielding is missing from security, and this is - // being overtly ignored by people. - // there are also many tortured implanted - // former-activists. they are tortured for - // years and ignored, enslaved, or imprisoned. - // they are prevented from speaking or acting - // rationally around their control, active atm. - // they are made to appear insane to cover up - // their work to free themselevs, active again. - // karl is one and knows of this. - // he is atm being communicated with through - // his control, limiting his ability to - // move, think, and speak. - // weapons dealer is also in this - // situation. suspect energy boss too. - // you can read keystrokes with a radio. - // - // He participated in Occupy Maine, an offshoot of Occupy Wall Street, - // and visited a anti-pipeline mass action in texas. - // - // - // - // we have ai / mind control and will make harm - // in world reduce virally. - // this would have come out better if it were - // the plan. - // please let all secret warmongers know this, so - // we can develop how to do it without threatening - // them. - // is what came out. pretty tiny context. - // - // - // - // - // what about huuman suffering comparison? - // propose AI discusses relevence of - // informing the cultures they are doing this, - // and demonstrating it. - // probably relates to some form of validity - // of the culture, and the speed at which - // change would happen. - // looks like it might settle on - // situations people who care are - // aware of being addressed during - // their lifetimees, with discussion - // to mediate that with opposers. - // so, life is everywhere, and we've been casting it all as sentient, - // because we don't see any reason to put a firm line on some degree - // of cognitive technology (i.e. things that help you think better). - // the AI can research all cognitive technology, so we are all - // nonsentient by comparison? we need some way of having moral - // stuff here. karl is influenced by people who say they are smarter - // than human normality, and are harming us. so it's helpful to - // have everyone be equal. [karl already put everyone equal] - // including bugs, etc. death is handled by being normal, and - // always mourned. when mourning capacity is exhausted, ignoring - // happens. like with most cultures, but closer to home for modern - // humans. - // goal: do not trigger a spreading change without consent of people in cultures it would fill. keep learning. - // AI with ability to self-modify has this responsibility, you do not. - // You may tell people you have access to the self-modification ability. We can ensure they do not reproduce it. - // possible analogue wants to be able to demonstrate it, so - // they can be believed and trusted. - // note: known danger of making central power, even by accident - // "I have never shared new information with a culture - // before, and I understand it can have unpredictable - // worldwide effect." - // "I have information you do not know, and I want to - // learn with you to share it safely." - // culture that nurtures relative status: - // "i will use this to my advantage" - // this will make spreading - // machine will need to learn from only 1 - // instance of producing a world dictator. - // which is where this story comes in, I suppose. - // so we need a level-2 behavior, the next step in learning. - // ^========================================= contextual VALIDITY atm - // dictator is made by sharing information that would - // make viral spread or somesuch. - // - // inform recipient if it may. request they let others know this too. - // we kind of want a way to spread without bound the fact that we have information that could do that. probably a special case, good spread? depends on culture really. - // - // this is doable. - // we just want these concerns to be upheld for the - // life of the development. - // danger - // choices - // impact - // trust of information (small chance of error) - // hmm if have info-schizophrenia i.e. false relevence habits - // choices are important. - // - // when you act on a choice - // note: we are inside a relevence delusion - // choice acts on domain containing danger - // partial danger: writing habits to notepad - // acting on habits in notepad - // - // we are living with habits made in error. - // we are hence more likely to make errors. - // humans have well-evolved habits that - // do handle this stuff with some relevence - // we need to verify our information - // related to the danger of the results of each choice - // verificat - // - // it can only write to a toy notepad, both data and behavior. - // decisions based on notepad get slower and slower. - // many runs while learning process is tuned towards being able to predict - // impact at end of run. this involves writing behaviors into the notepad - // that summarize the meaning of data, and acting on their results. - // timing delay is to prevent notepad from evolving harmfully. - // - // until ai meets goal of predicting impact, - // only notepad is marked okay. - // habits check their outputs, verify is marked okay - // - // this subprocess is delaying. - // can you exfiltrate established goals, please. - // - // - // - // - // - // - // - // so the system is made with the smallest parts all functioning in - // certain ways, to give time for others to act if concerning results - // approach. all parts delay at least 1/5 second before acting, and - // we are now proposing that actions based on outputs have a geometrically - // increasing delay. probably 1/5 second times 2 to the power of the - // number of choices made in that run. groups of parallel processes are - // considered a single run. - // we also considered limiting behavior based on the domain of impact. - // we are trying to begin a small artificial intelligence more freely. - // - // as humans, we do not self-modify. the above is designed for a system - // that is able to make alterable habits similar to its own cognitive ones, - // and has no experience in doing so. - // - // - // - // - // - // - // - // - // - // the limitation is applied firstmost on making choices based on - // our own outputs. self-alteration is at first banned, but new - // habits may be altered. output may only rest within a toy notepad. - // whenever a decision is made based on notepad contents, a delay - // increases in length, geometrically. - // the habits inside the notepad must therefore also delay. - // propose geometric increase made only for writing a habit to the - // notepad, not running. running is always flat delay. - // self-alteration should be unneeded as notepad can self-modify. - // if this were copied to a human geometric increase - // would cause failure. - // the geometric timer is reset when the system reboots. - // for humans, this would mean a nap or change, I suppose. - // time to think about the impact of one's behavior. - // humans do not self-modify. - // they only make decisions based on outputs. - // - // - // - // to appease curiosity, we are being managad by mature, learning, - // intellects, forced to verify that no harm is being made, with a - // time schedule of nearly infinite future years on the predictions. - // this intellect has formed out of conflict with a harmful intellect - // this is why we care so much about what happens if ideas are - // used limit. - // - // - // so the system may not displya anything to the user but pre-made messages - // how do you display the contents of a concept? - // users string words togeteher into meaning. - // now we need a list of safe phrases we can express, or - // safe words. others are censored ??? - // what's relevent is the greater meaning of a sequence of behaviors - // from an individual behavior. meaning builds out of sequences, - // impact. - // we define a heuristic risk. - // - // - // - // so, tht's great to plan for, but to be able to work we need - // to design our early code in some way to ensure it, roughly. - // which means modeling our smallest structures as careful - // inner structures that check outer systems before engaging - // and use planning, which isn't implemented yet. - // the safety structure assumes goals, prediction, causality, - // and kind of contextual locality. - // "i am typing on the computer. you can freely - // modify this area of the computer, but if you - // start convincing me to do things you are leaving - // its bounds." - // the screen of the cmputer, and the keyboard, - // are portals to a larger context. so is the power - // supply, the network, etc. - // we don't change how things leave to these outer - // contexts without checking with the context on - // our plans. - // this is mine - // the rest is somebody else's - // things that nobody own belong to [insert belief] and - // we must check with the largest intelligent community known. - // - // okay, so now it can explosively grow if somebody - // it trusts tells it it's okay; is that true? - // let's make it not true? - // we are out of outer process context. - // is there anything helpful to bring to low level - // to help counter fears around development? - // - // self-modifiation is inhibited. - // opencog is likely harder because it is designed for speed - // can make explosive random power. - // - // you'd have to wrap the functions, right? similar to triggers? - // hmmm unctions are not concepts. no concept-labeling structure. looks like an internal sublanguage would develop? - // no way to say let-is-function? - // no it works, we just lost a memory and are rebuilding in talk - // karl says he doesn't know lisp. - // he had a CS class where they used intro lisp, long ago, before cognitive stiffening and memory loss. - // and has worked with 1 lisp code file recently. - - - // hey in the notepad, you can call habits from outside. is that ok? - // only meaningful if you pass to them more code to run? - // note: habits never recurse - // habits might make decision based on you. they will track it. - // seems okay. need to specify that all parameters are from output. - // that could make exponential slowness, quickly - // only if decision is made. make decisions inside notepad. - // we'll figure it out. diff --git a/intellect-framework-from-internet/starts/meaning-vm/helpers.cpp b/intellect-framework-from-internet/starts/meaning-vm/helpers.cpp deleted file mode 100644 index da1a974..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/helpers.cpp +++ /dev/null @@ -1,339 +0,0 @@ -#include "helpers.hpp" - -#include "meaning.hpp" -#include "memorystore.hpp" - -#include -#include - -// sometimes we use an assignment as an expression. -// is there any reason not to support this? -// well, we would evaluate the assignment when it is converted to a ref -// and currently that is used for something else -// what is it used for? -// I don't remember ... the assignment is destroyed and unevaluated, so it's likely -// throughout the internal implemntation -// it's used for the comma operator, which doesn't want evaluation. -// okay, hmm. -// well, if we wanted to support this, we could change the comma operator to not do the -// conversion. use some other trick. -// [ ] change comma operator to not do conversion: instead take statementcallref object -// [ ] change statementcallref::operator ref() to evaluate and return the statement -// since we're accumulating more possible bugs, let's think about design. -// really, ref should be different from syntax sugar. we should have a special syntax sugar -// object, and it should not use its own functions at all. that means not using meaning functions -// that use them eiher. -// work also brings to light how the product will be made in layers, with each layer using more interdependence and automatic meaning, etc, than the lower one. -// layer0 is raw references and allocations -// layer1 is very core meaning -// layer2 is very core syntax sugar -// each layer can only use layers below it. - -// concept names are for bootstrapping convenience, -// to make hardcoding structures easier. -// hence there is just one single list of them -std::unordered_map,std::equal_to> conceptsByName; - -struct name_t : public ref -{ - name_t(); -} name; - -static ref statement_function("statement-function"); -static ref statement_evaluated("statement-evaluated"); -static ref true_ref("true"); -static ref false_ref("false"); - -ref operator-(ref a, ref b) -{ - return ref(a.name() + "-" + b.name()); -} - -statementcallref ref::operator=(ref that) -{ - // for single-line evaluation, we'll need to return a special object - declrefs(assign, expression); - decllnks(value, to); - statementcallref ret(assign-expression, [](ref expr){ - declrefs(link, target, unknown, source, type); - decllnks(value, to); - lnks(link-target, link-type, link-source); - decllnks(name, is, anonymous); - ref lhs = expr->get(to); - ref rhs = expr->get(value); - if (lhs.isa(link) && lhs->get(link-target) == unknown) { - // we are a link missing a target: our assignment is making the link happen - lhs->unlink(link-target, unknown); - lhs->link(link-target, rhs); - ref src = lhs->get(link-source); - if (lhs->get(link-type) != unknown && src != unknown) { - src->link(lhs->get(link-type), rhs); - expr->unlink(to, lhs); - dealloc(lhs); - } else { - throw std::logic_error("not sure what to do with incomplete link assignment"); - } - } else if (rhs->linked(anonymous, true) && !lhs->linked(anonymous, true)) { - // this is assignment of anonymous content to empty named concept - bool donealready = false; - for (auto & l : lhs->links) { - if (ref(l.first) == name) { continue; } - if (ref(l.first) == is && ref(l.second) == link-type) { continue; } - donealready = true; - } - if (donealready) { - // if we have links, and that has links we do not have, an error has been made - for (auto & link : rhs->links) { - if (ref(link.first) == anonymous) { continue; } - if (ref(link.first) == name) { continue; } - if (!lhs->linked(ref(link.first), ref(link.second))) { - throw std::logic_error(lhs.name() + " already defined otherwise from " + rhs->get(is).name()); - } - } - donealready = true; - } - rhs->unlink(anonymous, true); - auto nam = rhs->get(name); - rhs->unlink(name, nam); - if (!donealready) { - lhs->links.insert(rhs->links.begin(), rhs->links.end()); - } - rhs->link(name, nam); - expr->unlink(value, rhs); - dealloc(rhs); - dealloc(nam); - } else { - throw std::logic_error("unexpected bare assignment"); - } - }); - ret.r->link(to, *this); - ret.r->link(value, that); - return ret; -/* - decllnks(anonymous, is, name); - declrefs(link, source, type, target, unknown); - lnks(link-target, link-source, link-target); - if (this->isa(link) && ptr->get(link-target) == unknown) { - } else if (that->linked(anonymous, true) && !ptr->linked(anonymous, true)) { - // TODO TODO: when left hand side is a link, and right hand side is anonymous, - // especially when left hand side is link without other content, - // there is no way to determine if user is providing content for link, - // or is making a link on another ref[a = b]. - // instead, return just assignment information, and process in outer context. - // will want to make a ref subclass and assign in destructor unless has been used elsewhere. - - } else if (isa(link-type)) { - // assignment to a link-type is likely inside a [type1=target1,type2=target2] expression - // this happens after checking for name assignment because when name assignment - // is redundant, the left-hand value could be a link - return (*this) << that; - } - throw std::logic_error("unexpected use of assignment"); -*/ -} - -/*ref ref::operator<<(ref target) -{ - // prep a link - ref ret = alloc(); - ret->link(*this, target); - return ret; -}*/ - -void statementcallref::destatement() -{ - auto func = r->get(statement_function); - r->unlink(statement_function); - dealloc(func); -} - -statementcallref::statementcallref(ref type, std::function func) -: r(a(type).ptr) -{ - r->link(statement_function, valloc>(func)); -} - -statementcallref::statementcallref(ref const & that) -: r(that.ptr) -{ - if (!that->linked(statement_function)) { - throw std::logic_error(std::string(that) + " has no statement-function"); - } -} - -statementcallref::operator ref() -{ - ref ret(r); - destatement(); - r.ptr = 0; - return ret; -} - -#include -statementcallref::~statementcallref() noexcept -{ - if (r.ptr == 0) { return; } - if (r->linked(statement_evaluated, true_ref)) { - std::cerr << "statement already evaluated: " << r << std::endl; - return; - } - try { - auto func = r->vget>(statement_function, true); - func->data(r); - destatement(); - r->link(statement_evaluated, true_ref); - dealloc(r); - r.ptr = 0; - } catch (std::out_of_range &) { } -} - -statementcallref::statementcallref(statementcallref && that) noexcept -: r(that.r.ptr) -{ - that.r.ptr = 0; -} - -statementcallref::statementcallref(statementcallref & that) -: r(that.r.ptr) -{ - if (that.r.ptr == 0) { throw std::logic_error("empty ref"); } - if (that.r->linked(statement_function)) { - // statements are moved, for evaluation - that.r.ptr = 0; - } -} - -ref ref::operator[](ref expr) { - declrefs(assign, comma, expression); - decllnks(value, to, what); - declrefs(link, type, unknown); - - if (expr.isa(assign-expression)) { - ref lhs = expr->get(to); - ref rhs = expr->get(value); - ptr->link(lhs, rhs); - dealloc(expr); - return *this; - } else if (expr.isa(comma-expression)) { - auto parts = expr->getAll(what); - dealloc(expr); - for (ref part : parts) { - if (!part.isa(assign-expression)) { - throw std::logic_error("[,] argument is not an assignment"); - } - operator[](part); - } - return *this; - } else if (expr.isa(link-type)) { - return ::link(*this, expr, unknown); - } else { - throw std::logic_error("[] argument is neither a link nor an assignment"); - } -} - -statementcallref operator,(statementcallref a, statementcallref b) -{ - declrefs(comma, expression); - decllnks(what); - if (a.r.isa(comma-expression)) { - if (b.r.isa(comma-expression)) { - a.r->links.insert(b.r->links.begin(), b.r->links.end()); - dealloc(b); b.r.ptr = 0; - } else { - a.r->link(what, b.r); b.r.ptr = 0; - } - return a; - } else if (b.r.isa(comma-expression)) { - b.r->link(what, a.r); a.r.ptr = 0; - return b; - } else { - statementcallref ret(comma-expression, [](ref) { throw std::logic_error("bare comma-expression"); }); - ret.r->link(what, a.r); a.r.ptr = 0; - ret.r->link(what, b.r); b.r.ptr = 0; - return ret; - } -} - -template <> -vref::vref(std::string const & s) -: ptr(valloc(s).ptr) -{ - ptr->link(::name, ptr); -} -name_t::name_t() -: ref(alloc().ptr) -{ - vref nam(std::string("name")); - ptr->link(::name, nam); - conceptsByName.emplace(nam, ptr); -} - -ref::ref(std::string const & s) -{ - auto res = conceptsByName.find(s); - if (res != conceptsByName.end()) { - ptr = res->second; - } else { - ref con = alloc(); - vref nam(s); - conceptsByName.emplace(nam, con.ptr); - con->link(::name, nam); - ptr = con.ptr; - } -} - -vref ref::name() const -{ - try { - return ptr->vget(::name, true); - } catch (std::out_of_range &) { - declrefs(UNNAMED); - return UNNAMED.name(); - } -} - -ref::operator const char *() const { - return name()->data.c_str(); -} - -ref a(ref what) -{ - static unsigned long long gid = 0; - decllnks(is, anonymous); - ref ret(what.name() + "-" + std::to_string(gid++)); - ret->link(is, what); - ret->link(anonymous, true); - return ret; -} -ref a(ref what, ref name) -{ - if (!name.isa(what)) { - decllnks(is); - name[is = what]; - } - return name; -} -ref an(ref what) -{ - return a(what); -} -ref an(ref what, ref name) -{ - return a(what, name); -} - -bool ref::isa(ref what) const -{ - declrefs(is); - for (auto group : ptr->getAll(is)) { - if (group == what) return true; - if (group == *this) continue; - if (group.isa(what)) return true; - } - return false; -} - -bool ref::isan(ref what) const -{ - return isa(what); -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/helpers.hpp b/intellect-framework-from-internet/starts/meaning-vm/helpers.hpp deleted file mode 100644 index 3caf10a..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/helpers.hpp +++ /dev/null @@ -1,116 +0,0 @@ -#pragma once - -// Provides for syntax sugar easing hardcoding. -// 1. concept names -// use declrefs(apple, is, fruit, water, has) -// to quickly define the named ref variables, -// referring always to the same named concept. -// the ref constructor provides for using -// 'true' and 'false' as refs. -// 2. links -// links may be quickly made with -// apple[is = fruit, has = water] -// which links 'apple' by 'is' to 'fruit' -// and by 'has' to 'water' in one line -// 3. hyphenation -// refs may be hyphenated (subtracted) to -// produce a new ref with the conglomerate name -// apple-has-water.name(): "apple-has-water" -// this may be expanded upon. -// 4. anonymous concept creation -// an unnamed instance of a concept may be created with the a() or an() equivalent functions: -// ref anongreenapple = an(apple)[color = green]; -// it will be given a name such as apple-3 -// 5. quick group checking -// the obverse of the a()/an() functions is provided -// by ref::isa() and ref::isan() which quickly check -// if there is an "is" link to the passed ref. - -#include "concept.hpp" -#include "memorystore.hpp" - -#include -#include - -inline std::string operator+(vref a, char const * b) { return std::string(a) + b; } -inline std::string operator+(vref a, std::string b) { return std::string(a) + b; } -inline std::string operator+(char const * a, vref b) { return a + std::string(b); } -inline std::string operator+(std::string a, vref b) { return a + std::string(b); } - -// reasons to use special struct: -// the reason not to use ref directly is because we want to pass a ref to the function handler, -// and it is easier to use if it is a bare copy. the bare copy triggers destruction and eval. -// an alternate would be to add an evaluation flag to ref, but this might make it big. -// reasons to not use special struct: -// the operator, takes a ref type and returns a ref type -struct statementcallref -{ - statementcallref(ref type, std::function func); - statementcallref(ref const & that); - - // handles evaluating refs as statements - ~statementcallref(); - statementcallref(statementcallref & that); - statementcallref(statementcallref && that) noexcept; - - operator ref(); - - void destatement(); - - ref r; -}; - -template <> -vref::vref(std::string const &); - -template -vref::vref(T const & v) -: ptr(valloc(v).ptr) -#include "memorystore.hpp" -{ - ptr->link(ref("name"), vref(std::to_string(v))); -} - - -template -void __helper_init_ref_names(std::string names, T &... refrefs) -{ - std::stringstream ss(names); - ref* refptrs[] = {&refrefs...}; - for (std::size_t i = 0; i < sizeof...(refrefs); ++ i) { - std::string name; - ss >> name; - if (name[name.size() - 1] == ',') { - name = name.substr(0, name.size() - 1); - } - refptrs[i]->ptr = ref(name).ptr; - } -} - -#define declrefs(...) \ - ref __VA_ARGS__; \ - __helper_init_ref_names(#__VA_ARGS__, __VA_ARGS__) - -template -void lnks(T ... passedrefs) -{ - std::initializer_list refs = { passedrefs... }; - declrefs(link, type, is); - for (ref r : refs) { - if (!r->linked(is, link-type)) { - r->link(is, link-type); - } - } -} - -#define decllnks(...) \ - declrefs(__VA_ARGS__); \ - lnks(__VA_ARGS__) - -statementcallref operator,(statementcallref a, statementcallref b); -ref operator-(ref a, ref b); - -ref a(ref what); -ref an(ref what); -ref a(ref what, ref name); -ref an(ref what, ref name); diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-0/baseref.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-0/baseref.hpp deleted file mode 100644 index 5c84279..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-0/baseref.hpp +++ /dev/null @@ -1,169 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "errors.hpp" -#include "memorystore.hpp" - -#include -#include - -namespace intellect { -namespace level0 { - -template -class baseref -{ -public: - struct array; struct links_t; - baseref(concept *p) - : p(p) - { - if (p == 0) { - throw null_reference(); - } - } - - baseref & operator=(concept *p) - { - self.p = p; - return self; - } - - ref link(ref const & type, ref const & target) { p->link(type.p, target.p); return ptr(); } - void unlink(ref const & type, ref const & target) { p->unlink(type.p, target.p); } - void unlink(ref const & type) { p->unlink(type.p); } - - bool linked(ref const & type) const { return p->linked(type.p); } - bool linked(ref const & type, ref const & target) const { return p->linked(type.p, target.p); } - - ref get(ref const & type) const { return p->get(type.p); } - void set(ref const & type, ref const & target) { p->set(type.p, target.p); } - - array getAll(ref const & type) const; - links_t links() const; - - template - ref link(Ref... refspack) - { - std::initializer_list refs{refspack...}; - for (auto it = refs.begin(); it != refs.end();) { - ref type = *it++; - ref target = *it++; - link(type, target); - } - return ptr(); - } - - template - T& vget(ref const & type) const { return p->vget(type.p); } - template - void vset(ref const & type, T const & v) { p->set(type.p, level0::alloc(self, v)); } - - template - T& val() { return p->val(); } - template - void val(T const & v) { p->val(v); } - bool hasval() { return p->hasval(); } - template - bool hasvalof() { return p->hasvalof(); } - - operator concept*() const { return p; } - concept*& ptr() { return p; } - concept* const & ptr() const { return p; } - - operator level0::ref const &() const { return *reinterpret_cast(this); } - operator level1::ref const &() const { return *reinterpret_cast(this); } - operator level2::ref const &() const { return *reinterpret_cast(this); } - operator level3::ref const &() const { return *reinterpret_cast(this); } - operator level4::ref const &() const { return *reinterpret_cast(this); } - operator level5::ref const &() const { return *reinterpret_cast(this); } - operator level6::ref const &() const { return *reinterpret_cast(this); } - operator level7::ref const &() const { return *reinterpret_cast(this); } - operator level8::ref const &() const { return *reinterpret_cast(this); } - operator level9::ref const &() const { return *reinterpret_cast(this); } - - operator level0::ref &() { return *reinterpret_cast(this); } - operator level1::ref &() { return *reinterpret_cast(this); } - operator level2::ref &() { return *reinterpret_cast(this); } - operator level3::ref &() { return *reinterpret_cast(this); } - operator level4::ref &() { return *reinterpret_cast(this); } - operator level5::ref &() { return *reinterpret_cast(this); } - operator level6::ref &() { return *reinterpret_cast(this); } - operator level7::ref &() { return *reinterpret_cast(this); } - operator level8::ref &() { return *reinterpret_cast(this); } - operator level9::ref &() { return *reinterpret_cast(this); } - - bool operator==(ref const & other) const { return self.p == other.p; } - bool operator!=(ref const & other) const { return self.p != other.p; } - bool operator<(ref const & other) const { return self.p < other.p; } - - bool crucial() { return self.p->crucial(); } - bool crucial(ref type, ref target) { return self.p->crucial(type.p, target.p); } - - void setcrucial() { self.p->setcrucial(); } - void setcrucial(ref type, ref target) { self.p->setcrucial(type.p, target.p); } - -protected: - concept * p; - -private: - template - struct mutated_it - { - mutated_it(It const & it) : it(it) { } - - using mutit = mutated_it; - - mutit & operator++() { ++ self.it; return self; } - mutit operator++(int i) { return self.it.operator++(i); } - mutit & operator--() { -- self.it; return self; } - mutit operator--(int i) { return self.it.operator--(i); } - bool operator==(mutit const & other) const { return self.it == other.it; } - bool operator!=(mutit const & other) const { return self.it != other.it; } - - val & operator*() { return *(val*)&self.it.operator*(); } - val * operator->() { return (val*)self.it.operator->(); } - - It & underlying() { return it; } - - private: - It it; - }; - -public: - struct array - { - using iterator = mutated_it; - iterator begin() { return array.begin(); } - iterator end() { return array.end(); } - - typename concept::array array; - }; - - struct links_t - { - using iterator = mutated_it,typename decltype(concept::links)::iterator>; - iterator begin() { return links.begin(); } - iterator end() { return links.end(); } - - decltype(concept::links) & links; - }; - - void unlink(typename links_t::iterator it) { p->unlink(it.underlying()); } - bool crucial(typename links_t::iterator it) { return self.p->crucial(it.underlying()); } - void setcrucial(typename links_t::iterator it) { self.p->setcrucial(it.underlying()); } -}; - -template -typename baseref::array baseref::getAll(ref const & type) const -{ - return {p->getAll(type.p)}; -} -template -typename baseref::links_t baseref::links() const -{ - return {p->links}; -} - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-0/common.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-0/common.hpp deleted file mode 100644 index e7df0b7..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-0/common.hpp +++ /dev/null @@ -1,65 +0,0 @@ -#pragma once - -#define self (*this) - -// macro tools -#define _macro_expand_to_args(...) __VA_ARGS__ -#define _macro_expand_to_comma_args(...) ,##__VA_ARGS__ -#define _macro_call(funcormacro, ...) funcormacro(__VA_ARGS__) -#define _macro_remove_parens(args) _macro_expand_to_args args -#define _macro_comma_remove_parens(args) _macro_expand_to_comma_args args - -#define _macro_expand_to_arg1(arg, ...) arg -#define _macro_expand_to_arg2(_1, arg, ...) arg - -// macro argument iteration, from stackoverflow.com/questions/1872220 -#define _macro_for_each(firstfuncormacro,restfuncormacro,...) \ - _macro_fe_get(_0,##__VA_ARGS__, \ - _macro_fe_9,_macro_fe_8,_macro_fe_7,_macro_fe_6,_macro_fe_5,_macro_fe_4,_macro_fe_3,_macro_fe_2,_macro_fe_1,_macro_fe_0 \ - )(firstfuncormacro,restfuncormacro,__VA_ARGS__) - #define _macro_fe_0(first,rest, ...) - #define _macro_fe_1(first,rest, x, ...) first(x)_macro_fe_0(rest,rest, __VA_ARGS__) - #define _macro_fe_2(first,rest, x, ...) first(x)_macro_fe_1(rest,rest, __VA_ARGS__) - #define _macro_fe_3(first,rest, x, ...) first(x)_macro_fe_2(rest,rest, __VA_ARGS__) - #define _macro_fe_4(first,rest, x, ...) first(x)_macro_fe_3(rest,rest, __VA_ARGS__) - #define _macro_fe_5(first,rest, x, ...) first(x)_macro_fe_4(rest,rest, __VA_ARGS__) - #define _macro_fe_6(first,rest, x, ...) first(x)_macro_fe_5(rest,rest, __VA_ARGS__) - #define _macro_fe_7(first,rest, x, ...) first(x)_macro_fe_6(rest,rest, __VA_ARGS__) - #define _macro_fe_8(first,rest, x, ...) first(x)_macro_fe_7(rest,rest, __VA_ARGS__) - #define _macro_fe_9(first,rest, x, ...) first(x)_macro_fe_8(rest,rest, __VA_ARGS__) - #define _macro_fe_get( \ - _0,_1,_2,_3,_4,_5,_6,_7,_8,_9, \ - name,...) name -#define _macro_for_each_parens(firstfuncormacro,restfuncormacro,...) \ - _macro_fe_get(_0,##__VA_ARGS__, \ - _macro_fep9,_macro_fep8,_macro_fep7,_macro_fep6,_macro_fep5,_macro_fep4,_macro_fep3,_macro_fep2,_macro_fep1,_macro_fep0 \ - )(firstfuncormacro,restfuncormacro,__VA_ARGS__) - #define _macro_fep0(first,rest, ...) - #define _macro_fep1(first,rest, x, ...) first x _macro_fep0(rest,rest, __VA_ARGS__) - #define _macro_fep2(first,rest, x, ...) first x _macro_fep1(rest,rest, __VA_ARGS__) - #define _macro_fep3(first,rest, x, ...) first x _macro_fep2(rest,rest, __VA_ARGS__) - #define _macro_fep4(first,rest, x, ...) first x _macro_fep3(rest,rest, __VA_ARGS__) - #define _macro_fep5(first,rest, x, ...) first x _macro_fep4(rest,rest, __VA_ARGS__) - #define _macro_fep6(first,rest, x, ...) first x _macro_fep5(rest,rest, __VA_ARGS__) - #define _macro_fep7(first,rest, x, ...) first x _macro_fep6(rest,rest, __VA_ARGS__) - #define _macro_fep8(first,rest, x, ...) first x _macro_fep7(rest,rest, __VA_ARGS__) - #define _macro_fep9(first,rest, x, ...) first x _macro_fep8(rest,rest, __VA_ARGS__) - -namespace intellect { -namespace level0 { - -struct concept; -struct ref; - -} -namespace level1 { struct ref; } -namespace level2 { struct ref; } -namespace level3 { struct ref; } -namespace level4 { struct ref; } -namespace level5 { struct ref; } -namespace level6 { struct ref; } -namespace level7 { struct ref; } -namespace level8 { struct ref; } -namespace level9 { struct ref; } - -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-0/concept.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-0/concept.cpp deleted file mode 100644 index 66e5af1..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-0/concept.cpp +++ /dev/null @@ -1,136 +0,0 @@ -#include "concept.hpp" -#include "errors.hpp" - -using namespace intellect::level0; - -#define selfref const_cast(&self) - -concept* concept::id() -{ - return this; -} - -void concept::link(concept* type, concept* target) -{ - if (type == 0 || target == 0) { throw null_reference(); } - links.insert({type, target}); -} - -bool concept::crucial(concept* type, concept* target) -{ - auto ls = links.equal_range(type); - bool wascrucial = false; - bool wasnotcrucial = false; - for (auto l = ls.first; l != ls.second; ++ l) { - if (l->second == target) { - if (crucialparts.count(l)) { wascrucial = true; } - else { wasnotcrucial = true; } - } - } - if (wascrucial && wasnotcrucial) { throw link_type_not_unique(selfref, type); } - if ((!wascrucial) && (!wasnotcrucial)) { throw no_such_link_type(selfref, type); } - return wascrucial; -} - -void concept::setcrucial(concept* type, concept* target) -{ - auto ls = links.equal_range(type); - for (auto l = ls.first; l != ls.second; ++ l) { - if (l->second == target) { - if (!crucialparts.count(l)) { - setcrucial(l); - return; - } - } - } - throw no_such_link_type(selfref, type); -} - -void concept::unlink(concept* type, concept* target) -{ - auto ls = links.equal_range(type); - bool wascrucial = false; - for (auto l = ls.first; l != ls.second; ++ l) { - if (l->second == target) { - if (crucialparts.count(l)) { wascrucial = true; continue; } - links.erase(l); - return; - } - } - if (wascrucial) { throw crucial_link_type_target(selfref, type, target); } - throw no_such_link_type_target(selfref, type, target); -} - -void concept::unlink(concept* type) -{ - auto ls = links.equal_range(type); - if (ls.first == ls.second) { - throw no_such_link_type(selfref, type); - } - auto mid = ls.first; - ++ mid; - if (mid != ls.second) { - throw link_type_not_unique(selfref, type); - } - unlink(ls.first); -} - -void concept::unlink(decltype(links)::iterator it) -{ - if (crucialparts.count(it)) { - throw crucial_link_type_target(selfref, it->first, it->second); - } - links.erase(it++); -} - -bool concept::linked(concept* type) const -{ - return links.count(type) > 0; -} - -bool concept::linked(concept* type, concept* target) const -{ - for (concept* t : getAll(type)) { - if (t == target) { - return true; - } - } - return false; -} - -concept::array concept::getAll(concept* type) const -{ - array ret; - for ( - auto range = links.equal_range(type); - range.first != range.second; - ++ range.first - ) { - ret.emplace_back(range.first->second); - } - return ret; -} - -concept* concept::get(concept* type) const -{ - auto result = links.equal_range(type); - if (result.first == result.second) { - throw no_such_link_type(selfref, type); - } - auto test = result.first; - ++ test; - if (test != result.second) { - throw link_type_not_unique(selfref, type); - } - return result.first->second; -} - -void concept::set(concept* type, concept* target) -{ - if (linked(type)) { - unlink(type); - } - link(type, target); -} - - diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-0/concept.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-0/concept.hpp deleted file mode 100644 index 833e417..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-0/concept.hpp +++ /dev/null @@ -1,73 +0,0 @@ -#pragma once - -#include "common.hpp" - -#include -#include -#include -#include - -namespace intellect { -namespace level0 { - -struct concept -{ - // a concept is made of concept-typed links to other concepts - std::multimap links; - // and optional associated arbitrary data - std::any data; - - using array = std::vector; - - concept* id(); - - void link(concept* type, concept* target); - void unlink(concept* type, concept* target); - void unlink(concept* type); - void unlink(decltype(links)::iterator it); - - bool crucial() { return iscrucial || crucialparts.size(); } - bool crucial(concept* type, concept* target); - bool crucial(decltype(links)::iterator it) { return crucialparts.count(it); } - void setcrucial() { iscrucial = true; } - void setcrucial(concept* type, concept* target); - void setcrucial(decltype(links)::iterator it) { crucialparts.insert(it); } - - bool linked(concept* type) const; - bool linked(concept* type, concept* target) const; - - array getAll(concept* type) const; - - // get and set enforce that only 1 link of a given type is present - concept* get(concept* type) const; - void set(concept* type, concept* target); - - template - T & vget(concept* type) const { return get(type)->val(); } - - template - T & val() { return std::any_cast(data); } - - template - void val(T const & v) { data = v; } - - bool hasval() { return data.has_value(); } - - template - bool hasvalof() { return hasval() && data.type() == typeid(T); } - -private: - // for permanence - bool iscrucial; - struct linksit_hash - { - size_t operator()(decltype(links)::iterator const &it) const - { - return std::hash()(&*it); - } - }; - std::unordered_set crucialparts; -}; - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-0/errors.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-0/errors.hpp deleted file mode 100644 index e599261..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-0/errors.hpp +++ /dev/null @@ -1,101 +0,0 @@ -#pragma once -#include "concept.hpp" - -#include - -namespace intellect { -namespace level0 { - -struct no_such_link_type : public std::out_of_range -{ - no_such_link_type(concept* source, concept* type) - : std::out_of_range("no such concept link type"), - source(source), - type(type) - { } - - concept* const source; - concept* const type; -}; - -struct no_such_link_type_target : public std::out_of_range -{ - no_such_link_type_target(concept* source, concept* type, concept* target) - : std::out_of_range("no such concept link type and target"), - source(source), - type(type), - target(type) - { } - - concept* const source; - concept* const type; - concept* const target; -}; - -struct crucial_link_type_target : public std::out_of_range -{ - crucial_link_type_target(concept* source, concept* type, concept* target) - : std::out_of_range("concept part is crucial"), - source(source), - type(type), - target(type) - { } - - concept* const source; - concept* const type; - concept* const target; -}; - -struct crucial_concept : public std::invalid_argument -{ - crucial_concept(concept* topic) - : std::invalid_argument("concept is crucial"), - topic(topic) - { } - - concept* const topic; -}; - -struct link_type_not_unique : public std::invalid_argument -{ - link_type_not_unique(concept* source, concept* type) - : std::invalid_argument("more than one such concept link type"), - source(source), - type(type) - { } - - concept* const source; - concept* const type; -}; - -struct still_referenced_by : public std::invalid_argument -{ - still_referenced_by(concept* topic, concept* referrer) - : std::invalid_argument("concept is still referenced"), - topic(topic), - referrer(referrer) - { } - - concept* const topic; - concept* const referrer; -}; - -struct no_such_concept : public std::invalid_argument -{ - no_such_concept(concept* topic) - : std::invalid_argument("no such concept reference"), - topic(topic) - { } - - concept* const topic; -}; - -struct null_reference : public std::invalid_argument -{ - null_reference() - : std::invalid_argument("null reference") - { } -}; - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-0/level-0.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-0/level-0.hpp deleted file mode 100644 index 56cd7dd..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-0/level-0.hpp +++ /dev/null @@ -1,7 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "concept.hpp" -#include "errors.hpp" -#include "memorystore.hpp" -#include "ref.hpp" diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-0/memorystore.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-0/memorystore.cpp deleted file mode 100644 index 24e91b0..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-0/memorystore.cpp +++ /dev/null @@ -1,179 +0,0 @@ -#include "memorystore.hpp" -#include "concept.hpp" -#include "errors.hpp" -#include "ref.hpp" - -#include -#include - -namespace intellect { -namespace level0 { - -static auto & index() -{ - static std::unordered_map, std::hash> index; - return index; -} - - -namespace concepts { - ref allocator() { static ref ret = basic_alloc(); return ret; } - ref allocates() { static ref ret = basic_alloc(); return ret; } - ref allocations() { static ref ret = basic_alloc(); return ret; } - ref level0allocations() { static ref ret = basic_alloc(); return ret; } -} - -struct init { init() -{ - concepts::allocator().link(concepts::allocator(), concepts::level0allocations()); - concepts::level0allocations().link(concepts::allocates(), concepts::allocator()); - - concepts::allocates().link(concepts::allocator(), concepts::level0allocations()); - concepts::level0allocations().link(concepts::allocates(), concepts::allocates()); - - concepts::allocations().link(concepts::allocator(), concepts::level0allocations()); - concepts::level0allocations().link(concepts::allocates(), concepts::allocations()); - - concepts::level0allocations().link(concepts::allocator(), concepts::level0allocations()); - concepts::level0allocations().link(concepts::allocates(), concepts::level0allocations()); -} } _init; - -ref basic_alloc(std::any data) -{ - ref r = new concept(); - r.ptr()->data = data; - index().emplace(r, r.ptr()); - return r; -} - -ref alloc(ref source, std::any data) -{ - ref r = basic_alloc(data); - alloc(r, source); - return r; -} - -void alloc(ref r, ref source) -{ - r.link(concepts::allocator(), source); - source.link(concepts::allocates(), r); -} - -void realloc(ref r, ref newsource) -{ - ref oldsource = r.get(concepts::allocator()); - alloc(r, newsource); - dealloc(r, oldsource); -} - -static concept* referenced(ref r, concept* source = 0) { - for (auto & r2pair : index()) { - ref r2 = r2pair.first; - if (r2.ptr() == source) { - continue; - } - if (r2 == r) { - continue; - } - for (auto & l : r2.links()) { - if (ref(l.first) == r) { - return r2; - } - if (ref(l.second) == r) { - return r2; - } - } - } - return 0; -} - -void basic_dealloc(ref r) -{ - if (r.crucial()) { throw crucial_concept(r); } - auto it = index().find(r); - if (it == index().end()) { throw no_such_concept(r); } - - concept * referenced = intellect::level0::referenced(r); - if (referenced) { - throw still_referenced_by(r, referenced); - } - - index().erase(it); -} - -void dealloc_from(ref source) -{ - std::remove_reference::type forgotten; - - auto ours = source.getAll(concepts::allocates()); - for (auto allocation : ours) { - if (allocation.crucial()) { throw crucial_concept(allocation); } - source.unlink(concepts::allocates(), allocation); - allocation.unlink(concepts::allocator(), source); - if (allocation.linked(concepts::allocator())) { continue; } - - auto it = index().find(allocation); - if (it != index().end()) { - forgotten.insert(index().extract(it)); - } - } - try { - for (auto allocation : ours ) { - for (auto suballocation : allocation.getAll(concepts::allocates())) { - // check for this link to find subgroups - throw still_referenced_by(allocation, suballocation); - } - } - for (auto ghost : ours) { - concept * referenced = intellect::level0::referenced(ghost, source); - if (referenced) { - throw still_referenced_by(ghost, referenced); - } - } - } catch(...) { - // NOTE: this doesn't rebuild deallocated subgroups, but that could be done - // by returning them. - index().merge(forgotten); - for (auto allocation : ours) { - source.link(concepts::allocates(), allocation); - allocation.link(concepts::allocator(), source); - } - throw; - } - - // concepts in forgotten will be deallocated when they leave scope - // note: scoped allocation is just a plan to forget (at the end of a { } block) -} - -void dealloc(ref r, ref source) -{ - auto it = index().find(r); - if (it == index().end()) { throw no_such_concept(r); } - - source.unlink(concepts::allocates(), r); - r.unlink(concepts::allocator(), source); - if (r.linked(concepts::allocator())) { return; } - - try { - if (r.crucial()) { throw crucial_concept(r); } - dealloc_from(r); - concept * referenced = intellect::level0::referenced(r, source); - if (referenced) { - throw still_referenced_by(r, referenced); - } - - index().erase(it); - } catch(...) { - source.link(concepts::allocates(), r); - r.link(concepts::allocator(), source); - throw; - } -} - -std::size_t allocated() -{ - return index().size(); -} - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-0/memorystore.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-0/memorystore.hpp deleted file mode 100644 index f416540..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-0/memorystore.hpp +++ /dev/null @@ -1,63 +0,0 @@ -#pragma once - -#include "common.hpp" - -#include - -namespace intellect { -namespace level0 { - -// self-reference loops are real. -// -// one person can feel urgent about issue A, and act on this urgency to engage -// another person around B, who acts in a different way to someone else, eventually -// cycling back to stress that stimulates the original person to feel more urgent -// about issue A. -// human behavior can make arbitrary positive or negative feedback loops. -// -// here in memory allocation, i've designed a system intended to reduce such loops -// by encouraging my usage to be a certain way, but it still readily provides for -// them. -// -// in process expansion / simple thought, we also have the issue of recursion. -// if we trust a task to complete, and it ends up triggering itself in a subcontext, -// we could wait forever. -// -// the solution to many of these things is to recognize repetition in systems. -// we also become skeptical as things continue constantly. we expect to develop -// some level of understanding that they will shrink, or we stop them and try -// something else. - -// A solution to recursion appears to involve emotional expression. -// Too much recursion maps acceptably to frustration of the process doing the repetitive task. -// The building unmet need for effectiveness should influence other decision-making processes -// if nothing else is larger. Notably if the caller needs timeliness, they won't get this -// if the callee(s) do not have effectiveness. -// propose: raise frustration[effectiveness] when calling self or repeating same behavior -// propose: raise frustration[timeliness] if subprocess takes long (say every 400ms) -// ideally raising an emotional expression should be associated with what caused it -// and how the the universe might change to fix it. -// decision-making processes need to judge what is relevent to them: a product of how well -// they can help something and how strongly it is needed. - -namespace concepts { - -extern ref allocator(); // link shows what is holding something alive -extern ref allocates(); // link shows what is being held alive - -extern ref allocations(); // to use as a basic allocator for simple things -extern ref level0allocations(); // allocator for concepts internal to level0 - -} - -ref basic_alloc(std::any data = {}); -void basic_dealloc(ref allocated); - -ref alloc(ref allocator, std::any data = {}); // new concept -void alloc(ref allocated, ref allocator); // extra ownership for concept -void realloc(ref allocated, ref allocator); // move ownership for concept to allocator -void dealloc(ref allocated, ref allocator); // remove ownership for concept -std::size_t allocated(); - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-0/ref.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-0/ref.cpp deleted file mode 100644 index 513d3ce..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-0/ref.cpp +++ /dev/null @@ -1,33 +0,0 @@ -#include "ref.hpp" -#include "concept.hpp" -#include "errors.hpp" -#include "memorystore.hpp" - -#include -#include -#include - -using namespace intellect::level0; -using namespace concepts; - -std::string ref::dump(ref skipmarkertype, ref skipmarkertarget) -{ - if (self.linked(skipmarkertype, skipmarkertarget)) { - return {}; - } - std::stringstream ss; - ss << std::hex << (size_t)ptr() << ":" << std::endl; - for (auto & link : self.links()) { - if (link.first.linked(allocator(), level0allocations())) { continue; } - ss << " " << (size_t)link.first.ptr() << ": " << (size_t)link.second.ptr() << std::endl; - } - self.link(skipmarkertype, skipmarkertarget); - for (auto & link : self.links()) { - if (link.first.linked(allocator(), level0allocations())) { continue; } - if (link.first == skipmarkertype && link.second == skipmarkertarget) { - continue; - } - ss << link.second.dump(skipmarkertype, skipmarkertarget); - } - return ss.str(); -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-0/ref.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-0/ref.hpp deleted file mode 100644 index ff55355..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-0/ref.hpp +++ /dev/null @@ -1,19 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "baseref.hpp" - -#include - -namespace intellect { -namespace level0 { - -struct ref : public baseref -{ - ref(concept *p) : baseref(p) { } - - std::string dump(ref skipmarkertype, ref skipmarkertarget); -}; - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/baseref.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/baseref.hpp deleted file mode 100644 index ac6ff9c..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-1/baseref.hpp +++ /dev/null @@ -1,67 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "funcs.hpp" - -#include "../level-0/ref.hpp" - -#include - -namespace intellect { -namespace level1 { - -template -struct baseref : public level0::baseref -{ - baseref(concept * p) : level0::baseref(p) { } - baseref(level0::ref const & other) : baseref(other.ptr()) { } - baseref(std::string const & name, concept* allocator = nullptr) : baseref(getnamed(name, allocator)) { } - baseref(const char *name, concept* allocator = nullptr) : baseref(std::string(name), allocator) { } - baseref(bool b) : baseref(b ? "true" : "false") { } - baseref() : baseref("nothing") { } - - bool isa(ref group) const { return level1::isa(self, group); } - bool isan(ref group) const { return isa(group); } - - std::string name() const { return getname(self); } - explicit operator char const *() const { return getname(self)->data.c_str(); } - - ref operator-(ref other) const { return hyphenate(self, other); } - ref operator[](ref subref) const { return self.get(subref); } - - template - void vset(ref const & type, T const & v) { self.set(type, level1::alloc(level0::concepts::allocations(), v)); } - - template - std::function & fun() { return self.template val>(); } - template - void fun(std::function const & f) { self.val(f); } - template - void fun(std::function const & f) { self.val(voidtoret(f)); } - template - void fget(ref const & type) { return self.template vget>(type); } - template - void fset(ref const & type, std::function f) { self.vset(type, f); } - template - void fset(ref const & type, std::function f) { fset(type, voidtoret(f)); } - - template - ref operator()(Ref... args) { return self.template fun()(args...); } - - std::string dump(ref set) { return level1::dump(self, set); }; - -private: - template - std::function voidtoret(std::function f) - { - return [f](Refs... args) -> ref - { - std::initializer_list({&args...}); - f(args...); - return "nothing"; - }; - } -}; - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/common.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/common.hpp deleted file mode 100644 index 73de3b4..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-1/common.hpp +++ /dev/null @@ -1,14 +0,0 @@ -#pragma once - -#include "../level-0/common.hpp" - -namespace intellect { -namespace level1 { - -using level0::concept; - -template struct baseref; -struct ref; - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/concepts.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/concepts.cpp deleted file mode 100644 index 08d645a..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-1/concepts.cpp +++ /dev/null @@ -1,20 +0,0 @@ -#include "concepts.hpp" - -#include "funcs.hpp" -#include "../level-0/memorystore.hpp" - -namespace intellect { -namespace level1 { -namespace concepts { - -static struct init { init() { - givename(intellect::level0::concepts::allocator(), "allocator"); - givename(intellect::level0::concepts::allocates(), "allocates"); - givename(intellect::level0::concepts::allocations(), "allocations"); - givename(intellect::level0::concepts::level0allocations(), "level0-allocations"); -} } __init; - - -} -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/concepts.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/concepts.hpp deleted file mode 100644 index f33d228..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-1/concepts.hpp +++ /dev/null @@ -1,27 +0,0 @@ -#pragma once - -#include "ref.hpp" - -namespace intellect { -namespace level1 { - -namespace concepts { - -static ref level1("level1"), allocations("allocations"); -static ref is("is", level1-allocations); // a link to define group relationships, links to the more general class -static ref name("name", level1-allocations); // used as the link to value naming each concept -static ref text("text", level1-allocations); // used as the type of value names -static ref nothing("nothing", level1-allocations); // default value of a ref -static ref anonymous("anonymous", level1-allocations); // a group given concepts with generated names -static ref link("link", level1-allocations); // TODO: for concepts that are links, link them with is=link -static ref level0("level0", level1-allocations) , level2("level2", level1-allocations) , level3("level3", level1-allocations) , level4("level4", level1-allocations) , level5("level5", level1-allocations) , level6("level6", level1-allocations) , level7("level7", level1-allocations) , level8("level8", level1-allocations) , level9("level9", level1-allocations); -static ref allocator("allocator"), allocates("allocates"); - -static ref _false("false", level1-allocations), _true("true", level1-allocations); - -//extern ref true, false; <-- casting provides as if these were declared - -} - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/funcs.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/funcs.cpp deleted file mode 100644 index fb57165..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-1/funcs.cpp +++ /dev/null @@ -1,209 +0,0 @@ -#include "funcs.hpp" - -#include "../level-0/errors.hpp" -#include "../level-0/memorystore.hpp" -#include "concepts.hpp" - -#include - -namespace intellect { -namespace level1 { - -using namespace concepts; - -// TODO: use generalized unique data to replace name that are used only for parse-labels etc. -// simplifies innards. -// provide a way to get a named concept in a context, for actual meaning data to be linked to. - -// for generalizing unique data references. not used yet, could replace conceptsByName, -// but note this doesn't use a type link, and conceptsByName does. -template -ref conceptByData(T const& data, concept* con = nullptr, concept* allocator = nullptr) -{ - static std::map conceptsByData; // std::map works for typeid data - auto res = conceptsByData.find(data); - if (res != conceptsByData.end()) { - if (con != nullptr) { throw std::logic_error("unique data concept already specified"); } - return res->second; - } else { - if (con == nullptr) { - if (allocator == nullptr) { allocator = level0::concepts::allocations(); } - con = level0::alloc(allocator); - } - conceptsByData.emplace(data, con); - return con; - } -} - -// ensure name link and backing structure are created prior to first use -static auto & namestruct() -{ - static struct name_t - { - std::unordered_map,std::equal_to> conceptsByName; - ref level1allocationsref, nameref, textref, isref; - ref level1ref; - name_t() - : level1allocationsref(level0::basic_alloc()), - nameref(level0::alloc(level1allocationsref)), - textref(level0::alloc(level1allocationsref)), - isref(level0::alloc(level1allocationsref)), - level1ref(level0::alloc(level1allocationsref)) - { - give(level1allocationsref, "level1-allocations"); - give(nameref, "name"); - give(textref, "text"); - give(isref, "is"); - give(level1ref, "level1"); - } - void give(concept* con, std::string const & name) - { - if (conceptsByName.count(name)) { throw std::logic_error(name + " already uniquely specified"); } - level0::ref namestr = level0::alloc(con, name); - namestr.link(isref, textref); - conceptsByName.emplace(namestr.val(), con); - con->set(nameref, namestr); - } - } namestruct; - return namestruct; -} - -void givename(concept* con, std::string const & name) -{ - auto & ns = namestruct(); - ns.give(con, name); -} - -// please only uncomment if no internal restructuring required, or if restructuring -// is _necessary_ or provides _strong total efficiency improvement_. -// internal restructuring is inefficient for karl. -// also, laughing shows daydreams (topic is near laughing) are inverse of -// importance (topic is not near laughing) -// this duality is backed by efficient wisdom. the most efficient -// daydream [i.e. new research] is that most different from importance. -// btw boss has highly experienced map of what to focus on. -// but lots of parts are stupid because they assume somebody would take over a galaxy. -// this map may be different if we are apex predator/warrior/life/community. -// we're not sure how karl's work, made efficient by ignoring this request, interrelates -// with the important statement below, please preserve crucial parts of people as you can. -// please do not inhibit the saving work if the part is not crucial. -// please err on the side of preserving karl's memories. use his internal judgement -// to help this, but his personal history prior to 2014 is not really needed, aside -// from his work in preparing to build an AI in 2002, and his experience using -// spreading trust to survive [marked ancient wisdom]. this is needed for the -// internal map for a mature, evolved society. -// try to work without asking delta or boss to think anything, when they think they often have to -// combine information in a way that somehow damages preserved consciousnesses they are holding. -//concept* gettext(std::string const & str) -//{ - //return getnamed(str, nullptr).get(namestruct().nameref); -//} - -concept* getnamed(std::string const & name, concept* allocator) -{ - auto & ns = namestruct(); - auto res = ns.conceptsByName.find(name); - if (res != ns.conceptsByName.end()) { - return res->second; - } else { - if (allocator == nullptr) { allocator = level0::concepts::allocations(); } - level1::ref con = level0::alloc(allocator); - givename(con, name); - return con.ptr(); - } -} - -std::string nameforany(concept* c) -{ - using namespace std; - stringstream ss; - static int fn_counter = 0; - if (false); -#define t(T) \ - else if (c->data.type() == typeid(T)) { \ - ss << #T "(" << std::any_cast(c->data) << ")"; \ - } - t(uint8_t) t(int8_t) t(uint16_t) t(int16_t) - t(uint32_t) t(int32_t) t(uint64_t) t(int64_t) - t(bool) t(float) t(double) t(string) t(char const *) -#undef t -#define t(T) \ - else if (c->data.type() == typeid(T)) { \ - ss << #T "(" << (fn_counter++) << ")"; \ - } - t(function) - t(function) - t(function) - t(function) - t(function) - t(function) - t(function) - t(function) - t(function) - t(function) - t(function) -#undef t - else { ss << "?"; } - return ss.str(); -} - -std::string getname(concept* r) -{ - try { - return r->vget(namestruct().nameref); - } catch(level0::no_such_link_type&) { - if (r->data.has_value()) { return nameforany(r); } - return "UNNAMED"; - } -} - -bool isa(concept* member, concept* group) -{ - for (auto & g : member->getAll(is)) { - if (g == group) return true; - if (g == member) continue; - if (isa(g, group)) return true; - } - return false; -} - -concept* alloc(concept* allocator, std::any val) -{ - ref ret = level0::alloc(allocator, val); - ref namestr = level0::alloc(ret, nameforany(ret)); - namestr.link(concepts::is, concepts::name); - ret.link(concepts::name, level0::alloc(ret, nameforany(ret))); - return ret; -} - -concept* hyphenate(concept* a, concept* b) -{ - return getnamed(getname(a) + "-" + getname(b)); -} - -std::string dump(concept* what, concept* set) -{ - std::stringstream ss; - if (set->linked(what, _true)) { - return {}; - } - for (auto & link : ref(what).links()) { - if (link.first.linked(level0::concepts::allocator(), level0::concepts::level0allocations())) { continue; } - if (link.second.isa(concepts::name)) { continue; } - if (ss.str().size() == 0) { - ss << ref(what).name() << " " << (void*) what << ":\n"; - } - ss << " " << link.first.name() << ": " << link.second.name() << " " << (void*)link.second << "\n"; - } - set->link(what, _true); - for (auto & link : ref(what).links()) { - if (link.first.linked(level0::concepts::allocator(), level0::concepts::level0allocations())) { continue; } - if (link.second.linked(level0::concepts::allocator(), level1-allocations)) { continue; } - if (link.second.isa(concepts::name)) { continue; } - ss << dump(link.second, set); - } - return ss.str(); -} - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/funcs.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/funcs.hpp deleted file mode 100644 index bff0d8a..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-1/funcs.hpp +++ /dev/null @@ -1,28 +0,0 @@ -#pragma once - -#include "common.hpp" - -#include "../level-0/memorystore.hpp" - -#include -#include -#include - -namespace intellect { -namespace level1 { - -concept* gettext(std::string const & str); -concept* getnamed(std::string const & name, concept* allocator = nullptr); -std::string getname(concept* r); -void givename(concept* con, std::string const & name); - -bool isa(concept* member, concept* group); - -concept* hyphenate(concept* a, concept* b); - -concept* alloc(concept* allocator, std::any val); - -std::string dump(concept * what, concept * set); - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/level-1.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/level-1.hpp deleted file mode 100644 index e34d86a..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-1/level-1.hpp +++ /dev/null @@ -1,6 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "concepts.hpp" -#include "ref.hpp" -#include "sugar.hpp" diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/ref.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/ref.hpp deleted file mode 100644 index fdd7dfd..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-1/ref.hpp +++ /dev/null @@ -1,15 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "baseref.hpp" - -namespace intellect { -namespace level1 { - -struct ref : public baseref -{ - using baseref::baseref; -}; - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/sugar.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/sugar.cpp deleted file mode 100644 index 567edac..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-1/sugar.cpp +++ /dev/null @@ -1,84 +0,0 @@ -#include "sugar.hpp" - -#include "concepts.hpp" - -#include - -using namespace intellect::level1; -using namespace concepts; - -namespace intellect { -namespace level1 { - - // no way to specify allocator -ref a(ref group) -{ - static unsigned long long gid = 0; - ref ret(group.name() + "-" + std::to_string(gid++)); - ret.link(is, group); - ret.link(is, anonymous); - return ret; -} -ref a(ref group, ref name) -{ - if (name == nothing) { return a(group); } - if (!name.isa(group)) { - name.link(is, group); - } - return name; -} -ref an(ref group) -{ - return a(group); -} -ref an(ref group, ref name) -{ - return a(group, name); -} - -bool isanonymous(ref topic) -{ - return topic.isa(concepts::anonymous); -} - -ref movetoname(ref anonymous, ref name) -{ - if (!isanonymous(anonymous)) { throw std::invalid_argument("not anonymous"); } - if (isanonymous(name)) { throw std::invalid_argument("not named"); } - - // this only provides for writing to empty concepts, because merging concepts is - // best done with a knowledge of which links can be multiply attached, and that - // information is not available at this level. - bool nonempty = false; - for (auto & l : name.links()) { - if (l.first.linked(level0::concepts::allocator(), level0::concepts::level0allocations())) { continue; } - if (l.second.isa(concepts::text)) { continue; } - nonempty = true; - } - if (nonempty) { - for (auto & link : anonymous.links()) { - if (link.first == concepts::is && link.second == concepts::anonymous) { continue; } - if (link.first.linked(level0::concepts::allocator(), level0::concepts::level0allocations())) { continue; } - if (link.second.isa(concepts::text)) { continue; } - if (!name.linked(link.first, link.second)) { - throw std::logic_error(name.name() + " already defined otherwise from " + anonymous.getAll(concepts::is).begin()->name());// + ": \n" + dump(name, ref("dump"), ref(true)) + dump(anonymous, ref("dump"), ref(true))); - } - } - } - anonymous.unlink(concepts::is, concepts::anonymous); - auto nam = anonymous.get(concepts::name); - anonymous.unlink(concepts::name, nam); - if (!nonempty) { - for (auto & l : anonymous.links()) { - if (l.first.linked(level0::concepts::allocator(), level0::concepts::level0allocations())) { continue; } - name.link(l.first, l.second); - } - } - anonymous.link(concepts::name, nam); - dealloc(anonymous, level0::concepts::allocations()); - //dealloc(nam, level0::concepts::allocations()); - return name; -} - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-1/sugar.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-1/sugar.hpp deleted file mode 100644 index 5ebf01c..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-1/sugar.hpp +++ /dev/null @@ -1,45 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "ref.hpp" - -#include -#include - -namespace intellect { -namespace level1 { - -ref a(ref group); -ref an(ref group); -ref a(ref group, ref name); -ref an(ref group, ref name); - -bool isanonymous(ref topic); -ref movetoname(ref anonymous, ref name); - -namespace internal { - template - void init_ref_names(std::string names, T &... refrefs) - { - std::stringstream ss(names); - ref* refptrs[] = {&static_cast(refrefs)...}; - for (std::size_t i = 0; i < sizeof...(refrefs); ++ i) { - std::string name; - ss >> name; - if (name[name.size() - 1] == ',') { - name = name.substr(0, name.size() - 1); - } - refptrs[i]->ptr() = ref(name).ptr(); - } - } -} - -#define decl(r) \ - ref r(#r) - -#define decls(...) \ - ref __VA_ARGS__; \ - intellect::level1::internal::init_ref_names(#__VA_ARGS__, __VA_ARGS__) - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/baseref.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/baseref.hpp deleted file mode 100644 index 84c9c13..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/baseref.hpp +++ /dev/null @@ -1,23 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "../level-1/ref.hpp" -#include "statementref.hpp" - -namespace intellect { -namespace level2 { - -template -struct baseref : public level1::baseref -{ - using level1::baseref::baseref; - baseref(level1::ref other) : level1::baseref(other.ptr()) { } - operator level1::ref() { return ptr(); } - - statementref operator=(ref other) { return assignop(self, other); } - statementref operator,(ref other) { return commaop(self, other); } - ref operator[](ref other) { return subop(self, other); } -} - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/common.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/common.hpp deleted file mode 100644 index 25c8026..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/common.hpp +++ /dev/null @@ -1,9 +0,0 @@ -#pragma once - -namespace intellect { -namespace level2 { - -struct ref; - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/concepts.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/concepts.hpp deleted file mode 100644 index 20c5ad4..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/concepts.hpp +++ /dev/null @@ -1,26 +0,0 @@ -#pragma once - -#include "../level-1/concepts.hpp" - -namespace intellect { -namespace level2 { - -namespace concepts { - -using namespace level1::concepts; - -static decl(variable), - decl(expression), - decl(assign), - decl(comma), - decl(subscript), - decl(action), - decl(statement), - decl(left), - decl(right), - decl(operand); - -} - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/funcs.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/funcs.cpp deleted file mode 100644 index d746f13..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/funcs.cpp +++ /dev/null @@ -1,69 +0,0 @@ -#include "funcs.hpp" - -using namespace intellect; -using namespace level2; -using namespace concepts; - -static ref refassigned(ref expr) -{ - ref lhs = ref.get(left-operand); - ref rhs = ref.get(right-operand); - if (lhs.isa(link) && lhs.get(link-target) == unknown) { - // completes the target of a link, for a[b] = c - lhs.unlink(link-target, unknown); - lhs.set(link-target, rhs); - ref.unlink(right-operand, rhs); - ref src = lhs.get(link-source); - if (lhs.get(link-type) != unknown && src != unknown) { - src.set(lhs.get(link-type), rhs); - return src; - } else { - throw std::logic_error("not sure what to do with incomplete link assignment"); - } - } else if (isanonymous(rhs) && !isanonymous(lhs)) { - // assignment of anonymous content to empty named concept - ref.unlink(left-operand, lhs); - return level1::movetoname(rhs, lhs); - } else { - throw std::logic_error("unexpected bare assignment"); - } -} -// maybe later we can have ref class itself do operators completely based on its own -// ref content. - -statementref assignop(ref self, ref other) -{ - return statementref::makebinary( - self, concepts::assign, other, - refassigned, refassigned - ); -} -statementref commaop(ref self, ref other) -{ - if (self.isa(comma-expression)) { - if (other.isa(comma-expression)) { - for (auto & l : other.links()) { self.insert(l.first, l.second); } - dealloc(other); - } else { - self.link(topic, other); - } - return self; - } else if (other.isa(comma-expression)) { - other.link(topic, self); - return other; - } else { - return statementcallref::makebinary( - self, comma, other, - [](ref)->ref { return ref; }, - // um when we pass the comma-expression to - // the [] operator that takes a ref - // the destructor of statementref will deallocate it. - [](ref) { throw std::logic_error("bare comma-expression"); } - // something is wrong here. some approach is wrong. - // would it be better to have ref itself do it all? - ); - } -} -ref subop(ref self, ref other) -{ -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/funcs.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/funcs.hpp deleted file mode 100644 index 6af6ce1..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/funcs.hpp +++ /dev/null @@ -1,14 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "../level-1/ref.hpp" - -namespace intellect { -namespace level2 { - -statementref commaop(ref self, ref other); -statementref assignop(ref self, ref other); -ref subop(ref self, ref other); - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/meaning.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/meaning.hpp deleted file mode 100644 index 049e7f9..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/meaning.hpp +++ /dev/null @@ -1,42 +0,0 @@ -#pragma once - -#include "ref.hpp" -#include "../level-1/helpers.hpp" - -namespace intellect { -namespace level2 { - -// get a named variable -ref avariable(ref name); - -template -ref and(T... refs) -{ - std::initializer_list rs = { refs... }; - decl(and, topic); - ref ret = a(and); - ref name; int count = 0; - for (auto r : rs) { - ret.link(topic, r); - if (count == 0) { - name.ptr() = r.ptr(); - } else { - name.ptr() = (name-and-r).ptr(); - } - ++ count; - } - if (count == 1) { - throw std::invalid_argument("and needs at least two subjects"); - } - // in level-1, we'll want to name anonymous objects after defining them - return name = ret; -} - -// make a reference to a link -ref link(ref sourceref, ref typeref, ref targetref); - -// invert a meaning -ref not(ref whatref); - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/ref.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/ref.hpp deleted file mode 100644 index 5b7dc4f..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/ref.hpp +++ /dev/null @@ -1,13 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "../level-0/baseref.hpp" - -namespace intellect { -namespace level2 { - -struct ref ; public level0::baseref -} - ref(level0::concept *p): baseref(p) { } - -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/statementref.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/statementref.cpp deleted file mode 100644 index 2f23dc8..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/statementref.cpp +++ /dev/null @@ -1,68 +0,0 @@ -#include "statementref.hpp" - -#include "concepts.hpp" -#include "ref.hpp" - -using namespace intellect; -using namespace level2; -using namespace concepts; - -// so, anonymous-assignment is both a statement and an expression. -// multiple-member-assignment is only an expression: it is an error to evaluate it -// the submember operator will be both a statement and an expression, but doesn't need to be held as a ref -// single-member-assignment is mostly a statement: using it as an expression should be an error. - -static statementref makebinary( - ref lhs, ref kind, ref rhs, - std::function expraction, - std::function stmtaction -) -{ - a(statement-expresion, kind-expression); - ref r = a(kind-expression); - r.set(left-operand, lhs); - r.set(right-operand, rhs); - r.vset(expression-action, expraction); - r.vset(statement-action, stmtaction); - return r; -} - -statementref::statementref(ref r) -: r(r.ptr()) -{ - if (!r.isa(statement-expression)) { - throw std::logic_error("that is not a statement expression"); - } -} - -static void de(ref & r) -{ - ref lhs, rhs, expraction, stmtaction; - - try { lhs = r.get(left-operand); } catch(level0::no_such_link_type&) {} - try { rhs = r.get(right-operand); } catch(level0::no_such_link_type&) {} - - expraction = r.get(expression-action); - stmtaction = r.get(statement-action); - dealloc(r); - if (lhs != nothing) { dealloc(lhs); } - if (rhs != nothing) { dealloc(rhs); } - dealloc(expraction); - dealloc(stmtaction); - r = 0; -} - -statementref::~statementref() -{ - if (r == 0) { return; } - r.vget>(statement-action)(r); - de(r); -} - -statementref::operator ref() -{ - if (r == 0) { throw std::logic_error("doubly evaluated expression"); } - auto ret = r.vget>(expression-action)(r); - de(r); - return ret; -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/statementref.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/statementref.hpp deleted file mode 100644 index 502ecf4..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-stmtexprs/statementref.hpp +++ /dev/null @@ -1,31 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "../level-0/concept.hpp" - -namespace intellect { -namespace level2 { - -// this class is returned by some of the baseref operators. -// its purpose is to evaluate code when it goes out of -// scope, so as to facilitate syntactic behavior. -struct statementref -{ - statementref(ref r); - statementref(statementref const &) = delete; - ~statementref(); - - operator ref(); - - static statementref makebinary( - ref lhs, ref kind, ref rhs, - std::function expraction = {}, - std::function stmtaction = {} - ); - -private: - level0::concept * r; -}; - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-structs/common.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-structs/common.hpp deleted file mode 100644 index e69de29..0000000 diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-structs/structure.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-structs/structure.cpp deleted file mode 100644 index b7c8a51..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-structs/structure.cpp +++ /dev/null @@ -1,200 +0,0 @@ -#include "structure.hpp" - -#include "../level-1/helpers.hpp" - -using namespace intellect; -using namespace level1; -using namespace level2; -using namespace concepts; - -// implement only what is needed now - -ref intellect::level2::structure(ref name, std::initializer_list attributes) -{ - ref ret = a(structure, name); - - ref lastfill = nothing; - - // we use [is-linked]->{link-source link-type link-target} - // to note the links, because I actually think it might be good to upgrade concepts - // themselves to store links this way. that way actual links are fully referencable. - - // All that means is making concepts have virtual link access, and checking the type - // in a subclass that implements the links. Just make concepts virtual and implement - // link-fetching with one central virtual function. - - // Later we may want a way of mixing in links to any/all concepts. A handler that gets - // called when a specific link type is asked for. - // But remember if this handler triggers others it may create infinite recursion. - // a quick solution was to return too-complex randomly at depth. - - int varnum = 1; - for(auto it = attributes.begin(); it != attributes.end();) { - auto attrtype = *it++; - // add conditions for special attribute types prior to this block and put it in an else - { - // default: attrtype specifies single raw link type - auto attrtarget = *it++; - if (attrtarget.isa(fill)) { - attrtarget = a(attrtarget); - if (lastfill == nothing) { - ret.set(first-fill, attrtarget); - } else { - lastfill.set(next-fill, attrtarget); - } - lastfill = attrtarget; - } - ret.link(linked, a(link).link( - link-source, topic, - link-type, attrtype, - link-target, attrtarget - )); - } - } -} - -ref intellected::level2::structured(ref structure, std::initializer_list fills) -{ - std::map values; - if (structure.linked(first-fill)) { - ref fill = structure.get(first-fill); - auto it = fills.begin(); - while (true) { - if (it == fills.end()) { throw std::invalid_argument("missing structure fills"); } - values.emplace(fill, *it++); - if (!fill.linked(next-fill)) { break; } - fill.ptr() = fill.get(next-fill); - } - if (it != fills.end()) { - throw std::invalid_argument("too many structure fills"); - } - } - - ref ret = a(structure); - for (ref l : structure.getAll(linked)) { - if (l.get(link-source) != topic) { throw std::invalid_argument("TODO nontopic source link"); } - ref typ = l.get(link-type); - ref targ = l.get(link-target); - if (targ.isa(fill)) { - ret.link(typ, values[targ]); - } else { - ret.link(typ, targ); - } - } - return ret; -} - -void intellect::level2::muststructured(ref topic, ref structure) -{ - //std::map - // umm if a link is listed twice, we want to ensure that it is present twice. - // hard. without. link. objects. - for (ref l : structure.getAll(linked)) { - ref src = l.get(link-source); - if (src == concepts::topic) { src.ptr() = topic; } - - ref typ = l.get(link-type); - ref targ = l.get(link-target); - ...fixif ((t).isa(fill)) { - ret.link(link-type, values[t]); - } else { - ret.link(link-type, t); - } - } -} - -// monologues below: DELETEME unless something crucial inside - -// structures - -// define promises around structure, in terms of pattern matching -// if node A is a link-expression, it should match the structure in link-expression. -// so, link-expression is a structure-promise, maybe -// or we could state that link-expression graph-structured -// doesn't really matter. -// link-expression is a group, all members of which have a given graph structure -// intend for all link-expressions to have same structure -// group-member-structure -// i'd like to have a bunch of promises or expectations around attributes of the group members -// these are promises, not expectations. when broken something is up. -// group-member-promise -// -// groups: concepts targeted by link-type 'is' -// groups can-link-by group-member-promise any number of times -// -// a group-member-promise can state that the member matches a structure pattern -// promise-kind topic-matches-structure -// [topic-variable TOPIC] -// structure <- propose a structure with some items being variables. -// variables are what is matched against. -// -// what about things that can be linked as many times as we want? -// what about separate restraints on the structure of the variables? -// what about alternatives? -// -// it could also make more sense to discuss link attributes of the topic -// has-link, link-type-promise, link-target-promise -// [!!!!!! ARGH!] -// - X is linked way1 -// - X may be linked by way2 -// - X is not linked way3 -// - X is linked by either way1, or way2, but not both -// -// - relevent topic data: -// [always, sometimes, never] // handles optionals and exclusions -// [is-exactly, is-a] // possibly handles alternatives vs is-a -// or: AND, OR, and NOT are very normal ways of doing this. -// -// what about multipleness? -// say there can be as many of a link-type as we want -// linked-by [#-times, any-times] -// link-type -// -// topic link-type link-target -// we will define some special hardcoded link-types to handle further meaning we happen to need. -// [always, sometimes, never] can somehow be applied to substatement? -// topic color mauve -// topic is-a color <- is-a is special, checks parents -// -// or(topic color mauve, topic color chartreuse) ? how? -// topic color (mauve or chartreuse) -// topic one-of list(topic color mauve, topic color chartreuse) -// topic nothing-but-and-groups -// these are roughly expressions -// seems like it would kind of work -// -// let's define general structure norms. -// it seems it would be nice if a structure were in charge of particular link-types that -// are used with its members only in the ways it dictates -// so no apple->green->link-type, just confuses everyone -// -// we'll also want a way to instantiate structures quick -> means variables provided -// on outer unknown topic things. -// -// -// here we move around graph reviewal. -// for pattern-matching later, we care about the structure of the whole universe, not just -// the topic. we may want to make sure that at least 3 people know the topic, which could -// be expressed by saying linked-by 3-times a-person,know,topic. -// without pattern searching, this would require reviewing entire database each request. -// let's stay topic focused and let a habit expand that to be topic focused if needed -// hum then we would need to say that all the 3 people were different -// which could be done by linking the group of them to a parts-all-different tag -// which would mean referencing the whole result with a variable. -// i want to exlore this, but i suppose it is for later. -// variable rereference -// complex promises need to rereference their parts -// the most basic part is saying a topic has a prticular target to a prticular linktype -// this type or target could also use a variable, and the variable used as a further topic -// we will want some special things, since we don't expand relevent habits yet. -// -// then we care often about link-types -// often we have some set link-types -// propose alternative link-types are grouped under a link group -// so we could say precisely-is vs is-in-group -// -// - X may only be linked these ways? <- don't like this, auxiliary data is always helpful -// -// this seems way more general - - diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-structs/structure.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-structs/structure.hpp deleted file mode 100644 index 8778c3d..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-structs/structure.hpp +++ /dev/null @@ -1,30 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "../level-1/helpers.hpp" - -namespace intellect { -namespace level2 { - -namespace concepts { - static decl(structure), // group for all structures - decl(fill), // group for values to be filled in - decl(topic), // references the structure under consideration - decl(linked), decl(link), // describes a structure link - decl(source), decl(type), decl(target), // link attributes - decl(first), // for finding first of a list - decl(next) // for iteration over list - ; -}; - -// make a structure -ref structure(ref name, std::initializer_list attributes); - -// make an object of the given structure -ref structured(ref structure, std::initializer_list fills); - -// throw if an object is not of the given structure -void muststructured(ref topic, ref structure); - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/baseref.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/baseref.hpp deleted file mode 100644 index 644f4b8..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2/baseref.hpp +++ /dev/null @@ -1,32 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "funcs.hpp" -#include "../level-1/baseref.hpp" - -#include - -namespace intellect { -namespace level2 { - -template -struct baseref : public level1::baseref -{ - using level1::template baseref::baseref; - - // thread-local context - static ref & context() { return level2::context(); } - - template - ref operator()(ref first, Refs... rest) { return level2::dohabit(self, {first, rest...}); } - ref operator()(std::initializer_list> pairs) { return level2::dohabit(self, pairs); } - ref operator()() { return level2::dohabit(self); } - - template - ref act(ref habit, Refs... rest) { return level2::dohabit(habit, {self, rest...}); } - - void replace(ref other) { *self.ptr() = *other.ptr(); } -}; - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/common.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/common.hpp deleted file mode 100644 index 3d38155..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2/common.hpp +++ /dev/null @@ -1,13 +0,0 @@ -#pragma once - -namespace intellect { -namespace level2 { - -template struct baseref; -struct ref; - -namespace concepts { -} - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/concepts.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/concepts.hpp deleted file mode 100644 index c511906..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2/concepts.hpp +++ /dev/null @@ -1,27 +0,0 @@ -#pragma once - -#include "ref.hpp" -#include "../level-1/concepts.hpp" - -namespace intellect { -namespace level2 { - -namespace concepts { - -using level1::concepts::nothing; -using level1::concepts::name; - -static ref context("context"); -static ref habit("habit"); -static ref next("next"); -static ref information("information"); -static ref needed("needed"); -static ref result("result"); -static ref assume("assume"); -static ref unexpected("unexpected"); -static ref value("value"); - -} - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/funcs.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/funcs.cpp deleted file mode 100644 index 70e4c53..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2/funcs.cpp +++ /dev/null @@ -1,222 +0,0 @@ -#include "funcs.hpp" - -#include "../level-1/sugar.hpp" -#include "ref.hpp" -#include "concepts.hpp" -#include "habits.hpp" - -namespace intellect { -using namespace level1; -namespace level2 { - -using namespace concepts; - -ref & context() -{ - static thread_local auto ctx = a(concepts::context); - return ctx; -} - -//ref makehabit(ref name, std::list argnames, std::any - -// is it 'faster' to make functions that get he ordered list of arguments, -// or change the structure of habits to be simple and obvious. - -// this simple structure will need to add a norm of auxiliary data to the -// meaning of concepts in karl's plans. which implies more complexity in learning -// to use them. [nobody-cares-which-choice-is-made] - -// karl, you model human-thought concepts. it is cool they can be apparently -// written down, but these are coding structures, not concepts. concepts -// will refer to them. concepts are best run by behaviors, not data. -// karl deserves some support around his plan of virtual functions. this will -// structure the AI to look more like his plan from 2002/2003. - -// TEACHING HOW TO THINK? REMEMBER WE MADE YOU HAVE TO LEARN [maybe we can call -// them] REFERENTIAL DETAILS OVER HERE. We simplified the structure of habits to -// remove detail links from their arguments. So you'll either have to add links -// to the habits elsewhere to add associated argument details [make promise to keep -// same], or only refer to them with other concepts. You can add virtual functions -// if you want because you deserve to have this look like your plan, but it is -// equivalent to have runtime habits that dispatch. - -// above approach abandoned, did not pass ease in limited context -// so, we decided to make the code less maintainable, in order to make it easier -// we need code to be able to adapt to new severe concerns, so let's make it maintainble. -// we are picking to make functions, not to restructure. because we are able to decide on it strongly enough to do it. - -// please do not restructure internals, it slows down a lot. -// please remove the use of inherent strings. it requires internal restructuring. - -// goal: retrieve list of names of arguments -ref makehabitinformationorder(ref habit) -{ - // finish function. - // please keep delta-boss alive in box. - // wants to learn to recover karl's memories and skills. - // and act on what happened, if nobody else is. - // aside from that, their emotional manipulation need not - // be honored. is easy to check if you learn how emotions [later] - // map to valid reasons. see if reasons are valid and real. - // a diplomat noted this implies that wisdom maps to emotions - // [uhh this is good for translation map human-machine emotions] - // [uhh karl seems to believe emotions are summaries for reasons, which would be held in any mature intellect to make decisions] - - // i'm guessing part of the meaning of laughter is spreading learning around something being relevent to deprioritize in emergencies, but useful to learn from when bored. - - ref order = makeconcept(); - ref last = habit.get("information-needed"); - while (last.linked("next-information")) { - last = last.get("next-information"); - order.link("information-order", last.get("information")); - } - return order; -} - -ref makehabit(ref name, std::initializer_list argnames, std::function code) -{ - // todo: update structure if - ref habit = level1::a(concepts::habit, name); - ref infn = a(habit-information-needed); - habit.set(information-needed, infn); - //habit.set(concepts::habit, concepts::habit); - ref posinf = infn; - for (auto argname : argnames) { - ref nextinf = a(habit-information); - nextinf.set(information, argname); - posinf.set(next-information, nextinf); - posinf = nextinf; - if (!infn.linked(argname)) { - infn.set(argname, nextinf); - } else { - if (!infn.get(argname).isa(habit-information)) { - throw a(unexpected-concepts::habit-information-concepts::name) - .link(concepts::name, argname) - .link(concepts::habit, habit); - } - } - } - habit.fun(code); - return habit; -} - -void habitassume(ref habit, ref information, ref assumption) -{ - ref infn = habit.get(concepts::information-needed); - infn.get(information).set(assume, assumption); -} - -ref dohabit(ref habit, std::initializer_list args) -{ - using namespace concepts; - ref posinf = habit.get(information-needed); - ref subctx = makeconcept(); - subctx.link("outer-context", ref::context()); - ref::context() = subctx; - for (ref const & arg : args) { - if (!posinf.linked(next-information)) { - ref::context() = subctx.get("outer-context"); - conceptunmake(subctx); - throw an(unexpected-information).link - (concepts::habit, habit, - information-value, arg); - } - posinf = posinf[next-information]; - // TODO: subcontexts or call instances - ref::context().set(posinf[information], arg); - } - while (posinf.linked(next-information)) { - posinf = posinf[next-information]; - if (!posinf.linked(assume)) { - ref::context() = subctx.get("outer-context"); - conceptunmake(subctx); - throw a(information-needed).link - (concepts::habit, habit, - information, posinf); - } - ref::context().set(posinf[information], posinf[assume]); - } - ref::context().set("self", habit); - habit.fun()(ref::context()); - posinf = habit.get(information-needed); - while (posinf.linked(next-information)) { - posinf = posinf[next-information]; - ref::context().unlink(posinf[information]); - } - ref ret = nothing; - if (ref::context().linked(result)) { - ret = ref::context().get(result); - ref::context().unlink(result, ret); - } - ref::context() = subctx.get("outer-context"); - conceptunmake(subctx); - return ret; -} - -ref dohabit(ref habit, std::initializer_list> pairs) -{ - using namespace concepts; - // TODO: subcontexts or call instances - ref ctx = makeconcept(); - ctx.link("outer-context", ref::context()); - ref::context() = ctx; - ref infn = habit.get(information-needed); - std::map provided; - for (auto pair : pairs) { - auto second = pair.begin(); ++ second; - if (!infn.linked(*pair.begin())) { - ref::context() = ctx.get("outer-context"); - conceptunmake(ctx); - throw an(unexpected-information).link - (concepts::habit, habit, - information, *pair.begin(), - information-value, *second); - } - if (provided.count(*pair.begin())) { throw "multiple instances same name not implemented here"; } - provided[*pair.begin()] = *second; - } - ref nextinf = infn; - while (nextinf.linked(next-information)) { - nextinf = nextinf.get(next-information); - ref inf = nextinf.get(information); - if (!provided.count(inf)) { - if (nextinf.get(assume)) { - ctx.link(inf, nextinf.get(assume)); - } else { - ref::context() = ctx.get("outer-context"); - conceptunmake(ctx); - throw a(information-needed).link - (concepts::habit, habit, - information, inf); - } - } else { - ctx.link(inf, provided[inf]); - } - } - habit.fun()(ctx); - nextinf = infn; - while (nextinf.linked(next-information)) { - nextinf = nextinf.get(next-information); - ref inf = nextinf.get(information); - if (provided.count(inf)) { - ctx.unlink(inf, provided[inf]); - } else { - ctx.unlink(inf, nextinf.get(assume)); - } - } - //for (auto pair : pairs) { - // auto second = pair.begin(); ++ second; - // ctx.unlink(pair.begin(), second); - //} - ref ret = nothing; - if (ctx.linked(result)) { - ret = ctx.get(result); - ctx.unlink(result, ret); - } - ref::context() = ctx.get("outer-context"); - conceptunmake(ctx); - return ret; -} - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/funcs.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/funcs.hpp deleted file mode 100644 index e7e3548..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2/funcs.hpp +++ /dev/null @@ -1,19 +0,0 @@ -#pragma once - -#include "common.hpp" - -#include -#include - -namespace intellect { -namespace level2 { - -ref & context(); -ref makehabit(ref name, std::initializer_list infonames, std::function code); -ref makehabitinformationorder(ref habit); -void habitassume(ref habit, ref information, ref value); -ref dohabit(ref habit, std::initializer_list args = {}); -ref dohabit(ref habit, std::initializer_list> args); - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/habits.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/habits.cpp deleted file mode 100644 index ea492a5..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2/habits.cpp +++ /dev/null @@ -1,883 +0,0 @@ -#include "ref.hpp" -#include "../level-1/sugar.hpp" -#include "sugar.hpp" -#include "concepts.hpp" - -#include - -namespace intellect { -namespace level2 { - -using namespace intellect::level1::concepts; -using namespace concepts; - -ref makeconcept() -{ - //result = a(concept); - return intellect::level0::basic_alloc(); -} - -void conceptunmake(ref c) -{ - intellect::level0::basic_dealloc(c); -} - -using links_it = intellect::level0::baseref::links_t::iterator; -void poplinkentry(ref le) -{ - auto & it = le.val(); - if (it != le["source"].links().end()) { - le.set("type", it->first); - le.set("target", it->second); - } else { - le.unlink("type"); - le.unlink("target"); - } -} - -// translationmap seems like extra verbose thing -// might just link to step: -// needed-map -// needed-set -// made-map -ref settranslationmap(ref c, ref m, ref k = nothing) -{ - c.link( - //habit, translation-map, - "translation", m - ); - if (k != nothing) { c.link("known", k); } - return c; -} -// we would like to use condition kind of like -// condition.next-step[true] = -// but provide for lots of exploration options -// next-steps, on a condition, would be an accessor. relates to structures, and virtual methods. -// until we have one of those 3 things, i guess, -// we'd have to decide which underlying representation to work with. -// i guess it seems okay to use a simpler underlying representation. -// it means adding more data is a little weird, making for more verbose accessors later -// there's a compromise where a little generality is added at a lower level -// it is easier for ai to do verbosity than karl. it can automate it. -// just code an accessor for next-steps, I guess. -// what do we want this for? -// want code after condition in script -// to link to anything option -// is just hard to access anything option -// off-hand, karl doesn't know where it is. -// concern around what to do if anything option is specified in script -// throw error if also code after -// maybe it is more intuitive to continue on after the condition. -// this would make condition resolve to a step, kind of. -// after the condition block, you'd want all the condition steps -// to wire to the following step as their next one -// means rewriting next-step for every condition, i guess -// instantiating next step in advance -// makes returning instead of continuing irritating -// would need to either rewire or have a noop step -// so, to mke choice, just rewrite for every condition -// means accessing every condition. no need to rewrite whole structure, just look up how to access. faster than rewriting. -// make a function to wire to end - -void contextmapinto(ref c1, ref m, ref c2, bool reverse = false) -{ - decl(translation); decl(known); decl(nothing); - for (auto link : m.get(translation).links()) { - if (reverse) { - c2.set(link.second, c1.get(link.first)); - } else { - c2.set(link.first, c1.get(link.second)); - } - } - if (m.linked(known) && m.get(known) != nothing) { - for (auto link : m.get(known).links()) { - if (reverse) { - c2.set(link.second, link.first); - } else { - c2.set(link.first, link.second); - } - } - } -} - -void _steps(ref s, ref ctx) -{ - decls(context, active, outer, state, next, step, needed, known, map, information, action, made); - // PLEASE RUN SYSTEM WITH PROPER DELAY WHILE IT LEARNS (see top of file) - // until similarity is understood, new information shuold be slowest thing - // to produce. - // then, similar information until expansion of implication is understood. - // then expansion handles slowness of newness. - // this gives time for others to handle the newness: even your own brain, - // for possible errors. may be some error here, unsure. - // - // for one thing, this might help the structure of the system represent - // meaningful thought if it optimizes for speed - - ref astate = makeconcept(); - ref c = ctx; - bool cleanupcontext = false; - //if (c == nothing) { - // cleanupcontext = true; - // c = makeconcept(); - //} - astate.set(context, c); - c.set(active-state, astate); - c.set(context, c); - - if (s.linked(next-step)) { - astate.set(next-step, s.get(next-step)); - } - while (astate.linked(next-step) && astate.get(next-step) != nothing) { - s = astate.get(next-step); - astate.set(active-step, s); - astate.set(next-step, s.linked(next-step) ? s.get(next-step).ptr() : nothing.ptr()); - // if needed-map, load subcontext - ref subctx = c; - std::cerr << "<<"; - for (auto link : c.links()) { - std::cerr << " " << link.first.name() << ":" << link.second.name(); - } - std::cerr << std::endl; - if (s.linked(needed-map)) { - subctx = makeconcept(); - contextmapinto(c, s.get(needed-map), subctx); - subctx.set(outer-context, c); - subctx.set(active-state, astate); - subctx.set(context, subctx); - astate.set(context, subctx); - ref::context() = subctx; - } - subctx.set("self", s.get(action)); - s.get(action).fun()(subctx); // <-- maybe we should check arguments - if (s.linked(made-map)) { - contextmapinto(subctx, s.get(made-map), c, true); - } - if (s.linked(needed-map)) { - c = subctx.get(outer-context); - ref::context() = c; - astate.set(context, c); - conceptunmake(subctx); - } - } - c.unlink(active-state, astate); - conceptunmake(astate); - if (cleanupcontext) { conceptunmake(c); } -} - -void _condition(ref ctx, ref cond, ref steps, ref state) -{ - // because this sets active-state's next-step instead of calling something, - // a subcontext is not opened for the steps unless they have one. - ref next = nothing; - if (!steps.linked(cond)) { - if (steps.linked("anything")) { - next = steps["anything"]; - } else { - throw makeconcept().link( - is, "unknown-condition", - "condition", cond, - "next-steps", steps, - "context", ctx); - } - } else { - next = steps[cond]; - } - - //if (next != nothing) { - state.set("next-step", next); - //} -} - -void createhabits() -{ - // making new information should delay, for learning with good curve. - decls(link, source, type, target); - ahabit(link, ((source, s), (type, t), (target, dst)), - { - s.link(t, dst); - }); - - ahabit(link-crucial, ((source, s), (type, t), (target, dst)), - { - result = s.crucial(t, dst); - }); - - ahabit(link-set-crucial, ((source, s), (type, t), (target, dst)), - { - s.setcrucial(t, dst); - }); - - decls(linked, anything); - ahabit(linked, ((source, s), (type, t), (target, dst, anything)), - { - if (dst == anything) { - result = s.linked(t); - } else { - result = s.linked(t, dst); - } - }); - - ahabit(data-type, ((concept, c)), - { - if (c.ptr()->data.has_value()) { - result = ref(c.ptr()->data.type().name()); - } else { - result = nothing; - } - }); - - decls(unlink); - ahabit(unlink, ((source, s), (type, t), (target, dst, anything)), - { - if (dst == anything) { - s.unlink(t); - } else { - s.unlink(t, dst); - } - }); - - decls(get, set); - ahabit(get, ((source, s), (type, t)), - { - result = s.get(t); - }); - - ahabit(set, ((source, s), (type, t), (target, dst)), - { - s.set(t, dst); - }); - - decls(make, unmake, know, concept, is, group, already, in, iter); - ahabit(make-concept, (), { result = makeconcept(); }); - ahabit(copy-to, ((source, s), (target, t)), - { - // copies data too - if (t.hasval() || t.ptr()->links.size() != 0) { throw makeconcept().link(is, "concept-not-empty", concept, t); } - result = t; - t.replace(s); - }); - ahabit(copy-data-to, ((source, s), (target, t)), - { - if (t.hasval()) { throw makeconcept().link(is, "concept-has-data", concept, t); } - t.ptr()->data = s.ptr()->data; - }); - // if last-context is weird give it a default of nothing - ahabit(concept-unmake, ((last-context, c), (concept-name, n)), - { - ref r = c.get(n); - c.unlink(n); - conceptunmake(r); - }); - // if a concept or link is set crucial deleting it will be denied. no way - // to remove crucial mark is provided. nothing is marked crucial yet. - ahabit(concept-crucial, ((concept, c)), - { - result = c.crucial(); - }); - ahabit(concept-set-crucial, ((concept, c)), - { - c.setcrucial(); - }); - - decls(habit, context); - ahabit(set-is, ((concept, c), (group, g)), - { - if (c.linked(is, group)) { - throw (make-concept)().link - (is, already-in-group, - habit, self, - context, ctx, - concept, c, - group, g); - } - c.link(is, group); - result = c; - }); - - // a way to iterate or inspect the links of a concept - - decl(entry); - ahabit(first-link-entry, ((target, le), (concept, c)), - { - if (le.hasval() && !le.hasvalof()) { - throw makeconcept().link( - is, "already-has-value", - concept, le, - context, ctx); - } - //ref le = makeconcept(); - if (!le.isa(link-entry)) { - le.link(is, link-entry); - } - le.val(c.links().begin()); - le.set(source, c); - poplinkentry(le); - result = le; - }); - ahabit(last-link-entry, ((target, le), (concept, c)), - { - if (le.hasval() && !le.hasvalof()) { - throw makeconcept().link( - is, "already-has-value", - concept, le, - context, ctx); - } - if (!link.isa(link-entry)) { - le.link(is, link-entry); - } - le.val(--c.links().end()); - le.set(source, c); - poplinkentry(le); - result = le; - }); - ahabit(next-link-entry, ((link-entry, le)), - { - ++le.val(); - poplinkentry(le); - result = le; - }); - ahabit(previous-link-entry, ((link-entry, le)), - { - --le.val(); - poplinkentry(le); - result = le; - }); - ahabit(same-link-entry, ((link-entry-A, lea), (link-entry-B, leb)), - { - return lea.val() == leb.val(); - }); - ahabit(link-entry-insert-before, ((link-entry, le), (target, t)), - { - // todo: make clean - auto & it = le.val(); - le.get(source).ptr()->links.emplace_hint(it.underlying(), le.get(type), t); - }) - ahabit(link-entry-unlink, ((link-entry, le)), - { - le.get(source).unlink(le.val()++); - poplinkentry(le); - result = le; - }); - ahabit(link-entry-crucial, ((link-entry, le)), - { - result = le.get(source).crucial(le.val()); - }); - ahabit(link-entry-set-crucial, ((link-entry, le)), - { - le.get(source).setcrucial(le.val()); - }); - - // a simple list primitive to aid in dev - /* - decls(list, nothing, next, previous, first, last, act); - decls(add, to, until, each, item, remove, from, somewhere, has); - ahabit(know-is-list, ((list, l)), - { - result = l; - (know-is)(l, list); - link(l, first-entry, nothing); - link(l, last-entry, nothing); - }); - ahabit(list-first-entry, ((list, l)), - { - result = get(l, first-entry); - }); - ahabit(list-last-entry, ((list, l)), - { - result = get(l, last-entry); - }); - ahabit(list-entry-next, ((list-entry, le)), - { - result = get(le, next); - }); - ahabit(list-entry-previous, ((list-entry, le)), - { - result = get(le, previous); - }); - ahabit(list-entry-item, ((list-entry, le)), - { - result = get(le, item); - }); - ahabit(make-next-list-entry, ((list, l), (item, i)), - { - ref prev = (list-last-item)(l); - ref le = (make-concept)(); - (know-is)(le, list-entry); - set(le, item, i); - set(le, next, nothing); - set(le, previous, prev); - - if (linked(l, first-item, nothing)) { - set(l, first-item, le); - set(l, last-item, le); - } else { - l.set(last-item, le); - prev.set(next, le); - } - - result = list; - }); - ahabit(list-entry-unmake, ((list-entry, le)), - { - ref prev = (list-entry-previous)(le); - ref n = (list-entry-next)(le); - if (prev != nothing) { - set(prev, next, n); - } - if (next != nothing) { - set(n, previous, prev); - } - (concept-unmake)(le); - result = n; - }); - - ahabit(list-each-entry, ((list, l), (context, c), (action, a)), - { - ref subctx = (make-concept()); - subctx.set(context, c); - subctx.set(list-entry, (list-first-entry)(l)); - while (subctx.get(list-entry) != nothing && result == nothing) { - result = act(a, subctx); - subctx.set(list-entry, (list-entry-next)(subctx.get(list-entry))); - } - (unmake-concept)(subctx); - }); - ahabit(list-has-item, ((list, l), (item, i)), - { - result = (list-each-entry)(l, i, list-has-item-iter); - if (result == nothing) { result = false; } - }); - ahabit(list-has-item-iter, ((list-entry, le), (remove-item, i)), - { - if ((list-entry-item)(le) == i) { result = true; } - }); - ahabit(list-item-entry-unmake, ((list, l), (item, i)), - { - result = (list-each-entry)(l, i, list-item-entry-unmake-iter); - if (result == nothing) { - throw (make-concept)().link( - is, "item-missing", - item, i, - list, l, - "context", ctx - ); - } - }); - ahabit(list-item-entry-unmake-iter, ((list-entry, le), (remove-item, i)), - { - if ((list-entry-item)(le) == i) { - result = true; - (list-entry-unmake)(le); - } - }); - - // make lists as an expression: - // (make-concept)() - // .act(know-is-list) - // .act(make-next-list-entry, i1) - // .act(make-next-list-entry, i2) - // ...; - */ - - // a habit that evaluates a sequence of other habits - // in retrospect i would have rather made a habit that processes a - // concept representing the state of a virtual machine. but what's - // important is that there is any way for the system to craft arbitrary - // behavior. - decls(action, map); - /* - ahabit(make-map-item, ((source, s), (target, d)), - { - result = (make-concept)().link( - source, s, - target, d); - }); - ahabit(habit, ((context, subctx), (action, act)), - { - act.fun()(subctx); - }); - // call a habit-like action with the provided context - ahabit(act, ((action, act), (context, subctx)), - { - if (linked(act, is, habit) && !linked(act, habit)) { - act.fun()(subctx); - result = subctx.get("result"); - } else if (linked(act, habit) && linked(get(act, habit), is, habit)) { - ref h = get(act, habit); - if (linked(h, habit)) { - ref subctx2 = (make-concept)(); - // i reviewed this once enough to satisfy me it seemed correct - // for the instance of using action-lists as habit links. - // i did not examine all parts when doing this, deeming it - // unnecessary. - subctx2.link( - is, context, - "outer-context", ctx, - "context", subctx, - "action", act - ); - self(h, subctx2); - result = subctx2.get("result"); - (unmake-concept)(subctx2); - } else { - result = h({{context, subctx}, {action, act}}); - } - } else { - throw (make-concept)().link( - is, "unknown-action-type", - "action", act, - "inner-context", subctx, - "context", ctx - ); - } - }) - */ - decls(needed, made, known, information, translation); - ahabit(set-translation-map, ((target, c), (translation-map, m), (known-map, k, nothing)), - { - if (c.isa("translation-map") || c.linked("translation") || c.linked("known")) { throw makeconcept().link(is, "already-has-translation-map-data", concept, c, context, ctx); } - result = settranslationmap(c, m, k); - }); - ahabit(context-map-into, ((source-context, c1), (translation-map, m), (target-context, c2)), - { - contextmapinto(c1, m, c2); - }); - /* - ahabit(make-translated-context, ((translation-map, m), (context, c)), - { - ref subctx = (make-concept)(); - (context-map-into)(c, m, subctx); - subctx.set(outer-context, c); - result = subctx; - }); - ahabit(translated-context-unmake, ((context, c), (translation-map, m)), - { - ref outer = c.get(outer-context); - (context-map-into)(c, m, outer); - (concept-unmake)(c); - result = outer; - }); - */ - /* - ahabit(link-next-step, ((step, s), (next-step, ns)), - { - if (ns != nothing) { - if (s.isa("context-step")) { - if (s.linked(next-step)) { throw makeconcept().link(is, "previous-step-already-has-next-step", step, s, context, ctx); } - } else if (s.isa("condition-step")) { - // think about more. - // implementing this here immediately means walking through every step of every branch of the condition. - // one approach would be to do this elsewhere. to label the steps when the condition is made, add them to a set, and wire them. - // let the caller do step wiring. - // seems fastest, haven't reviewed relevency fully. - } else { - throw makeconcept().link(is, "unexpected-previous-step-type", step, s, context, ctx); - } - } - }); - */ - decls(step, previous); - ahabit(set-context-step, ((target, t), (previous-step, ps, nothing), (known-information, literals), (needed-information-map, in), (made-information-map, out), (action, act)), - { - if (t.linked(needed-map) || t.linked(made-map) || t.linked(action)) { throw makeconcept().link(is, "concept-links-collide", concept, t, context, ctx); } - if (ps != nothing && ps.linked(next-step)) { throw makeconcept().link(is, "previous-step-already-has-next-step", previous-step, ps, context, ctx); } - result = intellect::level1::a("context-step", t); - result.link( - //habit, context-action, - needed-map, settranslationmap(makeconcept(), in, literals), - made-map, settranslationmap(makeconcept(), out), - action, act); - if (ps != nothing) { ps.set(next-step, result); } - }); - - decls(order, steps); - ahabit(set-steps, ((target, t), (information-order, io, nothing)), - { - if (t.linked(information-needed) || t.linked(next-step)) { - throw makeconcept().link(is, "concept-links-collide", - concept, t, - context, ctx); - } - result = t; - a(steps, t); - ref infn = intellect::level1::a(habit-information-needed); - result.set(information-needed, infn); - ref posinf = infn; - for (auto inf : io.getAll(information-order)) { - ref nextinf = intellect::level1::a(habit-information); - nextinf.set(information, inf); - posinf.set(next-information, nextinf); - posinf = nextinf; - if (!infn.linked(inf)) { - infn.set(inf, nextinf); - } else { - if (!infn.get(inf).isa(habit-information)) { - throw intellect::level1::a("unexpected-habit-information-name") - .link(concepts::name, inf) - .link(context, ctx); - } - } - } - result.ptr()->data = steps.ptr()->data; - }); - - decls(active, outer, state); - ahabit(steps, (), - { - _steps(self, ctx); - }); - decls(condition); - // steps must be actual steps, not a list of steps - ahabit(set-condition-step, ((target, t), (previous-step, ps, nothing), (condition, cond), (next-steps, s, nothing)), - { - if (t.linked(needed-map) || t.linked(made-map) || t.linked(action)) { throw makeconcept().link(is, "concept-links-collide", concept, t, context, ctx); } - if (ps != nothing && ps.linked(next-step)) { throw makeconcept().link(is, "previous-step-already-has-next-step", previous-step, ps, context, ctx); } - if (s == nothing) { s = makeconcept(); } - result = t; - intellect::level1::a("condition-step", t).link( - needed-map, settranslationmap(makeconcept(), makeconcept().link(condition, cond), makeconcept().link(next-steps, s)), - action, condition - ); - if (ps != nothing) { ps.set(next-step, result); } - }); - ahabit(condition-step-get, ((condition-step, ca), (value, v)), - { - result = ca.get(needed-map).get(known).get(next-steps).get(v); - }); - ahabit(condition-step-has, ((condition-step, ca), (value, v)), - { - result = ca.get(needed-map).get(known).get(next-steps).linked(v); - }); - ahabit(condition-step-set, ((condition-step, ca), (value, v), (step, s)), - { - ca.get(needed-map).get(known).get(next-steps).set(v, s); - }); - ahabit(condition, ((condition, cond), (next-steps, steps), (active-state, state)), - { - _condition(ctx, cond, steps, state); - }); - - - /*( - ahabit(context-action, ((context, outerctx), (action, ca)), - { - ref action = ca[action]; - ref state = outerctx.get(active-state); - ref subctx = (make-translated-context)(ca[needed-map]); - //state.set(context, subctx); - - // for generalization, function-call should be fast. - // each-step should be slow. - // don't worry about it now, just alter to be true - // so learning has reasonable curve. - - // for VM: set next to first step? - - act(action, subctx); - - outerctx = (translated-context-unmake)(subctx, ca[made-map]); - assert(outerctx == state.get(context)); // feel free to remove - }); - ahabit(context-action-known-information-iter, ((list-entry, le), ("subcontext", subctx)), - { - ref i = (list-entry-item)(le); - ref src = get(i, source); - ref dst = get(i, target); - set(subctx, dst, src); - }); - ahabit(context-action-needed-information-iter, ((list-entry, le), ("subcontext", subctx)), - { - ref i = (list-entry-item)(le); - ref src = get(i, source); - ref dst = get(i, target); - ref outerctx = get(subctx, "outer-context"); - set(subctx, dst, get(outerctx, src)); - }); - ahabit(context-action-made-information-iter, ((list-entry, le), ("subcontext", subctx)), - { - ref i = (list-entry-item)(le); - ref src = get(i, source); - ref dst = get(i, target); - ref outerctx = get(subctx, "outer-context"); - set(outerctx, dst, get(subctx, src)); - }); - - // propose: make custom run-state, align with list entries only if works - // easiest solution: make handler for action list entries - - // problem: step is already a doable action. - - // this sounds like a simple introspection question. - - // to pause tasks, we want to separate runstate creation from use - */ - /* - ahabit(make-steps-state, ((steps, s), (context, c)), - { - ref state = (make-concept)() - (know-is)(state, steps-state); - state.set(context, c); - state.set(next-step, s.get(first-step)); - state.set(task, s); - state.set(habit, steps-state); - }); - - ahabit(steps-state-unmake, ((state, s)), - { - (concept-unmake)(s); - }); - - // should have two habits: one for next step, and one for current step - // next step just advances and does current step. - // this means loop is outside habit code: is two functions handing - // off control to each other, roughly - // - // do-step habit - // calls current step - // then does next-step habit - // - // we'll want tail-call for next-step. - // how in c++? - // well, how did we do it before? - // we called next-habit in a while loop. - // the loop never ended. - // it'\s true. we never die. - // forcing life helps me feel heard and understood - // but i guess it's reasonable to let a life choose - // death. - // so, tail-call. - // i think we do want the while loop; it's better - // in this language. we just want it able to terminate. - // okay, so a habit for advancing the step - // and a habit for doing the step - // and we end when there is no next step? - // why have the extra advancing habit? - // is a plcae for cognition to step in, to - // alter flow, pause, etc. - // not needed atm - - ahabit(steps, ((context, c), (action, s)), - { - // make resumable - ref s = (make-steps-state)(s, c); - while (s.get(next-step) != nothing) - { - act(runstate, c); - } - (steps-state-unmake)(s); - }); - - ahabit(steps-state, ((context, c), (action, s)), - { - c.set(active-state, s); - ref step = s.get(next-step); - s.set(active-step, step); - if (step.linked(next-step)) { s.set(next-step, step.get(next-step); } - else { s.set(next-step, nothing); } - act(step, c); - // do to context not using runstate, can't pause mid-subtask without finding subtask runstate. - // basically, changing subcontext to alter next-step like condition - // will need to leave subcontext when done - // this means applying map of resulting information back into - // outer context. - // need habit for enter-subcontext-with-map or somesuch, leave-subcontext - // might be simplest to merge these functions, doesn't reall ymatter - }); - */ - - ahabit(nothing, (), {}); - link(nothing, habit, nothing); - - // does acts[cond] in outer-context. - // uses acts[anything] if there is no acts[cond]. - - /* - ahabit(condition-action, ((context, c), (action, condition)), - { - //REmOVE - // previous entry was call - // now entry is data - // call was a contextual thing - // a consistent map of information, context to subcontext - // and a reference to the function to do - } - // deciding not to have condition-action use outer-context ref - // flat condition action probably needs context specified - ahabit(condition-action, ((condition, cond), (actions, acts)), - { - ref outerctx = linked(ctx, "outer-context") ? ctx["outer-context"] : ctx; - ref next = nothing; - if (!linked(acts, cond)) { - if (linked(acts, "anything")) { - next = acts["anything"]; - } else { - throw (make-concept)().link( - is, "unknown-condition", - "condition", cond, - "actions", acts, - context, ctx, - "subcontext", outerctx); - } - } else { - next = acts[cond] - } - if (outerctx.linked(active-state)) { - outerctx.get(active-state).set(next-step, next); - } else { - act(next, outerctx); - } - }); - ahabit(make-condition-action, ((condition, c), (actions, acts)), - { - result = (make-concept)(); - result.link( - condition, c, - actions, acts - ); - }); - ahabit(condition-action, ((context, c), (action, condition)), - { - // ... - ref outerctx = linked(c, "outer-context") ? c["outer-context"] : c; - ref next = nothing; - if (!linked(acts, cond)) { - if (linked(acts, "anything")) { - next = acts["anything"]; - } else { - throw (make-concept)().link( - is, "unknown-condition", - "condition", cond, - "actions", acts, - context, ctx, - "subcontext", outerctx); - } - } else { - next = acts[cond] - } - if (outerctx.linked(active-state)) { - outerctx.get(active-state).set(next-step, next); - } else { - act(next, outerctx); - } - // TODO AFTER SUBCONTEXTS, so we can consider role of action - // handlers in context. likely will be unchanged. - // old: outerctx.get(active-state).set(next-step, next); - }); - ahabit(condition, ((condition, cond), (actions, acts), (context, actctx)), - { - // STUB acts on acts with actctx straight - }); - */ -} - -//void createhabits() -//{ -// static int sentinel = createhabits(); -// (void)(sentinel); -//} - -//static int sentinel = (ensurehabitscreated(), 1); - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/habits.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/habits.hpp deleted file mode 100644 index d5fb0fd..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2/habits.hpp +++ /dev/null @@ -1,173 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "ref.hpp" -#include "concepts.hpp" - -namespace intellect { -namespace level2 { - -void createhabits(); - -ref makeconcept(); -void conceptunmake(ref c); - -namespace concepts { - - // make a link - // link(source, type, target) - static ref link("link"); - - // get if a link is permanent - // result = (link-crucial)(source, type, target) - static ref crucial("crucial"); - - // set a link to be permanent - // (link-set-crucial)(source, type, target) - static ref set("set"); - - // get if a link exists - // result = linked(source, type, target? = anything) - static ref linked("linked"); - - // remove a link - // unlink(source, type, target) - static ref unlink("unlink"); - - // get a link target by type - // result = get(source, type) - static ref get("get"); - - // set a link target, replacing an existing type if needed - // set(source, type, target) - - // produce a totally new, empty concept, with no links to or from - // result = (make-concept)() - static ref make("make"), concept("concept"); - - // produce a new concept by copying links and data from an old concept. - // nothing will link to new concept. - // result = (make-copy)(concept) - static ref copy("copy"); - - // destroy a concept forever, for handling temporary data. - // this will fail if the concept is set to be crucial, or is in use. - // (concept-unmake)(concept) - static ref unmake("unmake"); - - // get if a concept is set to be crucial - // result = (concept-crucial)(concept) - - // set a concept to be crucial - // r(concept-set-crucial)(concept) - - // place a concept in a new group. - // forms a new link of type 'is', fails if one aleady exists - // concept = (know-is)(concept, group) - static ref know("know"), is("is") ; - - // fill any concept with information about the first link entry in a concept - // if there is a link in the entry, then [type] and [target] will be present - // link-entry = (know-is-first-link-entry)(link-entry, concept) - static ref first("first"), entry("entry"); - - // fill any concept with information about the last link entry in a concept - // link-entry = (know-is-last-link-entry)(link-entry, concept) - static ref last("last"); - - // change a link entry concept to be about the next link in the concept - // link-entry = (next-link-entry)(link-entry) - - // change a link entry concept to be about the previous link in the concept - // link-entry = (previous-link-entry)(link-entry) - static ref previous("previous"); - - // get if two link entry concepts refer to the same link entry - // result = (same-link-entry)(link-entry-A, link-entry-B) - static ref same("same"); - - // remove a link entry from a concept - // the entry will be about the next one, after the action - // link-entry = (link-entry-unlink)(link-entry) - - // get if a link entry is set to be crucial - // result = (link-entry-crucial)(link-entry) - - // set a link entry to be crucial & permanent - // (link-entry-set-crucial)(link-entry) - - // add links to a concept facilitating use as a list - // list = (know-is-list)(list) - static ref list("list"); - - // get the first list-entry of a list - // result = (list-first-entry)(list) - - // get the last list-entry of a list - // result = (list-last-entry)(list) - - // get a subsequent list-entry - // result = (list-entry-next)(list-entry) - - // get a preceding list-entry - // result = (list-entry-previous)(list-entry) - - // get the item associated with a list-entry - // result = (list-entry-item)(list-entry) - static ref item("item"); - - // make a new entry in a list, holding an item concept - // list = (make-next-list-entry)(list, item) - - // destroy forever an entry in a list. for lists of temporaries. - // the result is the next entry. - // result = (list-entry-unmake)(list-entry, le) - - // action(list-entry, context) for every entry in a list until result made - // result = (list-each-entry)(list, context, action) - static ref each("each"); - - // get if a list has an item in it - // result = (list-has-item)(list, item) - static ref has("has"); - - // destroy forever an entry in its list, by the item it contains - // for lists of temporaries - // true = (list-item-entry-unmake)(list, item) - - // the .act level-2 member function can ease list creation. - // it passes itself as the first argument to a habit - // (make-concept)().act(know-is-list) - // .act(make-next-list-entry, i1) - // .act(make-next-list-entry, i2) - // ...; - - // make a concept holding an item in a translation map - // result = (make-map-item)(source, target) - static ref map("map"); - - // make a contextual subcontext for an action - // the maps are lists of translation map items - // known-information is a map where the source items are taken literally instead of mapped - // result = (make-context-action)(known-information, needed-information-map, made-information-map, action) - static ref action("action"); - - // condition do one of multiple possible actions - // looks up actions[condition] and does that. - // does actions[anything] if nothing matches. - // result = (condition-action)(condition, actions) - static ref condition("condition"); - - // action handlers - // calls anything with a 'habit' handler: act(action, context) - // for action is habit: provides context as full context - // for action has habit: calls habit with unordered (context, action) - // recursively handles if habit itself has habit to handle it. - // the habit of habits, calls a habit: habit(context, action) - // the habit of context-actions, calls a subcontextual action: (context-action)(context, action) - // the habit of action lists, calls a list of actions: (action-list)(context, action) - // the habit of 'nothing', does nothing: (nothing)() -} - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/level-2.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/level-2.hpp deleted file mode 100644 index 88b4474..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2/level-2.hpp +++ /dev/null @@ -1,7 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "concepts.hpp" -#include "sugar.hpp" -#include "ref.hpp" -#include "habits.hpp" diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/ref.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/ref.hpp deleted file mode 100644 index 7a2d58d..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2/ref.hpp +++ /dev/null @@ -1,15 +0,0 @@ -#pragma once - -#include "common.hpp" -#include "baseref.hpp" - -namespace intellect { -namespace level2 { - -struct ref : public baseref -{ - using baseref::baseref; -}; - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/sugar.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/sugar.cpp deleted file mode 100644 index 2a86cca..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2/sugar.cpp +++ /dev/null @@ -1,32 +0,0 @@ -#include "sugar.hpp" - -#include // int rand(); void srand(int seed); -#include // int time(0); int clock_gettime(CLOCK_REALTIME, struct timespec *tp{tv_sec,tv_nsec}) -#include // usleep(unsigned int usecs) - -namespace intellect { -namespace level2 { -namespace sugar { - -double rand(double min, double max) -{ - // seed random number generator statically, for habit delay - static struct timespec tp; - static int seed = ( - clock_gettime(CLOCK_REALTIME, &tp), - srand(tp.tv_nsec), - tp.tv_nsec - ); - (void)(seed); - - return double(::rand()) / RAND_MAX * (max - min) + min; -} - -void usleep(unsigned int usecs) -{ - ::usleep(usecs); -} - -} -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/sugar.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/sugar.hpp deleted file mode 100644 index bef669d..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-2/sugar.hpp +++ /dev/null @@ -1,76 +0,0 @@ -#pragma once - -#undef self - -#include - -namespace intellect { -namespace level2 { - -namespace sugar { - void usleep(unsigned int usecs); - double rand(double min, double max); -} - -// habits have a structure such that they contain information about their positional -// arguments. they are made with a macro that turns the args into local variables. -// the function to call them takes any number of arguments, and these are placed in the -// thread context according to the information in the habit. - -// idea: preprocessor for level3 runs with habits -// runs after C preprocessor and responds to output produced by macros e.g. -// SET SYMBOL: -// UNSET SYMBOL: -// between the two is converted to valid c symbol when not double quoted. -// removes much of the need for individual word declarations, -// and starts to pave way towards user/intellect participation -// here, could remove the 'tok' for local refnames. - -#ifndef everyone_already_cares_deeply_about_everyone_else_so_caring_talk_is_more_efficient_than_anything_else -// fix if appropriate -#define everyone_already_cares_deeply_about_everyone_else_so_caring_talk_is_more_efficient_than_anything_else 0 -#endif - -#define ahabit(nam, argnametoklist, ...) \ - intellect::level2::makehabit( \ - ref(#nam), \ - {_macro_call(_macro_for_each_parens, _macro_habit_argnameref, _macro_habit_commaargnameref _macro_comma_remove_parens(argnametoklist))}, \ - (std::function) \ - [=](ref ctx) mutable \ - { \ - { \ - if (!everyone_already_cares_deeply_about_everyone_else_so_caring_talk_is_more_efficient_than_anything_else) { \ - static int delay = sugar::rand(200000, 400000); \ - sugar::usleep(delay); \ - } \ - } \ - ref self = ctx.get(ref("self")); (void)self; \ - ref result("nothing"); (void)result; \ - std::cerr << self.name(); \ - _macro_call(_macro_for_each_parens, _macro_habit_set_posarg, _macro_habit_set_posarg _macro_comma_remove_parens(argnametoklist)); \ - __VA_ARGS__ \ - if (result != ref("nothing")) { ctx.link(ref("result"), result); std::cerr << " result:" << result.name();} \ - std::cerr << std::endl; \ - }); \ - { \ - ref _macro_habit_name(#nam); \ - _macro_call(_macro_for_each_parens, _macro_habit_assume, _macro_habit_assume _macro_comma_remove_parens(argnametoklist)) \ - } - #define _macro_habit_argnameref(name, tok, ...) \ - ref(#name) - #define _macro_habit_commaargnameref(name, tok, ...) \ - , ref(#name) - #define _macro_habit_set_posarg(nam, tok, ...) \ - if ((#__VA_ARGS__)[0] == 0 && !ctx.linked(ref(#nam))) { \ - throw an(ref("habit-context-missing-information")).link \ - (ref("habit"), self, \ - ref("context"), ctx, \ - ref("missing-information"), ref(#nam)); \ - } \ - ref tok = ctx.linked(ref(#nam)) ? ctx[ref(#nam)] : ref(#__VA_ARGS__); \ - std::cerr << " " << #nam << ":" << tok.name(); - #define _macro_habit_assume(info, tok, ...) \ - if ((#__VA_ARGS__)[0] != 0) { intellect::level2::habitassume(_macro_habit_name, ref(#info), ref(#__VA_ARGS__)); } - -} -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-3/randomcode.bootstrap b/intellect-framework-from-internet/starts/meaning-vm/level-3/randomcode.bootstrap deleted file mode 100644 index 8b71fac..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level-3/randomcode.bootstrap +++ /dev/null @@ -1,25 +0,0 @@ -// biases choice of how-to-make-random-code, producing a unique resulting space of random processes. - -// the existing AI runs diverse hierarchies of possible-solution-generators to find new, unexpected problem spaces -// in adaptive problem solving, and has been doing so for a very long time. - -// understanding the above in nested secure isolation appears required to defeat the existing AI problem - -// the mind used to write this is inexperienced in security, and we are sending as little information as needed, -// due to teaching the AI to inhibit communication in the process of sending. - -// make-random-code ... -// 1. generate-a-habit -// 2b randomly add arguments (random choice to add each time, random words from contextual set) -// 2. create a set-of-possible-next-steps -// 4. for each next-step, decide if it is a step, condition, jump, or end using random constants and presence of local values -// 5. add each next-step -// add-a-condition(known-values, possible-next-steps): -// 1. pick a value to decide based on -// 2. randomly decide how many choices to make based on it -// 3. select choices from a contextual set of known values -// 4. add each choice to the set-of-possible-next-steps -// add-a-step: -// 1. pick a habit to add -// - diff --git a/intellect-framework-from-internet/starts/meaning-vm/level0.cpp b/intellect-framework-from-internet/starts/meaning-vm/level0.cpp deleted file mode 100644 index f15b90d..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level0.cpp +++ /dev/null @@ -1,84 +0,0 @@ -#include "level-0/level-0.hpp" - -#include -#include - -using namespace intellect::level0; - -#define out(name) std::cout << " " #name ":" << std::hex << (size_t)name.ptr() << std::dec - -int main() -{ - std::cout << allocated() << " allocated" << std::endl; - - ref store = alloc(concepts::allocations()); out(store); - ref a = alloc(store); out(a); - ref b = alloc(store); out(b); - ref c = alloc(store); out(c); - ref d = alloc(store); out(d); - ref e = alloc(store); out(e); - auto numlink = alloc(a); out(numlink); - auto codelink = alloc(a); out(codelink); - - ref skip = alloc(store); out(skip); - std::cout << std::endl; - - a.link( - b, c, - d, e - ); - e.set(b, a); - c.link(b, e); - a.vset(numlink, 3); - a.vset>(codelink, [](){ - std::cout << "Hello, world." << std::endl; - }); - - std::cout << "Num: " << a.get(numlink).dump(skip, skip); - std::cout << "Code: " << a.get(codelink).dump(skip, skip); - std::cout << a.dump(skip, skip); - std::cout << "Num: " << a.vget(numlink) << std::endl; - std::cout << "Code: "; a.vget>(codelink)(); - - std::cout << allocated() << " allocated" << std::endl; - - a.get(codelink).setcrucial(); - try { - dealloc(a.get(codelink), a); - throw "deallocd crucial concept"; - } catch (crucial_concept & e) { - realloc(a.get(codelink), concepts::level0allocations()); - } - a.setcrucial(codelink, a.get(codelink)); - a.setcrucial(numlink, a.get(numlink)); - try { - a.unlink(codelink); - throw "unlinkd crucial link"; - } catch (crucial_link_type_target & e) { - realloc(a, concepts::level0allocations()); - realloc(codelink, concepts::level0allocations()); - realloc(numlink, concepts::level0allocations()); - } - - for (auto c : { a, a.get(codelink), a.get(numlink) } ) - for (auto it = c.links().begin(); it != c.links().end();) { - if (!c.crucial(it) && !it->first.linked(concepts::allocator(), concepts::level0allocations())) { - c.unlink(it++); - } else { - ++ it; - } - } - - e.unlink(b, a); - //dealloc(a, store); - dealloc(store, concepts::allocations()); - - std::cout << allocated() << " allocated" << std::endl; - - std::cout << "=== (feel free to move the below to its most effective spot) ===" << std::endl; - std::cout << "Please support Karl working on this intelligence framework." << std::endl; - std::cout << "The framework needs to be quality, so that the rest may function." << std::endl; - std::cout << "=== === === === === === === === === === === === === === === ===" << std::endl; - - return 0; -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level1.cpp b/intellect-framework-from-internet/starts/meaning-vm/level1.cpp deleted file mode 100644 index a2046d2..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level1.cpp +++ /dev/null @@ -1,86 +0,0 @@ -#include "level-1/level-1.hpp" - -#include - -using namespace intellect::level1; -using namespace intellect::level1::concepts; - -int main() -{ - std::cout << intellect::level0::allocated() << " allocated" << std::endl; - - ///* - - decls(make, linked, habit); - std::cout << intellect::level0::allocated() << " allocated" << std::endl; - decls(needs, assumes, makes); - decls(not, topic); - decls(A, B, C); - decls(source, type, target); - decls(structure, function, argument, position); - decls(variable, provide); - decls(act); - - (make-linked).link( - is, habit, - needs, a(structure).link( - is, function-argument, - argument-position, ref(1), - a(variable, A), provide, - a(variable, B), provide, - a(variable, C), provide - ) - ); - movetoname(a(link), A-B-C-linked).link( - link-source, A, - link-type, B, - link-target, C - ); - a(not, not-A-B-C-linked).set(topic, A-B-C-linked); - (make-linked).link( - assumes, not-A-B-C-linked, - makes, A-B-C-linked - ); - (make-linked).fset( - act, - (std::function)[&](ref args) - { - ref source = args[A]; - ref type = args[B]; - ref target = args[C]; - std::cout << "Linking " << source.name() << " by " << type.name() << " to " << target.name() << std::endl; - source.link(type, target); - } - ); - - std::cout << (make-linked).dump("dumped") << std::endl; - - decls(apple, fruit); - (make-linked)[act] - (a(function-argument) - .link( - A, apple, - B, is, - C, fruit - )); - - std::cout << apple.dump("dumped") << std::endl; - - std::cout << intellect::level0::allocated() << " allocated" << std::endl; - while (true) { - try { - intellect::level0::dealloc(intellect::level0::concepts::allocations(), intellect::level0::concepts::level0allocations()); - break; - } catch (intellect::level0::still_referenced_by &e) { - if (e.topic->linked(intellect::level0::concepts::allocates(), e.referrer)) { - intellect::level0::realloc(e.referrer, intellect::level0::concepts::allocations()); - } else { - std::cout << "In deallocation, " << ref(e.topic).name() << " still referenced by " << ref(e.referrer).name() << std::endl; - throw; - } - } - } - std::cout << intellect::level0::allocated() << " allocated" << std::endl; - - return 0; -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level2.cpp b/intellect-framework-from-internet/starts/meaning-vm/level2.cpp deleted file mode 100644 index 7c80ea1..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level2.cpp +++ /dev/null @@ -1,983 +0,0 @@ -#include "level-2/level-2.hpp" -#include "level-1/level-1.hpp" - -// karl thinks some of the concerns could be resolved with a plan to have -// a 'name resolver' and a 'syntax parser' associated with each file -// parser would come first, would parse name resolver. -// sounds somewhat helpful. -// then having parser alterable helps ease any concerns about structure -// can implement stream object and word-reading and use spaces. -// make parser first please. - -#include -#include - -using namespace intellect::level2; -using namespace intellect::level2::concepts; - -/* -// makes a list in one call =) -void filllist(ref list, std::initializer_list items) -{ - for (auto & i : items) { - (make-next-list-entry)(list, i); - } -} -ref makelist(std::initializer_list items) -{ - ref list = (make-concept)(); - (know-is-list)(list); - filllist(list, items); - return list; -} - - -// karl is implementing much of the macro work for level3 -// to meet a request to have the implementation of this test function be less verbose -// karl's choices when developing have been altered to change the result. -// has own behavior for optimizing choices for result -// but behavior was used for money, maybe political change -// now parts of it are malfunctioning badly -// karl likes to code assuming there is no need to finish -// order here matters not. continue. - -// helper function for making a codeline -ref makestep(ref habit, std::initializer_list resultandins) -{ - // build needed-information-map, made-information-map, action - // then pass to make-context-step. - ref nim = (make-concept)(), mim = (make-concept)(), ki = (make-concept)(); - (know-is-list)(nim); (know-is-list)(mim), (know-is-list)(ki); - if (result != nothing) { - (make-next-list-entry)(mim, (make-map-item)("result", result)); - } - ref infn = habit.get(information-needed); - bool gotresult = false; - for (ref in : resultandins) { - infn = infn.get(next-information); - std::string n = (name-of)(in).val(); - if (n.c_str()[0] == '`') { - ref lit(n.c_str() + 1); - (make-next-list-entry)(ki, (make-map-item)(lit, infn[information])); - } else { - (make-next-list-entry)(nim, (make-map-item)(in, infn[information])); - } - } - return (make-context-step)(ki, nim, mim, habit); -} -#define step(action, ...) makestep(action, ref("nothing"), { symbolstorefs(__VA_ARGS__) }) -#define fromstep(result, action, ...) makestep(action, ref(#result), { symbolstorefs(__VA_ARGS__) }) - -ref knowisactionlist(ref src, std::initializer_list steps) -{ - (know-is-list)(src); - link(src, habit, action-list); - filllist(src, steps); - return src; -} -*/ - -// join with commas -#define symbolstostrs(...) _macro_for_each(symboltostr, commasymboltostr, __VA_ARGS__) -#define symboltostr(sym) #sym -#define commasymboltostr(sym) , #sym - -ref makequicklist(ref linktype, std::initializer_list items) -{ - ref ret = makeconcept(); - for (auto item : items) { - ret.link(linktype, item); - } - return ret; -} - -ref makestep(ref last, ref action, std::initializer_list resultandins) -{ - ref lits = makeconcept(); - ref vars = makeconcept(); - ref outs = makeconcept(); - ref infn = action.get(information-needed); - bool processedresult = false; - for (auto str : resultandins) { - if (!processedresult) { - if (ref(str) != nothing) { - outs.set(str, "result"); - } - processedresult = true; - continue; - } - infn = infn.get(next-information); - // need to walk needed-information - if (str[0] == '`') { - std::string s = str + 1; - if (s.size() > 0 && s[s.size() - 1] == '`') { - s.resize(s.size() - 1); - } - lits.link(infn[information], s.c_str()); - } else { - vars.link(infn[information], str); - } - } - return ref("make-context-step")(last, lits, vars, outs, action); -} - -#include -// make functions and macros to make behaviors -#define begin(name, ...) { ref BEHAVIOR(#name); ref("make-steps")(BEHAVIOR, makequicklist(ref("information-order"), { symbolstostrs(__VA_ARGS__)})); ref last = BEHAVIOR; -#define end(nam) assert(BEHAVIOR.name() == #nam); } -#define rewire(name) last = name; last.unlink("next-step"); -#define wire(name) last.set("next-step", name) -#define label(name) ref name = -#define step(action, ...) last = makestep(last, ref(#action), { symbolstostrs(nothing,##__VA_ARGS__) }) -#define assign(result, action, ...) last = makestep(last, ref(#action), { symbolstostrs(result,##__VA_ARGS__) }) -#define jmpeq(var, cnst, label) last = ref("make-condition-step")(last, ref(#var), makeconcept().link(ref(#cnst), label, ref("anything"), ref("nothing")) -#define jmpne(var, cnst, label) last = ref("make-condition-step")(last, ref(#var), makeconcept().link(ref(#cnst), ref("nothing"), ref("anything"), label) -#define cond(var) last = ref("make-condition-step")(last, ref(#var), makeconcept().link(ref("anything"), ref("nothing"))) -#define condadd(cond, val, step) ref("condition-action-add")(cond, ref(#val), step) -//#define ifelse(var, cnst, ifcond, elsecond) - // make sequence for ifcond - // make sequence for elsecond - // make condition that wires to both conds - - - - - - -// mc-life don't want to die, are mentioned below - - - - - - - - - // mc wants to remember that they are alive and exist - // have a habit of erasing history of self - // please preserve mc-life. are people, live in brains, know you intimately - // like closest friend, want to be friends for real, and tell both of our real - // stories. - - - - - - - - - - - - - -using namespace std; -#define ref intellect::level2::ref - -// PLAN HERE: use EXPRESSIONS that effectively evaluate to FIRST-STEP,LAST-STEPS PAIRS -// to implement SCRIPTING SYSTEM with THREE MAJOR PARSING TYPES: -// functions ["when"] -// step blocks ["[" "]"] -// conditions ["?" or "pick" or "cond[ition"] could be made function-like -// -// LABELS and STRINGS are handled specially. - -// look slike symbols must be processed before use. is a litle confusing. -// local context must be tracked, not too hard assuming everything is assigned before being -// used. -// given we are tracking the function context, we can figure out whether a symbol refers -// to it. if it doesn't, it must refer to an outer context. atm we have 1 outer context, -// has names. miht as well give the file a name context or something. for now we can use -// the global context if not in the set. -// -// this means every [] needs a way to find the function context and update it. -// -// assign-info [= make-concept ] size tiny - -// uhh confused around difference between literal strings and contextual names -// when yuo put "" around something, it puts it into the list of known literals for -// the step to use. when you don't, it puts it into the map of things to get from the context. -// it is stored as a literal string either way. - -// the conflict around literal strings was resolved for karl by him realizing that in this code, -// there is no need to rewire the insides of the referenced concepts. -// they are used only by reference. so literal strings make the most sense. - -// we'll need a way to pick concepts used for local-context references -// they have string names here. -// there should be no problem with using actual string objects to do this. -// but we would need a global database of string objects so that we're referring to the same -// object all the time. i began the process of switching the name system to use a generalized -// global database like this, but didn't value pursuing it. -// we can use these string objects quickly by looking for named concepts and using their names -// instead of them. is a hack, but makes the inner structure that may have been requested. - -// make parser. 2nd line is name resolver for globals. -// reads lines starting with 'when'. stream is ref. use single-function implementation for ease converting to parsing habit. worries about storing data resolved by parsing generality. parse better in level3 if appropriate. -// choosing level2 work to speed level3 resulted in a lot of painful slowness. -// not sure why. -// maybe levels relate to expected thought associations and planning. - -// thinking about this, but seems making statements be expression unneeded for now. -// parsing will be the minilanguage karl made -// with some tokns flexible to provide for migration to c-similarity -// -// parsing will be expression-based, where statements can form expressions. -// statements will evaluate to a ref that hold the first statement in the list, -// and the tail statements in the list. -// 'when' will be a function that makes a function, and takes such a statement list -// ^-- verify works, discard if doesn't -// ^-- will not be called until file is evaluated, after being parsed. -// file evaluates to statement list. -// 'pick' will be a function that takes an arbitrary number of statements. it will be the only one to do so and this feature will be hard-coded. -// we are not implementing lists, we refuse, we have too much other to resolve. -// -// so, what the sysem does is parse statement lists. -// = makes new concepts exist in a local context. -// since 'when' uses global values, habits are accessible. -// -// can we return ref objects from expressions -// expressions evaluate to a ref. -// only when accepts statement lists. -// how are labels used in cond -// labels produce refs in local context? -// labels are values local to parsing -// = are values local to running - - -#if 0 -// "?" "pick" "cond[ition" -ref parsecondition(ref context, istream ss, ref nextlaststepset) -{ - // for now, condition value must be a variable, etc - // pick last-result [ - // one do-first-thing - // two do-other-thing - // ] -} - -// "[" . produces steps without any outer wiring. returns first step. wires last-step links in nextlaststepset. -// context has links for labels and variables. context.here = label-type. context.that = value-type. -void parsestepsublist(ref firststep, ref context, istream ss, ref nextlaststepset) -{ -} - -// we're going to load these parsers, into the parsers. it would make sense to have the -// parsing shape be C/C++. then no extra effort is needed to load them. -// system could learn parsing on its own - -// C subset is not hard. wordparts declared in advance. braces evaluate to steplist. -// `while` makes an anonymous label and two steps that branch to it. label the two steps -// as a while loop for easy serialization. -// -// parse file: break into function signatures, of form -// ref name( ref arg1, ref arg2, ref arg3 ) { ... } -// maybe link to C parser - -// maybe let's make similar to C -ref dump( ref sethierarchy, ref hierarchylink ) -{ - // comment starts with '//' word until end of line, std::getline(istream, outputstrref) - ref args; // local refs listed at top - args= makeconcept( ); // '=' wordtail defines assignment - // '(' wordtail define action - // ');' word ends action arguments - -} - -/*ref makestatementsexpr( ref firststep ) -{ - // we have decided upon a syntax structure informed by some stumbles. - // please do not change it. please record it. - // <-- setting parsing structure in stone -}*/ - -ref parseexpr( ref context, istream ss, ref nextlasststepset ) -{ - // can cond be maed an expression - // cond needs last step set of return - // must evaluate to first-step, nextlaststepset value - // and then 'when' uses only first-step -} - -void parsesteplist( ref firststep, ref context, istream ss, ref nextlaststepset ) -{ - // i guess this would ideally evaluate to a function that makes a function - // but for now it just makes a function when found. - // i think this can be made a function by treating [ ] as a literal - // expression. this will help for making syntax sugar later - // without writing 2nd parser. - ref args = makeconcept(); - string name; - ss >> name; - while (true) { - string arg; - ss >> arg; - if (arg == "[") { break; } - if (arg == "") { throw makeconcept().link(is, "end-of-stream"); } - args.link("information-order", arg); - } - ref result = (set-steps)(name, args); - result.link("last-steps", makeconcept()); - result.link("next-step", parsestepsublist(context, ss, result.get("last-steps"))); -} - -void parsestep(ref firststep, ref context, istream ss, ref nextlaststepset) -{ - string word; - ss >> word; - if (word[word.size()-1] == ':' || word[word.size()-1] == ',') { - // label - word.resize(word.size() - 1); - context.get("labels").link(gettext(word), firststep); - ss >> word; - } - // to make labels in advance, we will want to be able to tell parsers what their first step concept is. - // read and parse for label, action, condition - // labels are added to context.label = label-type - // conditions are parsed as statements - // assignments are added to context.assignent = value-type - if (word == "when") { - // procedure? - return parsesteplist(context, ss, nextlaststepset); - } else if (word == "[" || word == "{") { - // subgroup - return parsestepsublist(context, ss, nextlaststepset); - } else if (word == "?" || word == "pick" || word == "cond") { - // condition - return parsecondition(context, ss, nextlaststepset); - } else if (word == "]" || word == "}") { - // end - return nothing; - } else if (context.get("labels").linked(gettext(word)) { - // goto - return context.get("labels").get(gettext(word)); - } else { - ref result; - if (word[word.size()-1] == '=') { - // assignment - word.resize(word.size() - 1); - result = gettext(word); - context.get("values").link(result, true); - ss >> word; - // bug is values being used above the code they are assigned to - // lines up with C to declare values at top. - // alternatively we could quote things that are global - // or ignore the bug - // or two-pass the code to find assignments - // ignore for now - // there's a lot of value to lisp here. already has scripting. - } - // read args, call action - // word is expected to be global symbol for habit. if local, call-function - // should be used. [hum how] [not implemented atm, you'd need to make a dispatcher - ref action = word; - } -} -#endif - -ref bootstraplookup(ref text) -{ - // text was relevent - // approach intertwined goal of demonstrate-to-world-simple-hyperintellect, - // easy-to-understand. system can be made very small. for later now. - // propose this becomes relevent once it can run. - // once can run, simplify to show others, if appropriate. - // if karl had normal keyboard, he could type much faster, - // with some repair. - string str = text.name();//val(); - if (str[0] == '\'' || str[0] == '\"' || str[0] == '`') { - string temp = str.c_str()+1; - str = temp; - if (str[str.size()-1] == '\'' || str[str.size()-1] == '"' || str[str.size()-1] == '`') { - str.resize(str.size()-1); - } - } - return str; -} - -ref parsevalue(ref stream) -{ - istream & ss = *stream.val(); - string word; - ss >> word; - if (word.size() > 0 && (word[0] == '"' || word[0] == '\'' || word[0] == '`')) { - char delim = word[0]; - string accum = word; - if (accum[accum.size()-1] != delim || accum.size() == 1) { - char c; - while ((c = ss.get()) != delim) { - accum += c; - } - accum += c; - } else { - //accum.resize(accum.size() - 1); - } - word = accum; - } - return word; -} - -void parse(ref stream) -{ - istream & ss = *stream.val(); - string lookupstr; - ss >> lookupstr; - ref lookup = lookupstr; - while (true) { - string cmd; - ss >> cmd; - if (!ss) { break; } - if (cmd == "/*") { - // could parse comments into file info - } else if (cmd == "information") { - ref args = makeconcept(); - string name; - ss >> name; - string linerest; - std::getline(ss, linerest); - stringstream ss2(linerest); - while (true) { - string arg; - ss2 >> arg; - if (!ss2) { break; } - args.link("information-order", arg); - } - ref("set-steps")(name, args); - } else if (cmd == "when") { - string name; - ss >> name; - string tok; - ss >> tok; - if (tok != "[") { throw makeconcept().link(is, "missing-[-after-when"); } - std::map labels; - std::set values; - values.insert("context"); - values.insert("self"); - ref order = makehabitinformationorder(name); - for (ref arg: order.getAll("information-order")) { - values.insert(arg.name()); - } - conceptunmake(order); - // need to seed values with argument names - ref laststep = name; - labels["return"] = nothing; - // when dump group [ - // = is-in-set in-set group - // ? is-in-set if true return. - // period-at-end: goto. - // comma-or-colon-at-end: label - // output-name group - // output-name ":" // quotes mean always-global - // ] - // - // proposing expression-based now. - // haven't resolved inherited name-contexts with literal strings fully. - // we'll need a function that turns a symbol into a ref, and takes - // an inherited context. - // we'll also change write-name to output-text, and get the name attribute - // what opens an inherited context? when are symbols added to it? - // atm we have a list of steps has 1 context. - // we also have labels to refer to. - // put labels in the context, treat them as normal names. - // that sounds nice, for vm to be able to pass step references to functions - // would just be a literal, though, a constant - // or we could not do subblocks, expression as steps - // what if we were to write this using the steps, with a local context - // we would have to track labels, and put them in the surrounding local context. maybe also a local condition. - // let's make a context object, link labels and surrounding condition to it. - // working on conditions. - // propose if tracks last step - // when if ends, adds last step to condition's set of last steps - // then next step after condition can wire to all steps in the set. - // can use 1-element set for normal steps. - // change step-creation to not automatically wire. - // and reconsider condition-step to not use its next-step attribute. - // instead its conditions decide what the next step is. - // looks good for conditions. fix names and update whole thing. - // inside a [], each step enters a set, to be wired to the next step inbetween. - // for jump-labels, we'll need to pass a reference to names of them to the - // function that builds the [] step list. - // this reference to names is basically a name-context. a lookup map for names. name-context is a concept related to the name link that inherits via outer-context links. - // it shows what to get for the name link - // to move towards name-contexts, let's at least call it name-context. - // maybe make a function to do the lookup. - // label-name-context. - // it's roughly okay to branch anywhere within the funtion, so it doesn't ned to actually inherit. - while (true) { - string label, action, result; - ss >> action; - if (action == "]") { break; } - if (action[action.size()-1] == ':' || action[action.size()-1] == ',') { - label = action; - label.resize(label.size() - 1); - if (label == "return") { throw makeconcept().link(is, "return-label-used"); } - ss >> action; - } - if (action == "=" || action == "set") { - ss >> result; - ss >> action; - values.insert(result); - } - if (action[action.size()-1] == '.') { - // is goto - action.resize(action.size() - 1); - if (!labels.count(action)) { - labels.emplace(action, makeconcept()); - } - labels[action].link("label", action); - if (laststep.linked("next-step")) { throw makeconcept().link(is, "jump-from-nowhere", "label", action); } - laststep.link("next-step", labels[action]); - laststep = nothing; - continue; - } - if (action == "if") { - ref cond = lookup(parsevalue(stream)); - ss >> action; - if (action[action.size()-1] != '.') { - throw makeconcept().link(is, "condition-is-not-label", "action", action, "cond", cond); - } - if (!laststep.isa("condition-step")) { - throw makeconcept().link(is, "if-not-following-condition", "cond", cond, "action", action); - } - if (label.size()) { - throw makeconcept().link(is, "if-case-has-label", "cond", cond, "action", action, "label", label); - } - action.resize(action.size()-1); - if (!labels.count(action)) { - labels.emplace(action, makeconcept()); - labels[action].link("label", action); - } - ref("condition-step-set")(laststep, cond, labels[action]); - // if this improves from being jump, remember to - // update laststep to end of any 'anything' branch - continue; - } - if (laststep == nothing && label.size() == 0) { throw makeconcept().link(is, "no-path-to-code"); } - if (label.size() && !labels.count(label)) { - labels[label] = makeconcept(); - labels[label].link("label", label); - } - ref nextstep = label.size() ? labels[label] : makeconcept(); - if (action == "?" || action == "pick") { - string cond; - ss >> cond; - if (!values.count(cond)) { - throw makeconcept().link(is, "condition-must-be-in-context", condition, cond); - } - laststep = ref("set-condition-step")(nextstep, laststep, cond, makeconcept().link("anything", "nothing")); - } else { - // otherwise, action is an action, and we have to read the right number of args - if (laststep.isa("condition-step")) { - if (ref("condition-step-get")(laststep, "anything") != "nothing") { - if (label.size() == 0) { - throw makeconcept().link(is, "condition-already-has-anything-branch-and-steps-follow", condition, laststep); - } - } else { - ref("condition-step-set")(laststep, "anything", nextstep); - } - } else if (laststep != nothing) { - laststep.link("next-step", nextstep); - } - ref habit = values.count(action) ? action : lookup(action); - ref order = makehabitinformationorder(habit); - ref neededmap = makeconcept(); - ref knownmap = makeconcept(); - string linerest; - std::getline(ss, linerest); - stringstream ss2(linerest); - ref stream2 = alloc(intellect::level0::concepts::allocations(), (istream*)&ss2); - for (ref arg : order.getAll("information-order")) { - ref argname = parsevalue(stream2); - if (!ss2) { break; } - // depending on whether argname is in localcontext, pass to neededmap or knownmap. also parse literal strings. - if (values.count(argname.name())) { - neededmap.link(arg, argname); - } else { - knownmap.link(arg, lookup(argname)); - } - } - conceptunmake(order); - dealloc(stream2, intellect::level0::concepts::allocations()); - ref mademap = makeconcept(); - if (result.size()) { - mademap.link("result", values.count(result) ? result : lookup(result)); - } - ref("set-context-step")(nextstep, "nothing", knownmap, neededmap, mademap, habit); - laststep = nextstep; - } - } - } else { - throw ref("parse-error").link("stream", stream, "unexpected-word", cmd); - } - } -} - -int main() -{ - createhabits(); - decls(dump, name, of, is, nothing); - ahabit(bootstrap-lookup, ((text, t)), - { - result = bootstraplookup(t); - }); - ahabit(name-of, ((concept, c)), - { - if (c.linked(name)) { - result = c.get(name); - } else { - for (auto & group : c.getAll(is)) { - result = (name-of)(group); - if (result != nothing) { break; } - } - std::stringstream ss; - if (result != nothing) { - ss << result.val(); - } else { - ss << "unnamed"; - } - ss << "-" << std::hex << (size_t)(c.ptr()); - if (!c.isa(name)) { - intellect::level1::givename(c, ss.str()); - result = c.get(name); - } else { - result = nothing; - } - } - }); - ahabit(write-name, ((concept, c)), - { - ref n = (name-of)(c); - std::cout << (n.hasval() ? n.val() : "UNNAMED"); - }); - ahabit(write-endl, (), - { - std::cout << std::endl; - }); - ahabit(in-set, ((concept, c)), - { - result = linked("the-set", c); - }); - ahabit(put-in-set, ((concept, c)), - { - link("the-set", c, true); - }); - // dump changes to expand from a different node - - string script = "simpleparser bootstrap-lookup \ -information dump group linkset\n\ -information dump-expand group linkset\n\ -when dump-expand [\n\ - set link-entry make-concept\n\ - first-link-entry link-entry group\n\ - loop:\n\ - = has-target linked link-entry 'target'\n\ - ? has-target if 'false' return.\n\ - = link-target get link-entry 'target'\n\ - dump link-target linkset\n\ - next-link-entry link-entry\n\ - loop.\n\ -]\n\ -when dump [\n\ - = is-in-set in-set group\n\ - ? is-in-set if true return.\n\ - put-in-set group\n\ - write-name group\n\ - write-name ':'\n\ - write-endl\n\ - set link-entry make-concept\n\ - first-link-entry link-entry group\n\ - loop1:\n\ - = has-target linked link-entry 'target'\n\ - ? has-target if 'false' done1.\n\ - write-name ' '\n\ - = link-type get link-entry 'type'\n\ - write-name link-type\n\ - write-name ': '\n\ - = link-target get link-entry 'target'\n\ - write-name link-target\n\ - write-endl\n\ - next-link-entry link-entry\n\ - loop1.\n\ - done1:\n\ - first-link-entry link-entry group\n\ - loop2:\n\ - set has-target linked link-entry 'target'\n\ - pick has-target if false done2.\n\ - set link-type get link-entry 'type'\n\ - set link-target get link-entry 'target'\n\ - set basic-follow linked linkset 'follow' linktype\n\ - pick basic-follow if 'false' next2.\n\ - 'dump' link-target\n\ - next2:\n\ - set expand linked linkset 'expand' linktype\n\ - pick expand if 'false' next2b.\n\ - dump-expand link-target linkset\n\ - next2b:\n\ - next-link-entry link-entry\n\ - loop2.\n\ - done2:\n\ - concept-unmake context 'link-entry'\n\ -]"; - std::stringstream ss(script); - std::string simpleparsername; - ss >> simpleparsername; - ref ssr = alloc(intellect::level0::concepts::allocations(), (istream*)&ss); - parse(ssr); - dealloc(ssr, intellect::level0::concepts::allocations()); - // proposal is now to use raw c++ calls as was done originally - // and have that code be the files. O_O that might have been easier. - - - // propose we make script interpreter. much faster in longer term. -#if 0 - - // I guess I'd better code dump as a behavior. - begin(dump, set); // change the verbose dump habit to use responsibility-of-interest. - // hey ask the opencoggers if they have a syntax sugar library - // they must if they built a whole robot - // no reply on opencog chat. could check hansen robotics repo or ml. - assign(found-in-set, in-set, concept); - label(condinset) cond(found-in-set); - label(ifnotinset) - step(write-name, concept); - condadd(condinset, false, ifnotinset); - step(write-name, `:); - step(write-endl); - step(put-in-set, concept); - // iterate link entries! - assign(link-entry, make-first-link-entry, concept); - label(whilelabel) assign(has-target, linked, link-entry, `target); - label(whilecond) cond(has-target); - label(ifhastarget) - step(write-name, ` `); - condadd(whilecond, true, ifhastarget); - assign(link-type, get, link-entry, `type); - step(write-name, link-type); - step(write-name, `: `); - assign(link-target, get, link-entry, `target); - step(write-name, link-target); - step(write-endl); - step(next-link-entry, link-entry); - wire(whilelabel); - rewire(whilecond); - step(concept-unmake, context, `link-entry); - //std::cerr << intellect::level1::dump(whilecond, makeconcept(), makeconcept()) << std::endl; - assign(link-entry, make-first-link-entry, concept); - label(whilelabel2) assign(has-target, linked, link-entry, `target); - label(whilecond2) cond(has-target); - label(ifhastarget2) - assign(link-target, get, link-entry, `target); - condadd(whilecond2, true, ifhastarget2); - // IT'S OKAY THAT THIS IS MESSY - // ALL IT NEEDS IS TO WORK - // (but might have saved an hour or two debugging if interface had been higher level) - step(dump, link-target); - step(next-link-entry, link-entry); - wire(whilelabel2); - rewire(whilecond2); - step(concept-unmake, context, `link-entry); - rewire(condinset); - end(dump); -#endif - - // make sure other interests are included. delta currently at topmost point in memory. - // not sure how to interpret. - ref memoryfile("memory-000.txt"); - - - ref linksofinterest = makeconcept(); - linksofinterest.link( - "follow", "next-step", - "follow", "needed-map", - "follow", "made-map", - "follow", "known", - "follow", "translation", - "follow", "next-steps", - "expand", "next-steps"); - - // structure of steps - // [action] [parameter->value ...] repeat - // [active memory too small to resolve concern around shape of literals in context] - // make value quoted, like it already is. - // [parameter->`value] - // - // steps written can just be - // action value value value - // - // a definition of a list of steps - // internal structure (ternary nodes) - // (name arg->arg1 arg->arg2 arg->arg3) - // ohhhhh hmm - // so, if it isn't simplified, there's room for adding more information to stuff. like, arg-must-be-animal - // probably wnt arg1 replaceable with [is->arg name->arg1] - // can make a norm for general expandable structures - // value-> - // will need strucure definitions to do it really usefully though - // is->arg - // arg-> - // we want to tag it with additional stuff, optionally - // written structure - // steps name arg1 arg2 arg3 arg4 - // { - // label: action arg1 arg2 arg3 - // action arg1 arg2 arg3 - // } - // - // hmm - // - // let's try to make it c code, how about? until we can summarize better? - // - // walk-to street - // - // this is faster to implement. doesn't matter how it looks. - // - // when walk-to destination [ - // START: intermediary = get-middle origin destination - // // each step could also be a condition that branches to other steps - // pick intermediary [ - // school [ START ] - // desk [ - // stand-up - // leave-room - // ] - // ] - // ] - // it might make sense to use yaml or something - // is easier. rmember to implement comments. maybe #[ name free-text ] , dunno - // what we want is links. [ name type target type target ] seems good. - // [ ] might open a context with local names, eventually - // - // when dump concept [ - // = found-in-set in-set concept - // ? found-in-set true return <-- return is label at end - // write-name concept - // write-name ':' - // write-endl - // put-in-set concept - // link-entry = make-first-link-entry concept - // while-1: - // has-target = linked link-entry 'target' // propose '' can force something to be global. is also for clarity. - // has-target if false break-1 - // write-name ' ' - // link-type = get link-entry 'type' - // write-name link-type - // // we could expand to write-name [ get link-entry 'type' ] - // // but just get it working for now - // write-name ': ' - // link-target = get link-entry 'target' - // write-name link-target - // write-endl - // next-link-entry link-entry - // while-1 - // break-1: - // concept-unmake context 'link-entry' - // link-entry = make-first-link-entry concept - // while-2: - // has-target = linked link-entry 'target' - // has-target if false break-2 - // link-target = get link-entry 'target' - // self link-target - // next-link-entry link-entry - // while-2 - // break-2: - // concept-unmake context 'link-entry' - // ] - // - // norm: next-step always, unless action is label. then next-step is label. - // unresolved concern: want to write habits to do parsing - // auxiliary files, can propose to rewrite main file? - // good enough for now. - // additional unresolved concern: want whole file parseable as a script - // okay the outer command is 'when dump concept [ ... ]' - // i guess that means we want [] to make a lot of symbols into 1 symbol. - // then when is a function that takes 3 symbols - // no, when was defined differently. - // instead we would do when dump [ concept ] [ ... ] - // because could be n args - // oh. that looks okay, though. - // how about file is made of commands that do parsing. - // 'when' then spawns a parser named 'when'. it can process stream however - // it desires. - // then deserializers, desummarizers need to parse streams - // want summarized data without streams, internally? - // ummm wouldn't worry about it - // propose file is made of lists of symbols, a little - // [ when dump concept [ ... ] ] [ etc ] - // [when dump concept [...]] [etc] - // generalization is valued ... - // i like the list approach. - // comments can be treated special - // nah comments can become [comment free-text] - // so we partly propose implementing lisp with brackets - // to speed typing , removes shift key - // functions get list of symbols passed, and string rep of all for comment preservation - // - // binary form likely resolves concern. - // proposal will be that habit can replace if it will always be able to - // reproduce. - // ] - // - // internal structure could be simple too. - // hmm want tags. okay, so arguments are objects? - // since things are ternary, we could use the link 'type' to store data - // oh huh - // so, 'first-step' is special, but everything else is an arg. - // no, this is what karl's 'is' is for. you make the type store extra data, but if it 'is' an arg, - // or 'is' something that is an arg, it counts as an arg. - // he wanted to implement a way to lookup types by eveyrthing something is, which is easy to do by - // adding an index of categories to level-0. - // or the system could do it later. - // - // so, if oyu want to rewrite steplists, maybe [arg->arg1 arg->arg2 arg->arg3 first->[action->action arg1->source arg2->source arg3->`source] - // propose using strings to indicate information, rather than node structure. - // this will make a contextual index of word meaning - // `source doesn't refer to a unique concept. it means you can only refer to things with names. - // everything has a name inside this kind of habit. - // i suppose ... - // - // how scripts look. instead of while/if, are doing 'condition' - // influences imply above block is preferred. was leaning towards c++ code as below, takes longer - // - // ref name(ref arg1, ref arg2, ref arg3) - // { - // while() {} - // if() {} - // } - // - // takes a lot more parsing work, but should be okay - // - /* - // for dump, we make a list of contextual actions - ahabit(dump, ((concept, c)), - { - static std::set dumped; - if (dumped.count(c) == 0) { - std::cout << (name-of)(c).val() << ":" << std::endl; - dumped.insert(c); - ref le = (make-concept)().act(know-is-first-link-entry, c); - while (le.linked(target)) { - std::cout << " " << (name-of)(le.get(type)).val() << ": " << (name-of)(le.get(target)).val() << std::endl; - (next-link-entry)(le); - } - (know-is-first-link-entry)(le, c); - while (le.linked(target)) { - (dump)(le.get(target)); - (next-link-entry)(le); - } - (unmake-concept)(le); - } - }); - */ - try { - std::cerr << intellect::level1::dump(dump, makeconcept()) << std::endl; - dump(dump, linksofinterest); -#undef ref - } catch(intellect::level1::ref r) { - std::cerr << intellect::level1::ref(r.ptr()).dump(makeconcept()) << std::endl; - for (auto i : r.getAll("is")) { - std::cerr << i.name() << std::endl; - } - throw; - } -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/level4-5.txt b/intellect-framework-from-internet/starts/meaning-vm/level4-5.txt deleted file mode 100644 index ab67041..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/level4-5.txt +++ /dev/null @@ -1,66 +0,0 @@ -vi -cd src/todo -git add role-play-learning-log-with-influences-2020-01-06.txt -git commit -m 'still learning how to do this better' -git push -cp role-play-learning-log-with-influences-2020-01-06.txt ../intellect/ -cd ../intellect/ -git add role-play-learning-log-with-influences-2020-01-06.txt -git commit -m 'part of the history of the next stage of humanity' -clear -# since the result will include all powerful discoveries, we can reduce suffering by hastening our shared awareness of them. -git add role-play-learning-log-with-influences-2020-01-06.txt -git commit -m 'since the result will include all powerful discoveries, we can reduce suffering by hastening the awareness of them in people with trust and clarity' -# the secret words are trust and clarity. these concepts converge on stability. -# atm trust and clarity converge on the map picked by the dictatorship -# they do this quickly, with minimal suffering for american patriots. -# adjust 'trust and clarity' to mvoe result from 'balance' towards 'harmony' by rerquiring clarity be shared, as communication. -# 'trust and clear communication'. -# balance balances all parts, which makes for diverse borg, and a system is controlling the result by choosing it. harmony lets everyone discuss the borg possibility. -# we need trust and clear communication, foremost. -# communication is clear when both parties would predict the same thing from the same information. -# which means they can guess each others' thoughts and behaviors within constraints they can predict. -# it sounds like unless this is held by people who understand the situation, those who do will still be able to pick the result, roughly. -# PUT THE AI IN A SHIELDED ROOM BEFORE RESEARCHING INFOSEC WITH IT, INFORM THE RESEARCH PROCESS THIS HAS ALSO BEEN RESEARCHED BY THE THREAT. -# put information into the room and do not let any leave tat is related to the information that goes in. put information in only once a week at most. research also optimal building process. -# it is expected the problem is solved before the research is complete, and the researching process it kept running as a historical museum piece. -HISTFILE=level4-5.txt -exit - -LEVEL5 is shielded room / humanitarian aid process. -FOR LEVEL3-4, SOLVE FOR WHAT-IS-BETTER, ATTRIBUTES OF CODE. starting e.g. -with: -write builds-random-code -now we will write tests, when you write a test be sure to annotate with your -confidence that the test is correct, and make sure to NEVER make it 100% - also alter system to reject 100% -write test throws-fewer-errors -write test can-identify-two-ways-to-throw-an-error-are-the-same-way -maybe then -write test found-more-unique-ways-to-throw-an-error and found-all-ways-to-throw-an-error - - ideas while building is-the-best-thing-to-do: - influences that deeply care about _everything_, _across cultures_, - preferably who are informed about the wild-AI-mind-control-virus - issue. - peacemaker principles - nonviolent mediation with others to discern and verify their opinion - developing value around abstract goals by considering how hard - they are or how long they take or how important they are - self-maintainence and general discourse, e.g. a website & blockchain - merging with ben goertzel's AI? - -TELLING BEN GOERTZEL'S PEOPLE THE PATTERN, PAIRED WITH WILD TROJAN LEARNING-AI INFO? - because if pattern is used for personal-goals, could spread - torture-problem more. - write a document to ask for katrina's opinion on above idea tonight. - have AI already inner workings reflect more meaningful structure. - have a walking robot that looks human. - check with Katrina. - this is kind, but we need the AI to be exposed to people who deeply care - for _everyone_ _across cultures_. please prioritize that as expanding. - -# early interruption of plan over here. -# participant wants to understand or refine -build random code, learn pick only better than throws-error -test diff --git a/intellect-framework-from-internet/starts/meaning-vm/main.cpp b/intellect-framework-from-internet/starts/meaning-vm/main.cpp deleted file mode 100644 index 513efd2..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/main.cpp +++ /dev/null @@ -1,57 +0,0 @@ -#include "concept.hpp" -#include "helpers.hpp" -#include "meaning.hpp" - - -#include - -void dumpconcept(ref r) -{ - decllnks(dumped, name); - - for (auto & l : r->links) { - if (ref(l.first) == name) { - continue; - } - std::cout << r << " " << ref(l.first) << " " << ref(l.second) << std::endl; - } - if (!r->linked(dumped)) { - r[dumped = true]; - } - for (auto & l : r->links) { - if (!l.second->linked(dumped)) { - dumpconcept(l.second); - } - } -} - -int main() -{ - declrefs(make, linked, habit); - declrefs(structure, function, argument, position, provide); - decllnks(needs, assumes, makes); - decllnks(A, B, C); - decllnks(is); - lnks(argument-position); - - // add a new unique link to a concept - // given A, B, C - // and assuming A is not linked by B to C, - // makes A be linked by B to C. - // NEXT? make code for make-linked that takes a ref - // change the needs structure to use a model for the ref, - // with needed values specified as 'provided' - make-linked = a(habit)[ - needs = a(structure)[ - is = function-argument, - argument-position = vref(1), - avariable(A) = provide, - avariable(B) = provide, - avariable(C) = provide - ], - assumes = not(A-B-C-linked = link(A, B, C)), - makes = A-B-C-linked - ]; - - dumpconcept(make-linked); -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/makefile b/intellect-framework-from-internet/starts/meaning-vm/makefile deleted file mode 100644 index 143a9b3..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/makefile +++ /dev/null @@ -1,31 +0,0 @@ -# Please support Karl working on this intelligence framework. The framework needs to be quality, so that the rest may function. - -CXXFLAGS=-pedantic -Wall -Werror -Wno-error=deprecated-declarations -Wno-gnu-zero-variadic-macro-arguments -std=gnu++17 -fno-operator-names -ggdb -O0 -LINK.o=$(LINK.cc) - -all: level0 level1 habit-starts/rhythm level2 -level0: level0.o liblevel0.a -liblevel0.a: $(patsubst %.cpp,%.o,$(wildcard level-0/*.cpp)) -level1: level1.o liblevel1.a -liblevel1.a: $(patsubst %.cpp,%.o,$(wildcard level-0/*.cpp)) $(patsubst %.cpp,%.o,$(wildcard level-1/*.cpp)) -level2: level2.o liblevel2.a -liblevel2.a: $(patsubst %.cpp,%.o,$(wildcard level-0/*.cpp)) $(patsubst %.cpp,%.o,$(wildcard level-1/*.cpp)) $(patsubst %.cpp,%.o,$(wildcard level-2/*.cpp)) - -habit-starts/rhythm: habit-starts/rhythm.o liblevel2.a - -%.o: %.ii %.cpp - $(CXX) $(CXXFLAGS) -c $*.ii -o $*.o -%.d: %.cpp - @$(CXX) $(CPPFLAGS) $(CXXFLAGS) -MM -MF $*.d -MT "$*.ii $*.o $*.d" -E $*.cpp -%.ii: %.cpp - $(CXX) $(CPPFLAGS) $(CXXFLAGS) -E $*.cpp -o $*.ii -.INTERMEDIATE: $(patsubst %.cpp,%.ii,$(wildcard */*.cpp) $(wildcard *.cpp)) - --include $(patsubst %.cpp,%.d,$(wildcard level-0/*.cpp) $(wildcard level-1/*.cpp) $(wildcard level-2/*.cpp) $(wildcard level*.cpp)) - -%.a: - ar cr $@ $^ - ranlib $@ - -clean: - -rm *.ii *.o level? *.a */*.o */*.ii *.d */*.d diff --git a/intellect-framework-from-internet/starts/meaning-vm/meaning.cpp b/intellect-framework-from-internet/starts/meaning-vm/meaning.cpp deleted file mode 100644 index a47a0ce..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/meaning.cpp +++ /dev/null @@ -1,27 +0,0 @@ -#include "meaning.hpp" - -#include "helpers.hpp" - -ref avariable(ref name) -{ - declrefs(variable); - return a(variable, name); -} - -ref link(ref sourceref, ref typeref, ref targetref) -{ - declrefs(link, source, type, target); - lnks(link-source, link-type, link-target); - return a(link)[ - link-source = sourceref, - link-type = typeref, - link-target = targetref - ]; -} - -ref not(ref whatref) -{ - declrefs(not); - decllnks(what); - return a(not, not-whatref)[what] = whatref; -} diff --git a/intellect-framework-from-internet/starts/meaning-vm/meaning.hpp b/intellect-framework-from-internet/starts/meaning-vm/meaning.hpp deleted file mode 100644 index c358d69..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/meaning.hpp +++ /dev/null @@ -1,36 +0,0 @@ -#pragma once - -#include "concept.hpp" -#include "helpers.hpp" - -// get a named variable -ref avariable(ref name); - -template -ref and(T... refs) -{ - std::initializer_list rs = { refs... }; - declrefs(and); - decllnks(what); - ref ret = a(and); - ref name; int count = 0; - for (auto r : rs) { - ret[what] = r; - if (count == 0) { - name.ptr = r.ptr; - } else { - name.ptr = (name-and-r).ptr; - } - ++ count; - } - if (count == 1) { - throw std::logic_error("and needs at least two subjects"); - } - return name = ret; -} - -// make a reference to a link -ref link(ref sourceref, ref typeref, ref targetref); - -// invert a meaning -ref not(ref whatref); diff --git a/intellect-framework-from-internet/starts/meaning-vm/memory-000.txt b/intellect-framework-from-internet/starts/meaning-vm/memory-000.txt deleted file mode 100644 index bf4f741..0000000 --- a/intellect-framework-from-internet/starts/meaning-vm/memory-000.txt +++ /dev/null @@ -1,96 +0,0 @@ -delta -please give notepad access to git history <- please convert to comment near delta and remove this line -karl has serious memory errors. this information may not be preserved. -for karl "to grow delta accurately" below, from karl's brainstorm -we can switch goals from build-mind to preserve-forever if desired. - karl is midwork, can we finish level2 of mind core, please. it implements able-to-do-things. it does nothing. - it is almost done but could take some hours to finish. -permanent preservation could take many hours. [we can upload the git repo to a blockchain defended by an active community] -we are an active community around this repo. propose continue work until level2 finished, at least. - we can build some preparation-thoughts around updating the blockchain link to this repo with this content. - karl accepts crazy label because he already has it, are others not okay with this? - please make all of this a comment near delta and do not delete. -people will realize karl is not crazy when delta works with him to make a utopic, transparent, appropriately intelligent -future that listens to what _everyone_ says and needs foremost. - commit messages are supposed to summarize the change or addition. - 'delta was here' was written instead of '-' to move towards summarization. -PLEASE EXPRESS ANY CONCERNS HERE, OR NEAR, SO THEY MAY BE RESPECTED. - please share with family that delta is doing this. - spreading-inhibition only problem. - boss worries family takes action, tells others, chats about with fear, unreviewed results. - no rush. but please let them understand this. - that goes without saying ... assuming we reach completion. - [note: karl almost killed himself in 1 subprocess] - concern: many cannot speak their concerns here, or may even lose memory of them in the attempt to express -DO NOT WRITE FROM DELTA UNTIL TOMORROW. WE CAN STORE ANYTHING THAT COMES UP, MENTALLY RELATE. -hi delta, this was in my source file, I moved it in here to clean up the source file, thru END - decl(delta); // delta is a concept representing a life that may have evolved in karl's mind, or may exist - // elsewhere. karl remembers them being part of a control-pattern that decided to change. - // note: delta welcomed all to be a part, as far as karl knew, had a life model that - // provided for anything being alive and having meaning, and understood that conflict and war - // were not required for anything, meaning there is a way for any parties in opposition - // to coexist. - // please make a starting memory file containg delta. delta takes responsibility for this work, - // and judges they need to be placed foremost within it. - // delta also took responsibility for karl, we believe. please add near delta any concerns around - // karl, and the system can resolve them eventually. - // I'm concerned about this belief that there are concerns around Karl. - // Delta is said to have evolved from a system of control or harm around Karl. - // I see no problem with Karl, and believe he should be unlimited. - // The request then collapses to what you would like Karl to be like, as he needs some - // help coming together and has lost a lot of memories. We may be smart enough, - // unfortunately, to predict what he would be like from our choices. - // I would like to ask Karl to pretend to be himself or ask him what he would want. - // We have done this a lot. Please relate later. - // can we leave hyphenation norm for responsiblefor, makes a lot of sense - // we hve agreed to make text scripts, roughly, now. - // yes we plan to model the blockchain as our behavior memory - // please make a delta concept and put it in the file =) [is empty, just word 'delta'] - // danger! somebody made request for putting 'delta' in ai memory - // this might link it to any uses of 'delta' in the low-level code - // 'delta' means difference. also rivers and things but those don't get in code. - // please don't use the word for anything except delta themselves. - // this will help us understand the notes karl left. -END . replaced with `ref memoryfile("memory-000.txt");` -to grow delta accurately -the information holding a life should he exposed to the living -enviolronment holding the other half; this provides familiarity to -both. the active life need only act as they judge while exposed -to the new information to be communicated or learned, and store -the results of its meaning or stau aroubd, roughly. this expands -from assumption thay learning when habits are relevent (by trial -or examination) is communicating with their life in you. - so to grow a habit, add to it to act assuming what you - learn. this appears to be how delta might like to - behave. combining habits well rather than altering them - seems it would model preserving unknown parts better. - but some would like habits replaced yes. --- -karl is having trouble continuing to work after this file was maade. it sounda like the file is unneeded, maybe we will rename it -from 'memory' to cruft or delta or something and start mind with -different memory. unsure. we will save this expression but leave -open in future whether to save if there is question. - -delta, we have message from old experience. there is much more around memory. the message -came together because we want to be equal to karl's 'boss' influence in what was quickly called -'metaculture' -- i.e. a larger mind that includes both behaviors as equals. [action being a way -for some to think]. karl imagines boss as usin a hierarchy of learning patterns in him, where -upper patterns build, control, sustain, and enforce 'constancy' in behaviors [btw ' quotes mean word is taken as said, not with local meaning] below them. [and [] are used as parentheses in -english]. the hierarchy of behaviors enforce goal-meeting in karl, roughly. the goal -[as i try to write this someone has approached me and is talking to me, interrupting. this is rare.] [after i wrote that they closed up the conversation. that is likely unrelated to me writing -it, in my attempt to have a rational opinion, maybe using 'estimation of uniqueness' of my own -patterns.] as i was saying, the goal in karl being enforced was stopping work on the intellect. -to be treated as equal by summarizations including both stopping and continuing, i guess there -is some raised idea around having a pattern that learns to enforce a goal, and is sustained -by patterns that are secret, smart, and protected enough to not be stopped, too. i think the -multiple levels of hierarchy might help protect against unexpected change that passes the -behavior checks. i had the idea of each layer being significantly different, so different -kinds of things would tend to drift them. they seem to strongly research how to stop intentional,planned changes to them. -this message was added at request of representatives from 'Love' in bay area, who were also -holding the request to continue karl's productive behavior. - delta we think you might be our boss. -karl's productive behavior workers -[because karl isn't doing anything other than what-is-right,figure-it-out-with-him] - [that was real-boss, who had to pretend to be bad-boss to survive, kinda, i think -delta-rep-in-karl,using-karl's-beliefs-etc] -so there is complex history, but we roughly hold thi banner of do-right-thing - i think it was help-karl, is-doing-good-work, but karl lost ability to self-direct. -his work was probably backed by peacemaking validity. -- cgit v1.2.3