Syntactically whole statement
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

A schematic model of a syntactically complete statement

Summary
This page looks at how
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
processes the statement, such as a test request, to ensure that the statement contains all required parts. 
Smiley does this through the operation of a statement codelet which indirectly sponsors the modeling of the whole statement. 
The
The agents in complex adaptive systems (CAS) must model their environment to respond effectively to it.  Samuel modeling is described as an approach. 
modeling
itself is performed by model codelets
The group models'
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
associations are included
The codelets and supporting functions are included
Introduction
A test request statement's syntax 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
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. 
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 that a statement has all the required parts
The statement evaluator will only run once the parts that compose a statement are
This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is integral. 
Smiley does this through the operation of a part codelet which initiates a program to assess the integrity of the parts. 
The modeling itself is performed by model codelets. 
The group models' Slipnet associations are included. 
The codelets and supporting functions are included. 
well formed
.  The evaluator will check that each part of the statement is whole, and that the development 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. 
clause is whole.  The modeling is controlled by nuclear operons signalled by the evaluator's statement whole (statementlabel1) with nlmbindtomsigstc and development whole which checks that the development clause conforms to a
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. 
whole part
and if so signals the nucleus, a membrane bounded module in a eukaryotic cell where the DNA is encapsulated and operated on. 
via (developmentlabel1) with nlmbindtomsigdvw have been
This page describes the Smiley infrastructure that supports the associative binding of schematic strings to codelets defined in the Meta file and Slipnet. 
The infrastructure supporting the associations is introduced. 
The role of Jeff Hawkins neocortical attributes is discussed. 
Relevant Slipnet configurations are included. 
The codelets and supporting functions are included. 
associated
in 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
with a signal type (mpsignal). 
Indirect modeling response to the statement evaluator's signal
The statement whole group operon has a subgroup used as one model of the completeness of the statement. 
The whole statement subgroup schemata
The transfer of RNA (RNA), a polymer composed of a chain of ribose sugars.  It does not naturally form into a paired double helix and so is far less stable than DNA.  Chains of DNA are converted by transcription into equivalently sequenced messenger m-RNA.  RNA also provides the associations that encode the genetic code.  Transfer t-RNAs have a site that maps to the codon and match the associated amino-acid.  Stuart Kauffman argues that RNA polymers may be the precursor to our current DNA based genome and protein based enzymes.  In the adaptive web framework's (AWF) Smiley we use a similar paradigm with no proteins. 
like verb specific subgroups from the nuclear
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
to the statement's Workspace include mwstabindtomsigr which is associated with the evaluator of the model whole statement codelet mwstaverb. 
The whole statement model codelets
The codelet builders: mwstabuilder & mwstdbuilder model the required and conditional groups within the statement.  The model uses the Meta file is loaded by the adaptive web framework's (AWF) Smiley.  It defines the application system's basic rules, its keywords and their properties and the form of the assertion or implementation statement the application uses.   to map general concept tokens to the application's specific language and is implemented in Perl code running 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





#<!-- start tag gm -->

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. 

sscstatementwhole signalled meme
The statementwhole function'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
(<model> <schema> <statementcategory> <assert> <statementcomplete>) 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 statement schematic structure Slipnet description associates codelet forces (nuclabmevaluator) with the signal. 

 



<comment> (<rhlmspg> <memgroup> <model> <schema> <statementcategory> <assert> <statementcomplete> <model> <statementcategory> <assert> <process> <statementwhole> </memgroup> </rhlmspg> )<comment>




#<!-- start tag gm -->

comment (<rhlmspg> <memgroup> <model> <schema> <statementcategory> <assert> <statementcomplete> <model> <statementcategory> <assert> <process> <statementwhole> </memgroup> </rhlmspg> ) comment

#<!-- end tag gm -->

#
    my ($pconc, $jhlsid);
# nlmbindtomsigstc
# setup the binding string for the multi path signal to initiate statement complete model - model codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {model}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {model}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon really want qmark rather than assert
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 16, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {statementcategory}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {statementcomplete});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {model}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$pconc,$Awfif::memes-> {snnh} {model},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {model}]);
# nlmbindtomsigstw
# setup the binding string for the multi path signal to initiate statement whole model - model codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {model}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {model}] [1], 8, $Awfif::memes-> {currentwsbi});
# next want to setup the operon really want qmark rather than assert
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 17, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {statementcategory}, $Awfif::memes-> {snnh} {qmark}, $Awfif::memes-> {snnh} {statementwhole});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {model}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$pconc,$Awfif::memes-> {snnh} {model},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {model}]);
# mwstabindtomsigr
# & a label for a sps indirectly from model via $pconc

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {model}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {model}] [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, 18, $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} {model}, $Awfif::memes-> {snnh} {statementcategory}, $Awfif::memes-> {snnh} {assert}, $Awfif::memes-> {snnh} {process}, $Awfif::memes-> {snnh} {statementwhole});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {mwstaevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {model}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$pconc,$Awfif::memes-> {snnh} {model},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {model}]);
# nlmbindtomsigdvw
# setup the binding string for the multi path signal to initiate development whole model - model codelets launch nuclabmcodelets which ignore the concept as long as it had an evaluator

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {model}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {model}] [1], 8, $Awfif::memes-> {currentwsbi});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {attrib}, Awfif::addjhlst ($Awfif::memes-> {snnh} {mpsignal}, $pconc, 17, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {devcategory}, $Awfif::memes-> {snnh} {development}, $Awfif::memes-> {snnh} {statementcomplete});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {nuclabmevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {model}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$pconc,$Awfif::memes-> {snnh} {model},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {model}]);
# mwstdbindtomsigr
# & a label for a sps indirectly from model via $pconc

    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {model}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {model}] [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, 18, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {model}, $Awfif::memes-> {snnh} {schema}, $Awfif::memes-> {snnh} {development}, $Awfif::memes-> {snnh} {devcategory}, $Awfif::memes-> {snnh} {statementwhole});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {mwstdevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$Awfif::memes-> {snnh} {model}] = Awfif::newnlink ( $Awfif::memes-> {snnh} {cinstance},$pconc,$Awfif::memes-> {snnh} {model},
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh} {model}]);

Functions

#
sub listkwclass {
    my ($myli, $kwind, $class, $kwp, $kwpr, $kwlists)=@_;
    my ($i2, $ai2, $i3, $i4, $ismatched, $failed, $kw, $tkw, $ikw, $nooflists, $pwso, $pwsbi, $apwso, $cwsi, $more, $ni);
# search the streamed metafile for instances of the keyword and
# return lists of specified class of sub keywords for each instance
# (address 0) of array list is count of subkeywords for that instance

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnih}{$class};
      print ("listkwclass myli $myli, kwind $kwind class $pr kwp $kwp kwpr $kwpr ");
      };
    $cwsi = $Awfif::memes-> {currentwsbi};# to later restore current state
    $failed = '';
    $nooflists = 0;
    $$kwlists [$nooflists+1][0] = 0;
    $ismatched = '';
# get the wso's keyword

    $kw = getwsost4 ($kwind);
    $tkw = '/'.$kw;
    $ni = $kwind;
# find an acceptable declaration

    do {
      $pwso = getwsopkw ($ni, \$pwsbi, \$more);
      $Awfif::memes-> {currentwsbi} = $pwsbi;
      $apwso = awsoadr ($pwso);
      $Awfif::memes-> {currentwsbi} = $cwsi;
# compare the wso's keyword to the metafile based definition match to the specified token symbol

      for ($i3 = $Awfif::wsol-> {l}[$apwso][2]; (($i3 < ($Awfif::wsol-> {l} [$apwso][2] + $Awfif::wsol-> {l} [$apwso][3])) && (!$failed)); $i3++) {
        if (($Awfif::memes-> {keywordl} [$i3] eq $Awfif::symbolsets-> {meta} {start})
        or ($Awfif::memes-> {keywordl} [$i3] eq $Awfif::symbolsets-> {meta} {alternate})
        ){

          $nooflists++;
          $Awfif::memes-> {currentwsbi} = $pwsbi;
          $i2 = trwsoadr ($pwso,1);
          $ikw = getwsost4 ($i2);
          while ($ikw ne $tkw) {

            $ai2 = awsoadr ($i2);
            $Awfif::memes-> {currentwsbi} = $cwsi;
            for ($i4 = $Awfif::wsol-> {l}[$ai2][2]; (($i4 < ($Awfif::wsol->{l}[$ai2][2] + $Awfif::wsol-> {l} [$ai2][3])) && (!$failed)); $i4++) {
              if ($Awfif::memes-> {keywordl}[$i4] eq $Awfif::symbolsets-> {meta} {$Awfif::memes-> {snnih}{$class}}) {

                $$kwlists [$nooflists][0]++;
                $$kwlists [$nooflists][$$kwlists [$nooflists][0]] = $ikw;
                };#if
              };#for
            $Awfif::memes-> {currentwsbi} = $pwsbi;
            $i2 = trwsoadr ($i2,1);
            $ikw = getwsost4 ($i2);
            };#while
          $Awfif::memes-> {currentwsbi} = $cwsi;
          $$kwlists [$nooflists+1][0] = 0;#initialise next list
          };#if start present
        }; #for
      } while ((!$ismatched) && ($more != 0) && ($ni = $more));

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("listkwclassx ret ($nooflists)\n");
      };

    return ($nooflists);
    };# listkwclass
#
sub partwhole {# assess this part for its wholeness
    my($myli, $parti, $wholeid, $kwp, $kwpr, $sactset)=@_;
    my ($whole, $giveup);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {currentwsbi};
      print ("partwhole myli $myli ws $pr ");
      $pr = $Awfif::memes-> {snnih} {wsbasetype ($parti)};
      print (" i $pr($parti) ");
      $pr = $Awfif::pcache-> {p} [$Awfif::memes-> {currentwsbi}];
      print ("p $pr ");
      };
# updated for merged workspaces
# partwhole is called within part codelet As such it will assume the part has setup the pcache
# it uses statement/part model launcher to check if the plan associated with cascade partlabel is modelled and described as model-(subject|object|verb|development)->whole|devpwhole or stopped,

    $whole = ilaunchmodel ($myli, $parti, 'partlabel', $wholeid, \$giveup, $kwp, $kwpr, \@$sactset);
    if (findbond ($Awfif::wsol-> {l} [ awsoadr ($parti)] [2], $Awfif::memes-> {snnh} {dropopcheck}, wsbasetype ($parti), $Awfif::memes-> {snnh} {model})) {# terminate statement processing

      my ($pr);
      $pr = $Awfif::memes-> {snnih} {wsbasetype ($parti)};
      print ("bad group in part $pr - moving to next file\n");
      &actnodes ($Awfif::memes-> {snnh} {terminate}, $Awfif::memes-> {actmax});
      &invcaches ($Awfif::memes-> {snnh} {terminate});
      if ($Awfif::memes-> {partwholebreak}) {&break ()}
      };#else

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("partwholex ret ($whole)\n");
      };
    return $whole
    }# partwhole
#
#
sub mgparts {# check if this part has operons
    my ($myli, $nextinstance, $twso, $undecided, $kwp, $kwpr, $sactset)=@_;
    my ($inbounds, $msal, $groupcomplete, $i, $ai, $itwso, $atwso);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mgparts myli $myli, nextinstance $nextinstance twso $twso kwp $kwp kwpr $kwpr ");
      };
    $atwso = awsoadr ($twso);
# move the kwp out of the inactive histone
    if (($Awfif::wsol-> {l}[$atwso][ $Awfif::memes-> {wsohistbp}] != 0) #*** submacrok ***#
    && ($Awfif::histonel-> {l} [$Awfif::wsol-> {l}[$atwso][ $Awfif::memes-> {wsohistbp}]] [2] == 1)) {#*** submacrok ***#

      $itwso = nextihistone ($twso, \$atwso);
      }#if
    else {

      $itwso = $twso;
      };#else
    $inbounds = '';
    $$undecided = '';
# for each typed wso check their groups for existance of atleast one operon

    for ($i = trwsoadr ( $nextinstance, 1);
    $i != $itwso;
    $i = trwsoadr ($i, 1)) {

      $ai = awsoadr ($i);
      if (($Awfif::wsol-> {l}[$ai][ $Awfif::memes-> {wsohistbp}] != 0) #*** submacrok ***#
      && ($Awfif::histonel-> {l} [
        $Awfif::wsol-> {l}[$ai][ $Awfif::memes-> {wsohistbp}]#*** submacrok ***#
          ] [2] == 1)) {#ignore this inactive histone
        $groupcomplete = '';
        }#if
      else {
        $msal = ($msal + tdgroup1 ($myli, $i, $kwp, $kwpr, \$groupcomplete))/2;
        if ($groupcomplete) {

          my ($end, $sponsor, $sgdi);
# now move i beyond the group end
          &fgrpd ($myli, $i, \$sgdi, $Awfif::memes->{snnh}{groupcategory});
          $sponsor = fgrpsponsor ($i, $Awfif::workspace-> {l} [$sgdi] [3], $Awfif::memes-> {snnh} {groupcategory});
          $end = fgrpend ($sponsor);# of the group
          if (operonfound ($myli, $Awfif::memes-> {currentwsbi}, $i, $end)) {

            $msal = ($msal + $Awfif::memes-> {grcompaward})/2;
            };
          $i = $end;
          }# if
        else {
          my ($wsoindisle, $wsoindisue, $hle, $hue, $gtype, );
# should do each leaf under groupcategory

          $gtype = $Awfif::memes-> {snnh}{succgroup};
          if ((cantgroup ($myli, trwsoadr ($i, 1), $gtype, \$wsoindisle, \$wsoindisue, \$hle, \$hue, $kwp, $kwpr, \@$sactset) && ($wsoindisle) && ($hle))) {
# know this can't contribute
            }
          else {

            $$undecided = 't';
            };
          };# else of handle completed groups
        };#else
      };# for

    if ($msal >= $Awfif::memes-> {salthr} ) {

      $inbounds = 't';
      };#if threshold failure

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mgpartsx msal $msal undecided ($$undecided) ret ($inbounds)\n");
      };

    return ($inbounds);
    }# mgparts
#
#
sub mrequired {# check if this statement contains its required attributes
    my ($myli, $nextinstance, $swstype, $undecided, $kwp, $kwpr, $sactset)=@_;
    my ($requiredfound, $nooflists, @requiredkws, @matchkwstatus);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnih} {$swstype};
      print ("mrequired myli $myli, nextinstance $nextinstance swstype $pr ($swstype) kwp $kwp kwpr $kwpr ");
      };
    $nooflists = imrequested ($myli, $nextinstance, $Awfif::memes-> {snnh}{requires}, \$$undecided, $kwp, $kwpr, \@requiredkws, \@matchkwstatus, \@$sactset);

    if ($nooflists > 0) {# there are requested keywords If, for any definition, all that are requested are found then return true
      my ($i2, $i3);

      $$undecided = '';
      $requiredfound = '';
      for ($i2 = 1; $i2 <= $nooflists; $i2++) {
        if (($matchkwstatus [$i2][0] >= $requiredkws [$i2][0]) && (!$requiredfound)) {
          $requiredfound = 't';
          for ($i3 = 1; $i3 <= $requiredkws [$i2][0]; $i3++) {
            if (!$matchkwstatus [$i2][$i3]) {
              $requiredfound = '';
              };#if
            };#for
          };#if
        };#for
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mrequiredx undecided ($$undecided) ret ($requiredfound)\n");
      };

    return ($requiredfound);
    }# mrequired
#
sub imrequested {# check if this statement contains its requested attributes
    my ($myli, $nextinstance, $reqtype, $undecided, $kwp, $kwpr, $requestedkws, $matchkwstatus)=@_;
    my ($requestedfound, $msal, $groupcomplete, $i, $twso, $nooflists);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnih} {$reqtype};
      print ("imrequested myli $myli, nextinstance $nextinstance reqtype $pr ($reqtype) kwp $kwp kwpr $kwpr ");
      };
    $requestedfound = 't';
    $$undecided = '';

    $twso = getterminalid ($myli, $nextinstance, \$$undecided, $kwp, $kwpr);
# Check the meta file specification of the operation keyword and make a list of requested items.
    $nooflists = listkwclass ($myli, $nextinstance, $reqtype, trwsoadr ($twso,1), $kwpr, \@$requestedkws);
    if ($nooflists > 0) {
      my ($i2);

      for ($i2 = 1; $i2 <= $nooflists; $i2++) {
        $$matchkwstatus [$i2][0]= 0;
        };#for
      };#if
# iterate over the operational sentence to match top level keywords with the requested list;
    for ($i = trwsoadr ( $nextinstance, 1);
    ((!$$undecided) && ($i < $twso)); $i = trwsoadr ($i, 1)) {

      &tdgroup1 ($myli, $i, $kwp, $kwpr, \$groupcomplete);# if this is a group we just jump over it
      if ($groupcomplete) {

        my ($end, $sponsor, $sgdi);
# now move i beyond the group end
        &fgrpd ($myli, $i, \$sgdi, $Awfif::memes->{snnh}{groupcategory});
        $sponsor = fgrpsponsor ($i, $Awfif::workspace-> {l} [$sgdi] [3], $Awfif::memes-> {snnh} {groupcategory});
        $end = fgrpend ($sponsor);# of the group
        $i = $end;
        }# if
      else {# check for any requested aspects of keywords
        my ( $gtype );
# should do each leaf under groupcategory

        $gtype = $Awfif::memes-> {snnh}{succgroup};
        if (($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl} [wsbasetype ( $i)] == 0) ) {
# know this can't contribute have requested items
          }
        else {
# get any requested items from the metafile
          my ($i2, $i3, $kwi);

          $kwi = getwsost4 ($i);
          for ($i2 = 1; $i2 <= $nooflists; $i2++) {
            for ($i3 = 1; $i3 <= $$requestedkws [$i2][0]; $i3++) {
              if ($$requestedkws [$i2][$i3] eq $kwi) {
                $$matchkwstatus [$i2][$i3] = 't';
                $$matchkwstatus [$i2][0]++;
                };#if
              };#for
            };#for
          };#else
        };# else of handle completed groups
      };# for

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("imrequestedx msal $msal undecided ($$undecided) ret ($nooflists)\n");
      };

    return ($nooflists);
    }# imrequested
#
sub mconditional {# check if this statement contains all associated conditional attributes
    my ($myli, $nextinstance, $swstype, $undecided, $kwp, $kwpr, $sactset)=@_;
    my ($conditionalfound, $nooflists, @requestedkws, @matchkwstatus);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnih} {$swstype};
      print ("mconditional myli $myli, nextinstance $nextinstance swstype $pr ($swstype) kwp $kwp kwpr $kwpr ");
      };
    $nooflists = imrequested ($myli, $nextinstance, $Awfif::memes-> {snnh}{conditional}, \$$undecided, $kwp, $kwpr, \@requestedkws, \@matchkwstatus, \@$sactset);

    if ($nooflists > 0) {# there are conditional keywords If, for any definition, all that are requested are found then return true
      my ($i2, $i3, $conditionalrequired, $conditionalmissing);

      $$undecided = '';
      $conditionalfound = '';
      for ($i2 = 1; $i2 <= $nooflists; $i2++) {
        if (($matchkwstatus [$i2][0] > 0) && (!$conditionalfound)) {
          $conditionalfound = 't';
          $conditionalrequired = '';
          $conditionalmissing = '';
          for ($i3 = 1; $i3 <= $requestedkws [$i2][0]; $i3++) {
            if ($matchkwstatus [$i2][$i3]) {
              $conditionalrequired = 't';
              };#if
            if (!$matchkwstatus [$i2][$i3]) {
              $conditionalmissing = 't';
              };#if
            };#for
          if (($conditionalrequired) && ($conditionalmissing)) {
            $conditionalfound = '';
            };#if
          };#if
        };#for
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("mconditionalx undecided ($$undecided) ret ($conditionalfound)\n");
      };

    return ($conditionalfound);
    }# mconditional
#
#
sub statementwhole {# assess this part for its wholeness
    my($myli, $sti, $kwp, $kwpr, $sactset)=@_;
    my ($whole, $giveup);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("statementwhole myli $myli ");
      };
# updated for merged workspaces
# statementwhole is called within statement codelet
# it uses statement/part model launcher to check if the whole statement associated with cascade statementlabel is modelled and described as model-(assert|implement)->whole or stopped,

    $whole = ilaunchmodel ($myli, $sti, 'statementlabel', $Awfif::memes-> {snnh} {whole}, \$giveup, $kwp, $kwpr, \@$sactset);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("statementwholex giveup $giveup ret ($whole)\n");
      };
    return $whole
    }# statementwhole
#
#
sub developmentwhole {# assess this part for its wholeness
    my($myli, $sti, $kwp, $kwpr, $sactset)=@_;
    my ($whole, $giveup);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("developmentwhole myli $myli ");
      };
# updated for merged workspaces
# developmentwhole is called within statement codelet
# it uses statement/part model launcher to check if the plan associated with cascade developmentlabel is modelled and described as model-(assert|implement)->devpwhole or stopped,

# updated for merged workspaces
# first check that development is whole at the part level
    if (!findbond ($Awfif::wsol-> {l} [ awsoadr ($sti)] [2], $sti, wsbasetype ($sti), $Awfif::memes-> {snnh} {partscategory})) {
      if (partwhole ($myli, $sti, $Awfif::memes-> {snnh} {devpwhole}, $kwp, $kwpr, \@$sactset)) {
        my ($asti);

        $asti = awsoadr ($sti);
        $Awfif::wsol-> {l} [$asti][2]
            = setupdesc ( (wsbasetype ($sti)),
              ($Awfif::memes-> {snnh} {wsi} + $sti),
              $Awfif::memes-> {snnh}{partscategory},
              $Awfif::wsol-> {l} [$asti][2],
              $asti);
        };#if
      }#if
    else {
# Once that assessment is complete and successful can look at the statement level wholeness
# changed from devwhole since partwhole checks for whole specifically

      $whole = ilaunchmodel ($myli, $sti, 'developmentlabel', $Awfif::memes-> {snnh} {devpwhole}, \$giveup, $kwp, $kwpr, \@$sactset);
      };#else part level is whole

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("developmentwholex giveup $giveup ret ($whole)\n");
      };
    return $whole #which indicates only that the dev schema is structurally whole. It will not have been schematically developed until deviwhole is true
    }# developmentwhole
#
#
sub statementlabel1 {# setup the labels for statement
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("statementlabel myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {model});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {statementcategory});
    $labcount = labload (\@$lab, $labcount, wsbasetype ($sti));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {statementcomplete});

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("statementlabelx ret ($labcount)\n");
      };
    return $labcount
    }# statementlabel
#
#<!-- start tag swp -->
#
sub partlabel1 {# setup the labels for part
    my($myli, $parti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("partlabel myli $myli parti $parti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {model});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {partscategory});
    $labcount = labload (\@$lab, $labcount, wsbasetype ($parti));
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {groupcomplete});

    if (defined ($$static)) {
      $$static = '';#can't depend on this being the same every return - don't cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("partlabelx ret ($labcount)\n");
      };
    return $labcount
    }# partlabel
#
#
sub developmentlabel1 {# setup the labels for development
    my($myli, $sti, $lab, $kwp, $kwpr, $sactset, $static)=@_;
    my ($labcount);

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("developmentlabel myli $myli sti $sti kwp $kwp kwpr $kwpr sactset $$sactset[0] ");
      };
# updated for merged workspaces

    $labcount = 0;

    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {model});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {schema});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {devcategory});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {development});
    $labcount = labload (\@$lab, $labcount, $Awfif::memes-> {snnh} {statementcomplete});

    if (defined ($$static)) {
      $$static = 't';#can depend on this being the same every return - can cache
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("developmentlabelx ret ($labcount)\n");
      };
    return $labcount
    }# developmentlabel
#
#
sub msalthrevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
#
# checked for merged workspaces

    no strict 'refs';
    &imsalthrevaluator1 ($myli, \$$kwp, $kwpr, \@$sactset, 'msalthrbuilder');

    }# msalthrevaluator1
#
sub imsalthrevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset, $strategy) = @_;
    my ($sponsor, $signal, $schema, $found, $file, $spi, $swstype, @typelist,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# checked for merged workspaces

# models must use the full workspace

    $found = '';

# now check the workspace for salient workspace type with model status descriptor
    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, undef(), \$cdn, \$cdnx, 4)) {
      my ($stfound);
      $stfound = ltypedwso ($myli, $swstype, \@typelist, trwsoadr ($Awfif::codelet-> {l} [$myli][21],-1), $grkwpr, \@$sactset);
      if ($stfound > 0) {#lets check the following schemata's salience

        &updatelog ($myli,'ae', 5, $file);
        $Awfif::clp = ();
        $Awfif::clp-> {log} = $Awfif::codelet-> {l} [$myli][13];
        $Awfif::clp-> {urgency} = ($Awfif::codelet-> {l} [$myli][3] * $Awfif::memes-> {blaunchm});
        if (defined ($Awfif::codelet-> {l}[$myli][19])) {
          $Awfif::clp-> {wsi} = $Awfif::codelet-> {l}[$myli][19];
          }#wsi set
        else {
          $Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
          };
        $Awfif::clp-> {strategy} = "$strategy";
        $Awfif::clp-> {action}-> {sponsor} = $sponsor;
        $Awfif::clp-> {action}-> {signal} = $Awfif::codelet-> {l} [$myli][16];
        $Awfif::clp-> {action}-> {schema} = $Awfif::codelet-> {l} [$myli][18];
        $Awfif::clp-> {action}-> {ref} = $spi;
        $Awfif::clp-> {action}-> {sws} = $Awfif::codelet-> {l} [$myli] [20];
        $Awfif::clp-> {action}-> {wss} = $Awfif::codelet-> {l} [$myli][21];
        $Awfif::clp-> {action}-> {wse} = $Awfif::codelet-> {l} [$myli][22];
        &groupsinv1 ($myli, undef(), undef(), undef(), undef(), undef(), "$strategy", $$kwp, $kwpr, \@$sactset);
        };
      };#got buffer

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    }# imsalthrevaluator1
#
sub msalthrbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $signal, $schema, $found, $file, $swstype, $nextinstance,
    $grkwp, $grkwpr, $cdn, $cdnx);
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("msalthrbuilder myli $myli kwp($kwp) kwpr($kwpr)");
      };
#
# checked for merged workspaces

# models must use the full workspace

    $found = '';

# now check the workspace for salient workspace type with model status descriptor
    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, undef(), \$cdn, \$cdnx, 3)) {
      my ($stfound, $twso);
      $stfound = selsaltypedwso ($myli, $swstype, \$nextinstance, \$twso, trwsoadr ($Awfif::codelet-> {l} [$myli][21],-1), $grkwpr, \@$sactset);
      if ($stfound > 0) {#lets check the following schemata's salience
        my ($thrmet);

        &updatelog ($myli,'ae', 5, $file);
        $thrmet = thrtypedwso ($myli, $nextinstance, $twso, trwsoadr ($Awfif::codelet-> {l} [$myli][21],-1), $grkwpr, \@$sactset);
# if threshold met then allow checking to proceed
        if (!$thrmet) {
          my ($afrom);
# otherwise switch to some other test add model descriptor saying no thresholding

          $afrom = awsoadr ($nextinstance);
          $Awfif::wsol-> {l} [$afrom][2]
            = setupdesc ( ($swstype),
            ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {dropthreshold}), #to match findbond
            $Awfif::memes-> {snnh} {model},
            $Awfif::wsol-> {l} [$afrom][2],
            $afrom);
# if only one for thresholding reduce its activity
          };
        };
      };#got target wso

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# msalthrbuilder1
#
#<!-- start tag dli -->
#<!-- start tag vbt -->
#
sub mgpartevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
#
# checked for merged workspaces

    no strict 'refs';
    &imsalthrevaluator1 ($myli, \$$kwp, $kwpr, \@$sactset, 'mgpartbuilder');

    &clogstatx ();
    }# mgpartevaluator1
#
sub mgpartbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $signal, $schema, $found, $file, $swstype, $nextinstance,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# checked for merged workspaces

# models must use the full workspace

    $found = '';

# now check the workspace for salient workspace type with model status descriptor
    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, undef(), \$cdn, \$cdnx, 3)) {
      my ($stfound, $twso);
      $stfound = selsaltypedwso ($myli, $swstype, \$nextinstance, \$twso, trwsoadr ($Awfif::codelet-> {l} [$myli][21],-1), $grkwpr, \@$sactset);
      if ($stfound > 0) {#lets check the following schemata's completeness
        my ($thrmet, $undecided, $wholetype);
        if (wsbasetype ($nextinstance) == $Awfif::memes-> {snnh}{development}) {
          $wholetype = $Awfif::memes-> {snnh} {devpwhole};
          }#if
        else {
          $wholetype = $Awfif::memes-> {snnh} {whole};
          };#else
        if (((findbond ($Awfif::wsol-> {l} [ awsoadr ($nextinstance)] [2], $wholetype, wsbasetype ($nextinstance), $Awfif::memes-> {snnh} {model})))) {
          $thrmet = 't';
          $undecided = '';
          } #if
        else {

          &updatelog ($myli,'ae', 5, $file);
          $thrmet = mgparts ($myli, $nextinstance, $twso, \$undecided, trwsoadr ($Awfif::codelet-> {l} [$myli][21],-1), $grkwpr, \@$sactset);
# if threshold met then allow checking to proceed
          if ((!(findbond ($Awfif::wsol-> {l} [ awsoadr ($nextinstance)] [2], $wholetype, wsbasetype ($nextinstance), $Awfif::memes-> {snnh} {model}))) && (!$undecided) && ($thrmet)) {
            my ($afrom);
# didn't find any unresolved objects or fail the thresholding so

            $afrom = awsoadr ($nextinstance);
            $Awfif::wsol-> {l} [$afrom][2]
              = setupdesc ( ($swstype),
              ($Awfif::memes-> {snnh} {wsi} + $wholetype), #to match findbond
              $Awfif::memes-> {snnh} {model},
              $Awfif::wsol-> {l} [$afrom][2],
              $afrom);
# if only one for thresholding reduce its activity
            }
          elsif ((!(findbond ($Awfif::wsol-> {l} [ awsoadr ($nextinstance)] [2], $Awfif::memes-> {snnh} {dropopcheck}, wsbasetype ($nextinstance), $Awfif::memes-> {snnh} {model}))) && (!$thrmet)) {
            my ($afrom);
# otherwise switch to some other test add model descriptor saying no thresholding

            $afrom = awsoadr ($nextinstance);
            $Awfif::wsol-> {l} [$afrom][2]
              = setupdesc ( ($swstype),
              ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {dropopcheck}), #to match findbond
              $Awfif::memes-> {snnh} {model},
              $Awfif::wsol-> {l} [$afrom][2],
              $afrom);
# if only one for thresholding reduce its activity
            };
          };
        };
      };#got target wso

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      if (defined ($kwp)) {
        print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
        };#if
      };
    &clogstatx ();
    }# mgpartbuilder1
#
#<!-- start tag vbt -->
#
sub mwstaevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
#
# checked for merged workspaces

    no strict 'refs';
    &imsalthrevaluator1 ($myli, \$$kwp, $kwpr, \@$sactset, 'mwstabuilder');

    &clogstatx ();
    }# mwstaevaluator1
#
sub mwstabuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $signal, $schema, $found, $file, $swstype, $nextinstance, @typelist,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# checked for merged workspaces

# models must use the full workspace

    $found = '';

# now check the workspace for salient workspace type with model status descriptor
    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, undef(), \$cdn, \$cdnx, 3)) {
      my ($stfound);
      $stfound = ltypedwso ($myli, $swstype, \@typelist, trwsoadr ($Awfif::codelet-> {l} [$myli][21],-1), $grkwpr, \@$sactset);
      if ($stfound > 0) {#lets check the following schemata's match to required items
        my ($reqpresent, $conpresent, $undecided);

        &updatelog ($myli,'ae', 5, $file);
        $nextinstance = $typelist[0];#test schema structure seems to imply the first item will be of interest
        $reqpresent = mrequired ($myli, $nextinstance, $swstype, \$undecided, trwsoadr ($Awfif::codelet-> {l} [$myli][21],-1), $grkwpr, \@$sactset);
# if required present then finished with required syntactic checks of this clause
        $conpresent = mconditional ($myli, $nextinstance, $swstype, \$undecided, trwsoadr ($Awfif::codelet-> {l} [$myli][21],-1), $grkwpr, \@$sactset);
# if conditional present then finished with conditional syntactic checks of this clause
        if ((!(findbond ($Awfif::wsol-> {l} [ awsoadr ($nextinstance)] [2], $Awfif::memes-> {snnh} {whole}, wsbasetype ($nextinstance), $Awfif::memes-> {snnh} {model}))) && (!$undecided) && ($reqpresent) && ($conpresent)) {
          my ($afrom);
# report that required items are present

          $afrom = awsoadr ($nextinstance);
          $Awfif::wsol-> {l} [$afrom][2]
            = setupdesc ( ($swstype),
            ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {whole}), #to match findbond
            $Awfif::memes-> {snnh} {model},
            $Awfif::wsol-> {l} [$afrom][2],
            $afrom);
          }
        elsif ((!(findbond ($Awfif::wsol-> {l} [ awsoadr ($nextinstance)] [2], $Awfif::memes-> {snnh} {dropopcheck}, wsbasetype ($nextinstance), $Awfif::memes-> {snnh} {model}))) && ((!$reqpresent) or (!$conpresent))) {
          my ($afrom);
# otherwise report issues that model has identified for a manager to decide what to do

          $afrom = awsoadr ($nextinstance);
          $Awfif::wsol-> {l} [$afrom][2]
            = setupdesc ( ($swstype),
            ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {reqmissing}), #to match findbond
            $Awfif::memes-> {snnh} {model},
            $Awfif::wsol-> {l} [$afrom][2],
            $afrom);
          };
        };
      };#got target wso

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# mwstabuilder1
#
#<!-- end tag vbt -->
#<!-- start tag vbt -->
#
sub mwstdevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
#
# checked for merged workspaces

    no strict 'refs';
    &imsalthrevaluator1 ($myli, \$$kwp, $kwpr, \@$sactset, 'mwstdbuilder');

    &clogstatx ();
    }# mwstdevaluator1
#
sub mwstdbuilder1 {#The ignored parameters are required by the codelet calling architecture
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $signal, $schema, $found, $file, $swstype, @typelist, $nextinstance,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# checked for merged workspaces

# models must use the full workspace

    $found = '';

# now check the workspace for salient workspace type with model status descriptor
    if (getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, undef(), \$cdn, \$cdnx, 3)) {
      my ($stfound);
      $stfound = ltypedwso ($myli, $swstype, \@typelist, trwsoadr ($Awfif::codelet-> {l} [$myli][21],-1), $grkwpr, \@$sactset);
      if ($stfound > 0) {#lets check the following schemata's match to required items

        &updatelog ($myli,'ae', 5, $file);
        $nextinstance = $typelist [0];
        my ($afrom);
# report that required items are present

        $afrom = awsoadr ($nextinstance);
        $Awfif::wsol-> {l} [$afrom][2]
          = setupdesc ( ($swstype),
# changed from devwhole since partwhole checks for whole specifically
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {whole}), #to match findbond
          $Awfif::memes-> {snnh} {model},
          $Awfif::wsol-> {l} [$afrom][2],
          $afrom);
        };
      };#got target wso

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      if ((defined ($kwp))
      && ($kwp == 1)
      ) {
        print ("kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) \n");
        };#if
      };
    &clogstatx ();
    }# mwstdbuilder1
#
#<!-- end tag vbt -->
#
sub statementscout1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($ni,
    $grkwp, $grkwpr, $cdn, $cdnx, $giveup, $tinstances, $found, $cwsbi);
#
# checked for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $cdn = clogstat (\$cdnx);
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdn myli $myli ");
      &itcpoutput ($myli);
      };
# statements must use the full workspace

    $grkwp = $Awfif::wsbl->{wsoh}[$Awfif::memes->{currentwsbi}];
    $grkwpr = $Awfif::wsbl->{wsft}[$Awfif::memes->{currentwsbi}];
# Ensure all parts exist if to go forward

    if ((allpartsconstrained ($myli, \$giveup, $grkwp, $grkwpr, \@$sactset))
    && (!$giveup)
    && ($found = selsalwsitem ($myli, \$ni, \$tinstances, $grkwp, $grkwpr, \@$sactset, 'bustatement'))
    && ($ni > 0) ) {
      $Awfif::codelet-> {l}[$myli][4] = $ni;# updatelog needs this setup
# if the statement is not complete call in an evaluator
      if (!findbond ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $ni, $Awfif::memes->{snnh}{complete}, $Awfif::memes-> {snnh} {statementcategory})) {

        &updatelog ($myli,'ps',4, $ni);
# & call in a statement evaluator
        $Awfif::clp = ();
        $Awfif::clp-> {log} = $Awfif::codelet-> {l} [$myli][13];
        $Awfif::clp-> {urgency} = $Awfif::memes-> {parteu};
        if (defined ($Awfif::codelet-> {l}[$myli][19])) {
          $Awfif::clp-> {wsi} = $Awfif::codelet-> {l}[$myli][19];
          }#wsi set
        else {
          $Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
          };
        $Awfif::clp-> {strategy} = "statementevaluator";
        $Awfif::clp-> {bond}-> {ni} = $ni;
        &cdsubmitcodelet ($myli, \$Awfif::clp);
        };#got part
      }# got a statement to work on
    elsif ($giveup) {# terminate statement processing

      print ("badly formed statement - moving to next file\n");
      &actnodes ($Awfif::memes-> {snnh} {terminate}, $Awfif::memes-> {actmax});
      &invcaches ($Awfif::memes-> {snnh} {terminate});
      };
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# statementscout1
#
sub statementevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($ni,
    $grkwp, $grkwpr, $cdn, $cdnx, $cwsbi);
#
# checked for merged workspaces

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $cdn = clogstat (\$cdnx);
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdn myli $myli ");
      &itcpoutput ($myli);
      };
# statement must use the full workspace

    $grkwp = $Awfif::wsbl->{wsoh}[$Awfif::memes->{currentwsbi}];
    $grkwpr = $Awfif::wsbl->{wsft}[$Awfif::memes->{currentwsbi}];
# get a salient statement from the workspace

    if ($Awfif::codelet->{l}[$myli][4] > 0) {
      $ni = $Awfif::codelet->{l}[$myli][4];
      if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
        &itwsoutput ( trwsoadr ($ni,1), $ni);
        };
# if not completed statement processing
      if (!findbond ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $ni, $Awfif::memes->{snnh}{complete}, $Awfif::memes-> {snnh} {statementcategory})) {

        if (
        ((!(findbond ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $Awfif::memes-> {snnh} {stop}, wsbasetype ($ni), $Awfif::memes-> {snnh} {model}))) )
        && (findbond ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $Awfif::memes-> {snnh} {dropthreshold}, wsbasetype ($ni), $Awfif::memes-> {snnh} {model}))
        && (findbond ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $Awfif::memes-> {snnh} {reqmissing}, wsbasetype ($ni), $Awfif::memes-> {snnh} {model}))
        ){
# atppenalty3

          $Awfif::memes-> {fatp} = $Awfif::memes-> {fatp} - $Awfif::memes-> {failatpr};
          };#if
# if the statement part is structurally sound & development is whole call in a builder
        if (statementwhole ($myli, $ni, $grkwp, $grkwpr, \@$sactset)
        && (developmentwhole ($myli, finddevni($myli, $grkwp, $grkwpr), $grkwp, $grkwpr, \@$sactset))) {

          $Awfif::clp = ();
          $Awfif::clp-> {log} = $Awfif::codelet-> {l} [$myli][13];
          $Awfif::clp-> {urgency} = ($Awfif::codelet-> {l} [$myli][3] * $Awfif::memes-> {blaunchm});
          if (defined ($Awfif::codelet-> {l}[$myli][19])) {
            $Awfif::clp-> {wsi} = $Awfif::codelet-> {l}[$myli][19];
            }#wsi set
          else {
            $Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
            };
          $Awfif::clp-> {strategy} = "statementbuilder";
          $Awfif::clp-> {bond}-> {ni} = $ni;
          &cdsubmitcodelet ($myli, \$Awfif::clp);
          }#got whole statement
        else {

          $Awfif::memes-> {fatp} = $Awfif::memes-> {fatp} - $Awfif::memes-> {failatpr};
          if ($Awfif::memes-> {fatp} <= 0) {

            &break ();
            };#if
          };#else
        };#statement is not whole yet
      }# statement present to work on
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# statementevaluator1
#
#<!-- start tag inh -->
#<!-- start tag sca -->
#
sub statementbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#codelet launch architecture requires the ignored parameters for its general interface
    my ($ni, $ani, $statementcomplete, $compcount, @completed, $delayplan,
    , $sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdat, $stbst, $stbet,
    $grkwp, $grkwpr, $cdn, $cdnx, $cwsbi);
#
# operationalize the statement

    $cwsbi = $Awfif::memes-> {currentwsbi};
    $cdn = clogstat (\$cdnx);
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdn myli $myli ");
      &itcpoutput ($myli);
      };
    if ($Awfif::memes-> {trace} == $Awfif::memes-> {tracehrtime}) {
      use Time::HiRes 'time';
      ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdat) = localtime(time);
      };
# statements must use the full workspace

    $grkwp = $Awfif::wsbl->{wsoh}[$Awfif::memes->{currentwsbi}];
    $grkwpr = $Awfif::wsbl->{wsft}[$Awfif::memes->{currentwsbi}];
# choose a salient part from the workspace

    if ($Awfif::codelet->{l}[$myli][4] > 0) {
      $ni = $Awfif::codelet->{l}[$myli][4];
      if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
        &itwsoutput ( trwsoadr ($ni,1), $ni);
        };
# if not completed statement processing
      if (!findbond ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $ni, wsbasetype ($ni), $Awfif::memes-> {snnh} {statementcategory})
      ){
# if group contained operons are statement inhibited release them
# relstinhibitors

        if ((!findbond ($Awfif::wsol-> {l} [ awsoadr ($ni)][2], $Awfif::memes-> {snnh} {valid}, $Awfif::memes-> {snnh} {statementcategory}, $Awfif::memes-> {snnh} {model})) ){

          $Awfif::wsol-> {l} [awsoadr ($ni)][2]
          = setupdesc ( $Awfif::memes-> {snnh} {statementcategory},
              ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {valid}),
              $Awfif::memes-> {snnh} {model},
              $Awfif::wsol-> {l} [awsoadr ($ni)][2],
              awsoadr ($ni),
              't');
          };#release statement competitive inhibition
# sbinsgcu1
# inspect group contained operons to see if they have completed
        $stbst = time ();


        @completed = bindoptoinsp1 ($myli, $Awfif::memes->{currentwsbi}, $ni, isterminated ($ni, $grkwp, $grkwpr), \$compcount, \@$sactset);

        $stbet = time ();
        $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {stbbsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {stbbsum}] + $stbet - $stbst;
# sbextrau1
# external resources must be associated with the actual workspace stream they are deployed in and the agents that are interested in the resources
        $stbst = time ();

        &conagtoxr ($myli, $ni, $grkwp, $grkwpr, \@$sactset);
# if not bored with waiting for completion
        $delayplan = '';
        if ($compcount > 0) {
          my ($i);
          for ($i = 0; (($i < $compcount) && (!$delayplan));$i++) {
            if (!$completed [$i] ) {

              $delayplan = 't';
              };#if
            };#for
          };#if

        $stbet = time ();
        $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {stbcsum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {stbcsum}] + $stbet - $stbst;

        if (
        ((!(findbond ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $Awfif::memes-> {snnh} {stop}, wsbasetype ($ni), $Awfif::memes-> {snnh} {model}))) )
        && (findbond ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $Awfif::memes-> {snnh} {dropthreshold}, wsbasetype ($ni), $Awfif::memes-> {snnh} {model}))
        && (findbond ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $Awfif::memes-> {snnh} {dropopcheck}, wsbasetype ($ni), $Awfif::memes-> {snnh} {model}))
        ){
# atppenalty4

          $Awfif::memes-> {fatp} = $Awfif::memes-> {fatp} - $Awfif::memes-> {failatpr};
          };#if
        $stbst = time ();

# sbpdcau1
# manage PDCA of statement processing
        if ((!$delayplan)
        && (statementpdca ($myli, $ni, $grkwp, $grkwpr, \@$sactset)) ){

          $statementcomplete = 't';
          $ani = awsoadr ($ni);
          $Awfif::wsol-> {l} [$ani][2]
            = setupdesc ( (wsbasetype ($ni)),
            ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {valid}), #to match findbond
            $Awfif::memes-> {snnh} {model},
            $Awfif::wsol-> {l} [$ani][2],
            $ani);
          &invcaches (wsbasetype ($ni));
# sbwscup
          };#if manage PDCA

        $stbet = time ();
        $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {stbpdcasum}] = $Awfif::memes-> {time} [$Awfif::memes-> {spctime}] [$Awfif::memes-> {ch}{$Awfif::codelet-> {l} [$myli] [2]}] [$Awfif::memes-> {stbpdcasum}] + $stbet - $stbst;

        if ($statementcomplete) {#deploy the statement descriptor

          $Awfif::wsol-> {l} [$ani][2]
              = setupdesc ( (wsbasetype ($ni)),
                ($Awfif::memes-> {snnh} {wsi} + $ni),
                $Awfif::memes-> {snnh}{partscategory},
                $Awfif::wsol-> {l} [$ani][2],
                $ani);
          $Awfif::memes-> {fatp} = $Awfif::memes-> {fatp} + $Awfif::memes-> {batp};
# send activation to the involved Slipnet nodes
          &actnodes ( $Awfif::memes-> {snnh}{partscategory}, $Awfif::memes-> {openatype});
          &actnodes ( $Awfif::memes-> {snnh} {wsi}, $Awfif::memes-> {openato});
          &invcaches (wsbasetype ($ni));
          };#statement complete
        };#part is not whole yet
      }# got a pair to work on
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# statementbuilder1
#
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