|
|
| ? |
|---|
| ?, quantifier | Alternatives |
| ?, quantifier | Parser Assembler Program Structure |
| ?, quantifier | rege-markup-cfg |
|
| * |
|---|
| *, quantifier | Loops |
| *, quantifier | Marking a Left-Hand Side |
| *, quantifier | Marking a Right-Hand Side |
| *, quantifier | Parser Assembler Program Structure |
|
| A |
|---|
| accumulated cycle-summed value | Structures for Accessing Storage |
| 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 pair | Creating the Model Instance |
| actor, creating | Creating an Actor |
| actor, destroying | Creating an Actor |
| actor, handle | Creating an Actor |
| actor, large | Small and Large Actors |
| actor, n-gram buffer | Receiving Input Signals |
| actor, small | Small and Large Actors |
| actor, temperature | Actor Temperature |
| adaptive behavior mode | Switching Adaptive or Random Behavior of an Actor |
| adaptive behavior mode | Switching Adaptive or Random Behavior of a Multinode Model |
| adaptive parser, bottom-up | abu-parser |
| adaptive parser, top-down | atd-parser |
| adaptive probabilistic mapping | Building Blocks for Intelligent Machines |
| adaptive probabilistic mapping | Adaptive Probabilistic Mapping |
| aggregate statistics | Output Variables |
| aggregate statistics | Output Arrays |
| alternatives, in a grammar | Alternatives |
| array, output probabilities | choice Instruction Block |
| array, output probabilities | Output Arrays |
| array, signal ranges | Creating an Actor |
| array, signal ranges | Creating an Actor |
| array, signal ranges | Revising Action Choice States |
| array, signal ranges | Enumerating Action Choice States and Cycle Types |
| array, signal ranges | Creating a Handle |
| assembler instruction | Defining Instruction Meta-Classes |
| assembler instruction | Assembler Programs |
| assembler instruction | Assembler Instructions |
| assembler instruction, comment for | Comments |
| assembler instruction, fetching | Inspecting an Assembler Program |
| assembler instruction, handle | Basic Datatypes for Assembler Programs |
| assembler instruction, label, data | Plain Program |
| assembler instruction, label, location | Plain Program |
| assembler instruction, mixed-type | Assembler Instructions |
| assembler instruction, parameters | Instruction Class Identifiers |
| assembler instruction, parameters, binary | Accessing Binary Instruction Parameters |
| assembler instruction, parameters, binary | Registering Instruction Classes |
| assembler instruction, parameters, binary | Registering Instruction Classes |
| assembler instruction, parameters, text | Setting Text Instruction Parameters |
| assembler instruction, parameters, text | Registering Instruction Classes |
| assembler instruction, parser, bottom-up | Assembler Instruction Set for Bottom-Up Parser |
| assembler instruction, parser, top-down | Assembler Instruction Set for Top-Down Parser |
| assembler instruction, printing | Printing an Assembler Program |
| assembler instruction, splitting | Plain Program |
| assembler instruction, type | Inspecting an Assembler Program |
| assembler instruction, user | Assembler Instructions |
| assembler instruction, user | User Instructions |
| assembler program | Assembler Program Syntax |
| assembler program, comments | Comments |
| assembler program, compound | Compound Program |
| assembler program, creating empty | Basic Datatypes for Assembler Programs |
| assembler program, destroying | Basic Datatypes for Assembler Programs |
| assembler program, handle | Basic Datatypes for Assembler Programs |
| assembler program, loading | Loading a Parsed Program into a Node |
| assembler program, parsing | Parsing an Assembler Program |
| assembler program, plain | Plain Program |
| assembler program, plain | Recommended Assembler Program Structure |
| assembler program, preprocessing | Using the Assembler Preprocessor |
| assembling a node | Assembling 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 |
|---|
| 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 |
| binary instruction parameters | Accessing Binary Instruction Parameters |
| binary instruction parameters | Registering Instruction Classes |
| binary instruction parameters | Registering Instruction Classes |
| bottom-up parser | abu-parser |
| bottom-up parser assembler instructions | Assembler Instruction Set for Bottom-Up Parser |
| bottom-up template grammar | Bottom-Up Template Grammar |
| 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 |
| class, instruction | Instruction Class Sequences |
| cloning a nonterminal symbol | Cloning Nonterminal Symbols |
| cloning a nonterminal symbol class, deep | Symbol Class Expressions |
| cloning a nonterminal symbol, deep | Cloning Nonterminal Symbols |
| cloning a probability profile | Cloning the Probability Profile |
| cloning a probability profile, deferred | Memory Efficient Cloning the Probability Profile |
| comment for an assembler instruction | Comments |
| comments in a template grammar | Top-Down Template Grammar |
| comments in an assembler program | Comments |
| complexity, choice | Animate Machines |
| compound assembler program | Compound Program |
| compound nonterminal symbol | Nonterminal Symbols |
| compound nonterminal symbol | Compound Nonterminal Symbols |
| condition for an action choice state | Structures for Accessing Storage |
| consciousness, a rudiment of | Animate Machines |
| context-free grammar, factored | QSMM Components |
| context-free grammar, factored | Bottom-Up Template Grammar |
| context-free grammar, factored | rege-vit |
| context-free grammar, initial | Command-Line Options of Top-Down Parser |
| context-free grammar, initial | Command-Line Options of Bottom-Up Parser |
| context-free grammar, initial | rege-markup-cfg |
| context-free grammar, initial | rege-asm |
| context, nonterminal symbol | Compound Nonterminal Symbols |
| continuous cycle period | Receiving Input Signals |
| continuous time | Incrementing Time |
| 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 empty assembler program | Basic Datatypes for Assembler Programs |
| creating an iterator | Creating Maps and Iterators |
| cycle | Output Signal Selection |
| cycle direction | Receiving Input Signals |
| cycle period | Receiving Input Signals |
| cycle period | Receiving Input Signals |
| cycle period | Relative Probability Function Types |
| cycle start time | Receiving Input Signals |
| cycle type | Output Signal Selection |
| cycle type | Receiving Input Signals |
| cycle type | Spur Perception |
| cycle type statistics | Structures for Accessing Storage |
| cycle type statistics updates, intercepting | Specifying Redirection Functions |
| cycle-summed value | Statistics Storage |
| cycle-summed value, accumulated | Structures for Accessing Storage |
| cycle-summed value, initial | Structures for Accessing Storage |
|
| D |
|---|
| data label | Plain Program |
| data label | jprob Instruction |
| data label | choice Instruction Block |
| data label | choice Instruction Block |
| data label | Variables in an Assembler Program |
| data label | Output Arrays |
| default output signal choice tree | Number of Output Signals |
| default output signal choice tree | Preloading a Probability Profile |
| default output signal choice tree | Assigning a Preloaded Probability Profile |
| default output signal choice tree | Assigning a Preloaded Probability Profile |
| default probability profile | Registering the Instruction Class Set |
| default probability profile | Node Parameters |
| default probability profile | Node Parameters |
| default probability profile | Creating Nodes |
| deferred cloning a probability profile | Memory Efficient Cloning the Probability Profile |
| deferring a terminal symbol | Reverse Order Sequences |
| deferring a terminal symbol | Deferring a Terminal Symbol |
| deferring a terminal symbol | pushd Instruction |
| derived PCFG | abu-parser |
| derived PCFG | Command-Line Options of Bottom-Up Parser |
| 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 |
| 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 |
|---|
| empty terminal symbol class | Terminal Symbol Classes |
| end-of-production marker | Top-Down Template Grammar Specifiers |
| end-of-production marker | nprod Instruction |
| end-of-production marker | tprod Instruction |
| end-of-stream marker | Terminal Symbols |
| engine actor | Creating the Model Instance |
| engine type | Creating a Handle |
| engine, environment state identification | Principle of Operation |
| engine, instruction emitting | Principle of Operation |
| 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 |
| 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 |
| exclusive terminal symbol class | Terminal Symbol Classes |
| execution, model | Creating the Model Instance |
| execution, model | Terminating Model Execution |
| execution, node | Multinode Model |
| execution, node | Calling a Node |
| expression, symbol class | Symbol Class Expressions |
|
| F |
|---|
| factored context-free grammar | QSMM Components |
| factored context-free grammar | Bottom-Up Template Grammar |
| factored context-free grammar | rege-vit |
| factored PCFG | QSMM Components |
| factored PCFG | Bottom-Up Template Grammar |
| 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 class set | Instruction Class Set Function Declaration |
| function, event handler, instruction class set | Registering the Instruction Class Set |
| function, event handler, instruction meta-class | Instruction Meta-Class Function Declaration |
| function, event handler, instruction meta-class | Registering the Instruction Meta-Class Function |
| function, key comparison | Creating Maps and Iterators |
| function, proxy | Custom Random Number Generators |
| function, relative probability | Customizing the Relative Probability Function |
| function, relative probability, helper | Helper Relative Probability Functions |
| function, statistics update interception | Specifying Redirection Functions |
| function, storage redirection | Specifying Redirection Functions |
|
| G |
|---|
| global entity identifier | Entity References |
| global entity reference | Entity References |
| grammar, context-free, factored | QSMM Components |
| grammar, context-free, factored | Bottom-Up Template Grammar |
| grammar, context-free, factored | rege-vit |
| grammar, context-free, initial | Command-Line Options of Top-Down Parser |
| grammar, context-free, initial | Command-Line Options of Bottom-Up Parser |
| grammar, context-free, initial | rege-markup-cfg |
| grammar, context-free, initial | rege-asm |
| grammar, template, bottom-up | Bottom-Up Template Grammar |
| grammar, template, top-down | Top-Down Template Grammar |
|
| 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, model event handler call | Event Handler Call Parameters |
| handle, random number generator | Creating a Random Number Generator |
| handle, side | Registering Interaction Sides |
| handle, storage | Storage Handle |
| handle, vector | Ordinary and Sparse Vectors |
| helper relative probability function | Helper Relative Probability Functions |
|
| I |
|---|
| inclusive nonterminal symbol class | Nonterminal Symbol Classes |
| inclusive terminal symbol class | Terminal Symbol Classes |
| incrementing spur | Incrementing Spur |
| incrementing time | Incrementing Time |
| inhibitory (negative) spur | Automatic Spur |
| initial context-free grammar | Command-Line Options of Top-Down Parser |
| initial context-free grammar | Command-Line Options of Bottom-Up Parser |
| initial context-free grammar | rege-markup-cfg |
| initial context-free grammar | rege-asm |
| initial cycle-summed value | Structures for Accessing Storage |
| input signal | Adaptive Probabilistic Mapping |
| input signal | Receiving Input Signals |
| instance, instruction | Principle of Operation |
| instance, model | Creating the Model Instance |
| instruction class name | Instruction Class Identifiers |
| instruction class name | Registering Instruction Classes |
| instruction class sequence | Principle of Operation |
| instruction class sequence | Instruction Class Sequences |
| instruction class set | Principle of Operation |
| instruction class set | Defining Instruction Class Sets |
| instruction class set event handler | Instruction Class Set Function Declaration |
| instruction class set event handler | Registering the Instruction Class Set |
| instruction class set event handler | Instruction Class Set Function Layout |
| instruction class set name | Instruction Class Identifiers |
| instruction class set name | Instruction Class Set Function Declaration |
| instruction class set name | Registering the Instruction Class Set |
| instruction class weight | Setting Instruction Classes Weights |
| instruction class, individual | Principle of Operation |
| instruction class, individual | Instruction Class Identifiers |
| instruction class, individual | Registering Instruction Classes |
| instruction emitting engine | Principle of Operation |
| instruction meta-class | Principle of Operation |
| instruction meta-class | Defining Instruction Meta-Classes |
| instruction meta-class event handler | Instruction Meta-Class Function Declaration |
| instruction meta-class event handler | Registering the Instruction Meta-Class Function |
| instruction meta-class event handler | Instruction Meta-Class Function Layout |
| instruction meta-class name | Principle of Operation |
| instruction meta-class name | Instruction Meta-Class Function Declaration |
| instruction meta-class name | Registering the Instruction Meta-Class Function |
| instruction meta-class name | Instruction Class Identifiers |
| instruction meta-class name | Registering Instruction Classes |
| instruction, assembler | Defining Instruction Meta-Classes |
| instruction, assembler | Assembler Programs |
| instruction, assembler | Assembler Instructions |
| instruction, comment for | Comments |
| instruction, fetching | Inspecting an Assembler Program |
| instruction, handle | Basic Datatypes for Assembler Programs |
| instruction, instance | Principle of Operation |
| instruction, invocation | Handling Instruction Invocation |
| instruction, label, data | Plain Program |
| instruction, label, location | Plain Program |
| instruction, mixed-type | Assembler Instructions |
| 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, binary | Accessing Binary Instruction Parameters |
| instruction, parameters, binary | Registering Instruction Classes |
| instruction, parameters, binary | Registering Instruction Classes |
| instruction, parameters, canonical | Setting Text Instruction Parameters |
| instruction, parameters, text | Instruction Class Identifiers |
| instruction, parameters, text | Setting Text Instruction Parameters |
| instruction, parameters, text | Registering Instruction Classes |
| instruction, printing | Printing an Assembler Program |
| instruction, splitting | Plain Program |
| instruction, type | Inspecting an Assembler Program |
| instruction, user | Assembler Instructions |
| instruction, user | User Instructions |
| intelligence | What Is Intelligence? |
| interaction side | Registering Interaction Sides |
| intercepting cycle type statistics updates | Specifying Redirection Functions |
| invocation, instruction | Handling Instruction Invocation |
| iterator handle | Creating Maps and Iterators |
| iterator, creating | Creating Maps and Iterators |
| iterator, destroying | Creating Maps and Iterators |
|
| K |
|---|
| key comparison function | Creating Maps and Iterators |
|
| L |
|---|
| label, data | Plain Program |
| label, data | jprob Instruction |
| label, data | choice Instruction Block |
| label, data | choice Instruction Block |
| label, data | Variables in an Assembler Program |
| label, data | Output Arrays |
| label, location | Plain Program |
| large actor | Small and Large Actors |
| learned PCFG | Command-Line Options of Top-Down Parser |
| learning | Multinode Model |
| learning, reinforcement | Spur-Driven Behavior |
| length, nonterminal symbol | Nonterminal Symbols |
| length, nonterminal symbol | Compound Nonterminal Symbols |
| loading a probability profile into a node | Loading a Parsed Program into a Node |
| loading an assembler program into a node | Loading a Parsed Program into a Node |
| local entity identifier | Entity References |
| local entity reference | Entity References |
| location label | Plain Program |
| look-ahead signal | Setting Look-Ahead Signals |
| look-ahead signal | lookup Instruction |
| look-ahead terminal symbol | Alternatives |
| look-ahead terminal symbol | Loops |
| look-ahead terminal symbol | peek Instruction |
| look-ahead terminal symbol | Parser Assembler Program Structure |
| loop, in a grammar | Loops |
| loop, in a grammar | Parser Assembler Program Structure |
|
| M |
|---|
| map handle | Creating Maps and Iterators |
| map, creating | Creating Maps and Iterators |
| map, destroying | Creating Maps and Iterators |
| mapping, probabilistic | Building Blocks for Intelligent Machines |
| mapping, probabilistic, adaptive | Building Blocks for Intelligent Machines |
| mapping, probabilistic, adaptive | Adaptive Probabilistic Mapping |
| marker, end-of-production | Top-Down Template Grammar Specifiers |
| marker, end-of-production | nprod Instruction |
| marker, end-of-production | tprod Instruction |
| marker, end-of-stream | Terminal Symbols |
| marker, production side | Bottom-Up Template Grammar Specifiers |
| markup, source PCFG | Bottom-Up Template Grammar Specifiers |
| markup, source PCFG | rege-markup-cfg |
| 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 list, creating | Creating a Message List |
| message list, destroying | Creating a Message List |
| message list, handle | Creating a Message List |
| message, creating | Creating Messages |
| message, destroying | Creating Messages |
| message, handle | 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 event handler call handle | Event Handler Call Parameters |
| 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 | Registering Instruction Classes |
| name, instruction class set | Instruction Class Identifiers |
| name, instruction class set | Instruction Class Set Function Declaration |
| name, instruction class set | Registering the Instruction Class Set |
| name, instruction meta-class | Principle of Operation |
| name, instruction meta-class | Instruction Meta-Class Function Declaration |
| name, instruction meta-class | Registering the Instruction Meta-Class Function |
| name, instruction meta-class | Instruction Class Identifiers |
| name, instruction meta-class | Registering Instruction Classes |
| name, state | stt Instruction |
| name, state | State Names in stt Instructions |
| named terminal symbol segment | Terminal Symbols |
| named terminal symbol segment | Named Terminal Symbol Segments |
| named terminal symbol segment | rege-markup-cfg |
| node | Building Blocks for Intelligent Machines |
| node | Multinode Model |
| node class, instruction class set | Defining Instruction Class Sets |
| node, assembling | Assembling a Node |
| node, calling | Calling a Node |
| node, creating | Creating Nodes |
| node, destroying | Creating Nodes |
| node, disassembling | Disassembling a Node |
| node, execution | Multinode Model |
| node, execution | Calling a Node |
| node, loading a probability profile into | Loading a Parsed Program into a Node |
| node, parameters | Node Parameters |
| node, parameters | Node Parameters |
| 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 |
| nonterminal symbol class, deep cloning | Symbol Class Expressions |
| nonterminal symbol class, expression | Symbol Class Expressions |
| nonterminal symbol class, inclusive | Nonterminal Symbol Classes |
| nonterminal symbol, cloning | Cloning Nonterminal Symbols |
| nonterminal symbol, cloning, deep | Cloning Nonterminal Symbols |
| nonterminal symbol, compound | Nonterminal Symbols |
| nonterminal symbol, compound | Compound Nonterminal Symbols |
| nonterminal symbol, context | Compound Nonterminal Symbols |
| nonterminal symbol, length | Nonterminal Symbols |
| nonterminal symbol, length | Compound Nonterminal Symbols |
| nonterminal symbol, simple | Nonterminal Symbols |
| nonterminal symbol, start | Top-Down Template Grammar |
| nonterminal symbol, start | Nonterminal Symbols |
| nonterminal symbol, stem | Compound Nonterminal Symbols |
| nonterminal symbol, virtual | Reverse Order Sequences |
| nonterminal symbol, virtual | Ending a Terminal Production |
| nonterminal symbol, virtual | Restrictions for Bottom-Up Parsing |
| 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 | choice Instruction Block |
| output probabilities array | Output Arrays |
| output probability variable | Output Variables |
| output signal | Adaptive Probabilistic Mapping |
| output signal | Emitting an Output Signal |
| output signal | Emitting an Output Signal |
| output signal choice tree | Small and Large Actors |
| output signal choice tree, arity | Creating an Actor |
| output signal choice tree, arity | osct |
| output signal choice tree, default | Number of Output Signals |
| output signal choice tree, default | Preloading a Probability Profile |
| output signal choice tree, default | Assigning a Preloaded Probability Profile |
| output signal choice tree, default | Assigning a Preloaded Probability Profile |
| output signal permutation | Preloading a Probability Profile |
| output signal permutation | Preloading a Probability Profile |
| output signal weight | Specifying Output Signal Weights |
| output terminal symbol | Output Terminal Symbols |
| output terminal symbol | wr Instruction |
|
| P |
|---|
| parameters, assembler instruction | Instruction Class Identifiers |
| parameters, assembler instruction | Accessing Binary Instruction Parameters |
| parameters, assembler instruction | Setting Text Instruction Parameters |
| parameters, assembler instruction | Registering Instruction Classes |
| parameters, assembler instruction | Registering Instruction Classes |
| parameters, assembler instruction | Registering Instruction Classes |
| parameters, node | Node Parameters |
| parameters, node | Node Parameters |
| parse tree, printing | Command-Line Options of Top-Down Parser |
| parse tree, printing | Command-Line Options of Bottom-Up Parser |
| parse tree, printing | Command-Line Options of Bottom-Up Parser |
| parser, bottom-up | abu-parser |
| parser, bottom-up, assembler instructions | Assembler Instruction Set for Bottom-Up Parser |
| parser, top-down | atd-parser |
| parser, top-down, assembler instructions | Assembler Instruction Set for Top-Down Parser |
| parsing an assembler program | Parsing an Assembler Program |
| PCFG, derived | abu-parser |
| PCFG, derived | Command-Line Options of Bottom-Up Parser |
| PCFG, factored | QSMM Components |
| PCFG, factored | Bottom-Up Template Grammar |
| PCFG, format | PCFG Format |
| PCFG, learned | Command-Line Options of Top-Down Parser |
| PCFG, source | Bottom-Up Template Grammar |
| PCFG, source | Command-Line Options of Bottom-Up Parser |
| PCFG, source | rege-markup-cfg |
| PCFG, source, markup | Bottom-Up Template Grammar Specifiers |
| perceived state | Building Blocks for Intelligent Machines |
| perception, spur | Spur Perception |
| period, cycle | Receiving Input Signals |
| period, cycle | Receiving Input Signals |
| period, cycle | Relative Probability Function Types |
| permutation, output signals | Preloading a Probability Profile |
| permutation, output signals | Preloading a Probability Profile |
| plain assembler program | Plain Program |
| plain assembler program | Recommended Assembler Program Structure |
| pool, output signal permutations | 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 |
| prefix for virtual terminal symbols | Ending a Terminal Production |
| prefix for virtual terminal symbols | Restrictions for Bottom-Up Parsing |
| prefix for virtual terminal symbols | Command-Line Options of Bottom-Up Parser |
| preprocessing an assembler program | Using the Assembler Preprocessor |
| printing an assembler instruction | Printing an Assembler Program |
| probabilistic mapping | Building Blocks for Intelligent Machines |
| probabilistic mapping, adaptive | Building Blocks for Intelligent Machines |
| probabilities array, output | choice Instruction Block |
| probabilities array, output | Output Arrays |
| probabilities list normalization | Preloading a Probability Profile |
| probability profile, cloning | Cloning the Probability Profile |
| probability profile, cloning, deferred | Memory Efficient Cloning the Probability Profile |
| probability profile, default | Registering the Instruction Class Set |
| probability profile, default | Node Parameters |
| probability profile, default | Node Parameters |
| probability profile, default | Creating Nodes |
| 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 | jprob Instruction |
| probability variable, defining | choice Instruction Block |
| 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 |
| put-back terminal symbol | Put-Back Terminal Symbols |
| put-back terminal symbol | scn Instruction |
|
| Q |
|---|
| quantifier, ? | Alternatives |
| quantifier, ? | Parser Assembler Program Structure |
| quantifier, ? | rege-markup-cfg |
| quantifier, * | Loops |
| quantifier, * | Marking a Left-Hand Side |
| quantifier, * | Marking a Right-Hand Side |
| quantifier, * | Parser Assembler Program Structure |
|
| 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 |
| random number generator, handle | Creating a Random Number Generator |
| redirection function, initial condition | Specifying Redirection Functions |
| redirection function, initial statistics | Specifying Redirection Functions |
| redirection function, next cycle type | Specifying Redirection Functions |
| redirection function, statistics update | Specifying Redirection Functions |
| registering an interaction side | Registering Interaction Sides |
| reinforcement learning | Spur-Driven Behavior |
| relative probability function | Customizing the Relative Probability Function |
| relative probability function, helper | Helper Relative Probability Functions |
| returning control from a node | Returning Control from a Node |
| reverse order sequence | Reverse Order Sequences |
| run, model | Creating the Model Instance |
|
| S |
|---|
| sequence, in a grammar | Sequences and Groupings |
| sequence, in a grammar | Reverse Order Sequences |
| sequence, instruction class | Principle of Operation |
| sequence, instruction class | Instruction Class Sequences |
| sequence, reverse order | Reverse Order Sequences |
| Side API | Exchanging Data Packets in a Multithreaded Program |
| side handle | Registering Interaction Sides |
| signal | Basic Datatypes and Macros |
| signal ranges array | Creating an Actor |
| signal ranges array | Creating an Actor |
| signal ranges array | Revising Action Choice States |
| signal ranges array | Enumerating Action Choice States and Cycle Types |
| signal ranges array | Creating a Handle |
| signal, input | Adaptive Probabilistic Mapping |
| signal, input | Receiving Input Signals |
| signal, look-ahead | Setting Look-Ahead Signals |
| signal, look-ahead | lookup Instruction |
| signal, output | Adaptive Probabilistic Mapping |
| signal, output | Emitting an Output Signal |
| signal, output | Emitting an Output Signal |
| signal, output, permutation | Preloading a Probability Profile |
| signal, output, permutation | Preloading a Probability Profile |
| signal, output, weight | Specifying Output Signal Weights |
| small actor | Small and Large Actors |
| source PCFG | Bottom-Up Template Grammar |
| source PCFG | Command-Line Options of Bottom-Up Parser |
| source PCFG | rege-markup-cfg |
| source PCFG, markup | Bottom-Up Template Grammar Specifiers |
| source PCFG, markup | rege-markup-cfg |
| source terminal symbol | Ending a Terminal Production |
| splitting an assembler instruction | Plain Program |
| spur | Spur-Driven Behavior |
| spur, automatic | Automatic Spur |
| spur, excitatory (positive) | Automatic Spur |
| spur, increment velocity | Output Signal Selection |
| spur, increment velocity | Incrementing Time |
| spur, increment velocity | Relative Probability Function Types |
| spur, increment velocity | Spur Perception |
| spur, incrementing | Incrementing Spur |
| spur, inhibitory (negative) | Automatic Spur |
| spur, perception | Spur Perception |
| spur, scheme | Incrementing Spur |
| spur, type | Spur-Driven Behavior |
| spur, weight | Spur Weight |
| stack frame, system | Working with the Node Call Stack |
| stack frame, user | Working with the Node Call Stack |
| start nonterminal symbol | Top-Down Template Grammar |
| start nonterminal symbol | Nonterminal Symbols |
| state | Building Blocks for Intelligent Machines |
| state model | Introduction |
| 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 |
| state, in an assembler program | stt Instruction |
| state, in an assembler program | State Beginning and Instruction Selection |
| state, in an assembler program | Possible State Beginning Reasons |
| state, name | stt Instruction |
| state, name | State Names in stt Instructions |
| statistics for a cycle type | Structures for Accessing Storage |
| statistics update interception function | Specifying Redirection Functions |
| statistics, aggregate | Output Variables |
| statistics, aggregate | Output Arrays |
| stem, nonterminal symbol | Compound Nonterminal Symbols |
| STL map template | The Implementation of Functionality of STL map Template |
| storage handle | Storage Handle |
| storage redirection | Statistics Storage |
| storage redirection, function | Specifying Redirection Functions |
| sub-model, state | Building Blocks for Intelligent Machines |
| system stack frame | Working with the Node Call Stack |
|
| T |
|---|
| temperature, actor | Actor Temperature |
| template grammar, bottom-up | Bottom-Up Template Grammar |
| template grammar, comments | Top-Down Template Grammar |
| template grammar, top-down | Top-Down Template Grammar |
| terminal symbol class, empty | Terminal Symbol Classes |
| terminal symbol class, exclusive | Terminal Symbol Classes |
| terminal symbol class, expression | Symbol Class Expressions |
| terminal symbol class, inclusive | Terminal Symbol Classes |
| terminal symbol, deferring | Reverse Order Sequences |
| terminal symbol, deferring | Deferring a Terminal Symbol |
| terminal symbol, deferring | pushd Instruction |
| terminal symbol, input | Input Terminal Symbols |
| terminal symbol, input | rd Instruction |
| terminal symbol, look-ahead | Alternatives |
| terminal symbol, look-ahead | Loops |
| terminal symbol, look-ahead | peek Instruction |
| terminal symbol, look-ahead | Parser Assembler Program Structure |
| terminal symbol, named segment | Terminal Symbols |
| terminal symbol, named segment | Named Terminal Symbol Segments |
| terminal symbol, named segment | rege-markup-cfg |
| terminal symbol, output | Output Terminal Symbols |
| terminal symbol, output | wr Instruction |
| terminal symbol, placeholder | Terminal Symbols |
| terminal symbol, put-back | Put-Back Terminal Symbols |
| terminal symbol, put-back | scn Instruction |
| terminal symbol, source | Ending a Terminal Production |
| terminal symbol, virtual | Reverse Order Sequences |
| terminal symbol, virtual | Ending a Terminal Production |
| terminal symbol, virtual | Restrictions for Bottom-Up Parsing |
| terminal symbol, virtual | Command-Line Options of Bottom-Up Parser |
| terminating model execution | Terminating Model Execution |
| text instruction parameters | Instruction Class Identifiers |
| text instruction parameters | Setting Text Instruction Parameters |
| text instruction parameters | Registering Instruction Classes |
| text instruction parameters, canonical | Setting Text Instruction Parameters |
| time, continuous | Incrementing Time |
| time, cycle start | Receiving Input Signals |
| time, discrete | Incrementing Time |
| time, incrementing | Incrementing Time |
| time, type | Incrementing Time |
| top-down parser | atd-parser |
| top-down parser assembler instructions | Assembler Instruction Set for Top-Down Parser |
| top-down template grammar | Top-Down Template Grammar |
| trace log | Tracing Model Execution |
| trace log | Tracing the Exchange of Data Packets |
| transferring control to a node | Calling a Node |
| type, cycle | Output Signal Selection |
| type, cycle | Receiving Input Signals |
| type, cycle | Spur Perception |
| type, entity | Entity References |
| type, instruction | Inspecting an Assembler Program |
| type, spur | Spur-Driven Behavior |
| type, time | Incrementing Time |
|
| U |
|---|
| uniform probability profile | Registering the Instruction Class Set |
| uniform probability profile | Node Parameters |
| uniform probability profile | Node Parameters |
| uniform probability profile | Creating Nodes |
| 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 |
| velocity, spur increment | Output Signal Selection |
| velocity, spur increment | Incrementing Time |
| velocity, spur increment | Relative Probability Function Types |
| velocity, spur increment | Spur Perception |
| virtual nonterminal symbol | Reverse Order Sequences |
| virtual nonterminal symbol | Ending a Terminal Production |
| virtual nonterminal symbol | Restrictions for Bottom-Up Parsing |
| virtual terminal symbol | Reverse Order Sequences |
| virtual terminal symbol | Ending a Terminal Production |
| virtual terminal symbol | Restrictions for Bottom-Up Parsing |
| virtual terminal symbol | Command-Line Options of Bottom-Up Parser |
|
| W |
|---|
| weight, instruction class | Setting Instruction Classes Weights |
| weight, output signal | Specifying Output Signal Weights |
| weight, spur type | Spur Weight |
|