Part integrity
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 for ensuring integrity within a part

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 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
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 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 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
(codelets 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. 

Each test statement is composed of parts.  A part codelet (evaluator, builder) manages the assessment of each parts
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. 
wholeness
,
This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is valid. 
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. 
validity
,
This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is constrained. 
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. 
constraints
and integrity.
A
This page discusses the program strategy in a complex adaptive system (CAS).  Programs generate coherent end-to-end activity.  The mechanism is reviewed. 
program
models the integrity of the parts
Any part may contain groups that relate to each other.  The presence 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
which extend across multiple groups within a part requires that the groups must be integral.  Cross group model codelets specific to a particular schemata can describe conformance of the interdependent groups to the integration requirements.  A synchronization codelet then represents the descriptions at the part level to its manager.  The assessment of cross 'group' integrity is a general problem.  Smiley includes infrastructure to support specific assessments.  The pmman codelet utilizes general
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. 
signals
and infrastructure including: inspection and schematically associated integration assessment. 
The parts integrity program and model codelets
The pmman builder identifies the presence of cross group schematic associations, from the presence of equivalent conceptual structures 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
.  It then creates a full association between the structure in the
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
and the Slipnet equivalent and signals the Slipnet associated integration codelet.  Whereas other part model schematic signals are statically bound to codelet forces in the Slipnet, this signal is defined and bound dynamically. 

Partintegrated, acting as the integrity manager, coordinates the integrity assessment for the part builder.  It requests the pmman codelet to initiate a
This page discusses the program strategy in a complex adaptive system (CAS).  Programs generate coherent end-to-end activity.  The mechanism is reviewed. 
program
to assess the integrity of the part.  The pmman builder checks for cross group schemata within the part.  When these are found any
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
codelets are sps
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
.  The pmman codelet (top-down scout, evaluator, builder) leverages the cross group parts integrator model (mviint) codelet (evaluator, builder), which must have been associated in the Slipnet with the application specific cross group schematic structure. 

The
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. 
associations
of specific schematic strings potentially present in 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. 
test statement
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
include:
The part integrity model codelets
The
This page looks at how Smiley processes the statement, such as a test request, to ensure that each part of the statement is valid. 
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 validity
codelet builder msormbuilder specifies an abstract model of both a single and multiple group part which is mapped to the application's specific language by the Meta file specification 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.   and implemented in Perl is Larry Wall's programming language.  It is designed to make easy tasks easy and hard tasks possible.  It has powerful text processing features and can interpret a string of text as code.   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
.  It describes in the part WSO its recommendation -> single or multiple part model or non-conforming part (stop model).

The codelet builder miforallbuilder associates an abstract model of good scope with a part containing an associated schematic string such as <for> <each>.  The model is mapped to the application's specific language by the Meta file specification and 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
.  It describes in the part WSO its recommendation -> start iforall inspector, goodscope iterator model, all iterator model. miforallbuilder also initiates mittarbuilder, which is not associated with a signal. 

The codelet builder mittarbuilder specifies an abstract model of a multi-component resource which is mapped to the application's specific language by the Meta file specification and 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
.  It is a partner of the miforall codelet and describes in the part WSO its recommendation -> goodtarget iterator model and whole target inspector.

The codelet builder miterbuilder is associated with the schematic string <for> <each> <typedinstance> 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
.  It acts as an inspector of the groups target and scope models. If these models have run then it describes the completion writing whole part model. 

The codelet builder mviintbuilder specifies an abstract model of a synchronized part which is mapped to the application's specific language by the Meta file specification and 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
.  For example it is associated in the Slipnet with the multi-group schematic string <mreplaces> <subject> <resolved> <for> <each>.  It describes in the part WSO the descriptions that it found within the groups that are integrated.  It describes in the part WSO its recommendation -> whole integrate model or non-conforming part (stop model). The model requires that groups be described as single or, if they contain cross group schemata, multiple. 

The codelet builder pmmanbuilder specifies an abstract model of a verb part which is mapped to the application's specific language by the Meta file specification and 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

Part integrated
A part reports it is well integrated if it is a single group part, when a pmmanevaluator will describe the model of its situation as whole, or if a pmmaninspector finds that the mviint model codelet has run and described its model of the situation as whole. 

#
    my ($pconc, $jhlsid);
# miforallbindtosig
# setup the binding string for the single path signal to initiate a matchkword
    $Awfif::memes-> {maxoper}++; $jhlsid = 0;
    $pconc = Awfif::pconc ($Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {all}] [0], $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnc} [$Awfif::memes-> {snnh} {all}] [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), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);

    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {each});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {miforallevaluator}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# miforallibindtosig
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {inspector}, $Awfif::memes-> {snnh} {miforallinspector}, $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
# miterbindtomsigp
# & 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, 22, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);

    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {for}, $Awfif::memes-> {snnh} {each}, $Awfif::memes-> {snnh} {typedinstance});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {miterevaluator}, $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}]);
# mviintbindtomsigv
# & 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, 23, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc], $pconc), $pconc,
                  $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$pconc]);
    &Awfif::addjhlattribs ($pconc, $Awfif::memes-> {snnh} {mreplaces}, $Awfif::memes-> {snnh} {subject}, $Awfif::memes-> {snnh} {resolved}, $Awfif::memes-> {snnh} {sregex}, '(', '(', '?', '=', '[', '\D', ']', '[', '1', ']', '[', '2', ']', '[', '8', ']', '[', '\D', ']', '[', '1', ']', '[', '2', ']', '[', '8', ']', ')', '[', '\D', ']', '[', '1', ']', '[', '2', ']', '[', '8', ']', ')', '(', '[', '\D', '\d', '+', ']', '*', ')', ' ', '(', $Awfif::memes-> {snnh} {ichar}, ' ', $Awfif::memes-> {snnh} {for}, ' ', $Awfif::memes-> {snnh} {each}, ')', $Awfif::memes-> {snnh} {cregex});
    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}
      [$pconc] = Awfif::newnlink ($Awfif::memes-> {snnh} {evaluator}, $Awfif::memes-> {snnh} {mviintevaluator}, $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 partintegrated {#
    my($myli, $parti, $kwp, $kwpr, $sactset)=@_;
    my ($validated );

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {currentwsbi};
      print ("partintegrated myli $myli ws $pr kwp($kwp) kwpr($kwpr) sactset($$sactset[0]) ");
      $pr = $Awfif::memes-> {snnih} {wsbasetype ($parti)};
      print (" i $pr($parti) ");
      $pr = $Awfif::pcache-> {p} [$Awfif::memes-> {currentwsbi}];
      print ("p $pr ");
      };
# inspect the program manager
    $Awfif::codelet-> {l} [$myli] [26] = $Awfif::memes-> {snnh} {integrate};
    if ((!($validated = $Awfif::memes->{binds}-> {pmmaninspector}-> ($myli, $Awfif::memes-> {currentwsbi}, $parti, isterminated ($parti, $kwp, $kwpr)))
# when add the findbond it can lock out tpmmanscout leading to dead lock
    )) {

      &itcsuse ();
      $Awfif::clp = ();

      if ((defined($myli)) && ((!defined($Awfif::codelet-> {l} [$myli] [13])) or ($Awfif::codelet-> {l} [$myli] [13] == 0)) && (( $Awfif::wsol-> {l} [awsoadr ($parti)] [8] != 0)
      or ($Awfif::wsol-> {l}[awsoadr ($parti)][ $Awfif::memes-> {wsologucount}] != 0))) {&break()};#*** submacrok ***#
      $Awfif::clp-> {log} = $Awfif::codelet-> {l} [$myli][13];
      $Awfif::clp-> {urgency} = ($Awfif::codelet-> {l} [$myli][3] * $Awfif::memes-> {evlaunchm});
      if ($Awfif::codelet-> {l}[$myli][19] ne '') {

        $Awfif::clp-> {wsi} = $Awfif::codelet-> {l}[$myli][19];
        }#wsi set
      else {

        $Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
        };
      $Awfif::clp-> {strategy} = "tpmmanscout";
      $Awfif::clp-> {action}-> {sponsor} = $Awfif::codelet-> {l} [$myli] [17];
      $Awfif::clp-> {action}-> {signal} = $Awfif::codelet-> {l} [$myli] [16];
      $Awfif::clp-> {action}-> {schema} = $Awfif::codelet-> {l} [$myli] [18];
      $Awfif::clp-> {action}-> {sws} = $Awfif::memes->{currentwsbi};
      $Awfif::clp-> {action}-> {wss} = $parti;
      $Awfif::clp-> {action}-> {wse} = isterminated ($parti, $kwp, $kwpr);
      $Awfif::clp-> {action}-> {jhlabeli} = $Awfif::codelet-> {l} [$myli] [23];
      $Awfif::clp-> {action}-> {pmman} = $Awfif::memes-> {snnh} {integrate};
      &cdsubmitcodelet ($myli, \$Awfif::clp);
      $Awfif::wsol-> {l} [awsoadr ($parti)][2]
        = setupdesc ( wsbasetype ($parti),
        ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {integrate}),
        $Awfif::memes-> {snnh} {model},
        $Awfif::wsol-> {l} [awsoadr ($parti)][2],
        awsoadr ($parti));
      }; #if its not an operon

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("partintegratedx ret ($validated)\n");
      };
    return $validated
    }# partintegrated
#
#
sub iinspector1 {
    my ($myli, $sws, $wss, $wse, $goal, $program) = @_;
    my ($cwsbi, $result, $inspector,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# checked for merged workspaces

    $cdn = clogstat (\$cdnx);
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      my ($pr);
      $pr = $Awfif::memes-> {snnih}{$goal};
      print ("$cdn myli $myli sws $sws wss $wss wse $wse goal $pr($goal) program ($program) ");
      &itcpoutput ($myli);
      };
# check if the requested descriptors have been deployed

    $grkwp = $Awfif::wsbl-> {wsbloh}[$Awfif::memes-> {currentwsbi}];
    $grkwpr = $Awfif::wsbl-> {wsot}[$Awfif::memes-> {currentwsbi}];

# check if builder has ever accessed the operon
# use the specified ws
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $sws;
    $result = '';
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      &itwsoutput (trwsoadr ($wss,1), $wss);
      };
    if (defined ($program)) {
      $inspector = $program;
      } # indirect inspection
    else {
      $inspector = $Awfif::memes-> {snnh} {inspector};
      };
    if ((findbond ($Awfif::wsol-> {l} [ awsoadr ($wss)][2], $Awfif::memes-> {snnh} {start}, $goal, $inspector))
    && (findbond ($Awfif::wsol-> {l} [ awsoadr ($wss)][2], $Awfif::memes-> {snnh} {whole}, $goal, $inspector))
      ){
      $result = 't';
      };#record have accessed this operon
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx ret ($result)\n");
      };
    &clogstatx ();
    return $result
    }# iinspector1
#
#
sub miterevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $signal, $schema, $found, $spi,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# checked for merged workspaces

    $cdn = clogstat (\$cdnx);
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdn ");
      };

    $grkwp = $Awfif::wsbl-> {wsbloh}[$Awfif::memes-> {currentwsbi}];
    $grkwpr = $Awfif::wsbl-> {wsot}[$Awfif::memes-> {currentwsbi}];
    $found = '';
    $sponsor = $Awfif::codelet-> {l} [$myli][17];
    $signal = $Awfif::codelet-> {l} [$myli][16];
    $schema = $Awfif::codelet-> {l} [$myli][18];
# rework will be processed in real evaluator

    if (($Awfif::codelet-> {l}[$myli][16] > 0)
    && ($Awfif::codelet-> {l}[$myli][17] > 0)
    && ($Awfif::codelet-> {l}[$myli][18] > 0)
    && ($Awfif::codelet-> {l}[$myli] [20] > 0)
    && ($Awfif::codelet-> {l}[$myli][21] > 0)
    && ($Awfif::codelet-> {l}[$myli][22] > 0)
    ){#lets process the temporary buffer

      $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} = "miterbuilder";
      $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}-> {sws} = $Awfif::codelet-> {l} [$myli] [20];
      $Awfif::clp-> {action}-> {wss} = $Awfif::codelet-> {l} [$myli][21];
      $Awfif::clp-> {action}-> {wse} = $Awfif::codelet-> {l} [$myli][22];
      $Awfif::clp-> {action}-> {ref} = $spi;
      &groupsinv1 ($myli, undef(), undef(), undef(), undef(),undef(), "miterbuilder", $grkwp, $grkwpr, \@$sactset);
      };#if

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# miterevaluator1
#
sub miterbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $signal, $schema, $found, $spi, $swstype,
    $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 ($twso, $compcount, @completed, $delayplan, $ws, $startwso );
      $ws = $Awfif::codelet-> {l} [$myli] [20];
      $startwso = $Awfif::codelet-> {l} [$myli][21];
      $twso = trwsoadr ($Awfif::codelet-> {l} [$myli][22],1);
# inspect if the part's inspection associated operons have run
      @completed = bindoptoinsp1 ($myli, $Awfif::memes->{currentwsbi}, $startwso, $twso, \$compcount, \@$sactset);
# if all completed then proceed
      $delayplan = '';
      if ($compcount > 0) {
        my ($i);
        for ($i = 0; (($i < $compcount) && (!$delayplan));$i++) {
          if (!$completed [$i] ) {
            $delayplan = 't';
            };#if
          };#for
        };#if
      if ((!$delayplan)
      && (!($delayplan = !findbond ($Awfif::wsol-> {l} [ awsoadr ($startwso)][2], $Awfif::memes-> {snnh} {goodtarget}, $Awfif::memes-> {snnh} {iterator}, $Awfif::memes-> {snnh} {model})))
      && (!findbond ($Awfif::wsol-> {l} [ awsoadr ($startwso)][2], $Awfif::memes-> {snnh} {start}, $Awfif::memes-> {snnh} {iterator}, $Awfif::memes-> {snnh} {model})) ){
        my ($descfits);
        $Awfif::wsol-> {l} [awsoadr ($startwso)][2]
        = setupdesc ( $Awfif::memes-> {snnh} {iterator},
            ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {start}),
            $Awfif::memes-> {snnh} {model},
            $Awfif::wsol-> {l} [awsoadr ($startwso)][2],
            awsoadr ($startwso));
# assess the situation
        if ((findbond ($Awfif::wsol-> {l} [ awsoadr ($startwso)][2], $Awfif::memes-> {snnh} {goodtarget}, $Awfif::memes-> {snnh} {iterator}, $Awfif::memes-> {snnh} {model}))
        && (findbond ($Awfif::wsol-> {l} [ awsoadr ($startwso)][2], $Awfif::memes-> {snnh} {goodscope}, $Awfif::memes-> {snnh} {iterator}, $Awfif::memes-> {snnh} {model}))
        ){
          $descfits = 't';
          };
# now describe conclusions
        if (($descfits)) {
          $Awfif::memes-> {currentwsbi} = $ws;
          $Awfif::wsol-> {l} [awsoadr ($sponsor)][2]
          = setupdesc ( $Awfif::memes-> {snnh} {iterator},
              ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {whole}),
              $Awfif::memes-> {snnh} {model},
              $Awfif::wsol-> {l} [awsoadr ($sponsor)][2],
              awsoadr ($sponsor));
          $Awfif::memes-> {fatp} = $Awfif::memes-> {fatp} + $Awfif::memes-> {batp};
# send activation to the involved Slipnet nodes
          &actnodes ( $Awfif::memes-> {snnh} {iterator}, $Awfif::memes-> {openatype});
          &actnodes ( $Awfif::memes-> {snnh} {wsi}, $Awfif::memes-> {openato});
          }#if
        else {#describe problem
          $Awfif::memes-> {currentwsbi} = $ws;
          $Awfif::wsol-> {l} [awsoadr ($startwso)][2]
          = setupdesc ( $Awfif::memes-> {snnh} {iterator},
              ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {stop}),
              $Awfif::memes-> {snnh} {model},
              $Awfif::wsol-> {l} [awsoadr ($startwso)][2],
              awsoadr ($startwso));
          };#else
        };#if
      if ($delayplan) {
        $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} = "miterevaluator";
        $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}-> {sws} = $Awfif::codelet-> {l} [$myli] [20];
        $Awfif::clp-> {action}-> {wss} = $Awfif::codelet-> {l} [$myli][21];
        $Awfif::clp-> {action}-> {wse} = $Awfif::codelet-> {l} [$myli][22];
        $Awfif::clp-> {action}-> {ref} = $spi;
        &groupsinv1 ($myli, undef(), undef(), undef(), undef(),undef(), "miterevaluator", $grkwp, $grkwpr, \@$sactset);
# activate the pseudo concept to keep this evaluator around
        &actnodes ( $Awfif::jhls-> {l} [$Awfif::codelet-> {l}[$myli][23]][6], $Awfif::memes-> {openatype});
        &invcaches ($Awfif::jhls-> {l} [$Awfif::codelet-> {l}[$myli][23]][6]);
        };#reschedule evaluator
      };#got target wso

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

    $cdn = clogstat (\$cdnx);
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdn ");
      &itcpoutput ($myli);
      };

    $grkwp = $Awfif::wsbl-> {wsbloh}[$Awfif::memes-> {currentwsbi}];
    $grkwpr = $Awfif::wsbl-> {wsot}[$Awfif::memes-> {currentwsbi}];
    $found = '';
    $sponsor = $Awfif::codelet-> {l} [$myli][21];
    $signal = $Awfif::codelet-> {l} [$myli][16];
    $schema = $Awfif::codelet-> {l} [$myli][18];
# rework will be processed in real evaluator

    if (($Awfif::codelet-> {l}[$myli][16] > 0)
    && ($Awfif::codelet-> {l}[$myli][18] > 0)
    && ($Awfif::codelet-> {l}[$myli] [20] > 0)
    && ($Awfif::codelet-> {l}[$myli][21] > 0)
    && ($Awfif::codelet-> {l}[$myli][22] > 0)
    ){#lets process the temporary buffer

      my ($gsponsor, $sgdi, $afrom);
      $afrom = awsoadr ($sponsor);
      &fgrpd ($myli, $Awfif::codelet-> {l}[$myli][22], \$sgdi, $Awfif::memes->{snnh}{groupcategory});
      $gsponsor = fgrpsponsor ($Awfif::codelet-> {l}[$myli][22], $Awfif::workspace-> {l} [$sgdi] [3], $Awfif::memes-> {snnh} {groupcategory});
      if ((findbond ($Awfif::wsol-> {l} [ awsoadr ($gsponsor)][2], $Awfif::memes-> {snnh} {goodtarget}, $Awfif::memes-> {snnh} {iterator}, $Awfif::memes-> {snnh} {model}))
      && (findbond ($Awfif::wsol-> {l} [ awsoadr ($gsponsor)][2], $Awfif::memes-> {snnh} {goodscope}, $Awfif::memes-> {snnh} {iterator}, $Awfif::memes-> {snnh} {model}))
      ){
        $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} = "mviintbuilder";
        $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}-> {sws} = $Awfif::codelet-> {l} [$myli] [20];
        $Awfif::clp-> {action}-> {wss} = $Awfif::codelet-> {l} [$myli][21];
        $Awfif::clp-> {action}-> {wse} = $Awfif::codelet-> {l} [$myli][22];
        $Awfif::clp-> {action}-> {ref} = $spi;
        &groupsinv1 ($myli, undef(), undef(), undef(), undef(), undef(), "mviintbuilder", $grkwp, $grkwpr, \@$sactset);
        }# if find good iterator
      else {
        $Awfif::wsol-> {l} [$afrom][2]
          = setupdesc ( ($Awfif::memes-> {snnh} {integrate}),
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {dropmverb}), #to match findbond
          $Awfif::memes-> {snnh} {model},
          $Awfif::wsol-> {l} [$afrom][2],
          $afrom);
        };#else bad multi-verb part
      };

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# mviintevaluator1
#
sub mviintbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $signal, $schema, $found, $swstype,
    $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 ($gsponsor, $sgdi, $afrom,$part);
      $afrom = awsoadr ($sponsor);
      &fgrpd ($myli, $Awfif::codelet-> {l}[$myli][22], \$sgdi, $Awfif::memes->{snnh}{groupcategory});
      $gsponsor = fgrpsponsor ($Awfif::codelet-> {l}[$myli][22], $Awfif::workspace-> {l} [$sgdi] [3], $Awfif::memes-> {snnh} {groupcategory});
      if ((!findbond ($Awfif::wsol-> {l} [ $afrom][2], $Awfif::memes-> {snnh} {whole}, $Awfif::memes-> {snnh} {integrate}, $Awfif::memes-> {snnh} {model}))
      && (!findbond ($Awfif::wsol-> {l} [ $afrom][2], $Awfif::memes-> {snnh} {dropmverb}, $Awfif::memes-> {snnh} {integrate}, $Awfif::memes-> {snnh} {model}))
      && (findbond ($Awfif::wsol-> {l} [ awsoadr ($gsponsor)][2], $Awfif::memes-> {snnh} {goodtarget}, $Awfif::memes-> {snnh} {iterator}, $Awfif::memes-> {snnh} {model}))
      && (findbond ($Awfif::wsol-> {l} [ awsoadr ($gsponsor)][2], $Awfif::memes-> {snnh} {goodscope}, $Awfif::memes-> {snnh} {iterator}, $Awfif::memes-> {snnh} {model}))
      ){
        $Awfif::wsol-> {l} [$afrom][2]
          = setupdesc ( ($Awfif::memes-> {snnh} {iterator}),
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {goodtarget}), #to match findbond
          $Awfif::memes-> {snnh} {model},
          $Awfif::wsol-> {l} [$afrom][2],
          $afrom);
        $Awfif::wsol-> {l} [$afrom][2]
          = setupdesc ( ($Awfif::memes-> {snnh} {iterator}),
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {goodscope}), #to match findbond
          $Awfif::memes-> {snnh} {model},
          $Awfif::wsol-> {l} [$afrom][2],
          $afrom);
        $Awfif::wsol-> {l} [$afrom][2]
          = setupdesc ( ($Awfif::memes-> {snnh} {integrate}),
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {whole}), #to match findbond
          $Awfif::memes-> {snnh} {model},
          $Awfif::wsol-> {l} [$afrom][2],
          $afrom);
        $part = findpowner ($sponsor);
        $Awfif::wsol-> {l} [awsoadr ($part)][2]
          = setupdesc ( ($Awfif::memes-> {snnh} {integrate}),
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {start}), #to match findbond
          $Awfif::memes-> {snnh} {pmmanager},
          $Awfif::wsol-> {l} [awsoadr ($part)][2],
          awsoadr ($part));
        $Awfif::wsol-> {l} [awsoadr ($part)][2]
          = setupdesc ( ($Awfif::memes-> {snnh} {integrate}),
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {whole}), #to match findbond
          $Awfif::memes-> {snnh} {pmmanager},
          $Awfif::wsol-> {l} [awsoadr ($part)][2],
          awsoadr ($part));
        };#if
      };#got target wso

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# mviintbuilder1
#
sub miforallevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $signal, $schema, $found, $spi,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# should be deployed against a ws schema in a group that indicates iterate for all

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

    $grkwp = $Awfif::wsbl-> {wsbloh}[$Awfif::memes-> {currentwsbi}];
    $grkwpr = $Awfif::wsbl-> {wsot}[$Awfif::memes-> {currentwsbi}];
    $found = '';
    $sponsor = $Awfif::codelet-> {l} [$myli][17];
    $signal = $Awfif::codelet-> {l} [$myli][16];
    $schema = $Awfif::codelet-> {l} [$myli][18];
# rework will be processed in real evaluator

    if (($Awfif::codelet-> {l}[$myli][16] > 0)
    && ($Awfif::codelet-> {l}[$myli][17] > 0)
    && ($Awfif::codelet-> {l}[$myli][18] > 0)
    && ($Awfif::codelet-> {l}[$myli] [20] > 0)
    && ($Awfif::codelet-> {l}[$myli][21] > 0)
    && ($Awfif::codelet-> {l}[$myli][22] > 0)
    ){#lets process the temporary buffer

      $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} = "miforallbuilder";
      $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}-> {sws} = $Awfif::codelet-> {l} [$myli] [20];
      $Awfif::clp-> {action}-> {wss} = $Awfif::codelet-> {l} [$myli][21];
      $Awfif::clp-> {action}-> {wse} = $Awfif::codelet-> {l} [$myli][22];
      $Awfif::clp-> {action}-> {ref} = $spi;
      &groupsinv1 ($myli, undef(), undef(), undef(), undef(),undef(), "miforallbuilder", $grkwp, $grkwpr, \@$sactset);
      };

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# miforallevaluator1

#
sub miforallbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $asponsor, $signal, $schema, $found, $spi,
    $cwsbi, $ws, $startwso, $endwso,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# checked for merged workspaces

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

    $grkwp = $Awfif::wsbl-> {wsbloh}[$Awfif::memes-> {currentwsbi}];
    $grkwpr = $Awfif::wsbl-> {wsot}[$Awfif::memes-> {currentwsbi}];
    $found = '';
    $sponsor = $Awfif::codelet-> {l} [$myli][17];
    $asponsor = awsoadr ($sponsor);
    $signal = $Awfif::codelet-> {l} [$myli][16];
    $schema = $Awfif::codelet-> {l} [$myli][18];
    $ws = $Awfif::codelet-> {l} [$myli] [20];
    $startwso = $Awfif::codelet-> {l} [$myli][21];
    $endwso = $Awfif::codelet-> {l} [$myli][22];
# use the specified ws
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $ws;
#check if the work has already been done

    if ((!findbond ($Awfif::wsol-> {l} [ awsoadr ($startwso)][2], $Awfif::memes-> {snnh} {start}, $Awfif::memes-> {snnh} {iforall}, $Awfif::memes-> {snnh} {inspector})) ){
      $Awfif::wsol-> {l} [awsoadr ($startwso)][2]
      = setupdesc ( $Awfif::memes-> {snnh} {iforall},
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {start}),
          $Awfif::memes-> {snnh} {inspector},
          $Awfif::wsol-> {l} [awsoadr ($startwso)][2],
          awsoadr ($startwso));
# deploy descriptors

      $Awfif::memes-> {currentwsbi} = $ws;
      $Awfif::wsol-> {l} [awsoadr ($startwso)][2]
      = setupdesc ( $Awfif::memes-> {snnh} {iterator},
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {all}),
          $Awfif::memes-> {snnh} {model},
          $Awfif::wsol-> {l} [awsoadr ($startwso)][2],
          awsoadr ($startwso));
      $Awfif::wsol-> {l} [awsoadr ($startwso)][2]
      = setupdesc ( $Awfif::memes-> {snnh} {iterator},
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {goodscope}),
          $Awfif::memes-> {snnh} {model},
          $Awfif::wsol-> {l} [awsoadr ($startwso)][2],
          awsoadr ($startwso));
      $Awfif::memes-> {fatp} = $Awfif::memes-> {fatp} + $Awfif::memes-> {batp};
# send activation to the involved Slipnet nodes
      &actnodes ( $Awfif::memes-> {snnh} {iterator}, $Awfif::memes-> {openatype});
      &actnodes ( $Awfif::memes-> {snnh} {wsi}, $Awfif::memes-> {openato});
# sponsor the model iteration target codelet
      $Awfif::clp = ();
      $Awfif::clp-> {log} = $Awfif::codelet-> {l} [$myli][13];
      $Awfif::clp-> {urgency} = ($Awfif::codelet-> {l} [$myli][3]);
      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} = "mittarbuilder";
      $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}-> {sws} = $Awfif::codelet-> {l} [$myli] [20];
      $Awfif::clp-> {action}-> {wss} = $Awfif::codelet-> {l} [$myli][21];
      $Awfif::clp-> {action}-> {wse} = $Awfif::codelet-> {l} [$myli][22];
      $Awfif::clp-> {action}-> {ref} = $spi;
      &groupsinv1 ($myli, undef(), undef(), undef(), undef(),undef(), "mittarevaluator", $grkwp, $grkwpr, \@$sactset);
# report that have completed goal activity
      if ((!findbond ($Awfif::wsol-> {l} [ awsoadr ($startwso)][2], $Awfif::memes-> {snnh} {whole}, $Awfif::memes-> {snnh} {miforall}, $Awfif::memes-> {snnh} {inspector})) ){
        $Awfif::wsol-> {l} [awsoadr ($startwso)][2]
        = setupdesc ( $Awfif::memes-> {snnh} {iforall},
            ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {whole}),
            $Awfif::memes-> {snnh} {inspector},
            $Awfif::wsol-> {l} [awsoadr ($startwso)][2],
            awsoadr ($startwso));
        };#record have accessed this operon
      };#record have accessed this operon
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# miforallbuilder1
#
sub miforallinspector1 {
    my ($myli, $sws, $wss, $wse) = @_;
    my ($result,
    $cdn, $cdnx);
#
# checked for merged workspaces

    $cdn = clogstat (\$cdnx);
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdn myli $myli sws $sws wss $wss wse $wse ");
      &itcpoutput ($myli);
      };
    $result = iinspector1 ($myli, $sws, $wss, $wse, $Awfif::memes-> {snnh} {iforall});

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx ret ($result)\n");
      };
    &clogstatx ();
    return $result
    }# miforallinspector1
#
sub mittarevaluator1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $signal, $schema, $found, $spi,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# should be deployed against a ws schema in a group that indicates iterate for all

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

    $grkwp = $Awfif::wsbl-> {wsbloh}[$Awfif::memes-> {currentwsbi}];
    $grkwpr = $Awfif::wsbl-> {wsot}[$Awfif::memes-> {currentwsbi}];
    $found = '';
    $sponsor = $Awfif::codelet-> {l} [$myli][17];
    $signal = $Awfif::codelet-> {l} [$myli][16];
    $schema = $Awfif::codelet-> {l} [$myli][18];
# rework will be processed in real evaluator

    if (($Awfif::codelet-> {l}[$myli][16] > 0)
    && ($Awfif::codelet-> {l}[$myli][17] > 0)
    && ($Awfif::codelet-> {l}[$myli][18] > 0)
    && ($Awfif::codelet-> {l}[$myli] [20] > 0)
    && ($Awfif::codelet-> {l}[$myli][21] > 0)
    && ($Awfif::codelet-> {l}[$myli][22] > 0)
    ){#need to verify that $Awfif::codelet-> {l}[$myli][22] + 1 is a target name

      my ($descfits, $conformstotarget, $from, $afrom, $count, $twso);
      $descfits = '';
# $i1 == href && instance
# $i1+1 == char (#)
# $i1+2 == char
#
      $from = trwsoadr ($Awfif::codelet-> {l} [$myli][22],1);
      $afrom = awsoadr ($from);
      $twso = fgrpend ($Awfif::codelet-> {l} [$myli][21]);
      if (($count = ipartseqcount ('onematch', $myli, $from, $twso, \$descfits, \$conformstotarget, trwsoadr ($twso,1), $grkwpr,
        $Awfif::memes-> {snnh} {tokencategory}, $Awfif::memes-> {snnh} {href}, $Awfif::memes-> {snnh} {andcategory}, $Awfif::memes-> {snnh} {instance}, $Awfif::memes-> {snnh} {invalidatescategory}, $Awfif::memes-> {snnh} {hname}, $Awfif::memes-> {snnh} {failscategory}, $Awfif::memes-> {snnh} {ivariable}, $Awfif::memes-> {snnh} {failscategory}, $Awfif::memes-> {snnh} {msuccgstart}, $Awfif::memes-> {snnh} {failscategory}, $Awfif::memes-> {snnh} {msuccgend}, $Awfif::memes-> {snnh} {failscategory}, $Awfif::memes-> {snnh} {msuccgedges}, $Awfif::memes-> {snnh} {failscategory}, $Awfif::memes-> {snnh} {msuccgedgee},
        $Awfif::memes-> {snnh} {char},
        )>0)
      && ($conformstotarget)
      && ($descfits) && (!(findbond ($Awfif::wsol-> {l} [ $afrom] [2], $Awfif::memes-> {snnh} {goodtarget}, $Awfif::memes-> {snnh} {iterator}, $Awfif::memes-> {snnh} {model})))) {
        $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} = "mittarbuilder";
        $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}-> {sws} = $Awfif::codelet-> {l} [$myli] [20];
        $Awfif::clp-> {action}-> {wss} = $Awfif::codelet-> {l} [$myli][21];
        $Awfif::clp-> {action}-> {wse} = $Awfif::codelet-> {l} [$myli][22];
        $Awfif::clp-> {action}-> {ref} = $spi;
        &groupsinv1 ($myli, undef(), undef(), undef(), undef(), undef(), "mittarbuilder", $grkwp, $grkwpr, \@$sactset);
        };#if
      };#valid params

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# mittarevaluator1

#
sub mittarbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $asponsor, $signal, $schema, $found, $cwsbi, $ws, $startwso,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# checked for merged workspaces

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

    $grkwp = $Awfif::wsbl-> {wsbloh}[$Awfif::memes-> {currentwsbi}];
    $grkwpr = $Awfif::wsbl-> {wsot}[$Awfif::memes-> {currentwsbi}];
    $found = '';
    $sponsor = $Awfif::codelet-> {l} [$myli][17];
    $asponsor = awsoadr ($sponsor);
    $signal = $Awfif::codelet-> {l} [$myli][16];
    $schema = $Awfif::codelet-> {l} [$myli][18];
    $ws = $Awfif::codelet-> {l} [$myli] [20];
    $startwso = $Awfif::codelet-> {l} [$myli][21];
# use the specified ws
    $cwsbi = $Awfif::memes-> {currentwsbi};
    $Awfif::memes-> {currentwsbi} = $ws;
#check if the work has already been done

    if ((!findbond ($Awfif::wsol-> {l} [ awsoadr ($startwso)][2], $Awfif::memes-> {snnh} {start}, $Awfif::memes-> {snnh} {target}, $Awfif::memes-> {snnh} {inspector})) ){
      my ($from, $twso, $kw, $searchwso, $descfits, $conformstoresource, $pwsbi, $chartype);
      $Awfif::wsol-> {l} [awsoadr ($startwso)][2]
      = setupdesc ( $Awfif::memes-> {snnh} {target},
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {start}),
          $Awfif::memes-> {snnh} {inspector},
          $Awfif::wsol-> {l} [awsoadr ($startwso)][2],
          awsoadr ($startwso));
# setup the start and end addresses
      $from = trwsoadr ($Awfif::codelet-> {l} [$myli][22],3);#skip the hash
      $twso = trwsoadr (fgrpend ($Awfif::codelet-> {l} [$myli][21]),1);
# get the name of the target
      $kw = rbufchars ($from, $twso, \$chartype, $ws);
# validate the href
      $searchwso = $Awfif::hnamel-> {l} [$Awfif::memes-> {hrefwsl} {$kw}] [5];
      $pwsbi = 1;#should get this from info about the kw
      $descfits = searchmdefmcv ($myli, $searchwso, $pwsbi,
              \$conformstoresource, $grkwp, $grkwpr, \@$sactset);
# deploy descriptors

      if (($descfits) && ($conformstoresource)) {
        $Awfif::memes-> {currentwsbi} = $ws;
        $Awfif::wsol-> {l} [awsoadr ($startwso)][2]
        = setupdesc ( $Awfif::memes-> {snnh} {iterator},
            ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {goodtarget}),
            $Awfif::memes-> {snnh} {model},
            $Awfif::wsol-> {l} [awsoadr ($startwso)][2],
            awsoadr ($startwso));
        $Awfif::memes-> {fatp} = $Awfif::memes-> {fatp} + $Awfif::memes-> {batp};
# send activation to the involved Slipnet nodes
        &actnodes ( $Awfif::memes-> {snnh} {iterator}, $Awfif::memes-> {openatype});
        &actnodes ( $Awfif::memes-> {snnh} {wsi}, $Awfif::memes-> {openato});
        }#if
      else {#describe problem
        $Awfif::memes-> {currentwsbi} = $ws;
        $Awfif::wsol-> {l} [awsoadr ($startwso)][2]
        = setupdesc ( $Awfif::memes-> {snnh} {iterator},
            ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {badtarget}),
            $Awfif::memes-> {snnh} {model},
            $Awfif::wsol-> {l} [awsoadr ($startwso)][2],
            awsoadr ($startwso));
        };
# report that have completed goal activity
      if ((!findbond ($Awfif::wsol-> {l} [ awsoadr ($startwso)][2], $Awfif::memes-> {snnh} {whole}, $Awfif::memes-> {snnh} {target}, $Awfif::memes-> {snnh} {inspector})) ){
        $Awfif::wsol-> {l} [awsoadr ($startwso)][2]
        = setupdesc ( $Awfif::memes-> {snnh} {target},
            ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {whole}),
            $Awfif::memes-> {snnh} {inspector},
            $Awfif::wsol-> {l} [awsoadr ($startwso)][2],
            awsoadr ($startwso));
        };#record have accessed this operon
      };#record have accessed this operon
    $Awfif::memes-> {currentwsbi} = $cwsbi;

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# mittarbuilder1
#
#
sub tpmmanscout1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($sponsor, $signal, $schema, $proceed, $swstype, $noswstype,
      $grkwp, $grkwpr, $cdn, $cdnx);
#
# updated for merged workspaces
# uses operon jhlabels

# goals must use the full workspace

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

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

      if ((defined ($Awfif::codelet-> {l} [$myli][26]) )) {

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

      }# rework
    elsif ($proceed) {#main line
# Top-down nuclear label group scouts validate their calling information and then call in an evaluator to
# match operon jhlabels of completed groups in their workspace with their sponsoring label
# where ever they find a completed group if there is a match request a builder transcribes a salient aspect of the following 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
#

      my ($nongroupc, @nga, $i, $i2, $keeplooking);
      $nongroupc = arrayng ($myli, $Awfif::codelet-> {l} [$myli][21], \@nga);
      $keeplooking = 't';
      $i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 1);
      while ($keeplooking) {
        $keeplooking = '';
        for ($i2 = 0; (($i2 < $nongroupc) && (!$keeplooking)); $i2++) {
          if (($nga [$i2] == $i)
          ) {#find first non gap
            $i = trwsoadr ($i, 1);
            $keeplooking = 't';
            };#if i is a gap
          };#for
        };#while
      if ((defined($Awfif::codelet-> {l} [$myli][26]) )
      && (!findbond ($Awfif::wsol-> {l} [ awsoadr ($i)] [2], $Awfif::memes-> {snnh} {whole}, $Awfif::codelet-> {l} [$myli][26], $Awfif::memes-> {snnh} {model}))
      ) {
# now skip to the end of this group and keep processing
        $Awfif::clp = ();
        $Awfif::clp-> {action}-> {schema} = $schema;
        $Awfif::clp-> {action}-> {signal} = $signal;
        $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];
        $Awfif::clp-> {action}-> {jhlabeli} = $Awfif::codelet-> {l} [$myli][23];
        $Awfif::clp-> {action}-> {pmman} = $Awfif::codelet-> {l} [$myli][26];
        &groupsinv1 ($myli, $sponsor, trwsoadr ($sponsor,1),0, $sponsor,0, 'pmmanevaluator', $$kwp, $kwpr, \@$sactset);
        };# sps or mps signal
      };# main line

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# tpmmanscout1
#
sub pmmanevaluator1 {
    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, $noswstype, $afrom,
      $grkwp, $grkwpr, $cdn, $cdnx);
#
# updated for merged workspaces

# goals must use the full workspace

    $noswstype = 't';
    $proceed = getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, $noswstype, \$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])))) {
        &updatelog ($myli, 'tngs', 1, $signal);#
        &updatelog ($myli,'tngs', 2, $schema);#

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

      }# rework
    elsif ($proceed) {#main line
# The program manager evaluator will call in a builder if there are cross group operons found
#

      my ($nongroupc, @nga, $i, $i2, $keeplooking);
      $afrom = awsoadr ($Awfif::codelet-> {l} [$myli][21]);
      $nongroupc = arrayng ($myli, $Awfif::codelet-> {l} [$myli][21], \@nga);
      $keeplooking = 't';
      $i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 1);
      while ($keeplooking) {
        $keeplooking = '';
        for ($i2 = 0; (($i2 < $nongroupc) && (!$keeplooking)); $i2++) {
          if (($nga [$i2] == $i)
          ) {#find first non gap
            $i = trwsoadr ($i, 1);
            $keeplooking = 't';
            };#if i is a gap
          };#for
        };#while
      if ((defined($Awfif::codelet-> {l} [$myli][26]))
      && (findbond ($Awfif::wsol-> {l} [ awsoadr ($Awfif::codelet-> {l} [$myli][21])] [2], $Awfif::memes-> {snnh} {multiple}, wsbasetype ($Awfif::codelet-> {l} [$myli][21]), $Awfif::memes-> {snnh} {model}))
      && (!findbond ($Awfif::wsol-> {l} [ awsoadr ($i)] [2], $Awfif::memes-> {snnh} {whole}, $Awfif::codelet-> {l} [$myli][26], $Awfif::memes-> {snnh} {model}))
      ){#there is a program management request
# 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];
# apply the linking function of group completion
# pmmanensu1
        if (($Awfif::codelet-> {l} [$myli] [36] > 0) ) {

          $Awfif::wsol-> {l}[awsoadr ($sponsor)][ $Awfif::memes-> {wsosubpid}] = $Awfif::codelet-> {l} [$myli] [36];#*** submacrok ***# cache a subpid for this subprogram schemata
          };#if
        $operoncount = labinv1 ($myli, $wss, $wse, '', '', \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge);
        if ($operoncount > 0) {

          my ($nongroupc, @nga, $i2, $bg, $nobuilder);
          $nongroupc = arrayng ($myli, $wss, \@nga);
          $nobuilder = 't';
          for ($i = 0;

            $i < $operoncount;
            $i++
            ) {
            $bg = '';
            if (($lomatchs [$i]) ) {

              for ($i2 = 0; $i2 < $nongroupc; $i2++) {
                if (($nga [$i2] >= $lostrts [$i])
                && ($nga [$i2] <= $loends [$i])
                  ) {#bridges groups
                  $bg = 't';
                  };#if bridges groups
                };#for
              if ($bg) {

                $nobuilder = '';
                $Awfif::clp = ();
                $Awfif::clp-> {action}-> {schema} = $schema;
                $Awfif::clp-> {action}-> {signal} = $signal;
                $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];
                $Awfif::clp-> {action}-> {jhlabeli} = $Awfif::codelet-> {l} [$myli][23];
                $Awfif::clp-> {action}-> {pmman} = $Awfif::codelet-> {l} [$myli][26];
                &groupsinv1 ($myli, $sponsor, trwsoadr ($sponsor,1),0 , $sponsor,0 , 'pmmanbuilder', $$kwp, $kwpr, \@$sactset);
                };#if bg
              };#if
            };#for
# pmmanedesc
          $afrom = awsoadr ($wss);
          if (($nobuilder) #must describe acceptable validation by program manager here
          && (!(findbond ($Awfif::wsol-> {l} [ $afrom] [2], $Awfif::memes-> {snnh} {start}, $Awfif::codelet-> {l} [$myli][26], $Awfif::memes-> {snnh} {pmmanager})))
          && (!(findbond ($Awfif::wsol-> {l} [ $afrom] [2], $Awfif::memes-> {snnh} {whole}, $Awfif::codelet-> {l} [$myli][26], $Awfif::memes-> {snnh} {pmmanager})))
          ) {

            $Awfif::wsol-> {l} [$afrom][2]
              = setupdesc ( ($Awfif::codelet-> {l} [$myli][26]),
              ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {start}), #to match findbond
              $Awfif::memes-> {snnh} {pmmanager},
              $Awfif::wsol-> {l} [$afrom][2],
              $afrom);
            $Awfif::wsol-> {l} [$afrom][2]
              = setupdesc ( ($Awfif::codelet-> {l} [$myli][26]),
              ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {whole}), #to match findbond
              $Awfif::memes-> {snnh} {pmmanager},
              $Awfif::wsol-> {l} [$afrom][2],
              $afrom);
            &invcaches ($sws);
# pmmwscup1
            &wsclinv (0, $Awfif::memes-> {currentwsbi}, $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bugroup}]);
            };#specify completion of validation
          };#in group
        } # sps or mps signal
      elsif ((defined ($Awfif::codelet-> {l} [$myli][26])) #must describe acceptable validation by program manager here
      && (findbond ($Awfif::wsol-> {l} [ awsoadr ($Awfif::codelet-> {l} [$myli][21])] [2], $Awfif::memes-> {snnh} {single}, wsbasetype ($Awfif::codelet-> {l} [$myli][21]), $Awfif::memes-> {snnh} {model}))
      && (!(findbond ($Awfif::wsol-> {l} [ $afrom] [2], $Awfif::memes-> {snnh} {start}, $Awfif::codelet-> {l} [$myli][26], $Awfif::memes-> {snnh} {pmmanager})))
      && (!(findbond ($Awfif::wsol-> {l} [ $afrom] [2], $Awfif::memes-> {snnh} {whole}, $Awfif::codelet-> {l} [$myli][26], $Awfif::memes-> {snnh} {pmmanager})))
        ){#if single found then deploy the single descriptors

        $Awfif::wsol-> {l} [$afrom][2]
          = setupdesc ( ($Awfif::codelet-> {l} [$myli][26]),
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {start}), #to match findbond
          $Awfif::memes-> {snnh} {pmmanager},
          $Awfif::wsol-> {l} [$afrom][2],
          $afrom);
        $Awfif::wsol-> {l} [$afrom][2]
          = setupdesc ( ($Awfif::codelet-> {l} [$myli][26]),
          ($Awfif::memes-> {snnh} {wsi} + $Awfif::memes-> {snnh} {whole}), #to match findbond
          $Awfif::memes-> {snnh} {pmmanager},
          $Awfif::wsol-> {l} [$afrom][2],
          $afrom);
        &invcaches ($Awfif::codelet-> {l} [$myli] [20]);
# pmmwscup2
        &wsclinv (0, $Awfif::memes-> {currentwsbi}, $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bugroup}]);
        };
      };# main line

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# pmmanevaluator1
#
sub pmmanbuilder1 {
    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, $noswstype,
      $grkwp, $grkwpr, $cdn, $cdnx);
#
# updated for merged workspaces

# goals must use the full workspace

    $noswstype = 't';
    $proceed = getcontext ($myli, \$sponsor, \$signal, \$schema, \$swstype, \$grkwp, \$grkwpr, $noswstype, \$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])))) {
        &updatelog ($myli, 'tngs', 1, $signal);#
        &updatelog ($myli,'tngs', 2, $schema);#

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

      }# rework
    elsif ($proceed) {#main line
      my ($nongroupc, @nga, $i, $i2, $keeplooking);
      $nongroupc = arrayng ($myli, $Awfif::codelet-> {l} [$myli][21], \@nga);
      $keeplooking = 't';
      $i = trwsoadr ($Awfif::codelet-> {l} [$myli][21], 1);
      while ($keeplooking) {
        $keeplooking = '';
        for ($i2 = 0; (($i2 < $nongroupc) && (!$keeplooking)); $i2++) {
          if (($nga [$i2] == $i)
          ) {#find first non gap
            $i = trwsoadr ($i, 1);
            $keeplooking = 't';
            };#if i is a gap
          };#for
        };#while
      if ((defined ($Awfif::codelet-> {l} [$myli][26]))
      && (findbond ($Awfif::wsol-> {l} [ awsoadr ($Awfif::codelet-> {l} [$myli][21])] [2], $Awfif::memes-> {snnh} {multiple}, wsbasetype ($Awfif::codelet-> {l} [$myli][21]), $Awfif::memes-> {snnh} {model}))
      && (!findbond ($Awfif::wsol-> {l} [ awsoadr ($i)] [2], $Awfif::memes-> {snnh} {whole}, $Awfif::codelet-> {l} [$myli][26], $Awfif::memes-> {snnh} {model}))
      ){#there is a new program management request
# 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];
# apply the linking function of group completion
# pmmanbnsu1
        if (($Awfif::codelet-> {l} [$myli] [36] > 0) ) {

          $Awfif::wsol-> {l}[awsoadr ($sponsor)][ $Awfif::memes-> {wsosubpid}] = $Awfif::codelet-> {l} [$myli] [36];#*** submacrok ***# cache a subpid for this subprogram schemata
          };#if
        $operoncount = labinv1 ($myli, $wss, $wse, '', '', \@lomatchs, \@lola, \@loconcs, \@lostrts, \@loends, \@logb, \@loge, 'notoporstbinding');
        if ($operoncount > 0) {

          my ($nongroupc, @nga, $i, $i2, $nobuilder, $atti, $deployed);
          $nongroupc = arrayng ($myli, $wss, \@nga);
          $nobuilder = 't';
          for ($i = 0;

            $i < $operoncount;
            $i++
            ) {
            if (($lomatchs [$i]) ) {

              $deployed = '';
              for ($i2 = 0; $i2 < $nongroupc; $i2++) {
                if (($nga [$i2] >= $lostrts [$i])
                && ($nga [$i2] <= $loends [$i])
# constraint to stop multiple deployments if lots of gaps forces only one deployment per part - may not be valid in general
                && (!$deployed)
                  ) {#bridges groups
# unless this is an operon
                  if (($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{operon}) && ($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{stbinding}) && ($Awfif::jhls-> {l} [$lola[$i]][4] != $Awfif::memes-> {snnh}{subpstbinding})) {

                    $deployed = 't';
                    &itcsuse ();
                    $Awfif::clp = ();
                    if ((defined ($myli)) && ((!defined ($Awfif::codelet-> {l} [$myli] [13])) or ($Awfif::codelet-> {l} [$myli] [13] == 0)) && (( $Awfif::wsol-> {l} [awsoadr ($sponsor)] [8] != 0)
                    or ($Awfif::wsol-> {l}[awsoadr ($sponsor)][ $Awfif::memes-> {wsologucount}] != 0))) {&break()};#*** submacrok ***#
                    $Awfif::clp-> {log} = $Awfif::codelet-> {l} [$myli][13];
                    $Awfif::clp-> {urgency} = ($Awfif::codelet-> {l} [$myli][3] * $Awfif::memes-> {evlaunchm});
                    if ($Awfif::codelet-> {l}[$myli][19] != 0) {
                      $Awfif::clp-> {wsi} = $Awfif::codelet-> {l}[$myli][19];
                      }#wsi set
                    else {
                      $Awfif::clp-> {wsi} = $Awfif::memes-> {currentwsbi};
                      };
                    $Awfif::clp-> {strategy} = "tgoalscout";
                    $Awfif::clp-> {action}-> {sponsor} = $sponsor;
                    $Awfif::clp-> {action}-> {signal} = findsignal ($loconcs[$i]);
                    $Awfif::clp-> {action}-> {schema} = $loconcs[$i];
                    $Awfif::clp-> {action}-> {sws} = $Awfif::memes->{currentwsbi};
                    $Awfif::clp-> {action}-> {wss} = $lostrts[$i];
                    $Awfif::clp-> {action}-> {wsoname} = getwsoname ($lostrts[$i]);
                    $Awfif::clp-> {action}-> {wse} = $loends[$i];
                    if (($logb[$i] != 0)
                    && ($logb[$i] != $loge[$i]) ){
                      $Awfif::clp-> {action}-> {wsgs} = $logb[$i];
                      $Awfif::clp-> {action}-> {wsge} = $loge[$i];
                      };#operon has a gap
                    $Awfif::clp-> {action}-> {jhlabeli} = $lola[$i];
                    &icdsubmitcodelet ($myli, \$Awfif::clp, $Awfif::jhls-> {l} [$lola[$i]] [10], $grkwp, $grkwpr, \@$sactset);
# add a jhlabel for this workspace group
# pmmanbieu1

                    $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}] {snnl} [$Awfif::memes-> {snnh}{operon}] = newnlink ($Awfif::memes-> {snnh} {attrib}, addjhlst ($Awfif::memes-> {snnh} {groupcategory}, $Awfif::memes-> {snnh} {operon}, 1, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}] {snnl}[$Awfif::memes-> {snnh}{operon}], $Awfif::jhls-> {l} [$lola[$i]] [6], $Awfif::memes-> {currentwsbi}, $lostrts[$i], $loends[$i], $Awfif::jhls-> {l} [$lola[$i]] [15] [0]), $Awfif::memes-> {snnh}{operon}, $Awfif::memes-> {snw} [$Awfif::memes-> {currentwsbi}]-> {snnl}[$Awfif::memes-> {snnh}{operon}]);
# $lola[$i] is the index of the jhls when $lomatchs[$i] is true so can copy over its attributes
                    $atti = $Awfif::jhls-> {l} [$lola[$i]] [5];
                    $atti = $Awfif::attribs-> {l} [$atti][1];#move past the start attribute
                    while (($Awfif::attribs-> {l} [$atti][2]) != $Awfif::memes-> {snnh}{attribe}) {
                      &addjhlattrib ($Awfif::memes-> {snnh}{operon}, $Awfif::attribs-> {l} [$atti][3], $Awfif::attribs-> {l} [$atti][4]);
                      $atti = $Awfif::attribs-> {l} [$atti][1];#next
                      };

                    &addjhlattribs ($Awfif::memes-> {snnh}{operon});
                    }; #if its not an operon
                  };#launch the action scout if bridges groups
                };#for
              };#if
            };#for
          };#in group
        };# sps or mps signal
      };# main line

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx\n");
      };
    &clogstatx ();
    }# pmmanbuilder1
#
sub pmmaninspector1 {
    my ($myli, $sws, $wss, $wse) = @_;
    my ($result,
    $cdn, $cdnx);
#
# checked for merged workspaces

    $cdn = clogstat (\$cdnx);
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdn myli $myli sws $sws wss $wss wse $wse ");
      &itcpoutput ($myli);
      };
    $result = iinspector1 ($myli, $sws, $wss, $wse, $Awfif::codelet-> {l} [$myli] [26], $Awfif::memes-> {snnh} {pmmanager});

    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdnx ret ($result)\n");
      };
    &clogstatx ();
    return $result
    }# pmmaninspector1
#
#<!-- start tag pc -->
#<!-- start tag sm -->
#
sub partbuilder1 {
    my ($myli, $kwp, $kwpr, $sactset) = @_;#The ignored parameters are required by the codelet calling architecture
    my ($ni, $ani,
    $grkwp, $grkwpr, $cdn, $cdnx);
#
# checked for merged workspaces

    $cdn = clogstat (\$cdnx);
    if ($Awfif::memes-> {trace} > $Awfif::memes-> {traceentry}) {
      print ("$cdn myli $myli kwp($kwp) kwpr($kwpr)");
      &itcpoutput ($myli);
      };
# parts 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 (!findbond ($Awfif::wsol-> {l} [ awsoadr ($ni)] [2], $ni, wsbasetype ($ni), $Awfif::memes-> {snnh} {partscategory})) {
        my ($buildpart);
# if model thresholding has failed lower energy

        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}))
        ){
# atppenalty2

          $Awfif::memes-> {fatp} = $Awfif::memes-> {fatp} - $Awfif::memes-> {failatpr};
          };#if
# if the part is not marked as valid build completion descriptors
        if ((partvalid ($myli, $ni, $grkwp, $grkwpr, \@$sactset))
        && (partconstrained ($myli, $ni, $grkwp, $grkwpr, \@$sactset))
        && (partintegrated ($myli, $ni, $grkwp, $grkwpr, \@$sactset)) ){

          $buildpart = '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));
# pbwscup
          &wsclinv (0, $Awfif::memes-> {currentwsbi}, $Awfif::memes-> {strbool}[$Awfif::memes-> {streh} {bugroup}]);
          };#partvalid and constrained
        if ($buildpart) {#deploy the part 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));
          };#part can be built
        };#part is not whole yet
      }# got a pair to work on

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