Schematic modeling
This page describes the organizational forces that limit change.  It explains how to overcome them when necessary. 

Power& tradition holding back progress
This page uses an example to illustrate how:
  • A business can gain focus from targeting key customers,
  • Business planning activities performed by the whole organization can build awareness, empowerment and coherence. 
  • A program approach can ensure strategic alignment. 
Be responsive to market dynamics
This page uses the example of HP's printer organization freeing itself from its organizational constraints to sell a printer targeted at the IBM pc user. 
The constraints are described. 
The techniques to overcome them are implied. 
Overcome reactionaries
Primary Navigation

Schematic modeling

Summary
This page introduces the many ways a complex
The agents in complex adaptive systems (CAS) must model their environment to respond effectively to it.  Samuel modeling is described as an approach. 
modeling
and coordination activity can be implemented using
Plans are interpreted and implemented by agents.  This page discusses the properties of agents in a complex adaptive system (CAS). 
It then presents examples of agents in different CAS.  The examples include a computer program where modeling and actions are performed by software agents.  These software agents are aggregates. 
The participation of agents in flows is introduced and some implications of this are outlined. 
agent-based
programming (
This presentation applies complex adaptive system (CAS) agents to computer programming. 
see presentation
). 

It describes how salient schematic alternative strings can be used to model a situation and make a decision under evolved control

It also introduces bottom up model codelets and complex techniques that are covered more fully on other pages. 

Constraints on the modeling process including requirements for timeliness, parallelism, synchronization and emergence of new models are discussed. 

Once a schematic sequence is selected by a group codelet or any additional type of modeling codelet the codelet will initiate an iterative cycle of detect, signal, match, deploy.  This allows the actions of a schematically selected sequence of model codelets to aggregate into a focused agent. 

A series of example signals sent by complex modeling codelets along with their associated operons is an addressable control structure which is used in biological cells to control access to other regions of the DNA. 
and subgroup schematic sequences are included.  The signals are sent by the:
And the
This page describes the Copycat Slipnet. 
The goal of the Slipnet is reviewed. 
Smiley's specialized use of the Slipnet is introduced. 
The initial Slipnet network used by the 'Merge Streams' and 'Virtual Robot' agent-based applications is setup in initchemistry and is included. 
The Slipnet infrastructure and initialization functions are included. 
Slipnet
configuration which activates the schematic subgroup sequence <mergestreams> <for> <case> <resolved> <assert> <true> is included
Introduction
The agents in complex adaptive systems (CAS) must model their environment to respond effectively to it.  Samuel modeling is described as an approach. 
Modeling
is fundamental to the effective operation of any complex adaptive system (
This page introduces the complex adaptive system (CAS) theory frame.  The theory is positioned relative to the natural sciences.  It catalogs the laws and strategies which underpin the operation of systems that are based on the interaction of emergent agents. 
John Holland's framework for representing complexity is outlined.  Links to other key aspects of CAS theory discussed at the site are presented. 
CAS
)
Plans are interpreted and implemented by agents.  This page discusses the properties of agents in a complex adaptive system (CAS). 
It then presents examples of agents in different CAS.  The examples include a computer program where modeling and actions are performed by software agents.  These software agents are aggregates. 
The participation of agents in flows is introduced and some implications of this are outlined. 
agent
.  It is also required for effective cooperation between agents.  It is needed to help an agent adapt to the actions of competitors. 

This page introduces various modeling, coordination and control techniques used by CAS agents. 

A fundamental schematic modeling technique - salient schematic alternatives - is described here. 
Complex modeling
Some of the other modeling techniques are complex and have their own dedicated pages:
Timely decisions
To be competitive the agents must make good and relatively timely decisions.  So modeling is often associated with mechanisms which ensure the decision is definite and is carried out rapidly.  CAS can use
Representing state in emergent entities is essential but difficult.  Various structures are used to enhance the rate and scope of state transitions.  Examples are discussed. 
structurally enhanced state
to setup the decision making operations in a developmental phase is a phase during the operation of a CAS agent.  It allows for schematic strategies to be iteratively blended with environmental signals to solve the logistical issues of migrating newly built and transformed sub-agents.  That is needed to achieve the adult configuration of the agent and optimize it for the proximate environment.  Smiley includes examples of the developmental phase agents required in an emergent CAS.  In situations where parents invest in the growth and memetic learning of their offspring the schematic grab bag can support optimizations to develop models, structures and actions to construct an adept adult.  In humans, adolescence leverages neural plasticity, elder sibling advice and adult coaching to help prepare the deploying neuronal network and body to successfully compete. 
and then enable them at the completion of the modeling process.  For example the cassert codelet does this.  It is a receptor, in biological cells these proteins are able to span the cell membrane and present an active site which is tailored to interact with a specific signal.  When the receptor pairs with its signal, its overall shape changes resulting in changes in the part internal to the cell which can be relayed by the cells signalling infrastructure.  In neuron synapses one type of receptor (fast) is associated with an ion channel.  The other (slow) is associated with a signalling enzyme chain and modulates the neuron's response. 
which is schematically deployed during an early schematic cascade of the
This page discusses how a Smiley based application the event processor test program's operational phase is structured. 
The goals of the event processor test application are described. 
The implementation strategy is outlined. 
Synchronization of Smiley setup completion and operation phase initiation is discussed. 
The association of structural Workspaces for state representation is discussed. 
An application specific codelet merge streams assert responds to the nature of the assertion.  It does not have an emergent structure.  Instead it reflects software engineering practice.  It includes:
  • Merge stream case specific
    • Modeling with sub-programs
    • Resolving of case
  • Non case assertion
The operation is setup, inhibited, initiated, and managed by iterative phase check-pointing provided by Smiley codelets. 
Schematic synchronization of parallel codelet cascades is performed structurally. 
The assert merge operon cascade is included. 
The Slipnet concept network for merge streams is included. 
The codelets and supporting functions are included. 
merge streams agent-based testing application
.  It then defers its actions until activated by the deployment of descriptors from the various modeling cascades. 
Schematic cascades
In a system where all events can occur in parallel the result of any particular modeling activity will need to be seen in context.  It may be helpful or even necessary to ensure that some modeling activities happen in series.  Depending on the current situation getting the results of a modeling activity may vary in priority. 
Synchronization of parallel flows
Making decisions based on the results of modeling often requires being able to wait until the modeling has occurred.  But then the decision should be made rewarding the existence of a coordination mechanism as exists with the synchronization of parallel flows in the merge streams application. 

In a CAS even a simple activity such as parsing and validating a programs command string requires a number of different actions to occur:
  • models must be tried,
  • results to be recorded and then
  • decisions about what should happen be
And implicitly the models must be developed. 

So how can a CAS initiate the initial set of models and make a judgment about their results? 

This activity can be
The agents in complex adaptive systems (CAS) must model their environment to respond effectively to it.  Samuel modeling is described as an approach. 
modeled
and managed by a complex adaptive system (
This page introduces the complex adaptive system (CAS) theory frame.  The theory is positioned relative to the natural sciences.  It catalogs the laws and strategies which underpin the operation of systems that are based on the interaction of emergent agents. 
John Holland's framework for representing complexity is outlined.  Links to other key aspects of CAS theory discussed at the site are presented. 
CAS
) using operon is an addressable control structure which is used in biological cells to control access to other regions of the DNA. 
control of
Plans emerge in complex adaptive systems (CAS) to provide the instructions that agents use to perform actions.  The component architecture and structure of the plans is reviewed. 
schemata
to coordinate
Plans are interpreted and implemented by agents.  This page discusses the properties of agents in a complex adaptive system (CAS). 
It then presents examples of agents in different CAS.  The examples include a computer program where modeling and actions are performed by software agents.  These software agents are aggregates. 
The participation of agents in flows is introduced and some implications of this are outlined. 
agents
(function list) assessments. 
Salient schematic alternatives
Any structure can be deployed into an active
This page describes the Adaptive Web framework (AWF) test system and the agent programming framework (Smiley) that supports its operation. 
Example test system statements are included.  To begin a test a test statement is loaded into Smiley while Smiley executes on the Perl interpreter. 
Part of Smiley's Perl code focused on setting up the infrastructure is included bellow. 
The setup includes:
  • Loading the 'Meta file' specification,
  • Initializing the Slipnet, and Workspaces and loading them
  • So that the Coderack can be called. 
The Coderack, which is the focus of a separate page of the Perl frame then schedules and runs the codelets that are invoked by the test statement structures. 
Smiley
This page describes the Copycat Workspace. 
The specialized use of the Workspace by the adaptive web framework's (AWF) Smiley is discussed. 
How text and XML are imported into the Smiley Workspace is described. 
Telomeric aging of schematic structures is introduced. 
The internal data structure used to represent the state of each workspace object is included. 
The Workspace infrastructure functions are included. 
Workspace
.  Smiley is an agent programming framework (
This presentation applies complex adaptive system (CAS) agents to computer programming. 
see presentation
).  A Workspace is active if it has group scout codelets exploring the Workspace. 
Modeling is initiated and sustained by assignment of group relations
The structure is modeled by a sequence of codelets.  Each of these is initiated by a group codelet which happens to select some potential groupable sequence to group. 
Initially this will be a sequence within the test request.  For subsequent iterations the sequence will be a newly deployed subgroup schematic string from the nucleus, a membrane bounded module in a eukaryotic cell where the DNA is encapsulated and operated on. 


If the selected sequence is groupable the group codelet will deploy a group relation within the sequence which will result in any
This page describes the Copycat Slipnet. 
The goal of the Slipnet is reviewed. 
Smiley's specialized use of the Slipnet is introduced. 
The initial Slipnet network used by the 'Merge Streams' and 'Virtual Robot' agent-based applications is setup in initchemistry and is included. 
The Slipnet infrastructure and initialization functions are included. 
Slipnet
associated model evaluators for the sequence becoming scheduled to run on the
This page describes the Copycat Coderack. 
The details of the codelet architecture are described. 
The specialized use of the Coderack by the adaptive web framework's (AWF) Smiley is discussed. 
The codelet scheduling mechanism is discussed. 
A variety of Smiley extensions to the Coderack are reviewed. 
The Coderack infrastructure functions are included. 
Coderack
.  This is discussed in more detail in the page
This page describes the adaptive web framework (AWF) Smiley agent progamming infrastructure's codelet based Copycat grouping operation. 
The requirements needed for a group to complete are described. 
The association of group completion with a Slipnet defined operon is described.  Either actions or signals result from the association. 
How a generated signal is transported to the nucleus of the cell and matched with an operon is described. 
A match with an operon can result in deployment of a schematic string to the original Workspace.  But eventually the deployed string will be destroyed. 
Smiley infrastructure amplification of the group completion operation is introduced.  This includes facilities to inhibit crowding out of offspring. 
A test file awfart04 is included. 
The group codelet and supporting functions are included. 
group completion

Activation depends on a matching Slipnet configuration
The
This page describes the Copycat Slipnet. 
The goal of the Slipnet is reviewed. 
Smiley's specialized use of the Slipnet is introduced. 
The initial Slipnet network used by the 'Merge Streams' and 'Virtual Robot' agent-based applications is setup in initchemistry and is included. 
The Slipnet infrastructure and initialization functions are included. 
Slipnet
configuration for the schematic subgroup sequence <mergestreams> <for> <case> <resolved> <assert> <true> is included

The Coderack's bottom up models
There is another way that modeling can begin in Smiley.  The Coderack scheduled 'bottom up' codelets include a variety of scout codelets including the bonding, grouping, part and statement codelets.  In the particular case of a part of a statement with a completed grouping, in Copycat grouping codelets can group two or more bonded Workspace objects (WSO) together.  In effect grouping adjusts the system to reflect the presence of a chemically active molecule in the molecules local environment. 
a Coderack scheduled part evaluator will find the group salient, Douglas Hofstadter controlled the amount of attention a Workspace object in Copycat would receive from codelets via its salience.  The more descriptions, analogous to geons, an object has and the more highly activated the nodes involved therin, the more important the object is.  Modulating this tendency is any relative lack of connections from the object to the rest of the objects in the Workspace.  Salience is a dynamic number that takes into account both these factors.  In Smiley the instantaneous salience of a Workspace's objects is calculated by itsalience.   and will schedule model codelets to evaluate if the
This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is composed of groups. 
Smiley does this through the operation of a part codelet which indirectly sponsors the modeling of the parts of the statement. 
The modeling itself is performed by model codelets. 
The part codelet synchronizes with the completion of the modeling. 
The part evaluator's signal along with the associated operons and subgroup schematic sequences are included. 
The group models' Slipnet associations are included. 
The codelets and supporting functions are included. 
part is whole
.  Once the groups in the part are described as whole the part evaluator will schedule the part builder to work on the part. 
A series of model codelets thus inspect the salient group
When the model codelet runs it will inspect the activated test request sequence and if it matches its requirements the codelet will add a descriptor to the sequence and or send a
Agents use sensors to detect events in their environment.  This page reviews how these events become signals associated with beneficial responses in a complex adaptive system (CAS).  CAS signals emerge from the Darwinian information model.  Signals can indicate decision summaries and level of uncertainty. 
signal
to the nucleus. 

When a codelet sends a signal it is relayed by a series of signalling codelets, is an emergent capability which is used by cooperating agents to support coordination & rival agents to support control and dominance.  In eukaryotic cells signalling is used extensively.  A signal interacts with the exposed region of a receptor molecule inducing it to change shape to an activated form.  Chains of enzymes interact with the activated receptor relaying, amplifying and responding to the signal to change the state of the cell.  Many of the signalling pathways pass through the nuclear membrane and interact with the DNA to change its state.  Enzymes sensitive to the changes induced in the DNA then start to operate generating actions including sending further signals.  Cell signalling is reviewed by Helmreich.  Signalling is a fundamental aspect of CAS theory and is discussed from the abstract CAS perspective in signals and sensors.  In AWF the eukaryotic signalling architecture has been abstracted in a codelet based implementation.  To be credible signals must be hard to fake.  To be effective they must be easily detected by the target recipient.  To be efficient they are low cost to produce and destroy. 
which transport the signal across the nuclear membrane, formed from a lipid (fat) bilayer which creates a barrier between aqueous (water soluble) media.  In AWF a key property of membranes - their providing a catalytic environment and supporting the suspension of enzymatically active proteins within the membrane; is simulated with a Workspace list where 'active' structures can be inserted and codelets can detect and act on the structure's active promise configured as an association in the Slipnet.   to the schematic strings supported by the nuclabm codelet. 
Signal to operon subgroup associative matching
The
This page describes the Adaptive Web framework (AWF) test system and the agent programming framework (Smiley) that supports its operation. 
Example test system statements are included.  To begin a test a test statement is loaded into Smiley while Smiley executes on the Perl interpreter. 
Part of Smiley's Perl code focused on setting up the infrastructure is included bellow. 
The setup includes:
  • Loading the 'Meta file' specification,
  • Initializing the Slipnet, and Workspaces and loading them
  • So that the Coderack can be called. 
The Coderack, which is the focus of a separate page of the Perl frame then schedules and runs the codelets that are invoked by the test statement structures. 
adaptive web framework (AWF) test system
's matching of schematic sub-groups of a
Agents use sensors to detect events in their environment.  This page reviews how these events become signals associated with beneficial responses in a complex adaptive system (CAS).  CAS signals emerge from the Darwinian information model.  Signals can indicate decision summaries and level of uncertainty. 
signalled
operon is performed by nuclabmbuilder.  The subgroup schemata is selected based on salience, Douglas Hofstadter controlled the amount of attention a Workspace object in Copycat would receive from codelets via its salience.  The more descriptions, analogous to geons, an object has and the more highly activated the nodes involved therin, the more important the object is.  Modulating this tendency is any relative lack of connections from the object to the rest of the objects in the Workspace.  Salience is a dynamic number that takes into account both these factors.  In Smiley the instantaneous salience of a Workspace's objects is calculated by itsalience.   from the various alternatives included within the operon.  Each schematic string is represented by a pseudo concept and can have a Slipnet depth and current activation. 

The selection is modeled by selsaliam which performs the normalization is a technique for mapping a weighted population of items to a standardized equivalent.  This allows a random value within the standardized sequence to select a specific member of the original weighted sequence.   process.  The potential set of schemata is filtered by tokenactive.  The set returned may include alternatives, with different pseudo concepts, which could vary in current salience due to their
This page describes the Copycat Slipnet. 
The goal of the Slipnet is reviewed. 
Smiley's specialized use of the Slipnet is introduced. 
The initial Slipnet network used by the 'Merge Streams' and 'Virtual Robot' agent-based applications is setup in initchemistry and is included. 
The Slipnet infrastructure and initialization functions are included. 
Slipnet
depth characteristics and modeling codelets having activated the schematic strings pseudo concepts to differing extents. 
Initiate deployment of the schematic subgroup
The nuclabm codelet will then initiate deployment of the subgroup schemata by scheduling a deployment codelet such as an nsdep codelet with the Coderack. 
Once the deployment codelets deploy the subgroup schemata in the active Workspace it becomes a target for selection by a group codelet. 

An iterative cycle of detect, signal, match, deploy allows the actions of a schematically selected sequence of model codelets to aggregate into a focused agent. 
No proteins?
This iterative cycle is a simplification of the biological equivalent.  Folded proteins, a relatively long chain (polymer) of peptides.  Shorter chains of peptides are termed polypeptides.   do most of the active work in a biochemial environment.  They are typically created from a DNA (DNA), a polymer composed of a chain of deoxy ribose sugars with purine or pyrimidine side chains.  DNA naturally forms into helical pairs with the side chains stacked in the center of the helix.  It is a natural form of schematic string.  The purines and pyrimidines couple so that AT and GC pairs make up the stackable items.  A code of triplets of base pairs (enabling 64 separate items to be named) has evolved which now redundantly represents each of the 20 amino-acids that are deployed into proteins, along with triplets representing the termination sequence.  Chemical modifications and histone binding (chromatin) allow cells to represent state directly on the DNA schema.  To cope with inconsistencies in the cell wide state second messenger and evolved amplification strategies are used. 
encoding, the mapping of DNA base triplet sequences, such as AAA and AAT, to amino-acids (AAA maps to the amino-acid lysine for example) and transcription termination sequences (TGA maps to stop transcription for example) that has currently evolved. 
of the proteins amino-acid are the building blocks of proteins.  The 20 main variants differ by the nature of their side chain.  Some are positively charged, others negatively charged.  Some are water seeking while others are fat seeking.  The genetic code mapping of DNA base pair triplets thus specifies the primary sequence of amino-acids in any protein polymer. 
backbone sequence.  The encoding is carried out by a two step transcription is the process where DNA is converted into messenger m-RNA.  A complex of enzymes cooperates to bind to the DNA and generate the m-RNA copy.  There are a number of such transcription complexes which are based on RNA polymerase I, II or III. 
and translation is the process where messenger m-RNA is cross coded by Ribosomal agents and t-RNA into an amino-acid polymer. 
process.  Then the proteins must fold correctly to obtain their active form.  AWF's simplified process associates the activity with the primary sequence of the schematic string via the Slipnet configuration. 

Schematic modeling is used in the Smiley agent programming framework for:
Schematic modeling is used in the merge streams agent-based application for:
Schematic control enables evolutionary action
The schematic nature of the modeling allows
This page reviews the implications of selection, variation and heredity in a complex adaptive system (CAS).  The mechanism and its emergence are discussed. 
evolutionary
pressure to be applied.  But the flexibility comes at a cost.  Because the model codelets are dynamically deployed they use computing and real time.  Evolution has responded to this cost.  It pre-deploys relatively long lasting proteins, a relatively long chain (polymer) of peptides.  Shorter chains of peptides are termed polypeptides.   featuring
Representing state in emergent entities is essential but difficult.  Various structures are used to enhance the rate and scope of state transitions.  Examples are discussed. 
structurally enhanced state


AWF schematic strings: 


The following schematic strings are loaded by convbws.  They are group schemata which are associated with nuclear agents (nuclabm evaluator & builder) which respond to codelet signals by deploying the included sub-group schemata to the active
This page describes the Copycat Workspace. 
The specialized use of the Workspace by the adaptive web framework's (AWF) Smiley is discussed. 
How text and XML are imported into the Smiley Workspace is described. 
Telomeric aging of schematic structures is introduced. 
The internal data structure used to represent the state of each workspace object is included. 
The Workspace infrastructure functions are included. 
Workspace


The Meta-keyword <comment> toggles convbws loading between comment mode and processing active <keywords>.  In the following the initial <comment> switches convbws into active mode. 

The active keywords include meta-keyword instructions for convbws, such as <rhlmspg> and <memgroup> and schematic keywords that will be processed during nuclear operations.  The first keyword of a schematic string also identifies the start of the group and the start of the deployed subgroup. 




msspdca signalled meme
The spdca builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <program> <initiate>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <program> <initiate> <mergestreams> <for> <program> <initiate> </memgroup> </rhlmspg> )<comment> dcycip



msdcycip signalled meme
The dcycip builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <program> <do>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <program> <do> <mergestreams> <for> <case> <resolved> <assert> <true> </memgroup> </rhlmspg> )<comment> cassert



mscassert signalled meme
The cassert builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <source> <target> <assert> <true>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <source> <target> <assert> <true> <mergestreams> <for> <source> <target> <compare> <list> </memgroup> </rhlmspg> )<comment> stbind

<comment> (<rhlmspg> <memgroup> <mergestreams> <source> <target> <assert> <true> <mergestreams> <for> <source> <target> <list> <initial> </memgroup> </rhlmspg> )<comment> indsloc



msindsloc signalled meme
The indsloc builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <source> <target> <list> <initial>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <list> <initial> <mergestreams> <for> <source> <target> <merge> <initial> </memgroup> </rhlmspg> )<comment> shsloc

#<!-- end tag scs --> <!-- end tag aso --> <!-- start tag sir -->

The following schematic strings are loaded by convbws.  They are group schemata which are associated with nuclear agents (nuclabm evaluator & builder) which respond to codelet signals by deploying the included sub-group schemata to the active
This page describes the Copycat Workspace. 
The specialized use of the Workspace by the adaptive web framework's (AWF) Smiley is discussed. 
How text and XML are imported into the Smiley Workspace is described. 
Telomeric aging of schematic structures is introduced. 
The internal data structure used to represent the state of each workspace object is included. 
The Workspace infrastructure functions are included. 
Workspace


The Meta-keyword <comment> toggles convbws loading between comment mode and processing active <keywords>.  In the following the initial <comment> switches convbws into active mode. 

The active keywords include meta-keyword instructions for convbws, such as <rhlmspg> and <memgroup> and schematic keywords that will be processed during nuclear operations.  The first keyword of a schematic string also identifies the start of the group and the start of the deployed subgroup. 


#<!-- start tag aso --> <!-- start tag scs -->



msshsloc signalled meme
The shsloc builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <source> <target> <merge> <initial>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <merge> <initial> <mergestreams> <for> <source> <target> <compare> <streams> </memgroup> </rhlmspg> )<comment> rchpair



msrchpair signalled meme
The rchpair builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
(<mergestreams> <source> <target> <compare> <streams>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <compare> <streams> <mergestreams> <for> <source> <target> <integrate> <compare> <streams> </memgroup> </rhlmspg> )<comment> rchpint

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <merge> <initial> <mergestreams> <for> <source> <target> <match> <name> </memgroup> </rhlmspg> ) comment ripkwm

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <match> <name> <mergestreams> <for> <source> <target> <integrate> <match> <name> </memgroup> </rhlmspg> ) comment rpkwmint

#<!-- end tag sir -->
<comment> (<rhlmspg> <memgroup> <mergestreams> <program> <do> <mergestreams> <for> <program> <do> </memgroup> </rhlmspg> )<comment> ecycdop



pdcaecycdop signalled meme
The ecycdop builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
([<mergestreams> in
This page discusses how a Smiley based application the event processor test program's operational phase is structured. 
The goals of the event processor test application are described. 
The implementation strategy is outlined. 
Synchronization of Smiley setup completion and operation phase initiation is discussed. 
The association of structural Workspaces for state representation is discussed. 
An application specific codelet merge streams assert responds to the nature of the assertion.  It does not have an emergent structure.  Instead it reflects software engineering practice.  It includes:
  • Merge stream case specific
    • Modeling with sub-programs
    • Resolving of case
  • Non case assertion
The operation is setup, inhibited, initiated, and managed by iterative phase check-pointing provided by Smiley codelets. 
Schematic synchronization of parallel codelet cascades is performed structurally. 
The assert merge operon cascade is included. 
The Slipnet concept network for merge streams is included. 
The codelets and supporting functions are included. 
merge streams
This page discusses how Smiley provides deployment guarantees to its agent-based applications. 
Smiley's transaction services are reviewed. 
The complex interactions of codelets participating in a deployment cascade are discussed including: 
  • The implementation of schematic switches. 
  • The cooperative use of goal suppression.  
  • Evaluator codelets promotion of other siblings. 
Challenges of initiation of a cascade are discussed. 
Tools to associate transaction protection to an operon deployed codelet are described. 
Special support for sub-program codelets is described.  Completion of transactional sub-programs presents special challenges. 
Priority and synchronization support includes:
  • Delaying the operaton of the cascade sponsor. 
  • Delaying the notgcompleting cascade participant. 
  • Waiting for completion of parallel operations with the wait and relay service.  
The need to sustain resource pools is reviewed. 
The use of signals to coordinate siblings is described. 
The structural binding operon for the wait and relay service is included. 
The codelets and supporting functions are included.
cascade
substitution] <program> <check>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's merge stream cascade Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <program> <check> <mergestreams> <for> <program> <check> </memgroup> </rhlmspg> )<comment> acycchp



pdcaacycchp signalled meme
The acycchp builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
([<mergestreams> in
This page discusses how a Smiley based application the event processor test program's operational phase is structured. 
The goals of the event processor test application are described. 
The implementation strategy is outlined. 
Synchronization of Smiley setup completion and operation phase initiation is discussed. 
The association of structural Workspaces for state representation is discussed. 
An application specific codelet merge streams assert responds to the nature of the assertion.  It does not have an emergent structure.  Instead it reflects software engineering practice.  It includes:
  • Merge stream case specific
    • Modeling with sub-programs
    • Resolving of case
  • Non case assertion
The operation is setup, inhibited, initiated, and managed by iterative phase check-pointing provided by Smiley codelets. 
Schematic synchronization of parallel codelet cascades is performed structurally. 
The assert merge operon cascade is included. 
The Slipnet concept network for merge streams is included. 
The codelets and supporting functions are included. 
merge streams
This page discusses how Smiley provides deployment guarantees to its agent-based applications. 
Smiley's transaction services are reviewed. 
The complex interactions of codelets participating in a deployment cascade are discussed including: 
  • The implementation of schematic switches. 
  • The cooperative use of goal suppression.  
  • Evaluator codelets promotion of other siblings. 
Challenges of initiation of a cascade are discussed. 
Tools to associate transaction protection to an operon deployed codelet are described. 
Special support for sub-program codelets is described.  Completion of transactional sub-programs presents special challenges. 
Priority and synchronization support includes:
  • Delaying the operaton of the cascade sponsor. 
  • Delaying the notgcompleting cascade participant. 
  • Waiting for completion of parallel operations with the wait and relay service.  
The need to sustain resource pools is reviewed. 
The use of signals to coordinate siblings is described. 
The structural binding operon for the wait and relay service is included. 
The codelets and supporting functions are included.
cascade
substitution] <program> <act>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's merge stream cascade Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <program> <act> <mergestreams> <for> <program> <act> </memgroup> </rhlmspg> )<comment> bcycacp



pdcabcycacp signalled meme
The bcycacp builder's
This page discusses how Smiley provides signalling to its agent-based applications. 
Alternative strategies for initiating the signalling are reviewed. 
The codelets and supporting functions are included.
signal
([<mergestreams> in
This page discusses how a Smiley based application the event processor test program's operational phase is structured. 
The goals of the event processor test application are described. 
The implementation strategy is outlined. 
Synchronization of Smiley setup completion and operation phase initiation is discussed. 
The association of structural Workspaces for state representation is discussed. 
An application specific codelet merge streams assert responds to the nature of the assertion.  It does not have an emergent structure.  Instead it reflects software engineering practice.  It includes:
  • Merge stream case specific
    • Modeling with sub-programs
    • Resolving of case
  • Non case assertion
The operation is setup, inhibited, initiated, and managed by iterative phase check-pointing provided by Smiley codelets. 
Schematic synchronization of parallel codelet cascades is performed structurally. 
The assert merge operon cascade is included. 
The Slipnet concept network for merge streams is included. 
The codelets and supporting functions are included. 
merge streams
This page discusses how Smiley provides deployment guarantees to its agent-based applications. 
Smiley's transaction services are reviewed. 
The complex interactions of codelets participating in a deployment cascade are discussed including: 
  • The implementation of schematic switches. 
  • The cooperative use of goal suppression.  
  • Evaluator codelets promotion of other siblings. 
Challenges of initiation of a cascade are discussed. 
Tools to associate transaction protection to an operon deployed codelet are described. 
Special support for sub-program codelets is described.  Completion of transactional sub-programs presents special challenges. 
Priority and synchronization support includes:
  • Delaying the operaton of the cascade sponsor. 
  • Delaying the notgcompleting cascade participant. 
  • Waiting for completion of parallel operations with the wait and relay service.  
The need to sustain resource pools is reviewed. 
The use of signals to coordinate siblings is described. 
The structural binding operon for the wait and relay service is included. 
The codelets and supporting functions are included.
cascade
substitution] <program> <initiate>) is associated with a meme group.  The nuclabm nuclear codelet (builder) matches the signal with all the identically named nuclear Workspace deployed meme groups and heuristically selects subgroup schematic strings from the complete set to send for deployment.  The signal's merge stream cascade Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 


<comment> (<rhlmspg> <memgroup> <mergestreams> <program> <terminate> <mergestreams> <for> <program> <terminate> </memgroup> </rhlmspg> )<comment> dcyctp


comment (<rhlmspg> <memgroup> <mergestreams> <program> <initiate> <mergestreams> <for> <program> <initiate> </memgroup> </rhlmspg> ) comment dcycip

comment (<rhlmspg> <memgroup> <mergestreams> <program> <do> <mergestreams> <for> <case> <resolved> <assert> <true> </memgroup> </rhlmspg> ) comment cassert

comment (<rhlmspg> <memgroup> <mergestreams> <source> <target> <assert> <true> <mergestreams> <for> <source> <target> <compare> <list> </memgroup> </rhlmspg> ) comment stbind

comment (<rhlmspg> <memgroup> <mergestreams> <source> <target> <assert> <true> <mergestreams> <for> <source> <target> <list> <initial> </memgroup> </rhlmspg> ) comment indsloc

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <list> <initial> <mergestreams> <for> <source> <target> <merge> <initial> </memgroup> </rhlmspg> ) comment shsloc

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <merge> <initial> <mergestreams> <for> <source> <target> <compare> <streams> </memgroup> </rhlmspg> ) comment rchpair

#<!-- start tag sir -->
<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <merge> <initial> <mergestreams> <for> <source> <target> <match> <name> </memgroup> </rhlmspg> )<comment> ripkwm

comment (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <compare> <streams> <mergestreams> <for> <source> <target> <integrate> <compare> <streams> </memgroup> </rhlmspg> ) comment rchpint

<comment> (<rhlmspg> <memgroup> <mergestreams> <schema> <source> <target> <match> <name> <mergestreams> <for> <source> <target> <integrate> <match> <name> </memgroup> </rhlmspg> )<comment> rpkwmint

#<!-- end tag sir -->
comment (<rhlmspg> <memgroup> <mergestreams> <program> <do> <mergestreams> <for> <program> <do> </memgroup> </rhlmspg> ) comment ecycdop

comment (<rhlmspg> <memgroup> <mergestreams> <program> <check> <mergestreams> <for> <program> <check> </memgroup> </rhlmspg> ) comment acycchp

comment (<rhlmspg> <memgroup> <mergestreams> <program> <act> <mergestreams> <for> <program> <act> </memgroup> </rhlmspg> ) comment bcycacp

comment (<rhlmspg> <memgroup> <mergestreams> <program> <terminate> <mergestreams> <for> <program> <terminate> </memgroup> </rhlmspg> ) comment dcyctp

#
    my ($pconc, $jhlsid);
# mscabindtobis
# setup the binding string for the merge streams check assertion

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {mergestreams}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {spsignal}, $pconc, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc, undef(), undef(), undef(), 't'), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mergestreams}, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {case}, $Awfif::memes-> {snnh} {resolved}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {true}, $Awfif::memes-> {snnh} {attribr});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {cassertevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd}
      [$pconc] = 10;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$pconc][0] = 10;
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc}
      [$pconc][1] = 16;

Functions

#
sub selsaliam {
    my($myli, $sws, $wss, $wse, $operoncount, $lomatchs, $lola, $loends, $lostrts, $loge, $logb, $sactset, $strategy)=@_;
    my ($vs, @v, @vt, $vsi, $vmax, $t, $i, $i2, @found, $fn, @lopcs, $linkp, $operation, $cwsbi, $sgcount, @lotype, @loconc);
# select a candidate for an goal's operation using normalisation
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("selsaliam myli $myli sws $sws ");
      };
# This routine uses normalization to select a candidate for goal (action or model) implementation
    $cwsbi = $Awfif::memes-> {currentwsbi};
# initialise the normalisation variables

    $vs = 0;#tinstances in other salience normalisation procedures
    $vsi = $Awfif::memes-> {maxoper} + $Awfif::memes->{maxact} + 1; # case target consumed else
    for ($i = 1; $i <= $vsi; $i++) {
      $v[$i] = 0;#Assume a negative response is unsure
      $vt[$i][0] = '';#Assume a negative response is no activity
      };

    $i2 = 1;
    $linkp = $Awfif::memes->{snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes->{snnh}{opercategory}];
    @found = ();

    while (($linkp != 0)) {
      if ((($strategy == $Awfif::memes-> {snnh} {actioncategory}) && ($sgcount = tokenactives ($myli, $sws, $wss, $wse, $linkp, \@lopcs, $operoncount, \$operation, \@$lomatchs, \@$lola, \@$loends, \@$lostrts, \@$loge, \@$logb, \@lotype, \@loconc, \@$sactset)) != 0 )
      or (($strategy == $Awfif::memes-> {snnh} {model}) && ($sgcount = tokenactivem ($myli, $sws, $wss, $wse, $linkp, \@lopcs, $operoncount, \$operation, \@$lomatchs, \@$lola, \@$loends, \@$lostrts, \@$loge, \@$logb, \@lotype, \@loconc, \@$sactset)) != 0 )) {# physical attribute salient

        for ($i = 0; $i < $sgcount; $i++) {

          $v[$i2] = int(($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snna} {$Awfif::memes-> {snnih} {$lopcs [$i]}})
            * ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnd} [$lopcs [$i]])/2);
          if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
            print ("v[$i2]:$v[$i2] ");
            };
          $vt [$i2][0] = $operation;
          $vt [$i2][1] = $lotype [$i];#ltype
          $vt [$i2][2] = $loconc [$i];#concept
          $vt [$i2][3] = $$lostrts [$i];#start address
          $vt [$i2][4] = $$loends [$i];#end address
          $vt [$i2][5] = $$logb [$i];#gap start address
          $vt [$i2][6] = $$loge [$i];#gap end address
# nuclabmieuse1
          $vt [$i2][7] = $$lola [$i];#jhlsi
          $fn = 't';
          $vs = $vs + $v [$i2];
          $i2++;
          }; #for
        };#physical token active

      $linkp = $Awfif::slipnet-> {l} [$linkp][0];
      }#while operational tokens to check

# or grow something
# or model something
# or compare requestor to something (scout)
# or move requestor somewhere
# or change rate of flow
# or signal
# or exchange something
# or replicate
# else {# dont change
# although nothing can be sure and Samuel would argue we have to learn from mistakes for this
# strategy to be OK this weak force will be an ifluence when nothing else can contribute strongly
#

    if ($i2 < $vsi) {

      $vmax = $i2;
      }
    else {

      $vmax = $vsi;
      };

    $v[$vmax] = 2;
    $vt [$vmax][0] = '';
    $vt [$vmax][1] = 0;
    $vt [$vmax][2] = 0;
    $vt [$vmax][3] = 0;
    $vt [$vmax][4] = 0;
    $vs = $vs + $v [$vmax];
# normalize

    $fn = '';
    $t = 0;
    $i2 = 1 + int (rand ($vs));
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("vs($vs) -> i2($i2) ");
      };
    $i = 1;

    while (($i <= $vmax) && (!$fn)) {
      $t = $t + $v [$i];
      if ($t >= $i2 ) {

        if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
          print ("selected i($i) ");
          };#if
        $found[0] = $vt [$i][0];#operation
        $found[1] = $vt [$i][1];#ltype
        $found[2] = $vt [$i][2];#concept
        $found[3] = $vt [$i][3];#start address
        $found[4] = $vt [$i][4];#end address
# nuclabmieuse2
        $found[5] = $vt [$i][5];#gap start
        $found[6] = $vt [$i][6];#gap end
        $found[7] = $vt [$i][7];#jhlsi
        $fn = 't';
        };#if
      $i++;
      };#while

    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("selsaliamx ret (0:$found[0] 1:$found[1] 2:$found[2] 3:$found[3] 4:$found[4] 5:$found[5] 6:$found[6] 7:$found[7])\n");
      };

    return @found
    }# selsaliam
#
sub tokenactives {
    my($myli, $sws, $wss, $wse, $linkp, $lopcs, $operoncount, $nextinstance, $lomatchs, $lola, $loends, $lostrts, $loge, $logb, $lotype, $loconc, $sactset)=@_;
    my($i2, $desclink, $cwsbi, $sgcount, $opertype);
#
# checked for merged workspaces

    $opertype = $Awfif::slipnet-> {l} [$linkp][2];
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$opertype};
      print ("tokenactives linkp $linkp opertype $pr operoncount $operoncount ");
      };
    $sgcount = 0;
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $$nextinstance = '';
# using cytosolic label's descriptor matches to the input member of the operation set as a kinase like control if present the proceed
    $Awfif::memes-> {currentwsbi} = $sws;

    for ($i2 = $wss; $i2 <= $wse; $i2 = trwsoadr ($i2, 1)) {
      $desclink = $Awfif::wsol-> {l} [ awsoadr($i2)] [2]; #index to head of descriptor list
      while (($desclink != 0) && ($$nextinstance eq '')) {# more descriptors in this chain
# Now have the node that is head of links that should be matching matchtoo

        if ($opertype == $Awfif::workspace-> {l} [$desclink][2] ) {# slipnet to matches
# return a codelet strategy

          $$nextinstance = 't'.$Awfif::memes-> {snnih} {$opertype}.'scout';
          };#if match
        $desclink = $Awfif::workspace-> {l} [$desclink][0]; # walk back down chain
        };# while
      }# for
# with the presence of a cytosolic match now find a salient part of the sub-chema

    if ($$nextinstance ne '') {
      $sgcount = tokenactive ($myli, $sws, $wss, $wse, $linkp, \@$lopcs, $operoncount, \$$nextinstance, \@$lomatchs, \@$lola, \@$loends, \@$lostrts, \@$loge, \@$logb, \@$lotype, \@$loconc, \@$sactset)
      };#if kinase has phosphorylated the sponsor
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("tokenactivesx lopcs[0] $$lopcs[0] nextinstance $$nextinstance ret ($sgcount)\n");
      };

    return $sgcount
    }# tokenactives
#
sub tokenactivem {
    my($myli, $sws, $wss, $wse, $linkp, $lopcs, $operoncount, $nextinstance, $lomatchs, $lola, $loends, $lostrts, $loge, $logb, $lotype, $loconc, $sactset)=@_;
    my($cwsbi, $sgcount, $opertype);
#
# checked for merged workspaces

    $opertype = $Awfif::slipnet-> {l} [$linkp][2];
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$opertype};
      print ("tokenactivem linkp $linkp opertype $pr operoncount $operoncount ");
      };
    $sgcount = 0;
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $$nextinstance = '';
# no kinase for model instantiation

    $$nextinstance = 't'.'nsdep'.'scout';
# Deploy from the nucleus to the core workspace a salient part of the sub-chema

    if ($$nextinstance ne '') {
      $sgcount = tokenactive ($myli, $sws, $wss, $wse, $linkp, \@$lopcs, $operoncount, \$$nextinstance, \@$lomatchs, \@$lola, \@$loends, \@$lostrts, \@$loge, \@$logb, \@$lotype, \@$loconc, \@$sactset)
      };#if kinase has phosphorylated the sponsor
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("tokenactivemx lopcs[0] $$lopcs[0] nextinstance $$nextinstance ret ($sgcount)\n");
      };

    return $sgcount
    }# tokenactivem
#
sub tokenactive {
    my($myli, $sws, $wss, $wse, $linkp, $lopcs, $operoncount, $nextinstance, $lomatchs, $lola, $loends, $lostrts, $loge, $logb, $lotype, $loconc, $sactset)=@_;
    my($i, $i2, $sponsor, $sgdi, $cwsbi, $sgcount);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("tokenactive sws($sws) wss($wss) wse($wse) linkp($linkp) operoncount($operoncount) sactset($$sactset[0]) ");
      };
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $sgcount = 0;

    for ($i2 = 0; $i2 < $operoncount; $i2++) {#scan the full set of operons
      if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
        my ($pr );
        print ("lomatchs ($i2 = $$lomatchs[$i2]) ");
        if ($$lomatchs[$i2]) {
          $pr = $Awfif::jhls-> {l} [$$lola[$i2]] [8];
          print ("jhlsi [$$lola[$i2]] [8]=$pr ");
          $pr = $Awfif::jhls-> {l} [$$lola[$i2]] [9];
          print ("jhlsi [$$lola[$i2]] [9]=$pr ");
          };#if
        };
      if ($$lomatchs[$i2]) {

        my ($end, $start);
# $$lola[$i2] has the jhls index of the matching label
# ws is [7] start is [8] end is [9]
        $Awfif::memes-> {currentwsbi} = $Awfif::jhls-> {l} [$$lola[$i2]] [7];
        $start = $Awfif::jhls-> {l} [$$lola[$i2]] [8];# start is in operon and can get us to the group sponsor and hence group info
        $i = trwsoadr ($Awfif::jhls-> {l} [$$lola[$i2]] [9], 1);#want to check the items after the operon until the group end
# the end will be one link before the group end
        &fgrpd ($myli, $start, \$sgdi, $Awfif::memes->{snnh}{groupcategory});
        $sponsor = fgrpsponsor ($start, $Awfif::workspace-> {l} [$sgdi] [3], $Awfif::memes-> {snnh} {groupcategory});
        $end = fgrpend ($sponsor);# of the group
#
# now can find any salient sub-schema between $i and $end
# nuclabmieuta1

        &rtokenmatch ($i, $end, \$sgcount, \@$lopcs, \@$lola, \@$loends, \@$lostrts, \@$loge, \@$logb, \@$lotype, \@$loconc, $$lola[$i2]);

        };# if
      };# for
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("tokenactivex lopcs $$lopcs[0] nextinstance $$nextinstance ret ($sgcount)\n");
      };

    return $sgcount
    }# tokenactive
#
sub rtokenmatch {
    my($i, $end, $sgcount, $lopcs, $lola, $loends, $lostrts, $loge, $logb, $lotype, $loconc, $sjhls)=@_;
    my($i3, $i2);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("rtokenmatch i $i end $end sgcount $$sgcount ");
      };

# now can find any salient sub-schema between $i and $end
    if ((defined ($Awfif::memes-> {fjhls8})) && ($Awfif::memes-> {fjhls8} != 0)
    ) {#worth checking jhls 8,9
# nuclabmvbotu1
# if the jhls is in the vbotscmap then can just respond with the associated action jhls

      my ($vbotg, $vboti);
      if ((defined ($Awfif::memes-> {vbottgenmax}))
      && (defined ($vbotg = $Awfif::memes-> {vbottgenmax} - ($Awfif::workspace-> {l} [$Awfif::memes-> {vbotpgdsc} ] [3] - $Awfif::memes->{snnh}{wsi}) ) )
      && ( ($vboti = $Awfif::memes-> {vbottpopmax} + 1 - ($Awfif::workspace-> {l} [$Awfif::memes-> {vbotpgdsc} ] [2] - $Awfif::memes->{snnh}{wsi}) ) > 1)# to ensure that have run first vbot
      && (defined ($Awfif::vbotga-> {scmaph}-> {$sjhls}))
      ){

        $i3 = $Awfif::vbotha-> {gens} [0] [1]-> {vbotscbh}{$Awfif::vbotga-> {scmapc} [$vboti][$Awfif::vbotga-> {scmaph}-> {$sjhls}]};
        $$lostrts [$$sgcount] = $Awfif::jhls-> {l} [$i3][8];
        $$loends [$$sgcount] = $Awfif::jhls-> {l} [$i3][9];
        $$logb [$$sgcount] = $Awfif::jhls-> {l} [$i3][11];#gap start
        $$loge [$$sgcount] = $Awfif::jhls-> {l} [$i3][12];# gap end
        $$lotype [$$sgcount] = $Awfif::jhls-> {l} [$i3][3];#ltype such as operon & spsignal
        $$loconc [$$sgcount] = $Awfif::jhls-> {l} [$i3][4];#concept such as groupcategory
        $$lola [$$sgcount] = $i3;#jhlsi
        $$lopcs [$$sgcount++] = $Awfif::jhls-> {l} [$i3][6];#pseudo concept
        }#if its a vbot model action mapping
      else {
# nuclabmvbotu3

        if ( defined($Awfif::jhls-> {l} [$sjhls][20][0]) ){

          for ($i2 = 1; $i2 <= $Awfif::jhls-> {l} [$sjhls][20][0]; $i2++){

            $i3 = $Awfif::jhls-> {l} [$sjhls][20][$i2];
            $$lostrts [$$sgcount] = $Awfif::jhls-> {l} [$i3][8];
            $$loends [$$sgcount] = $Awfif::jhls-> {l} [$i3][9];
            $$logb [$$sgcount] = $Awfif::jhls-> {l} [$i3][11];#gap start
            $$loge [$$sgcount] = $Awfif::jhls-> {l} [$i3][12];# gap end
            $$lotype [$$sgcount] = $Awfif::jhls-> {l} [$i3][3];#ltype such as operon & spsignal
            $$loconc [$$sgcount] = $Awfif::jhls-> {l} [$i3][4];#concept such as groupcategory
            $$lola [$$sgcount] = $i3;#jhlsi
            $$lopcs [$$sgcount++] = $Awfif::jhls-> {l} [$i3][6];#pseudo concept
            };#for
          }#if
        else {

          for ($i3 = $Awfif::memes-> {fjhls8}; $i3 <= $Awfif::jhls-> {p}; $i3++) {
# nuclabmvbotu2
            if (($Awfif::jhls-> {l} [$i3][7] == $Awfif::memes->{currentwsbi})
            && (ainbtoc ($Awfif::jhls-> {l} [$i3][8], $i, $end, $Awfif::jhls-> {l} [$i3][7]))
            && (ainbtoc ($Awfif::jhls-> {l} [$i3][9], $i, $end, $Awfif::jhls-> {l} [$i3][7]))
            ) {#match assuming lists

              $$lostrts [$$sgcount] = $Awfif::jhls-> {l} [$i3][8];
              $$loends [$$sgcount] = $Awfif::jhls-> {l} [$i3][9];
              $$logb [$$sgcount] = $Awfif::jhls-> {l} [$i3][11];#gap start
              $$loge [$$sgcount] = $Awfif::jhls-> {l} [$i3][12];# gap end
              $$lotype [$$sgcount] = $Awfif::jhls-> {l} [$i3][3];#ltype such as operon & spsignal
              $$loconc [$$sgcount] = $Awfif::jhls-> {l} [$i3][4];#concept such as groupcategory
# nuclabmieurt1
              $$lola [$$sgcount] = $i3;#jhlsi
              $$lopcs [$$sgcount++] = $Awfif::jhls-> {l} [$i3][6];#pseudo concept
              };#if proximate jhlabel
            };#for each jhls
          };#else
        };#else
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("rtokenmatchx sgcount ($$sgcount)\n");
      };

    }# rtokenmatch
#
sub consumed {
    my($facettype, $kwp, $kwpr, $sactset)=@_;
    my($nextinstance);
#
# checked for merged workspaces

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr );
      $pr = $Awfif::memes-> {snnih} {$facettype};
      print ("consumed facettype $pr kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
      };
    $nextinstance = 0;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnih} {$nextinstance};
      print ("consumedx ret $pr\n");
      };

    return $nextinstance;
    }# consumed
#
#
sub compwfctran {# identify the evaluator's buildername, see if it matches a transaction recipient and complete it if it does
    my($myli, $procname, $sgjhlsi)=@_;
    my ($result, $i, $cwsbi, $codeletname, $vboti, $vbotg);

no strict 'refs';
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("compwfctran myli $myli procname($procname) ");
      };#if

    $cwsbi = $Awfif::memes-> {currentwsbi};
    if ( $Awfif::codelet-> {l} [$myli] [35] > 0 ) {

      $result = 0;
# identify the callers builder name
      $codeletname = setupbuildername ($procname);
# compwfctgmu1
# now if there is a genetic mapping apply it

      $vbotg = $Awfif::memes-> {vbottgenmax} - ($Awfif::workspace-> {l} [$Awfif::memes-> {vbotpgdsc} ] [3] - $Awfif::memes->{snnh}{wsi});
      $vboti = $Awfif::memes-> {vbottpopmax} + 1 - ($Awfif::workspace-> {l} [$Awfif::memes-> {vbotpgdsc} ] [2] - $Awfif::memes->{snnh}{wsi});
      if ( ($vboti > 1)
      && ( (defined ($Awfif::vbotha-> { gens} [0] [1]-> {vbotscbh} {$codeletname}))) #ensure it will find the builder in array
      && ( defined ($Awfif::vbotga-> {scmaph}-> {$sgjhlsi})) #check the mapped sgjhlsi exists
      && ( (defined ($Awfif::vbotga-> {scmapc} [$vboti][$Awfif::vbotga-> {scmaph}-> {$sgjhlsi}]))) #check the mapped builder is in the cache
      ){

        $codeletname = $Awfif::vbotga-> {scmap0} [1] [$Awfif::vbotga-> {scmaph}-> {$sgjhlsi}];
        };#if
# now check for a match to the transaction sponsor
      for ($i = 1; ( ($result == 0) && ($i <= $Awfif::tral-> {i} [ $Awfif::codelet-> {l} [$myli] [35] ] [0])); $i++) {
        if ($Awfif::tral-> {i} [$Awfif::codelet-> {l} [$myli] [35] ] [$i] eq $codeletname) {

          $result = $i;
          };#if
        };#for
# as long as wfc only contains simple transactions with no subprograms this completion mechanism should be ok - fingers crossed
      if (($result > 0) && ($Awfif::tral-> {w} [$Awfif::codelet-> {l} [$myli] [35] ] [$result] [1] != $Awfif::memes-> {snnh} {completed}) ){

        $Awfif::tral-> {w} [$Awfif::codelet-> {l} [$myli] [35] ] [$result] [1] = $Awfif::memes-> {snnh} {completed};
        };#if
      };#if

    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("compwfctranx ");
      print ("ret ");
      print ("($result)\n");
      };
    return $result
    }# compwfctran
#
#
sub operonlmatch {
    my ($myli, $jhlabeli, $lomatchs, $lola, $loconcs, $lostrts, $loends, $logb, $loge, $filstrategy, $stws) = @_;
    my ($i, $i2, $label, $type, $ltype, $sigcount, $cwsbi);
# find all the operon controlled groups in the current ws that match the source jhlabel
# the jhlabels for these operons should have been loaded by lbbuilder
#
# checked for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("operonlmatch myli $myli jhlabeli $jhlabeli ");
      &itcpoutput ($myli);
      };

    $label = '';
    $ltype = '';
    $i2 = 0;

# $Awfif::memes-> {currentwsbi} = $sws;
# compare the jhlabel to the nuclear ws operons return any matching operons for this ws
#
# create an input label for msublabel from the jhlabel's attrib list
    $i = $Awfif::jhls-> {l} [$jhlabeli] [5];
    $i = $Awfif::attribs-> {l} [$i][1];#move past the start attribute
    while (($Awfif::attribs-> {l} [$i][2]) != $Awfif::memes-> {snnh}{attribe}) {
      my ($nexti);
      $type = ' ' . $Awfif::attribs-> {l} [$i][3];
      $nexti = $Awfif::attribs-> {l} [$i][1];
      if( ($Awfif::attribs-> {l} [$i][4]) #note repeat
      or ($type eq ' ' . $Awfif::attribs-> {l} [$nexti][3]) #in case repeats not encoded in attrib list - it happens
      ){#note repeat

        $type = '_' . $Awfif::attribs-> {l} [$i][3];
        };#repeat
      if ($ltype ne $type) {# ignore repeats

        $label = $label.$type;
        $$lostrts[$i2++] = $i;
        };#build direct label
      $ltype = $type;
      $i = $Awfif::attribs-> {l} [$i][1];#next
      };#while
# apply the linking function of group completion
# if the groups labels result in a match with a signal then raise the signal
#

    $sigcount = msublabel1 ($myli, \$label, \@$lomatchs, \@$lola, \@$loconcs, \@$lostrts, \@$loends, \@$logb, \@$loge, $filstrategy, $stws);
# delete the non current ws & non operon matches
    $Awfif::memes-> {currentwsbi} = $cwsbi;
    if ($sigcount > 0) {

      for ($i = 0; $i < $sigcount; $i++) {

        if ($$lomatchs[$i]) {#there is a link validate the association
# matching jhlabel check if it is for operon and for current ws & operon includes the group sponsor
# if not remove it from the match set (set $lomatchs[$i] false
          if (($Awfif::jhls-> {l} [$$lola[$i]][4] != $Awfif::memes-> {snnh}{operon})
          or ($Awfif::jhls-> {l} [$$lola[$i]][7] != $Awfif::memes-> {currentwsbi})
          or (!ophasgs ($myli, $$lola[$i]))
          ) {

            $$lomatchs[$i] = '';
            };
          };#if link
        };#for
      };#if

    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("operonlmatchx ret $sigcount\n");
      };
    return $sigcount
    }# operonlmatch
#
#<!-- start tag vbt -->
#
sub ainbtoc {
    my ($a, $b, $c, $ws) = @_;
    my ($cwsbi, $succeeded, $i);
# If find a within range of b - c then reply succeeded
#
# checked for merged workspaces

# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# print ("ainbtoc a($a) in ws $ws: b $b - c $c ");
# };

    $succeeded = '';

    $cwsbi = $Awfif::memes-> {currentwsbi};

    if ((defined ($a))
    && ($a != 0)
    && (defined ($b))
    && ($b != 0)
    && (defined ($c))
    && ($c != 0)
    && (defined ($ws))
    && ($ws != 0)
    ){
      $Awfif::memes-> {currentwsbi} = $ws;
#

      $i = $b;
      while (($i != $c) && (!$succeeded) && ($i != 0)) {
        if ($i == $a) {
          $succeeded = 't';
          };#if
        $i = trwsoadr ($i, 1);
        };#while
        if ($a == $c) {
          $succeeded = 't';
          };#if
      };

    $Awfif::memes-> {currentwsbi} = $cwsbi;

# if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
# print ("ainbtocx ret ($succeeded)\n");
# };
    return $succeeded
    }# ainbtoc
#
#<!-- end tag vbt -->
#<!-- start tag inh -->
#
sub nuclabmbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $signal, $schema, @lomatchs, @lola, @loconcs, @lostrts, @loends, @logb, @loge, $operoncount, $proceed, $swstype,
      $grkwp, $grkwpr, @operation, $cdn, $cdnx);
#
# updated for merged workspaces

# goals must use the full workspace

    $proceed = getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, undef(), \$cdn, \$cdnx, 3);
# handle rework

    if (($proceed) && ($Awfif::codelet-> {l} [$myli][14] != 0)) {#rework so use previous parameters
      &reuselog ($myli);

      if ((($signal == $Awfif::memes->{snnh}{mpsignal}) && (defined($Awfif::memes->{snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$schema])))) {
        my ($spws);
        $spws = $Awfif::codelet-> {l} [$myli] [20];
        &updatelog ($myli, 'tngs', 1, $signal);#
        &updatelog ($myli,'tngs', 2, $schema);#

        print ("tnms sp=$spws:$sponsor,\n");
        }#multipath signal

      }# rework
    elsif ($proceed) {#main line
# Top-down nuclear label group codelets search completed groups looking for a match with their sponsoring label
# when this is true the builder will
# use selsalact to indicate which of the wso in the subschema terminated by the /memgroup are salient.
# transcribe the salient wso string
# to the cytosolic workspace
# the transcription will be active for one iteration of group builder complete when the telomeric strings will become 0 and the
# string of wso will be destroyed
#

      if ((($signal == $Awfif::memes->{snnh}{mpsignal}) && (defined($Awfif::memes->{snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$schema])))) {
# Using the mplabel check the nuclear schema for groups that match
        my ($sws, $wss, $wse);
        $sws = $Awfif::codelet-> {l} [$myli] [20];
        $wss = $Awfif::codelet-> {l} [$myli][21];
        $wse = $Awfif::codelet-> {l} [$myli][22];

# nuclabbbice
        if ((defined ($Awfif::jhls-> {l} [$Awfif::codelet-> {l} [$myli][23]] [13]))
        && ($Awfif::bicl-> {l} [$Awfif::jhls-> {l} [$Awfif::codelet-> {l} [$myli][23]] [13]] [3] == $Awfif::jhls-> {l} [$Awfif::codelet-> {l} [$myli][23]] [5])
          ){#there is a cache element setup

          $operoncount = usebice ($Awfif::jhls-> {l} [$Awfif::codelet-> {l} [$myli][23]] [13], \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge);
          }#if
        else {

          $operoncount = operonlmatch ($myli, $Awfif::codelet-> {l} [$myli][23], \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, 'specwsonlyopbinding', $Awfif::memes-> {currentwsbi});
          if (!defined ($Awfif::jhls-> {l} [$Awfif::codelet-> {l} [$myli][23]] [13])) {
            $Awfif::jhls-> {l} [$Awfif::codelet-> {l} [$myli][23]] [13] = addbice ($sws, $Awfif::jhls-> {l} [$Awfif::codelet-> {l} [$myli][23]] [5], $wse, $operoncount, \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge);
            };#if
          };#else
        if ($operoncount > 0) {

          my ($loopcount, $bcindex, $loperoncount, @llomatchs, @llola, @lloends, @llostrts, @lloge, @llogb, $opcount, $satisfied, $dontgiveup, $note35, $ctfifound);
          $llomatchs[0] = '';
          $llola [0] = 0;
          $lloends [0] = 0;
          $llostrts [0] = 0;
          $lloge [0] = 0;
          $llogb [0] = 0;
          for ($opcount = 0; $opcount < $operoncount; $opcount++) {
            if ($lomatchs [$opcount]) {

              $loopcount = 0;
# use selsalact to identify salient areas of the subschema of each matching schema

              $satisfied = '';
              $dontgiveup = 't';$ctfifound = '';
              while ((!$satisfied) && ($dontgiveup)) {
                if (($loopcount++ > $Awfif::memes-> {nuclabmblth}) && ($Awfif::memes-> {nuclabmbbreak}) ){ &break ();};
                $llomatchs[0] = $lomatchs [$opcount];
                $llola [0] = $lola [$opcount];
                $lloends [0] = $loends [$opcount];
                $llostrts [0] = $lostrts [$opcount];
                $lloge [0] = $loge [$opcount];
                $llogb [0] = $logb [$opcount];
                $loperoncount = 1;
                @operation = selsaliam ($myli, $sws, $wss, $wse, $operoncount, \@llomatchs, \@llola, \@lloends, \@llostrts, \@lloge, \@llogb, \@$sactset, $Awfif::memes-> {snnh}{model});
                if (($operation[0] ne '')
                && (( $operation [7] == 0 )
                  or (($operation [7] != 0)
                    && ( ( (!defined ($Awfif::jhls-> {l} [$operation [7]][17]))
# nuclabminhu1
                      or ( $dontgiveup = ctficomp ($myli, $operation [7], $kwp, $kwpr, \@$sactset, \$ctfifound) ) ) ) ) )
                ){
                  my ($hashname);
                  $satisfied = 't';

                  if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
                    &itjhloutput ($operation [7]);
                    };
# nuclabinwfcu1
# if find deployment operon in wfc cache ref don't signal deployment

                  if ((! $Awfif::memes-> {wfcoptdep})
                  or (! defined ($hashname = $Awfif::wfcdefl-> {operon} {wsolistaschst ($operation [3], $operation [4], $Awfif::codelet-> {l} [$myli] [19])}))
                  or (!defined ($Awfif::wfchchainl-> {hashname} {$hashname}))# the evaluator has been purged
                  ){

                    $Awfif::clp = ();
                    $Awfif::clp-> {urgency} = ($Awfif::codelet-> {l} [$myli][3] ); #* $Awfif::memes-> {evlaunchm});
                    $Awfif::clp-> {action}-> {schema} = $schema;
                    $Awfif::clp-> {action}-> {signal} = $signal;
                    $Awfif::clp-> {action}-> {sws} = $Awfif::codelet-> {l} [$myli] [20];
                    $Awfif::clp-> {action}-> {wss} = $operation [3];
                    $Awfif::clp-> {action}-> {wse} = $operation [4];
                    if (($operation [5] != 0)
                    && ($operation [5] != $operation [6]) ){
                      $Awfif::clp-> {action}-> {wsgs} = $operation [5];
                      $Awfif::clp-> {action}-> {wsge} = $operation [6];
                      };#operon has a gap
# nuclabmieu5
                    if (($operation [7] != 0) ){

                      $Awfif::clp-> {action}-> {sgjhlsi} = $operation [7];
                      };#operon has a subgroup jhlsi
# nuclabmtrau1
                    $note35 = $Awfif::codelet-> {l} [$myli] [35];
                    if ( ((defined ($Awfif::codelet-> {l} [$myli] [35])) && ($Awfif::codelet-> {l} [$myli] [35] != 0))
                    && (!schabldr ($myli, $lola [$opcount], $operation [7]))
                    ){#must not propogate the transaction id to this deployment codelet

                      $Awfif::codelet-> {l} [$myli] [35] = 0;
                      };#if
                    $Awfif::clp-> {action}-> {jhlabeli} = $Awfif::codelet-> {l} [$myli][23];
# nuclabmbpoolu1
                    $bcindex = matchbreakcodelet ($myli);#note if there is a breakpoint to conserve
                    &groupsinv1 ($myli, $sponsor, trwsoadr ($sponsor,1), 0, $sponsor, 0, $operation[0], $$kwp, $kwpr, \@$sactset,
                      undef(), #deferred
                      undef(), #ignore wso name
                      't' #attempt usepooling if codelet l 38 is > 0
                      );
                    $Awfif::codelet-> {l} [$myli] [35] = $note35;
                    }#if not a wfc operon match
# nuclabinwfcu2
                  elsif ( (defined ($hashname))
                  && (defined ($Awfif::wfchchainl-> {hashname} {$hashname}))
                  ){#complete this wfc operon matched transaction

                    &compwfctran ($myli, $hashname, $lola [$opcount]);
                    };#elsif
                  }#valid operation
                elsif (($Awfif::codelet-> {l} [$myli] [35] > 0) && ($ctfifound) && (!$dontgiveup) ){#if launch is tf inhibited then terminate the transaction

                  my ($trali);
                  for ($trali = 1; $trali <= $Awfif::tral-> {i} [$Awfif::codelet-> {l} [$myli] [35]] [0]; $trali++) {

                    $Awfif::tral-> {w} [$Awfif::codelet-> {l} [$myli] [35]][ $trali ] = $Awfif::memes-> {snnh} {terminated};
                    };#for
                  };#elsif
                };#while getting satisfied
              if ($bcindex > 0) {#setup for next child

                $Awfif::memes-> {breakcodelet}[++$Awfif::memes-> {breakcodelet}[0]] = $myli;
                $Awfif::memes-> {breaksubp}[++$Awfif::memes-> {breaksubp}[0]] = $Awfif::codelet-> {l} [$myli] [36];
                };#if
              &trackcodelet ($myli, $Awfif::memes-> {codeletdef}, $Awfif::memes-> {snnh} {assocf1}, undef(), undef(), $Awfif::codelet-> {l} [$myli] [36]);
              };#if
            };# for
          if ((defined ($bcindex)) && ($bcindex > 0)) {

            $Awfif::memes-> {breaksubp}[$Awfif::memes-> {breaksubp}[0]--] = undef();
            $Awfif::memes-> {breakcodelet}[$Awfif::memes-> {breakcodelet}[0]--] = undef();
            };#if
          &trackcodelet ($myli, $Awfif::memes-> {codeletdef}, $Awfif::memes-> {snnh} {assocf1}, undef(), undef(), $Awfif::codelet-> {l} [$myli] [36]);
          };#in group
        };# sps or mps signal
      };# main line

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# nuclabmbuilder1
#
#<!-- end tag inh -->
Market Centric Workshops
The Physics - Politics, Economics & Evolutionary Psychology
Politics, Economics & Evolutionary Psychology

Business Physics
Nature and nurture drive the business eco-system
Human nature
Emerging structure and dynamic forces of adaptation


integrating quality appropriate for each market
 
This page looks at schematic structures and their uses.  It discusses a number of examples:
  • Schematic ideas are recombined in creativity. 
  • Similarly designers take ideas and rules about materials and components and combine them. 
  • Schematic Recipes help to standardize operations. 
  • Modular components are combined into strategies for use in business plans and business models. 

As a working example it presents part of the contents and schematic details from the Adaptive Web Framework (AWF)'s operational plan. 

Finally it includes a section presenting our formal representation of schematic goals. 
Each goal has a series of associated complex adaptive system (CAS) strategy strings. 
These goals plus strings are detailed for various chess and business examples. 
Strategy
| Design |
This page uses an example to illustrate how:
  • A business can gain focus from targeting key customers,
  • Business planning activities performed by the whole organization can build awareness, empowerment and coherence. 
  • A program approach can ensure strategic alignment. 
Program Management
| Home

Profiles | Papers | Glossary | E-mail us