| Index Entry | | Section |
|---|
|
| A | | |
|---|
| action choice state: | | Event History |
| action choice state condition: | | Structures for Accessing Storage |
| action emission matrix: | | Node Parameters |
| action emission matrix: | | Dumping the Action Emission Matrix |
| actor: | | Building Blocks for Intelligent Machines |
| actor: | | Adaptive Probabilistic Mapping |
| actor handle: | | Creating an Actor |
| actor n-gram buffer: | | Receiving Input Signals |
| actor pair: | | Creating the Model Instance |
| actor temperature: | | Actor Temperature |
| actor, large: | | Small and Large Actors |
| actor, small: | | Small and Large Actors |
| adaptive behavior mode: | | Switching Adaptive or Random Behavior of an Actor |
| adaptive behavior mode: | | Switching Adaptive or Random Behavior of a Multinode Model |
| adaptive probabilistic mapping: | | Building Blocks for Intelligent Machines |
| adaptive probabilistic mapping: | | Adaptive Probabilistic Mapping |
| aggregate statistics: | | Output Variables |
| array, output probabilities: | | Output Arrays |
| assembler instruction: | | Assembler Instructions |
| assembler instruction, user: | | Assembler Instructions |
| assembler instruction, user: | | User Instructions |
| assembler program: | | Assembler Program Syntax |
| assembler program handle: | | Basic Datatypes for Assembler Programs |
| assembler program section, data: | | Variables in an Assembler Program |
| assembler program, destroying: | | Basic Datatypes for Assembler Programs |
| assembler program, parsing: | | Parsing an Assembler Program |
| assembler program, preprocessing: | | Using the Assembler Preprocessor |
| assembling a node: | | Loading a Parsed Program into a Node |
| automatic spur: | | Automatic Spur |
| automaton state: | | Building Blocks for Intelligent Machines |
| automaton state: | | Event History |
| automaton state: | | Automatic Spur |
| auxiliary probability variable: | | Auxiliary Variables |
|
| B | | |
|---|
| basic node parameters: | | Node Parameters |
| behavior mode: | | Switching Adaptive or Random Behavior of an Actor |
| behavior mode: | | Switching Adaptive or Random Behavior of a Multinode Model |
| binary instruction parameters: | | Instruction Class Identifiers |
| built-in instruction: | | Assembler Instructions |
|
| C | | |
|---|
| callback function, enumeration: | | Revising Action Choice States |
| callback function, enumeration: | | Enumerating Action Choice States and Cycle Types |
| callback function, enumeration: | | Enumerating Entities |
| calling a node: | | Calling a Node |
| canonical instruction parameters: | | Setting Text Instruction Parameters |
| choice complexity: | | Animate Machines |
| class, instruction: | | Principle of Operation |
| class, instruction: | | Instruction Class Identifiers |
| class, instruction: | | Registering Instruction Classes |
| cloning a probability profile: | | Cloning the Probability Profile |
| cloning a probability profile: | | Memory Efficient Cloning the Probability Profile |
| complexity, choice: | | Animate Machines |
| condition for an action choice state: | | Structures for Accessing Storage |
| continuous cycle period: | | Receiving Input Signals |
| continuous time: | | Incrementing Time |
| continuous time: | | Incrementing Time and Spur |
| control, possessing by a node: | | Multinode Model |
| control, returning from a node: | | Returning Control from a Node |
| control, transferring to a node: | | Calling a Node |
| controlled probability variable: | | Controlled Variables |
| creating a map: | | Creating Maps and Iterators |
| creating a message: | | Creating Messages |
| creating a message list: | | Creating a Message List |
| creating a model: | | Creating a Handle |
| creating a model instance: | | Creating the Model Instance |
| creating a node: | | Creating Nodes |
| creating a random number generator: | | Creating a Random Number Generator |
| creating an actor: | | Creating an Actor |
| creating an iterator: | | Creating Maps and Iterators |
| cycle direction: | | Receiving Input Signals |
| cycle period: | | Receiving Input Signals |
| cycle period: | | Receiving Input Signals |
| cycle start time: | | Receiving Input Signals |
| cycle type: | | Receiving Input Signals |
| cycle type: | | Spur Perception |
| cycle type statistics: | | Structures for Accessing Storage |
| cycle type statistics update, intercepting: | | Intercepting the Updates of Cycle Type Statistics |
|
| D | | |
|---|
| data section, assembler program: | | Variables in an Assembler Program |
| destroying a map: | | Creating Maps and Iterators |
| destroying a message: | | Creating Messages |
| destroying a message list: | | Creating a Message List |
| destroying a model: | | Creating a Handle |
| destroying a model instance: | | Creating the Model Instance |
| destroying a node: | | Creating Nodes |
| destroying a random number generator: | | Creating a Random Number Generator |
| destroying a vector: | | Ordinary and Sparse Vectors |
| destroying an actor: | | Creating an Actor |
| destroying an assembler program: | | Basic Datatypes for Assembler Programs |
| destroying an iterator: | | Creating Maps and Iterators |
| direction, cycle: | | Receiving Input Signals |
| direction, signal: | | Creating an Actor |
| disassembling a node: | | Disassembling a Node |
| discrete cycle period: | | Receiving Input Signals |
| discrete cycle period, mean: | | Relative Probability Function Types |
| discrete time: | | Incrementing Time |
|
| E | | |
|---|
| entity identifier, global: | | Entity References |
| entity identifier, local: | | Entity References |
| entity reference, global: | | Entity References |
| entity reference, local: | | Entity References |
| entity type: | | Entity References |
| enumeration callback function: | | Revising Action Choice States |
| enumeration callback function: | | Enumerating Action Choice States and Cycle Types |
| enumeration callback function: | | Enumerating Entities |
| environment state identification engine: | | Principle of Operation |
| error handler function: | | Error Handling for a Multinode Model |
| error handler function: | | Error Handling for the Side API |
| event handler, instruction class set: | | Instruction Class Set Function Declaration |
| event handler, instruction class set: | | Registering the Instruction Class Set Function |
| event handler, instruction class set: | | Instruction Class Set Function Layout |
| event handler, instruction meta-class: | | Instruction Meta-class Function Declaration |
| event handler, instruction meta-class: | | Registering the Instruction Meta-class Function |
| event handler, instruction meta-class: | | Instruction Meta-class Function Layout |
| event history: | | Event History |
| event type, instruction class set: | | Instruction Class Set Event Handling |
| event type, instruction meta-class: | | Instruction Meta-class Event Handling |
| excitatory (positive) spur: | | Automatic Spur |
| execution, model: | | Creating the Model Instance |
| execution, model: | | Terminating Model Execution |
| execution, node: | | Multinode Model |
| execution, node: | | Calling a Node |
| extended node parameters: | | Node Parameters |
|
| F | | |
|---|
| flat storage: | | Storage Types |
| function, enumeration callback: | | Revising Action Choice States |
| function, enumeration callback: | | Enumerating Action Choice States and Cycle Types |
| function, enumeration callback: | | Enumerating Entities |
| function, error handler: | | Error Handling for a Multinode Model |
| function, error handler: | | Error Handling for the Side API |
| function, event handler: | | Instruction Meta-class Function Declaration |
| function, event handler: | | Instruction Class Set Function Declaration |
| function, key comparison: | | Creating Maps and Iterators |
| function, proxy: | | Custom Random Number Generators |
| function, relative probability: | | Customizing the Relative Probability Function |
| function, statistics update interception: | | Intercepting the Updates of Cycle Type Statistics |
| function, storage redirection: | | Providing Initial Statistics |
|
| G | | |
|---|
| global entity identifier: | | Entity References |
| global entity reference: | | Entity References |
|
| H | | |
|---|
| handle: | | Object Handles |
| handle, actor: | | Creating an Actor |
| handle, actor pair: | | Creating the Model Instance |
| handle, assembler instruction: | | Basic Datatypes for Assembler Programs |
| handle, assembler program: | | Basic Datatypes for Assembler Programs |
| handle, iterator: | | Creating Maps and Iterators |
| handle, map: | | Creating Maps and Iterators |
| handle, message: | | Creating Messages |
| handle, message list: | | Creating a Message List |
| handle, model: | | Creating a Handle |
| handle, random number generator: | | Creating a Random Number Generator |
| handle, side: | | Registering Interaction Sides |
| handle, storage: | | Storage Types |
| handle, vector: | | Ordinary and Sparse Vectors |
|
| I | | |
|---|
| incrementing spur: | | Incrementing Spur |
| incrementing spur: | | Incrementing Time and Spur |
| incrementing time: | | Incrementing Time |
| incrementing time: | | Incrementing Time and Spur |
| inhibitory (negative) spur: | | Automatic Spur |
| input signal: | | Adaptive Probabilistic Mapping |
| instance, instruction: | | Principle of Operation |
| instance, model: | | Creating the Model Instance |
| instruction class: | | Principle of Operation |
| instruction class: | | Instruction Class Identifiers |
| instruction class: | | Registering Instruction Classes |
| instruction class name: | | Instruction Class Identifiers |
| instruction class set: | | Principle of Operation |
| instruction class set: | | Defining Instruction Class Sets |
| instruction class weight: | | Setting Instruction Classes Weights |
| instruction emitting engine: | | Principle of Operation |
| instruction handle: | | Basic Datatypes for Assembler Programs |
| instruction instance: | | Principle of Operation |
| instruction invocation: | | Handling Instruction Invocation |
| instruction meta-class: | | Principle of Operation |
| instruction meta-class: | | Defining Instruction Meta-classes |
| instruction outcome: | | Principle of Operation |
| instruction outcome: | | Setting the Number of Instruction Outcomes |
| instruction outcome: | | Handling Instruction Invocation |
| instruction parameters, binary: | | Instruction Class Identifiers |
| instruction parameters, canonical: | | Setting Text Instruction Parameters |
| instruction parameters, text: | | Instruction Class Identifiers |
| instruction, assembler: | | Assembler Instructions |
| instruction, user: | | Assembler Instructions |
| instruction, user: | | User Instructions |
| intelligence: | | What Is Intelligence? |
| interaction side: | | Registering Interaction Sides |
| intercepting cycle type statistics update: | | Intercepting the Updates of Cycle Type Statistics |
| invocation, instruction: | | Handling Instruction Invocation |
| iterator handle: | | Creating Maps and Iterators |
|
| K | | |
|---|
| key comparison function: | | Creating Maps and Iterators |
|
| L | | |
|---|
| large actor: | | Small and Large Actors |
| learning: | | Multinode Model |
| loading a probability profile into a node: | | Loading a Parsed Program into a Node |
| local entity: | | Entity References |
| look-ahead signal: | | Setting Look-ahead Signals |
|
| M | | |
|---|
| map handle: | | Creating Maps and Iterators |
| map storage: | | Storage Types |
| map, creating: | | Creating Maps and Iterators |
| map, destroying: | | Creating Maps and Iterators |
| mapping, probabilistic: | | Building Blocks for Intelligent Machines |
| matrix, action emission: | | Node Parameters |
| matrix, action emission: | | Dumping the Action Emission Matrix |
| matrix, state transition: | | Node Parameters |
| matrix, state transition: | | Dumping the State Transition Matrix |
| mean discrete cycle period: | | Relative Probability Function Types |
| mean nominal number of output signals: | | Number of Output Signals |
| message handle: | | Creating Messages |
| message list handle: | | Creating a Message List |
| message, creating: | | Creating Messages |
| message, destroying: | | Creating Messages |
| meta-class, instruction: | | Principle of Operation |
| meta-class, instruction: | | Defining Instruction Meta-classes |
| mixed-type instruction: | | Assembler Instructions |
| mode, behavior: | | Switching Adaptive or Random Behavior of an Actor |
| mode, behavior: | | Switching Adaptive or Random Behavior of a Multinode Model |
| model execution: | | Creating the Model Instance |
| model execution: | | Terminating Model Execution |
| model handle: | | Creating a Handle |
| model instance, creating: | | Creating the Model Instance |
| model instance, destroying: | | Creating the Model Instance |
| model, creating: | | Creating a Handle |
| model, destroying: | | Creating a Handle |
| model, state: | | Introduction |
| multinode model: | | Building Blocks for Intelligent Machines |
| multinode model: | | Multinode Model |
|
| N | | |
|---|
| n-gram buffer, actor: | | Receiving Input Signals |
| n-gram, action choice state: | | Event History |
| name, instruction class: | | Instruction Class Identifiers |
| name, instruction class set: | | Instruction Class Set Function Declaration |
| name, instruction meta-class: | | Principle of Operation |
| name, instruction meta-class: | | Instruction Meta-class Function Declaration |
| name, state: | | stt Instruction |
| name, state: | | Loading a Parsed Program into a Node |
| node: | | Building Blocks for Intelligent Machines |
| node: | | Multinode Model |
| node class, instruction class set: | | Defining Instruction Class Sets |
| node execution: | | Multinode Model |
| node execution: | | Calling a Node |
| node identifier, reserved: | | Creating Nodes |
| node parameters: | | Node Parameters |
| node parameters: | | Node Parameters |
| node, assembling: | | Loading a Parsed Program into a Node |
| node, calling: | | Calling a Node |
| node, creating: | | Creating Nodes |
| node, destroying: | | Creating Nodes |
| node, disassembling: | | Disassembling a Node |
| node, loading a probability profile into: | | Loading a Parsed Program into a Node |
| node, possessing control: | | Multinode Model |
| node, returning control from: | | Returning Control from a Node |
| node, transferring control to: | | Calling a Node |
| node, unloading a probability profile from: | | Unloading the Probability Profile |
| nominal number of output signals: | | Number of Output Signals |
| normalization, probabilities list: | | Preloading a Probability Profile |
| number of output signals, nominal: | | Number of Output Signals |
|
| O | | |
|---|
| outcome, instruction: | | Principle of Operation |
| outcome, instruction: | | Setting the Number of Instruction Outcomes |
| outcome, instruction: | | Handling Instruction Invocation |
| output probabilities array: | | Output Arrays |
| output probability variable: | | Output Variables |
| output signal: | | Adaptive Probabilistic Mapping |
| output signal permutation: | | Preloading a Probability Profile |
| output signal weight: | | Specifying Output Signal Weights |
|
| P | | |
|---|
| parameters, assembler instruction: | | Instruction Class Identifiers |
| parameters, node: | | Node Parameters |
| parameters, node: | | Node Parameters |
| parsing an assembler program: | | Parsing an Assembler Program |
| perceived state: | | Building Blocks for Intelligent Machines |
| perception, spur: | | Spur Perception |
| period, cycle: | | Receiving Input Signals |
| period, cycle: | | Receiving Input Signals |
| permutation, output signals: | | Preloading a Probability Profile |
| pool, output signal permutations: | | Preloading a Probability Profile |
| pool, probabilities lists in normal form: | | Preloading a Probability Profile |
| possessing control by a node: | | Multinode Model |
| preprocessing an assembler program: | | Using the Assembler Preprocessor |
| probabilistic mapping: | | Building Blocks for Intelligent Machines |
| probabilistic mapping, adaptive: | | Building Blocks for Intelligent Machines |
| probabilities list normalization: | | Preloading a Probability Profile |
| probability profile, cloning: | | Cloning the Probability Profile |
| probability profile, cloning: | | Memory Efficient Cloning the Probability Profile |
| probability profile, loading into a node: | | Loading a Parsed Program into a Node |
| probability profile, preloaded: | | Specifying Output Signal Weights |
| probability profile, preloaded: | | Preloading a Probability Profile |
| probability profile, unloading from a node: | | Unloading the Probability Profile |
| probability variable: | | Using Probability Variables |
| probability variable, auxiliary: | | Auxiliary Variables |
| probability variable, controlled: | | Controlled Variables |
| probability variable, defining: | | Variables in an Assembler Program |
| probability variable, output: | | Output Variables |
| program, assembler: | | Assembler Program Syntax |
| proxy function: | | Custom Random Number Generators |
| pseudo-random number generator: | | Random Number Generators |
|
| R | | |
|---|
| random behavior mode: | | Switching Adaptive or Random Behavior of an Actor |
| random behavior mode: | | Switching Adaptive or Random Behavior of a Multinode Model |
| random number generator, creating: | | Creating a Random Number Generator |
| random number generator, destroying: | | Creating a Random Number Generator |
| registering an interaction side: | | Registering Interaction Sides |
| reinforcement learning: | | Spur-driven Behavior |
| relative probability function: | | Customizing the Relative Probability Function |
| reserved node identifier: | | Creating Nodes |
| returning control from a node: | | Returning Control from a Node |
| run, model: | | Creating the Model Instance |
|
| S | | |
|---|
| section, assembler program: | | Assembler Program Syntax |
| Side API: | | Exchanging Data Packets in a Multithreaded Program |
| side handle: | | Registering Interaction Sides |
| signal: | | Basic Datatypes and Macros |
| signal direction: | | Creating an Actor |
| signal, input: | | Adaptive Probabilistic Mapping |
| signal, look-ahead: | | Setting Look-ahead Signals |
| signal, output: | | Adaptive Probabilistic Mapping |
| small actor: | | Small and Large Actors |
| spur: | | Spur-driven Behavior |
| spur perception: | | Spur Perception |
| spur scheme: | | Incrementing Spur |
| spur type: | | Spur-driven Behavior |
| spur weight: | | Spur Weight |
| spur, automatic: | | Automatic Spur |
| spur, excitatory (positive): | | Automatic Spur |
| spur, incrementing: | | Incrementing Spur |
| spur, incrementing: | | Incrementing Time and Spur |
| spur, inhibitory (negative): | | Automatic Spur |
| stack frame, system: | | Working with the Node Call Stack |
| stack frame, user: | | Working with the Node Call Stack |
| state: | | Building Blocks for Intelligent Machines |
| state model: | | Introduction |
| state name: | | stt Instruction |
| state name: | | Loading a Parsed Program into a Node |
| state sub-model: | | Building Blocks for Intelligent Machines |
| state transition matrix: | | Node Parameters |
| state transition matrix: | | Dumping the State Transition Matrix |
| state, automaton: | | Building Blocks for Intelligent Machines |
| state, automaton: | | Event History |
| state, automaton: | | Automatic Spur |
| statistics for a cycle type: | | Structures for Accessing Storage |
| statistics, aggregate: | | Output Variables |
| STL map template: | | The Implementation of Functionality of STL map Template |
| storage handle: | | Storage Types |
| storage redirection: | | Statistics Storage |
| storage redirection function: | | Providing Initial Statistics |
| storage type: | | Storage Types |
| sub-model, state: | | Building Blocks for Intelligent Machines |
| system stack frame: | | Working with the Node Call Stack |
|
| T | | |
|---|
| temperature, actor: | | Actor Temperature |
| terminating model execution: | | Terminating Model Execution |
| text instruction parameters: | | Instruction Class Identifiers |
| text instruction parameters: | | Setting Text Instruction Parameters |
| text instruction parameters, canonical: | | Setting Text Instruction Parameters |
| time type: | | Incrementing Time |
| time, continuous: | | Incrementing Time |
| time, continuous: | | Incrementing Time and Spur |
| time, cycle start: | | Receiving Input Signals |
| time, discrete: | | Incrementing Time |
| time, incrementing: | | Incrementing Time |
| time, incrementing: | | Incrementing Time and Spur |
| trace log: | | Tracing Model Execution |
| trace log: | | Tracing the Exchange of Data Packets |
| transferring control to a node: | | Calling a Node |
| type, cycle: | | Receiving Input Signals |
| type, cycle: | | Spur Perception |
| type, entity: | | Entity References |
| type, spur: | | Spur-driven Behavior |
| type, storage: | | Storage Types |
| type, time: | | Incrementing Time |
|
| U | | |
|---|
| unloading a probability profile from a node: | | Unloading the Probability Profile |
| unregistering an interaction side: | | Registering Interaction Sides |
| user instruction: | | Assembler Instructions |
| user instruction: | | User Instructions |
| user stack frame: | | Working with the Node Call Stack |
|
| V | | |
|---|
| variable, auxiliary: | | Auxiliary Variables |
| variable, controlled: | | Controlled Variables |
| variable, output: | | Output Variables |
| vector handle: | | Ordinary and Sparse Vectors |
| vector, destroying: | | Ordinary and Sparse Vectors |
|
| W | | |
|---|
| weight, instruction class: | | Setting Instruction Classes Weights |
| weight, output signal: | | Specifying Output Signal Weights |
| weight, spur type: | | Spur Weight |
|