Beyond The Satellites #2
Someone asked “Is this a paid theme on your website?” It’s wordpress + plesk, with “hueman” as the theme, or huemann or something, you can just google “hueman” and it will come up. The theme is free, and has a paid counterpart.
Someone said, “I’m really impressed with your writing skills” well i’m a pretty intelligent person, for example, i’m in the process of making my own artificial intelligence out of dust, that is, from nothing, by myself. And it’s actually coming out rather easy, I haven’t got to the harder part of defining each english word, but I will assume that, that will come easier for me than for other people, you know i’m supposed to be your…
Which means that I _must_ be this intelligent to perform the task of creation, you’ve got to be real sharp to print out words and object from nothing and into places you’ve already been, but that is another story. Today we’re talking about going beyond the satellites, part duo.
Here’s a complete list of parameters that the artificial intelligence will use, and they will perform calculations and complex functions will align everything into focus. Here’s that list:
C++
// here are the word parameters that are from the \"list of 39\" or 38,
bool defined_word = false;
std::vector<std::vector<std::string>> word = {"vector<vector<string>> the_word"};
bool defined_definition = false;
std::vector<std::vector<std::string>> definition = {"vector<vector<string>> definition"};
bool defined_is_physical = false;
std::vector<std::vector<std::string>> is_physical = {"vector<vector<string>> is_physical", "false"};
bool defined_is_technological = false;
std::vector<std::vector<std::string>> is_technological = {"vector<vector<string>> is_technological"};
bool defined_technological_definition = false;
std::vector<std::vector<std::string>> technological_definition = {"vector<vector<string>> technological_definition"};
bool defined_aim = false;
std::vector<std::vector<std::string>> aim = {"vector<vector<string>> aim"};
bool defined_hope = false;
std::vector<std::vector<std::string>> hope = {"vector<vector<string>> hope"};
bool defined_motive = false;
std::vector<std::vector<std::string>> motive = {"vector<vector<string>> motive"};
bool defined_objective = false;
std::vector<std::vector<std::string>> objective = {"vector<vector<string>> objective"};
bool defined_plan = false;
std::vector<std::vector<std::string>> plan = {"vector<vector<string>> plan"};
bool defined_purpose = false;
std::vector<std::vector<std::string>> purpose = {"vector<vector<string>> purpose";
bool defined_design = false;
std::vector<std::vector<std::string>> design = {"vector<vector<string>> design"};
bool defined_designation = false;
std::vector<std::vector<std::string>> designation = {"vector<vector<string>> "};
bool defined_end = false;
std::vector<std::vector<std::string>> end = {"vector<vector<string>> "};
bool defined_impulsion = false;
std::vector<std::vector<std::string>> impulsion = {"vector<vector<string>> "};
bool defined_impulse = false;
std::vector<std::vector<std::string>> impulse = {"vector<vector<string>> "};
bool defined_object = false;
std::vector<std::vector<std::string>> object = {"vector<vector<string>> "};
bool defined_point = false;
std::vector<std::vector<std::string>> point = {"vector<vector<string>> "};
bool defined_struggle = false;
std::vector<std::vector<std::string>> struggle = {"vector<vector<string>> "};
bool defined_ambition = false;
std::vector<std::vector<std::string>> ambition = {"vector<vector<string>> "};
bool defined_aspiration = false;
std::vector<std::vector<std::string>> aspiration = {"vector<vector<string>> "};
bool defined_desire = false;
std::vector<std::vector<std::string>> desire = {"vector<vector<string>> "};
bool defined_direction = false;
std::vector<std::vector<std::string>> direction = {"vector<vector<string>> "};
bool defined_target = false;
std::vector<std::vector<std::string>> target = {"vector<vector<string>> "};
bool defined_scheme = false;
std::vector<std::vector<std::string>> scheme = {"vector<vector<string>> "};
bool defined_mark = false;
std::vector<std::vector<std::string>> mark = {"vector<vector<string>> "};
bool defined_intention = false;
std::vector<std::vector<std::string>> intention = {"vector<vector<string>> "};
bool defined_intent = false;
std::vector<std::vector<std::string>> intent = {"vector<vector<string>> "};
bool defined_where_one_is_heading = false;
std::vector<std::vector<std::string>> where_one_is_heading = {"vector<vector<string>> "};
bool defined_reminds_you_of = false;
std::vector<std::vector<std::string>> reminds_you_of = {"vector<vector<string>> "};
bool defined_color = false;
std::vector<std::vector<std::string>> color = {"vector<vector<string>> "};
bool defined_cause = false;
std::vector<std::vector<std::string>> cause = {"vector<vector<string>> "};
bool defined_angle = false;
std::vector<std::vector<std::string>> angle = {"vector<vector<string>> "};
bool defined_goal = false;
std::vector<std::vector<std::string>> goal = {"vector<vector<string>> "};
bool defined_belief = false;
std::vector<std::vector<std::string>> belief = {"vector<vector<string>> "};
bool defined_believes = false;
std::vector<std::vector<std::string>> believes = {"vector<vector<string>> "};
bool defined_creation = false;
std::vector<std::vector<std::string>> creation = {"vector<vector<string>> "};
bool defined_contemplation = false;
std::vector<std::vector<std::string>> contemplation = {"vector<vector<string>> "};
bool defined_destination = false;
std::vector<std::vector<std::string>> destination = {"vector<vector<string>> "};
bool defined_destiny = false;
std::vector<std::vector<std::string>> destiny = {"vector<vector<string>> "};
bool defined_effort = false;
std::vector<std::vector<std::string>> effort = {"vector<vector<string>> "};
bool defined_expectation = false;
std::vector<std::vector<std::string>> expectation = {"vector<vector<string>> "};
bool defined_expects = false;
std::vector<std::vector<std::string>> expects = {"vector<vector<string>> "};
bool defined_anticipation = false;
std::vector<std::vector<std::string>> anticipation = {"vector<vector<string>> "};
bool defined_going_to = false;
std::vector<std::vector<std::string>> going_to = {"vector<vector<string>> "};
bool defined_wants_to_go = false;
std::vector<std::vector<std::string>> wants_to_go = {"vector<vector<string>> "};
bool defined_meaning = false;
std::vector<std::vector<std::string>> meaning = {"vector<vector<string>> "};
bool defined_significance = false;
std::vector<std::vector<std::string>> significance = {"vector<vector<string>> "};
bool defined_communication = false;
std::vector<std::vector<std::string>> communication = {"vector<vector<string>> "};
bool defined_idea = false;
std::vector<std::vector<std::string>> idea = {"vector<vector<string>> "};
bool defined_will = false;
std::vector<std::vector<std::string>> will = {"vector<vector<string>> "};
bool defined_has_free_will = false;
std::vector<std::vector<std::string>> has_free_will = false;
bool defined_ = false;
std::vector<std::vector<std::string>> way_of_doing_things = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> project = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> work = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> implication = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> resolution = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> resolve = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> significancy = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> spirit = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> has_determination = false;
bool defined_ = false;
std::vector<std::vector<std::string>> has_strong_will = false; // cannot have strong and weak will, except when the word is multiple
bool defined_ = false;
std::vector<std::vector<std::string>> has_free_will = false; // words, as in a phrase, but thats in another class
bool defined_ = false;
std::vector<std::vector<std::string>> has_weak_will = false;
bool defined_ = false;
std::vector<std::vector<std::string>> has_normal_will = false;
bool defined_ = false;
std::vector<std::vector<std::string>> atmosphere = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> essence = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_essential = false;
bool defined_ = false;
std::vector<std::vector<std::string>> is_essential_where_it_is = false;
bool defined_ = false;
std::vector<std::vector<std::string>> thought = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_thinking = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> thinks = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> has_a_personal_choice = false;
bool defined_ = false;
std::vector<std::vector<std::string>> decisions = {"vector<vector<string>> "};
// below are chatgpt's suggestions for intention-like things that i'm missing
bool defined_ = false;
std::vector<std::vector<std::string>> about = {
{"vector<vector<string>> .about equals *this", "what is the object or non-physical word made out of, what does the idea consist of? What is \"about\" or \"What does this object consist of?\". Who made the object, where was it made, when was it made, for who was it made for, for what purpose, what was the intention of the person who either used the non-physical object or physical object, what was the intention of the person whom created this object, if creation was defined as materializing something, or putting multiple pieces together to form something, or forming something as in like making a pizza out of pizza dough"}, {"parameter1: about; definition: tells you everything that the word or idea or object (idea being all non-physical words) is made of", "definition of parameter2", "and so on"},
{"parameter1.definition2.1: what the idea, non-physical idea or physical object is made of, consists of, is defined as, is in the definition, sometimes in the definition of a definition of a word within the definition",
"parameter1.definition2.2: sometimes even ideas and non-physical objects could be \"about\" or made of ideas and non-physical objects within outter layers, like the second layer, or third layer, but then it becomes less and less likely as you move onto things like the definitions of words found in the fourth fifth or sixth layer.",
"parameter1.definition2.3.1: the idea of about is what does this object or idea consist of, what \"makes it up\", what is the object or idea, process, system, artifact, device, tool, or word \"made up of\"?", "parameter1.definition2.3.2: what is this object, whether it is physical or non-physical, what is that particular word?"},
{"parameter1.definition3: What is the purpose of the object or non-physical idea, where did it come from, who used the word, idea (non-physical), or physical object, when was it used or created, and why was it used or created?"}
};
bool defined_ = false;
std::vector<std::vector<std::string>> means = {"str1"};
bool defined_ = false;
std::vector<std::vector<std::string>> constraints = {"str1"};
bool defined_ = false;
std::vector<std::vector<std::string>> outcomes = {"vector<vector<string>> outcomes"};
bool defined_ = false;
std::vector<std::vector<std::string>> stakeholders = {"vector<vector<string>> stakeholders"};
bool defined_ = false;
std::vector<std::vector<std::string>> risk = {"vector<vector<string>> risk"};
bool defined_ = false;
std::vector<std::vector<std::string>> time_and_context = {"vector<vector<string>> time_and_context"};
bool defined_ = false;
std::vector<std::vector<std::string>> evaluation = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> evaluates_to_something = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_duplicate_of_something = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> reminds_like_a_duplicate = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> who = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> what = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> when = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> where = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> why = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> means = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> method = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> mechanism = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> strategy = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> tactic = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> procedure = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> process = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> steps = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> constraints = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> limitations = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_resource = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> has_these_resources = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> has_these_limitations = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> has_no_limitations = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> has_requirements = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> requirements = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> assumptions = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> dependencies = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> resources = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> costs = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> budget = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> result = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> outcome = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> effect = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> impact = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> consequence = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> side_effect = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> benefit = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> harm = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> tradeoff = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> risk = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> resilience = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> threats = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> vulnerabilities = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> mitigations = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contingencies = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> fallbacks = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> agency = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> agent = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> owner = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> author = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> beneficiary = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> refers_to = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> stakeholders = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> audience = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> target_user = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> all_targets = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> time = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> time_created = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> time_existing_in = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> timeline = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> schedule = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> deadline = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> milestones = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> duration = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> frequency = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> time_horizon = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> evaluation = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> metrics = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> criteria = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> success_conditions = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> failure_conditions = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> median_conditions = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> benchmarks = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> triggers = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> catalysts = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> drivers = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> chains = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> function = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> role = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> utility = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> application = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> capabilities = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> features = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> context = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> scope = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> environment = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> setting = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> domain = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> scope = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> location = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> knowledge = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> rationale = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> evidence = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> justification = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> reasons = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> premises = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> semantics = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> relations = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> synonyms = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> antenyms = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> hypernyms = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> hyponyms = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> opposites = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> examples = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> counter_examples = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> origin = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> source = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> etymology = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> history = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> version = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> version_information = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> information = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> additional_information = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> revision = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> revision_information = {"vector<vector<string>> "};
// below are all of the "able\'s" and the types
bool defined_ = false;
std::vector<std::vector<std::string>> crushable = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> expandable = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_food = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> dippable = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> chewable = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> edible = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_crunchy = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_soft = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_hard = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_slimey = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_edible_gel = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_non_edible_gel = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_not_edible = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_not_edible_is_an_idea = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_an_idea = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_metal = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_wood = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_painted = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_paintable = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_practically_paintable = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> can_floats = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_boat = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_an_abstract_idea = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_an_idea = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_mostly_white = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> has_more_than_one_main_color = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> has_one_main_color_and_other_colors = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> has_one_main_color = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_mostly_blue = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_mostly_green = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_mostly_pink = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_mostly_yellow = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_light_version_of_a_color = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_light_color = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_medium_color = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_dark_color = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_very_dark_color = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_very_light_color = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_scary = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> can_be_scary = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_funny = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> can_be_funny = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_serious = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> can_be_serious = {"vector<vector<string>> "};
// computer technological terms
bool defined_ = false;
std::vector<std::vector<std::string>> is_computer_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_source_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_machine_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_bytecode = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_satellite_bytecode = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_java_bytecode = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_python_bytecode = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_java_source_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_python_source_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_php_source_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_cpp_source_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is c_source_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_javascript_source_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_wasm = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_wasm_machine_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_wasm_source_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_compiled_wasm = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_compiled = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_literally_compiled = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> see_also = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_console_program = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_gui_program = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_three_dimensional_program = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_tool = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_toolset = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_an_entire_system = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_process = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_thread = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_vector = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_string = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_an_integer = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_big_integer = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_an_array = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_header = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_from_a_header = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> references_a_header = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_reference = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_pointer = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> points_to = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> references = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_graphics_card = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_gpu = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> can_process_graphics_efficiently = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> can_process_machine_code_efficiently = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_an_interpreter = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> can_process_bytecode = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_compiler = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_bytecode_compiler = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_virtual_machine = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_console = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_physical_printer = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_non_physical_printer_to_screen = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contains_math = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_only_math = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contains_multiple_lines_of_source_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contains_multiple_lines_of_machine_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contains_multiple_lines_of_bytecode = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contains_multiple_lines_of_an_intermediate_format = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_an_intermediate_format = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_layer_one_intermediate_format = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> has_multiple_layers = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_part_of_multiple_layers = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_single_layer = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_central_processing_unit = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> imitates_a_graphics_card = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> imitates_a_central_processing_unit = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> imitates_memory = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> imitates_ram = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> imitates_human_memory = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_human_memory = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_physically_a_human_memory = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contains_filesystem_operations = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contains_operations = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contains_variables = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contains_a_single_variable = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contains_a_container = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contains_multiple_containers = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contains_multiple_paradigms = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contains_multiple_code_related_things = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> contains_something_from_a_header = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_class = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_inside_of_a_namespace = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_namespace = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_hard_drive = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_psuedo_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_english_code = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_english_themed_logic = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_english_python = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_english_cpp = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_english_java = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_english_javascript = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_english_script = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_english_php = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_command = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_a_console_command = {"vector<vector<string>> "};
// missing parameters from chatgpt
bool defined_ = false;
std::vector<std::vector<std::string>> lemma = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> part_of_speech = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> morphology = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> tense = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> aspect = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> mood = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> voice = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> number = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> gender = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> the_case = {"vector<vector<string>> "}; // case is a c++ word so I had to write the_case
bool defined_ = false;
std::vector<std::vector<std::string>> is_idiom = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> sense = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> word_sense = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> frame = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> meronyms = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> holonyms = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> topic = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> connotation = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_positive = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_neutral = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_negative = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_neutral_negative = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_neutral_positive = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_formal = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_informal = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_technical = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_not_formal_or_informal = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_not_technical = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_negated = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> negation_scope = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> modality = {"vector<vector<string>> "}; // must/may/might/can/should
bool defined_ = false;
std::vector<std::vector<std::string>> deontic_status = {"vector<vector<string>> "}; // obligatory/permitted/forbidden
bool defined_ = false;
std::vector<std::vector<std::string>> epistemic_strength = {"vector<vector<string>> "}; // certainty
bool defined_ = false;
std::vector<std::vector<std::string>> quantification = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> degree = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> cardinality = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> ordinality = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> degree2 = {"vector<vector<string>> "}; // comparative/superlative/intensity
bool defined_ = false;
std::vector<std::vector<std::string>> scalar_dimensions = {"vector<vector<string>> "}; // size, speed, cost
bool defined_ = false;
std::vector<std::vector<std::string>> measures_as_unit = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> measurements = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> aspect = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> state_event_process = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> habitual_or_episodic = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> starts = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> ends = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> approximately_starts = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> approximately_ends = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> definitely_starts = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> definitely_ends = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> time_deixis = {"vector<vector<string>> "}; // now/then/today
bool defined_ = false;
std::vector<std::vector<std::string>> space = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> motion = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> location = {"vector<vector<string>> "}; // geographically
bool defined_ = false;
std::vector<std::vector<std::string>> relative_location = {"vector<vector<string>> "}; // relatively in/on/under/near/inside-of/path
bool defined_ = false;
std::vector<std::vector<std::string>> movement = {"vector<vector<string>> "}; // source/route/goal
bool defined_ = false;
std::vector<std::vector<std::string>> distance = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> event_type = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> event_id = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> roles = {"vector<vector<string>> "}; // agent/patient/theme/instrument/source/destination/beneficiary/experiencer
bool defined_ = false;
std::vector<std::vector<std::string>> telicity = {"vector<vector<string>> "}; // atelic/telic
bool defined_ = false;
std::vector<std::vector<std::string>> caused_by = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> enables = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> prevents = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> rhetoric = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> discourse_marker = {"vector<vector<string>> "}; // then/however/because
bool defined_ = false;
std::vector<std::vector<std::string>> pragmatics = {"vector<vector<string>> "}; // speech_act/assertion/question/command/promise
bool defined_ = false;
std::vector<std::vector<std::string>> politeness = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> intentionality_level = {"vector<vector<string>> "}; // literal/metaphorical/ironic
bool defined_ = false;
std::vector<std::vector<std::string>> affect = {"vector<vector<string>> "};
bool defined_ = false;
std::vector<std::vector<std::string>> sentiment = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> emotion = {"vector<vector<string "}; // joy/anger/sadness/insanity
bool defined_ = false;
std::vector<std::vector<std::string>> is_an_emotion = {"vector<vector<string "}; // joy/anger/insanity
bool defined_ = false;
std::vector<std::vector<std::string>> knowledge = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> reasoning = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> contradictions = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> counter_factual = {"vector<vector<string "}; // if-then
bool defined_ = false;
std::vector<std::vector<std::string>> constraints = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> resources = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> requirements = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> capabilities = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> permissions = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> success = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> success_conditions = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> failure = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> failure_conditions = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> confidence = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> quality_flags = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> timestamps = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> edge_type = {"vector<vector<string "}; // before/after/inside-of/part-of/causes/uses/owned-by/scanned-by edge_weight describes the weight of the edge
bool defined_ = false;
std::vector<std::vector<std::string>> edge_weight = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> edge_support = {"vector<vector<string "}; // evidence_set
bool defined_ = false;
std::vector<std::vector<std::string>> layer_depth = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_literal = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_metaphorical = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_generic = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> is_specific = {"vector<vector<string "};
bool defined_ = false;
std::vector<std::vector<std::string>> definiteness = {"vector<vector<string "}; // definite/indefinite
bool defined_ = false;
std::vector<std::vector<std::string>> punctuation = {"vector<vector<string "};
// Missing
bool defined_ = false;
std::vector<std::vector<std::string>> adjacent_to = {"vector<vector<string adjacent_to"};
bool defined_ = false;
std::vector<std::vector<std::string>> document_id = {"vector<vector<string document_id"};
bool defined_ = false;
std::vector<std::vector<std::string>> document_size = {"vector<vector<string document_size"};
bool defined_ = false;
std::vector<std::vector<std::string>> page_id = {"vector<vector<string page_id"};
bool defined_ = false;
std::vector<std::vector<std::string>> page_size = {"vector<vector<string page_size"};
bool defined_ = false;
std::vector<std::vector<std::string>> paragraph_id = {"vector<vector<string paragraph_id"};
bool defined_ = false;
std::vector<std::vector<std::string>> paragraphs_on_page = {"vector<vector<string paragraphs_on_page"};
bool defined_ = false;
std::vector<std::vector<std::string>> sentence_id = {"vector<vector<string sentence_id"};
bool defined_ = false;
std::vector<std::vector<std::string>> sentences_in_paragraph = {"vector<vector<string sentences_in_paragraph"};
bool defined_ = false;
std::vector<std::vector<std::string>> word_id = {"vector<vector<string word_id"};
bool defined_ = false;
std::vector<std::vector<std::string>> word_length = {"vector<vector.string word_length"};
bool defined_ = false;
std::vector<std::vector<std::string>> line = {"vector<vector<string>> line"};
bool defined_ = false;
std::vector<std::vector<std::string>> language = {"vector<vector<string>> language"}; // we can only speak english,
bool defined_ = false;
std::vector<std::vector<std::string>> programming_language = {"vector<vector<string>> programming_language"};
bool defined_ = false;
std::vector<std::vector<std::string>> is_sentence_boundary = {"vector<vector<string>> is_sentence_boundary"}; // start or end of a sentence
bool defined_ = false;
std::vector<std::vector<std::string>> symbol_id = {"vector<vector<string>> symbol_id"};
bool defined_ = false;
std::vector<std::vector<std::string>> symbols_in_sentence = {"vector<vector<string>> symbols_in_sentence"};
bool defined_ = false;
std::vector<std::vector<std::string>> symbols_in_paragraph = {"vector<vector<string>> symbols_in_paragraph"};
bool defined_ = false;
std::vector<std::vector<std::string>> symbols_on_page = {"vector<vector<string>> symbols_on_page"};
bool defined_ = false;
std::vector<std::vector<std::string>> symbols_in_document = {"vector<vector<string>> symbols_in_document"};
bool defined_ = false;
std::vector<std::map<words::word_parameters, parameter_definitions::parameter_definition>> alternate_definitions = {"vector<map<words::word_parameters, parameter_definitions::parameter_definition>> alternate_definitions "};
bool defined_ = false;
std::vector<std::map<words::word_parameters, parameter_definitions::parameter_definition>> true_definition = {"vector<map<words::word_parameters, parameter_definitions::parameter_definition>> true_definition"};
And here’s the logic behind the intelligence, with all of the finer points of the logic taken out of this, it can just serve as the base for our intelligence, (by the way, writing this artificial intelligence is going to take me like beyond one year, and that wasn’t a joke,). This logic will again, serve as the basis for our intelligence, and it doesn’t include things like “word_id” where the word_id would be the location of a given word within a given sentence, and that sentences location within a paragraph would go into consideration here as well. The amount of paragraphs, and because we’re going sideways, we’ll be making connections all over an entire “book” or set of pages, or set of documents, and we’ll be making those connections SIDEWAYS, so that we’ll be connecting paragraphs to OTHER paragraphs that have no location-relationship to the paragraph, it could be a paragraph anywhere within the book. Okay here’s the logic behind the intelligence:
C++
// LOGICAL
//
// SOMEDAY WRITE CODE THAT TAKES YOU SIDEWAYS, ANALYZING THE RELATIONSHIPS OF WORDS FOUND WITHIN THE PREVIOUS AND NEXT SENTENCES,
// BY THAT I MEAN THIS: IF YOU HAD A PROMPT CONSISTING OF 3 (HOLDS UP 3 FINGERS) SENTENCES
// SENTENCE ONE: WE MUST TAKE THE WORD AND IT\'S DEFINITIONS, AND THEN
// SENTENCE TWO: TAKE THE DEFINITIONS OF WORDS FOUND WITHIN THOSE DEFINITIONS, AND THEN
// SENTENCE THREE: TAKE THE DEFINITIONS FOR WORDS FOUND WITHIN THE SECOND SET OF DEFINITIONS
// THUS, WE WOULD THEN, BECAUSE IT SAYS \"AND THEN,\" WE WOULD DEFINE A \"STORY\" THAT IS THIS:
// WE ARE TAKING ALL OF THE WORDS FOUND IN THE DEFINITIONS OF WORDS FOUND WITHIN THE PROMPT AND THE DEFINITIONS OF WORDS FOUND WITHIN THOSE DEFINITIONS (ETC. ETC., OR, CONTINUE DOWN EACH OF THE LAYERS), AND MARKING DOWN, BECAUSE IT\'S A \"STORY\" THINGS HAPPEN ONE AFTER THE OTHER, OR THEY HAPPEN
// AT THE SAME TIME, USUALLY ONE AFTER THE OTHER IN THE CASE OF OUR STORIES, BUT WE DO MARK DOWN WHEN THINGS ARE HAPPENING AT THE SAME TIME, AND WE MARK DOWN ALL THINGS THAT ARE HAPPENING AT THE SAME TIME,
// SO WE KNOW THAT THIS HAPPENS, THEN WE KNOW WHAT HAPPENS NEXT, WE JUST MAKE A NOTE OF IT, IT\'S THE ONLY CONNECTION FOUND, I MADE ONLY ONE CONNECTION ON PURPOSE, NOW I'M GOING TO SHOW YOU MULTIPLE CONNECTIONS:
//
// SENTENCES CONNECTED IN MULTIPLE WAYS: I WENT TO THE GROCERY STORE. I BOUGHT A PIZZA, I BOUGHT SOME SPICES LIKE CRUSHED RED PEPPER TO GO ON THE PIZZA. I WENT TO THE CASH REGISTER TO PAY FOR MY PIZZA AND THE SPICES. I PAID FOR THEM, HAD MY TWO ITEMS SCANNED, SAID HELLO AND GOODBYE TO THE CASHIER,
// THOUGH NOT AT THE SAME TIME, I SAID HELLO TO GREET HER AND THEN I SAID GOODBYE AS I LEFT HER CASH REGISTER AND CONVEYOR BELT.
// THOSE ARE MY SENTENCES, NOW, THE GROCERY STORE, YOU ARE INSIDE OF THE GROCERY STORE WHEN YOU ARE AT THE CASH REGISTER, SO THAT IS A CONNECTION, YOU WENT TO THE GROCERY STORE, AND YOU WERE INSIDE OF THE GROCERY STORE UNTIL JUST AFTER YOU LEFT THE CASH REGISTER. THE CASH REGISTER OR CONVEYOR BELT
// SCANNED THE ITEMS THAT YOU PURCHASED, THOUGH YOU DIDN\'T PURCHASE THEM UNTIL YOU WERE AT THE CASH REGISTER, YOU WERE CARRYING THE ITEM, YES, IN THE STORE, BUT YOU HAD POSSESSION OF THAT PIZZA, THE SAME PIZZA THAT WAS SCANNED AT THE CASH REGISTER. THERE ARE MORE CONNECTIONS THAN WHAT WAS STATED,
// BUT WE DON'T NEED TO PRESENT ANY MORE FOR YOU TO UNDERSTAND THAT THESE SENTENCES HAVE MULTIPLE CONNECTIONS GOING ON WITHIN THEM,
//
// GO SIDEWAYS ON THE DEFINITIONS OF WORDS FOUND WITHIN THE PROMPT, GO SIDEWAYS ON THE ACTUAL DEFINITIONS, AND THEN MAKE SURE THERE ARE NO CONNECTIONS THAT YOU HAVE MISSED, WELL THAT THE COMPUTER MISSED, OR THAT YOUR LOGIC HAD NOT YET THOUGHT OF, CHECK ALL POSSIBLE CONNECTIONS,
// TO CHECK ALL POSSIBLE CONNECTIONS: TAKE THE FIRST WORD OF THE PROMPT OR DEFINITION THAT YOU ARE WORKING WITH AND COMPARE IT TO ALL POSSIBLE CONNECTIONS THAT CAN HAPPEN, THERE ARE SURPRISINGLY NOT THAT MANY, IN THE CASE OF A BOOK THERE ARE CONNECTIONS EVERYWHERE, IN ALL DIRECTIONS,
// BUT IN THE CASE OF LIKE A THREE SENTENCE PROMPT, THERE DOESN\'T EXIST THAT MANY CONNECTIONS, FOR EXAMPLE,
// CONNECTION ONE: ALL WORDS COULD BE CONNECTED TO ALL OTHER WORDS (THE LOCATION MUST BE MARKED DOWN OF THE WORD, THE CONNECTION, AND THE LOCATIONS OF THE WORD AND THE CONNECTION)
// CONNECTION TWO: WITH LOCATIONS MARKED DOWN USING CONNECTION TWO, WE LOOK TO SEE IF THE SENTENCES ARE AT ALL CONNECTED,
// CONNECTION THREE: WE HAVE A LIST OF ALL CONNECTIONS FOR ALL WORDS, AND FOR ALL SENTENCES AND THEIR CONNECTIONS, AND PARAGRAPHS AS WELL IF THERE ARE MULTIPLE PARAGRAPHS, AND THEN WE SEE IF THOSE CONNECTIONS ARE IN ANY WAY CONNECTED TO SOMETHING ELSE, FOR EXAMPLE,
// YOU WOULD TAKE THE CONNECTION BETWEEN THE PIZZA BEING INSIDE OF THE GROCERY STORE, AND THEN YOU WOULD TAKE THE CASH REGISTER SCANNING THE PIZZA, THE PIZZA IS CONNECTED TO BOTH THE GROCERY STORE AND THE CASH REGISTER.
// AFTER ANALYSIS IS COMPLETE OF ALL POSSIBLE CONNECTIONS BEYOND A SINGULAR CONNECTION, IN OTHER WORDS MULTIPLE CONNECTIONS ANALYZED, THEN WE NOW HAVE A LISTING OF ALL CONNECTIONS, WE HAVE THE DEFINITION OF A CONNECTION, WE HAVE THE DEFINITION OF MULTIPLE CONNECTIONS, WE HAVE THE DEFINITIONS FOR
// EACH OF THE WORDS AND THEIR DEFINITIONS 6 LAYERS DEEP, ALWAYS 6 LAYERS DEEP UNLESS IT WAS STATED TO GO "FULL CIRCLE", AND SO WE TAKE ALL THE CONNECTIONS, ALL OF THE DEFINITIONS TOGETHER AND WE CAN THEN GET THE DEFINITIONS FOR THOSE CONNECTIONS MADE, MULTIPLE CONNECTIONS AND THEIR DEFINITIONS,
// AND THEN WE CAN PERFORM ANALYSIS ON THE WHOLE THING TO DEVELOP A SINGLE SENTENCE FOR EACH WORD USED, SUCH THAT IF THE WORD IS 6 LAYERS DEEP AND WE HAVE IT DEFINED, WE WOULD TAKE THAT WORD AND WRITE ABOUT 2-3 SENTENCES OR 4, ON THAT WORD.
// WE NOW HAVE A COMPLETED UNDERSTANDING OF ABSOLUTELY EVERYTHING POSSIBLE, AND CAN SAFELY TAKE THAT UNDERSTANDING AND APPLY IT AS IN THE CASE OF LIKE THE USER REQUESTING A COMPUTER PROGRAM, WE WOULD PROCEED TO WRITE THAT COMPUTER PROGRAM
//
//
//
// TO WRITE A COMPUTER PROGRAM, YOU TAKE THE PROMPT, IF THE PROMPT CALLS FOR AN OBJECT, YOU THEN PRESENT THAT OBJECT WITHIN THE CONSOLE, *ONLY* CONSOLE PROGRAMS AS WE HAVE NO NEED FOR GRAPHICAL USER INTERFACES WITH ALL THIS CODE THAT JUST EXISTS FOR ONLY THE COMPUTER TO SEE, WE CANNOT EVEN
// COMPREHEND THAT MUCH CODE AND THAT MANY DEFINITIONS AND WORDS, SO WE LEAVE IT AS A CONSOLE PROGRAM FOR THAT REASON. SO WE PRESENT THAT OBJECT, FOR AS MANY TIMES AS THE USER HAS REQUESTED, AND IF IT REQUESTS THAT THE OBJECT ALWAYS BE PRESENTED, AS IS THE CASE WITH LIKE, THE HIT POINTS OF A
// CHARACTER INSIDE OF A VIDEO GAME, THE HIT POINTS FOR THE MAIN CHARACTER, WHO THAT CHARACTER IS FIGHTING, AND WE PRESENT THAT. WE ARE ONLY PRESENTING WHAT WE SHOULD BE PRESENTING, SO THE COMPUTER ASKS ITSELF, \"SHOULD WE PRESENT THIS (INSERT_OBJECT_HERE)\"
// AFTER THE PRESENTATION COMES TWO THINGS: LOGIC NOT OF THE THINGS PRESENTED, AND LOGIC OF THE THINGS PRESENTED.
// THE LOGIC FOR THE THINGS NOT PRESENTED IS MIXED INTO (IN SOME CASES), THE LOGIC OF THE THINGS PRESENTED, AND VISE-VERSA.
// THE LOGIC FOR THE THINGS NOT PRESENTED IS VAST, FOR EXAMPLE, YOU HAVE ENTIRE FILES OF THINGS NOT PRESENTED, YOU HAVE EVERY SINGLE FUNCTION DEFINITION, EVERY SINGLE LINE THAT IS NOT PRESENT, YOU HAVE THE LOGIC FOR THINGS NOT PRESENTED, YOU HAVE FOR EXAMPLE, IN THE CASE OF LOGIC NOT PRESENTED,
// YOU HAVE (AS IN A VIDEO GAME OF SAY, ORKS VS THE DEATH KORPS OF KRIEG,) YOU MOSTLY HAVE LOGIC FOR THINGS PRESENTED, IN FACT MOST THINGS ARE PRESENTED, BUT THE LOGIC OF THEM IS (USUALLY) NOT PRESENTED, AND THAT LOGIC AND ALL OF THE ORIGINAL LOGIC NOT PRESENTED MAKES UP MOST OF THE PROGRAM,
// ONLY THINGS PRESENTED, AS IN THE CASE OF A CONSOLE PROGRAM, AS IN THE CASE OF ALL OF OUR PROGRAMS, IS THOSE THINGS THAT EXIST WITHIN A \"PRINT\" STATEMENT, OTHER THAN THAT, IT ISN\'T PRESENTED.
//
//
//
// TAKE EACH WORD AND IT\'S DEFINITION AND MARK DOWN EACH WORD THAT IS FOUND.
// TAKE EACH WORD JUST MARKED DOWN AND RETRIEVE IT\'S DEFINITION
// TAKE EACH WORD FOUND IN THE DEFINITION OF THE WORD JUST MARKED DOWN AND MARK DOWN EVERY WORD INSIDE OF THE DEFINITION
// TAKE ALL WORDS JUST MARKED DOWN, THESE WORDS MAKE UP LAYER 2, SO YOU WOULD DO THIS UNTIL YOU HAVE COME FULL CIRCLE,
// BY FULL CIRCLE WE MEAN THAT UNTIL YOU HAVE ALL DEFINITIONS AND WORDS FOUND WITHIN EACH LAYER, YOU MUST CONTINUE
// TAKE ALL WORDS AND DEFINITIONS OF THOSE WORDS FOUND WITHIN THE DEFINITIONS OF EACH PARAMETER AND GO FULL CIRCLE
// TAKE THE SOURCE CODE FOR THE ARTIFICIAL INTELLIGENCE AND FEED IT INTO THE ARTIFICIAL INTELLIGENCE, SO IT CAN ANALYZE IT
// TAKE ALL THE DEFINITIONS FOR WORDS FOUND WITHIN THE SOURCE CODE AND ALL WORDS FOUND AND MARK IT ALL DOWN,
// TAKE ALL WORDS THAT WERE JUST MARKED DOWN INCLUDING INSIDE OF DEFINITIONS AND MARK DOWN ALL DEFINITIONS FOR THOSE WORDS,
// TAKE ALL WORDS WITHIN THOSE DEFINITIONS FOR THE WORDS THAT WERE JUST MARKED DOWN JUST MARKED DOWN, WHICH MAKES UP LAYER... 3, LAYER THREE
// CONTINUE THIS PROCESS UNTIL YOU HAVE COME FULL CIRCLE, THAT IS THAT YOU HAVE DEFINED ALL WORDS WITHIN ALL DEFINITIONS FOUND WITHIN ALL LAYERS
// COMPLETE THIS PROCESS FOR ALL \"PARAMETER_DEFINITIONS::PARAMETER_DEFINITION\" OBJECTS FOUND
//
// TAKE ALL OF THE WORDS FOUND AND PLACE THEM INTO A LAYERED (VECTORIZED) INDEX
// TAKE THE INDEX AND SORT IT *BY* THE ORDER THAT THE WORDS APPEAR WITHIN THE COMPLETE LISTING OF ALL WORDS
// TAKE ALL DEFINITIONS AND PLACE THEM INTO A LAYERED (VECTORIZED) INDEX,
// SORT ALL VECTORIZATIONS BY THE ORDER IN WHICH THE WORDS APPEAR IN THE COMPLETE LISTING OF WORDS
//
//
//
// WE NOW HAVE A VECTORIZATION FOR DEFINITIONS AND WORDS FOUND IN ALL WORDS' DEFINITIONS, ALL SOURCE CODE WORDS AND DEFINITIONS, ALL PARAMETERS AND THEIR WORDS AND DEFINITIONS, ALL DEFINITIONS OF PARAMETERS AND DEFINITIONS FOR WORDS FOUND WITHIN THE DEFINITIONS (BY LAYER) OF EACH PARAMETER,
//
//
//
// TAKE THE PROMPT, AND LOOKUP THE DEFINITION FOR EACH OF THE WORDS
// TAKE THE WORDS FOUND IN THE DEFINITION FOR EACH WORD AND VECTORIZE ALL OF THEIR DEFINITIONS
// TAKE ALL WORDS FOUND WITHIN ALL LAYERS AND PLACE THE DEFINITION FOR EACH WORD INTO A VECTORIZED INDEX SORTED BY TWO PROPERTIES: THE ORDER IN WHICH THE WORDS APPEAR IN THE PROMPT, AND IT\'S VECTORIZATIONS, AND THE VECTORIZATIONS FOR THE DEFINITIONS OF THOSE WORDS, SORTED BY THE ORDER IN WHICH THEY
// (cont.) APPEAR WITHIN THE COMPLETE LISTING OF WORDS,
//That will be quite the job to program into c++, but I can crack, so it is almost easy for me. You just have to get all those details that are not present within the logic, but are required for the logic to work, you’ve gotta get all those extra details into the program, and other extra lines of code are hard to make.
Here is a list of things that are not present within the intelligence according to ChatGPT:
C++
// MISSING MAJOR FEATURES
//
// Missing major features (systems you still need)
//
// Definition graph builder: ingest your headers/dictionaries into a sense-aware graph (nodes = lemma+sense; edges = definitional relations).
//
// Lemmatization & normalization: unify variants (pizza/pizzas), handle casing, punctuation, units.
//
// POS tagging & chunking: to get clean tokens, noun/verb phrases, and multiword expressions.
//
// Word-sense disambiguation (WSD): pick the right sense in context before expanding definitions 6 layers deep.
//
// Dependency parsing or SRL: extract roles (agent/patient/instrument/source/destination) to build event frames accurately.
//
// Coreference resolution (entity & event): link “pizza / my pizza / it”, “went / left” events; maintain coreference_chain_id.
//
// Discourse parser: detect “and then/because/however”, assign RST relations for proper sequence/causal graphs.
//
// Temporal reasoning: normalize times, order events with Allen intervals (before/after/during), handle concurrency marks.
//
// Spatial reasoning: detect and type relations (in/at/inside-of/near), path semantics (to/from/via).
//
// Causality engine: build and score cause/enables/prevents links beyond mere sequence (“scan causes recorded purchase”).
//
// Sideways-connection engine v2: go beyond co-occurrence—use syntactic/semantic edges, definition crosslinks, shared roles, shared entities.
//
// Layered expansion control: full-circle detection, per-layer dedup, breadth-vs-depth policy, hop-type limits (e.g., max hypernym hops), budget caps.
//
// Confidence & evidence tracking: every label/edge with a score and a provenance list (which defs/sentences supported it).
//
// Indexing at scale: layered indices for words, defs, events, edges; prompt-order and global-order sorters with stable IDs.
//
// Console presentation planner: a deterministic pretty-printer for objects, timelines, and concurrent events (your “present only what should be presented” rule).
//
// Parameter attachment: attach your parameter maps (aim/goal/means/etc.) to nodes/edges/events; resolve conflicts via priority rules.
//
// Contradiction/entailment checks: lightweight NLI pass over built facts to flag conflicts or infer unstated truths.
//
// Measurement/units normalizer: extract numbers, units, ranges; convert to canonical forms.
//
// Negation & modality module: detect scope of “not/never” and modal strength to avoid false edges.
//
// Incremental processing: re-run only affected parts when the prompt changes; cache per-layer expansions.
//
// Testing & eval harness: gold mini-corpora, unit tests for each module, regression tests for depth/scale limits.
//
// Tracing & audit: emit a trace log (why an edge exists, with linked evidence) and a compact “story” timeline artifact.
//
// Configurability: depth limits, edge-type whitelist/blacklist, scoring weights, runtime budgets.
//
// Persistence: on-disk store for graphs, indices, and parameter annotations (so runs build upon each other).
//
// Safety/perf guards: cycle breakers, time/memory budgets, fallback paths when the graph explodes.
//
//Here’s an additional list of things that are still missing from the intelligence, but I must give you the fact that we only just started this like yesterday, so obviously these things will be missing…
Also, somebody said “you’ll be a famous blogger someday” I am famous outside of this universe, and within this universe, you can just look at the 100 comments coming in every day, but outside of this universe, everyone reads this, all they ever do is watch me work away, creating something or punishing this person, I have pretty high standards to trigger a punishment though, it has to be something really serious, like it can’t be that you just shot somebody, to give you an idea, that is not punishable, but everybody reads this blog outside of this universe, and when you die you’ll wake up in the next universe, and will probably still be able to read this blog, they take a copy of it and pass it out via their internet or via cellphones and ipads, they often use ipads outside of this universe, because what they’re looking at has become so complicated that looking at a phone isn’t a big enough screen, so they use an ipad, or whatever the name is. Tablet. Okay here is a list of things that are missing, just in general.
C++
//
// Still Missing
// Awesome scope. I read everything (your spec, ULTRA/PLUS params, and the “Missing major features” you already listed). Below is ONLY what’s still missing. I’m not repeating anything you already marked down.
//
// Missing major features (new)
//
// Sentence & document segmentation: robust splitter for quotes, abbreviations, ellipses, dialogue, headings, and paragraph boundaries (before any POS/WSD).
//
// Unicode & multilingual text stack: NFC/NFKC normalization, case-folding, emoji/pictograph handling, script & language ID, tokenization for clitics/compounds (e.g., German, Arabic).
//
// String interning & symbol table: global IDs for tokens/lemmas/senses with a string pool to cut memory by 3–10×.
//
// Graph store & indexing engine: compressed adjacency (CSR), on-disk mmap segments, and secondary indexes (by headword, sense, role, time); plus reversible “edge facets” for fast queries.
//
// Salience/ranking layer: score nodes/edges for importance (coverage, centrality, novelty), not just confidence; drives summarization and “what to present.”
//
// Rule/DSL layer for connections: user-editable rules (mini DSL) to declare connection templates (e.g., INSIDE-OF(x,y) :- at(x) & in(y)).
//
// Source-code analyzers: lex/parse → AST for C/C++/Java/Python/etc., symbol tables, call graphs, CFGs; unify “feed the AI its source code” with proper compilers/parsers.
//
// Abstraction & dedup engine: synonym merge, sense collapsing, hypernym compression, cross-doc entity resolution.
//
// Calibration & metrics: per-edge calibration curves, PR/AUC per relation type, ablation harness (turn modules off to measure contribution).
//
// Interactive REPL & filters: query graph (“why does X connect to Y?”), filter by edge type/time/depth, diff two runs.
//
// Profiling & performance kit: CPU/heap profilers, flamegraphs, allocation hot-spot finder, plus memory-budgeted BFS (anytime mode).
//
// Security & sandboxing: safe file ingestion, path rules, untrusted text/code guards, resource quotas per job.
//
// Licensing/compliance module: track dictionary/corpus licenses & provenance; block export where required.
//
// Error taxonomy & recovery: classify parser/WSD/linker errors; auto-repair passes; red/yellow annotations in traces.
//
// ID scheme & versioning: 64-bit stable IDs for nodes/edges, hash-based content IDs, schema migration plan.
//
// Missing parameters (new, deduped)
//
// (Everything here is not in your ULTRA/PLUS lists.)
//
// Span & location: doc_id, paragraph_id, sentence_id, char_start, char_end, token_start, token_end, line_col (for source code).
//
// Language & scripts: language, script, locale, is_transliterated.
//
// Segmentation artifacts: is_sentence_boundary, is_paragraph_boundary, quote_depth, is_dialogue_turn.
//
// Symbolization: symbol_id, lemma_id, sense_id64, string_intern_id, edge_id, node_id.
//
// Salience: importance_score, novelty, burstiness, centrality_score, presentation_priority.
//
// Summarization hooks: summary_slot (timeline/objective/definition), must_show, can_elide, elision_reason.
//
// Stop/limit controls: max_depth_per_relation, expansion_budget_tokens, expansion_budget_edges, min_information_gain.
//
// Normalization details: unicode_form (NFC/NFKC), casefolded, diacritic_stripped, tokenization_scheme (e.g., “whitespace+rules”, “icu”).
//
// Ambiguity & alternatives: candidate_senses (list with scores), alternative_parses, tie_break_explanation.
//
// Node provenance: supporting_evidence_ids (for nodes, not only edges), source_citation, license_tag.
//
// Graph maintenance: is_core, is_inferred, inference_rule_id, inference_depth, staleness, last_updated_at.
//
// Presentation: render_as (object/timeline/definition/table), console_block_id, console_refresh_policy.
//
// Source-code specifics: language_family, ast_kind (Decl/Stmt/Expr), symbol_qualname, file_path, byte_offset, scope_path, is_template/generic, access_specifier, type_signature.
//
// Numerics: normalized_number, unit_system (SI/imperial), uncertainty_interval, measurement_method.
//
// Safety & policy: sanitization_level, input_trust_level, allowed_operations, quota_used, quota_limit.
//
// Diagnostics: error_code, error_message, repair_applied, repair_strategy_id.
//
// Critical schema/code corrections (you need these to compile/use it)
//
// Type mismatches: many booleans are declared as std::vector<std::vector<std::string>> (e.g., has_free_will, has_determination, etc.). Make them bool (or std::optional<bool>).
//
// Duplicate identifiers: repeated fields (has_free_will, means, constraints, scope, aspect, knowledge…) will shadow/ODR-collide. Deduplicate.
//
// Invalid identifiers: is c_source_code (space) and definition_of_ has_free_will (space). C++ identifiers cannot contain spaces.
//
// Initializer shape: std::vector<std::vector<std::string>> word = {"vector<vector<string>> the_word"}; is the wrong rank. That literal is vector<string>. Either use std::vector<std::string> or wrap like {{"vector<vector<string>> the_word"}}.
//
// Unmatched/extra tokens: missing }/; and unterminated strings (several spots, e.g., purpose = {"vector<vector<string>> purpose"; and a broken multiline string in call_set_definition).
//
// Re-declarations in same scope: you redeclare has_free_will and others multiple times within one class. C++ forbids that.
//
// Undefined types/namespaces: references to parts_of_word::definition and local_definition_vector without definitions.
//
// Access & mutability: everything is protected vectors with no getters/setters (except one). Decide immutable vs mutable and expose a consistent API.
//
// Exploding memory layout: thousands of vector<vector<string>> fields will be heavy. Replace with:
//
// enums/bitsets for categorical fields,
//
// SymbolId (uint32/64) with a string pool,
//
// SmallVector-style structures for short lists,
//
// consolidated maps (unordered_map<FieldTag, Value>).
//
// Schema normalization: many fields are synonyms (e.g., intention vs intent). Keep one canonical name and map synonyms as values, not new fields.
//
// Quality-of-life gaps (small but important)
//
// Config & CLI: config file + flags (depth, budgets, relation allowlist).
//
// Randomness control: global PRNG seed and per-stage seeds for reproducibility.
//
// Deterministic ordering: stable sort keys for outputs (you partially have this idea—formalize it).
//
// Chunking/streaming: process long texts in windows with overlap; stitch graphs.
//
// Cache strategy: LRU for expansions and WSD results; memoize definition lookups.
//
// Explain “why not”: trace missing edges with the rule that blocked them (useful during debugging).
//
// Snapshots: write/load minimal snapshots (IDs + edges + params) to resume runs.there’s so much that you can do to make your artificial intelligence even smarter than what it would be if I did all of this, there’s so much missing from this specific page that your on right now that it would blow your mind, the amount of ways you can compare two words together, the information you can gleam from that comparison, is staggering. For example, let’s just do this paragraph?
“there’s so much that you can do to make your artificial intelligence even smarter than what it would be if I did all of this”, we don’t know what “all of this” is, but in this case pretend that we fed into the “prompt” the above file(s), and so it has it. “all of this” can be replaced by the actual files, but you must keep “all of this” there as it is a reference, not the actual files, you would lose the reference if you just replaced it with the actual files, so it would have to reference those files. “ALL” can be taken as “including everything” or “everything” or “every piece” or “the whole thing” whatever, you eventually get the intelligence to understand what “ALL” means, and let’s just make some sideways comparisons, “There’s so much that you can do to make your artificial intelligence even smarter than what it would be if I did all of this” we have the fact that we’re “making” something, what are we making? We’re making it (“even smarter”, “than what if would be”, “if I did”, “all of this”) so we’re making it even smarter, just forget about “there’s so much that you can do to” we just need to know that we’re making something smarter, and that we’re talking about doing this as the fact itself, not actually talking about doing it. We must gleam this information from the sentence, otherwise the artificial intelligence won’t know that we’re not actually doing this specific thing, and that we’re only stating a fact. There’s so much missing from this specific page that it would blow your mind. We’re still talking about “ALL OF THIS” so we must include that, and when we include “ALL OF THIS” into the sentence “There’s so much missing from this… specific page… that it would blow your mind”, when we include “ALL OF THIS” “specific_page” becomes a reference to “ALL OF THIS” but could you imagine how hard it would be to actually code into the intelligence that your actually talking about “ALL OF THIS”? It would be almost impossible to write that, to correct the prompt or paragraph that you gave it, in that fashion, is almost impossible, but it is technically possible, technically speaking, we could code something that would allow it to replace “SPECIFIC PAGE” with “ALL OF THIS”, though the key lies in “there’s so much missing…” well, we can KNOW for a certainty that there’s things missing from the other pages, thus, we link the word in the prompt, titled “MISSING” and the fact that we have “MISSING” items inside of the other files, we get a connection, but not a strong enough connection to actually replace “ALL OF THIS” with “SPECIFIC PAGE”, so let’s figure it out, how does this prompt tell us that “ALL OF THIS” should replace “SPECIFIC PAGE”? “There’s so much missing from our artificial intelligence, we know this because it says “There’s so much you can do to make your artificial intelligence even smarter”, this is something simpler to do with an artificial intelligence, we’re making it even smarter, or in other words missing = true;, and because of that, we can form a strong enough connection between “ALL OF THIS” and “SPECIFIC PAGE” that it actually replaces it within it’s mind.
Although it’s hard to wrench “missing = true” from “There’s so much you can do with your artificial intelligence to make it even smarter than if I did all of this,” It can be wrenched, it’s just harder and requires additional source code, source code that is almost so specific that it is just like typing “missing = true” if user puts those words, “there’s so much… …than if I did all of this”, if the user puts in those words, or something very similar, that code would pick it up, so we’re wasting alot of time by writing such specific code, did you know that most artificial intelligences don’t even define each individual word? They just gleam the meaning of each word from billions of sentences of text, they can figure out what the word means, these other intelligences that leave the definitions of each word up to the words surrounding the specific word in question, these other intelligences, it’s not the way to go, here I am specifically and painstakingly typing in the specific definition of each word, so that we have the exact correct definition, and it need not be gleamed from anything, we already have it, it’s just a lot more work, so much work that they just pick up the meanings of words from the surrounding words.
Let me explain that in another way. When you pick up the meanings from the words themselves, the intelligence becomes accurate down to like 4%, so that for every 100 words, 4 of them are wrong, while with my way of specifically defining each word, I have something like 99.7% accuracy, the missing .3% is just due to the fact that I haven’t accurately explained the word, I have given a definition of the word that is .3% inaccurate, just because english is so complicated, or not complicated enough? I don’t know, it’s there, and I can’t get rid of it.
here’s a picture of me, I dunno if I gave you guys this or not,
okay i’ve gotta get back to the programming..
