Previous: , Up: Top   [Contents][Index]


Concept Index

Jump to:   A   B   C   D   E   F   G   H   I   K   L   M   N   O   P   R   S   T   U   V   W  
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

Jump to:   A   B   C   D   E   F   G   H   I   K   L   M   N   O   P   R   S   T   U   V   W  

Previous: , Up: Top   [Contents][Index]