/ 
Sim-OPT-0.997
/ Sim::OPT::StructureDesignProcedure

NAME

Sim::OPT::StructureDesignProcedure - Perl-embedded procedure language for Sim::OPT hierarchical structure design

VERSION

Module version 0.27.

Procedure-language version 1.0.

Procedure schema Sim::OPT::StructureDesign/procedure-1.

SYNOPSIS

A procedure is an ordinary Perl file that returns one design(...) value. The language is embedded in Perl: Perl supplies syntax, data structures, modules, interpolation and error handling; this module supplies the StructureDesign vocabulary and execution semantics.

use strict;
use warnings;
use Sim::OPT::StructureDesignProcedure qw(
    design state experience derive reembed merge abstract
    retain_memory reconstruct_memory statistics compare
    search clustering_and_finding_medoids
    reduce_scope increase_resolution
    enlarge_scope maintain_resolution pan
    incumbent result_of
);

return design 'example',
    root_dir => ($ENV{STRUCTUREDESIGN_ROOT} || $ENV{HOME}),
    steps => [

        state('base',
            id       => 'state_base',
            existing => 1,
            config   => 'base.pl',
        ),

        experience('base',
            id         => 'search_base',
            config     => 'base.pl',
            using      => search(),
            model_root => 'base',
            executable => "$ENV{HOME}/base/opt",
        ),

        derive('local',
            id            => 'make_local',
            from          => 'base',
            parent_config => 'base.pl',
            config        => 'local.pl',
            around        => incumbent('search_base'),
            by => [
                reduce_scope(
                    variables => [1, 2, 3],
                    levels    => 3,
                ),
                increase_resolution(
                    variables => [1, 2, 3],
                    factor    => 2,
                ),
            ],
        ),
    ];

A procedure can be loaded and planned without executing it:

use Sim::OPT::StructureDesignProcedure qw(load_procedure run_procedure);
my $p = load_procedure('./example-procedure.pl');
run_procedure($p);

Execution is requested explicitly:

run_procedure($p, commit => 1);

DESCRIPTION

Sim::OPT::StructureDesignProcedure is the public procedure-language layer for hierarchical StructureDesign workflows in Sim::OPT. It describes design processes as ordered, inspectable declarations rather than embedding each experiment directly in filesystem manipulation or Sim::OPT launch code.

The module intentionally separates three levels:

procedure file
    -> Sim::OPT::StructureDesignProcedure language/runtime
    -> Sim::OPT::StructureDesign geometric planner and workspace engine
    -> generated Sim::OPT configurations, searches and result artifacts

A file such as bt-procedure.pl is therefore a program written in this embedded domain-specific language. It is not itself the language definition. The language definition is the constructor vocabulary and execution semantics implemented here.

The language is declarative in the following limited sense: constructors such as derive(...) and abstract(...) create data structures that describe intent. They do not perform filesystem operations when the procedure file is loaded. Execution occurs later through run_procedure().

DESIGN PRINCIPLES

Procedure declarations are separate from operator implementations

The procedure states what should happen and in what order. Detailed geometry, configuration rewriting, workspace construction, model copying and Sim::OPT execution are implemented by installed modules.

State transitions are explicit

Each major representation is named as a state. Transformations create new states rather than silently mutating the conceptual identity of a previous state.

References are explicit dependencies

incumbent($step_id) and result_of($step_id, $key) refer to results of previous completed steps. They are resolved from the run manifest at execution time.

Checkpoint reuse is conservative

Completed steps are associated with signatures of their declarations and with a runtime signature. A completed checkpoint is reused only when the runtime can verify that the declaration and required output artifacts remain compatible.

Scientific choices belong in the procedure

Acquisition density, scope transformations, abstraction choices and memory reactivation density belong in the procedure declaration when they are experimental choices. They should not be hard-coded inside a generic runtime operator.

LANGUAGE AND MODULE VERSIONING

$Sim::OPT::StructureDesignProcedure::VERSION identifies the Perl module implementation. procedure_language_version() identifies the public embedded language version. procedure_schema() returns the procedure data schema.

my $language = procedure_language_version();  # "1.1"
my $schema   = procedure_schema();            # procedure-1 schema

The language version is deliberately separate from the module version. An implementation can receive bug fixes without requiring a new language version.

PROCEDURE FILE CONTRACT

A procedure file must return a HASH reference created by design(...) or an equivalent structure using the supported procedure schema. load_procedure() loads the file with Perl do, verifies the returned object and records the absolute procedure-file path for provenance.

The normal form is:

return design 'procedure_name',
    root_dir => '/path/to/root',
    steps    => [ ... ];

design($name, %args)

Creates the top-level procedure object.

Common arguments:

root_dir

Root directory under which named state directories are resolved. Defaults to $ENV{HOME} and then ..

manifest

Optional explicit run-manifest path. If omitted, the default is:

<root_dir>/.structuredesign/<procedure-name>.json
steps

Array reference containing the ordered procedure steps.

Every constructor-generated step is enabled by default. Set enabled => 0 to retain a declaration without executing it.

STEP IDENTIFIERS

A step should normally have an explicit id. References and --from-style resumption use step identifiers, not state names.

If no id is supplied, the runtime generates an identifier from ordinal position, step type and step name. Explicit IDs are preferable for procedures intended to be resumed, cited or maintained over time.

Example:

experience('base',
    id => 'search_base',
    ...
)

CORE STEP CONSTRUCTORS

state($name, %args)

Declares a named problem-space state.

For an already existing state:

state('base',
    id       => 'state_base',
    existing => 1,
    config   => 'base.pl',
)

The runtime verifies that the state directory and configuration file exist.

A state can also be cloned from another state:

state('branch',
    id                => 'state_branch',
    from              => 'source',
    source_config     => 'source.pl',
    config            => 'branch.pl',
    model_root        => 'bt',
    geometry_manifest => 'structuredesign-scope.json',
)

For cloned states the canonical model root is copied, the configuration is rendered for the target directory, and an optional geometry manifest is materialized for the clone. Existing target directories are not overwritten.

Optional config_variant and inherited dowhat values can be used when the clone requires a controlled configuration variant.

experience($state, %args)

Runs an acquisition/evaluation operation in a state.

The installed executor supports search() and star(...) acquisition kinds. Other acquisition descriptors may be representable by the language but are not silently substituted for an installed executor.

Typical search form:

experience('sampled',
    id           => 'sample_sampled',
    config       => 'sampled.meta.pl',
    config_from  => 'sampled.pl',
    using        => search(),
    model_root   => 'bt',
    executable   => "$ENV{HOME}/bt/opt",
    config_variant => {
        sweeps => [ [ '2>1', 2, 3, 4, 5 ] ],
        dowhat => {
            names             => 'short',
            metamodel         => 'y',
            convergeintomodel => 'y',
        },
    },
)

When config_from is present, the runtime creates the requested configuration variant before launching Sim::OPT.

Useful validation arguments include:

expected_result_rows

Require an exact number of rows in the direct result file after the run.

expected_full_factorial

Array reference of variables expected to have been exhaustively enumerated. The expected count is derived from the active lattice rather than hard-coded.

required_output_files

Array reference of files that must exist and be non-empty after execution.

geometry_manifest or lattice_manifest

Geometry information used to validate or count the active lattice.

config_variant

Controlled modifications to @sweeps, %dowhat and, where used internally, explicit star positions.

inherit_dowhat

Requests selected %dowhat string values from another state's configuration. An explicit value in config_variant.dowhat takes precedence over an inherited value.

After Sim::OPT completes, the runtime determines the clear incumbent from the produced result evidence. An incumbent-dependent downstream step cannot proceed without a resolvable winner.

derive($target, %args)

Declares a structural transformation from one state into another.

The by argument is an array of structural operators.

The current runtime has two installed derive families.

Local refinement

derive('local',
    from   => 'base',
    around => incumbent('search_base'),
    by => [
        reduce_scope(variables => [1,2,3], levels => 3),
        increase_resolution(variables => [1,2,3], factor => 2),
    ],
)

reduce_scope is required by this executor. increase_resolution is optional. Geometry is planned by Sim::OPT::StructureDesign::plan_zoom_in.

mediumiters and refined_mediumiters can be supplied explicitly when a procedure needs to override the planner's normal policy.

Scope enlargement with preserved resolution and panning

derive('wide',
    from => 'merged',
    by => [
        enlarge_scope(variables => [1,2,3,4,5], factor => 2),
        maintain_resolution(variables => [1,2,3,4,5]),
        pan(around => incumbent('make_merged')),
    ],
)

The installed executor requires all three operators. The source lattice manifest supplies the existing global counts; the planner derives the enlarged geometry without requiring physical step sizes to be repeated in the procedure.

reembed($target, %args)

Re-embeds a locally refined state into the global refined lattice described by a zoom manifest.

Typical form:

reembed('refined_global',
    id         => 'make_refined_global',
    from       => 'local',
    into       => 'global_refined_lattice',
    config     => 'refined_global.pl',
    incumbent  => incumbent('search_local'),
    model_root => 'bt',
)

The executor maps local clear instance identifiers into global refined-lattice coordinates, rewrites result identities and cryptolinks consistently, and can translate the local incumbent into the global coordinate system.

merge($target, %args)

Combines compatible parent and refined experience on a common refined lattice.

merge('merged',
    id               => 'make_merged',
    parent           => 'base',
    refined          => 'refined_global',
    zoom_plan        => 'local/structuredesign-zoom.json',
    incumbent_policy => 'best_merged_scalar',
    config           => 'merged.pl',
    model_root       => 'bt',
)

Overlapping physical instances must have compatible result payloads. The refined state's canonical geometry is cloned into the merged state; merging changes accumulated experience, not the lattice geometry itself.

Do not specify both an explicit incumbent and incumbent_policy.

abstract($state, %args)

Compresses a represented landscape by clustering and medoid selection.

abstract('landscape',
    id               => 'abstract_landscape',
    source           => 'weightordmeta',
    results_file     => 'bt-report-0-0.csv_sortm.csv_weightordmeta.csv',
    lattice_manifest => 'structuredesign-scope.json',
    using            => clustering_and_finding_medoids(
                            selection => 'hierarchical_distortion'),
    output_dir       => 'abstract',
    output_prefix    => 'landscape-weightordmeta',
    model_root       => 'bt',
)

The installed abstraction executor delegates to Sim::OPT::ClusterMedoid. The supplied results file defines the landscape being clustered. Consequently, a medoid is an actual row of that landscape, but it is not necessarily a directly simulated row if the landscape itself is a surrogate weightordmeta representation.

The abstraction manifest records the selected medoids and the metric metadata needed by later reconstruction and statistical comparison.

The source string is provenance metadata. The operative dataset is selected by results_file.

retain_memory($state, %args)

Materialises the declarative memory passed from a completed abstraction. The retained object is not only the medoid set: every directly experienced result row is joined to its already-frozen cluster membership and stored with the corresponding medoid/category.

retain_memory('landscape',
    id              => 'retain_landscape_memory',
    abstraction     => result_of('abstract_landscape', 'manifest'),
    experience_file => 'bt-0_ordres.csv',
    experience_kind => 'direct_simulation',
    output_dir      => 'memory-retained',
)

experience_file must contain actual accumulated experience, not the surrogate landscape used for clustering. Cluster pertinence is inherited by exact instance identity from the frozen clustered landscape; retention does not recluster or reassign those experiences. A category is allowed to have zero direct support: its medoid remains a valid retained archetypal cue.

reconstruct_memory($target, %args)

Reactivates a retained abstraction into one shared compact memory workspace. The reconstruction semantics are selected by reconstruction_mode. This is an experimental/scientific choice and should be explicit in new procedures.

Two modes are available.

reconstruction_mode => 'legacy_medoid_only'

This reproduces the historical reconstruction used for the first recall runs. Only the abstraction medoids are retained as memory cues. They remain explicit star centres in a compact shared lattice derived from their source positions. Optional star_divisions adds an n>-equivalent evenly distributed set of auxiliary centres over that same recalled lattice; these auxiliary centres do not replace the medoids.

reconstruct_memory('memory',
    id                  => 'reconstruct_memory',
    reconstruction_mode => 'legacy_medoid_only',
    from                => 'landscape',
    source_config       => 'landscape.pl',
    abstraction         => result_of('abstract_landscape', 'manifest'),
    variables           => [1,2,3,4,5],
    star_divisions      => 3,       # optional enriched legacy probing
    model_root          => 'bt',
    memory_model_root   => 'btmed',
    executable          => "$ENV{HOME}/bt/opt",
)

No retained experiential packet is required or consumed in this mode. If a procedure also contains a memory argument, it is deliberately ignored by the legacy executor so that a comparison procedure can change only the mode switch. For the same reason cloud_star_divisions is accepted as an alias of star_divisions while legacy mode is selected.

reconstruction_mode => 'experiential_cloud'

This implements medoid-anchored experiential recall. The abstraction medoids remain privileged archetypal cues, but a retained memory packet also carries directly experienced points with their already-frozen category pertinence.

reconstruct_memory('memory',
    id                  => 'reconstruct_memory',
    reconstruction_mode => 'experiential_cloud',
    from                => 'landscape',
    source_config       => 'landscape.pl',
    abstraction         => result_of('abstract_landscape', 'manifest'),
    memory              => result_of('retain_landscape_memory', 'manifest'),
    variables           => [1,2,3,4,5],
    cloud_star_divisions => 3,      # optional enriched cloud probing
    model_root          => 'bt',
    memory_model_root   => 'btmed',
    executable          => "$ENV{HOME}/bt/opt",
)

The architecture is:

frozen categories + retained medoids + cluster-conditioned direct experience
    -> one compact shared source-grid-aligned memory lattice
    -> remembered direct rows seed the accumulated result set
    -> one mandatory reactivation star per medoid
    -> optional cloud-conditioned auxiliary stars
    -> one reconstructed surrogate landscape

The recalled scope is not expanded to the full antecedent lattice merely because remembered points span it. Retained experiential clouds position the compact window. If a category has direct remembered support but the nominal window would contain none of it, the planner expands only enough to admit at least one remembered point from that category. A category with zero direct support remains represented by its medoid alone.

cloud_star_divisions enriches renewed probing by selecting additional actual remembered experiences within each frozen category using deterministic maximin spatial coverage. These centres are therefore conditioned by the remembered cloud rather than cast uniformly across an invented common box.

Backward-compatible mode inference

Historical procedure files predate reconstruction_mode. To keep them replayable under one installed Sim::OPT version, omission of the switch is interpreted as follows:

memory => ... present     -> experiential_cloud
no memory argument        -> legacy_medoid_only

This inference exists only for backward compatibility. Procedures prepared for publication or new experiments should specify reconstruction_mode explicitly so the reconstruction semantics are directly inspectable.

Other useful arguments in both modes include medoid_limit, mediumiters, inherit_dowhat, source_config, model_root and memory_model_root.

The executor verifies the exact expected sampled union and the completeness of the reconstructed surrogate lattice according to the selected mode.

statistics($pair_name, %args)

Compares two represented landscapes and their abstractions.

statistics('source-memory',
    id                    => 'statistics_source_memory',
    left                  => 'source',
    right                 => 'memory',
    left_abstraction      => result_of('abstract_source', 'manifest'),
    right_abstraction     => result_of('abstract_memory', 'manifest'),
    right_memory_manifest => 'structuredesign-memory-local.json',
    left_model_root       => 'bt',
    right_model_root      => 'btmed',
    statistics_dir        => 'statistics',
    output_dir            => 'source-memory',
)

When the right-hand state is a compressed memory state, the memory manifest is used to map local memory coordinates back into source-lattice coordinates before comparison. Raw local memory instance names therefore must not be compared directly with source instance names.

The statistics executor records pointwise regression/error measures, categories based on direct versus surrogate status, globally matched medoid distances, set-level medoid measures, adjusted Rand index and aligned cluster agreement. It writes machine-readable JSON and CSV outputs.

compare($name, %args)

Performs direct-evidence validation between two states sharing physical instances and a prediction landscape.

compare('sparse_dense_validation',
    id               => 'validate_sparse_against_dense',
    left             => 'sparse',
    right            => 'dense',
    model_root       => 'bt',
    prediction_state => 'sparse',
    prediction_file  => 'bt-report-0-0.csv_sortm.csv_weightordmeta.csv',
    output_file      => 'structuredesign-validation.json',
)

Shared direct simulations are first required to agree within overlap_tolerance (default 1e-9). Right-only instances form the holdout set. Predictions for those instances are compared with their direct right-hand results on the left-hand normalization scale.

Optional count guards include expected_left_rows, expected_right_rows, expected_overlap_rows and expected_holdout_rows.

imagine($state, %args)

imagine is part of the article-facing language vocabulary. It represents "imagine by surrogating with ...". In module 0.25 the dedicated generic imagine configuration compiler is intentionally not installed. A committed imagine step therefore fails explicitly rather than silently running an incorrect surrogate operation.

Existing procedures obtain surrogate landscapes through supported Sim::OPT search/configuration variants and through memory reconstruction.

DESCRIPTOR CONSTRUCTORS

search(%args)

Returns an acquisition descriptor with kind => 'search'.

star(%args)

Returns an acquisition descriptor with kind => 'star'. The installed star-experience compiler uses StructureDesign star planning and validates the result count.

surrogate(%args)

Returns a generic surrogate descriptor. It is vocabulary-level infrastructure; not every descriptor has an independent committed executor.

surrogating_with($method, %args)

Article-facing surrogate descriptor retaining the named method.

medoids(%args)

Compatibility abstraction descriptor accepted by the installed abstraction executor.

clustering_and_finding_medoids(%args)

Preferred abstraction descriptor. The currently used selection policy is hierarchical_distortion when requested by the procedure. Parameters are passed through the generated ClusterMedoid configuration where supported.

clustering_and_medoiding(%args)

Backward-compatible alias for clustering_and_finding_medoids. New procedure files should use the latter spelling.

STRUCTURAL OPERATORS

These constructors are normally placed in a derive(..., by => [...]) array.

reduce_scope(%args)

Declares local scope reduction. Common arguments are variables and levels.

increase_resolution(%args)

Declares increased resolution. Common arguments are variables, factor, optional per-variable factors, and optional local_strides.

enlarge_scope(%args)

Declares scope enlargement. Common arguments are variables and factor.

maintain_resolution(%args)

Declares that enlargement should retain physical resolution for the listed variables.

pan(%args)

Declares a shift of the represented scope. around normally refers to an incumbent from an earlier step.

decrease_resolution(%args)

The constructor is part of the language vocabulary. The current derive executor does not install a general committed executor for an arbitrary decrease_resolution transformation. A procedure must therefore not assume that declaration alone implies executable support.

REFERENCE EXPRESSIONS

incumbent($step_id)

Creates a deferred reference to the incumbent result of a completed step.

around => incumbent('search_base')

The reference is resolved only during execution. The referenced step must be COMPLETE in the run manifest and must have recorded an incumbent.

result_of($step_id, $key)

Creates a deferred reference to a named result field of a completed step.

abstraction => result_of('abstract_source', 'manifest')

If $key is omitted, the default key is result.

CONFIGURATION VARIANTS AND INHERITANCE

Several state and experience operations can create a derived Sim::OPT configuration without hand-editing the generated file.

A config_variant can contain:

config_variant => {
    sweeps => [ [ '2>1', 2, 3, 4, 5 ] ],
    dowhat => {
        names             => 'short',
        metamodel         => 'y',
        convergeintomodel => 'y',
    },
}

The runtime patches the active @sweeps assignment and requested %dowhat keys, then validates that the generated text contains the requested values.

inherit_dowhat has the form:

inherit_dowhat => {
    from_state => 'base',
    config     => 'base.pl',
    keys       => [ 'canon' ],
}

Only the requested string-valued keys are inherited. An explicit value in config_variant.dowhat overrides the inherited value.

SIM::OPT SWEEP SYNTAX

The procedure language does not redefine Sim::OPT sweep semantics; it carries sweep declarations into generated configurations.

For this Sim::OPT codebase:

[ [ 1, 2, 3, 4, 5 ] ]

is one full-factorial sweep block over variables 1 through 5, whereas:

[ [1], [2], [3], [4], [5] ]

is sequential coordinate descent.

Subdivision star notation such as:

[ [ '2>1', 2, 3, 4, 5 ] ]

uses Sim::OPT's n> mechanism to generate star centres. Procedure code should not replace that mechanism with a hand-maintained external starpositions file unless an operator explicitly requires resolved star positions internally.

ABSTRACTION, EXPERIENCE AND SURROGATE LANDSCAPES

The dataset passed to abstract() determines what the medoids represent. Clustering bt-0_totres.csv selects medoids from directly accumulated result rows. Clustering a weightordmeta file selects medoids from the represented surrogate landscape. Such a medoid is an actual row of the clustered landscape, but it can correspond to a surrogate-predicted rather than directly simulated instance.

This distinction is intentional and should be preserved in scientific interpretation.

MEMORY RECONSTRUCTION SEMANTICS

Memory reconstruction treats retained medoids as privileged retrieval cues and retained direct cluster members as experiential support. It does not store one independent model workspace per medoid. The support clouds choose and, when needed, minimally enlarge one compact shared lattice. Direct remembered rows inside that lattice seed the result set before renewed probing, after which one reconstructed surrogate landscape is produced.

The source-to-memory mapping, seed provenance, category-conditioned support counts and auxiliary cloud centres are recorded in the memory manifest. Downstream recall classification applies the frozen antecedent category model; it does not refit clusters or move medoids.

cloud_star_divisions controls renewed probing density. It does not redefine the retained categories or medoids.

DRY RUNS AND EXECUTION

load_procedure($file)

Loads a procedure file and verifies its top-level schema.

run_procedure($procedure, %options)

Without commit => 1, the runtime performs a dry plan. It reports the declared operations without executing Sim::OPT or requiring downstream results that can exist only after earlier committed steps.

Common options:

commit

Execute rather than only plan.

from

Resume from a named step ID. Every enabled prerequisite step before from must be recorded as complete with the same step signature and with required artifacts still present.

only

Select only one step ID after normal manifest safety checks.

force

Allow a completed step to be rebuilt instead of reused. This does not waive operator-specific refusal to overwrite an existing target directory.

accept_runtime_change

With an explicit from, accept a manifest difference caused only by a changed StructureDesign runtime. Completed prerequisite declarations are still checked.

accept_tail_change

With an explicit from, accept a procedure declaration change in the selected step or later tail, provided earlier prerequisite step signatures still match.

RUN MANIFEST AND CHECKPOINTING

The default run manifest is stored under:

<root_dir>/.structuredesign/<procedure-name>.json

It records the procedure signature, runtime signature, step status, timestamps, step signatures and results returned by completed operators.

A procedure/runtime mismatch is treated conservatively. Unless an explicitly supported partial-resume exception is requested, a committed full run archives the stale manifest and generated states before starting a new run. Partial runs are rejected when the manifest cannot prove their prerequisites safe.

The runtime also verifies required artifacts for checkpointed abstractions, comparisons and reconstructed memories before treating their COMPLETE status as reusable.

FILESYSTEM SAFETY

Structural operators that create new states normally refuse to overwrite an existing target directory. This is separate from checkpoint policy. force controls checkpoint reuse; it is not a general filesystem overwrite switch.

Generated configuration variants are validated before or after materialization as appropriate. Geometry manifests are treated as part of the state contract, not merely as informal logs.

OUTPUT AND PROVENANCE ARTIFACTS

Depending on the operators used, a procedure can create:

  • state directories and generated Sim::OPT configuration files

  • zoom, re-embedding, merge, scope and memory manifests

  • direct totres result files

  • surrogate weightordmeta landscapes

  • clustering/medoid abstractions

  • comparison and validation JSON

  • landscape, medoid and cluster statistics in JSON/CSV form

  • the top-level procedure run manifest

These artifacts are part of the executable provenance of the procedure.

IMPLEMENTATION STATUS

The language vocabulary is intentionally somewhat broader than the installed executor set. Module 0.27 installs committed execution for the step families used by the current StructureDesign production workflows: state creation and cloning, search/star experience, the two supported derive families, re-embedding, merge, clustering/medoid abstraction, experiential-memory retention, frozen-category application, shared-memory reconstruction, statistics and comparison.

The generic imagine executor and arbitrary combinations involving decrease_resolution are represented but deliberately fail rather than being silently approximated by a different operation.

This distinction between a language construct and an installed executor should be maintained when the language is extended.

EXTENDING THE LANGUAGE

A new language operator should normally have three parts:

1. A small constructor that records intent without side effects.
2. An executor or compiler that validates the declaration and delegates geometry or workspace mechanics to the appropriate Sim::OPT module.
3. Manifest/provenance output sufficient to reproduce and validate the resulting state transition.

New experimental choices should be exposed as procedure arguments rather than embedded as fixed behavior in the runtime when more than one scientifically meaningful policy is possible.

COMPLETE PUBLIC EXPORT SET

Module 0.27 offers the following symbols through @EXPORT_OK:

design
state
experience
derive
reembed
merge
imagine
abstract
retain_memory
apply_abstraction
compare
statistics
reconstruct_memory

search
star
surrogate
medoids
surrogating_with
clustering_and_finding_medoids
clustering_and_medoiding

reduce_scope
enlarge_scope
increase_resolution
decrease_resolution
pan
maintain_resolution

incumbent
result_of

procedure_language_version
procedure_schema

load_procedure
run_procedure

Nothing is exported by default.

RELATION TO Sim::OPT::StructureDesign

This module is the procedure-language and execution-orchestration layer. Sim::OPT::StructureDesign is the lower-level geometric planner, mapping and workspace-construction engine. Procedure files should normally call the public constructors in this module rather than invoking private geometric helpers directly.

RELATION TO Sim::OPT::ClusterMedoid

abstract() with clustering_and_finding_medoids() delegates clustering and medoid selection to Sim::OPT::ClusterMedoid. Cluster-selection algorithms and dissimilarity mechanics are therefore implementation choices of the abstraction operator rather than syntax of the procedure language itself.

RECOMMENDED TERMINOLOGY

For technical documentation, the most precise description is:

Sim::OPT StructureDesign Procedure Language

or:

a Perl-embedded domain-specific language (DSL) for StructureDesign procedures

A particular *-procedure.pl file is a program written in that language.

DOCUMENTATION PROVENANCE

This manual was initially drafted with the assistance of ChatGPT (OpenAI) from the source code of Sim::OPT::StructureDesignProcedure, Sim::OPT::StructureDesign and the associated production procedure. The technical descriptions were checked against the implementation during drafting. Responsibility for the final software and documentation remains with the software author and maintainer.

SEE ALSO

Sim::OPT::StructureDesign, Sim::OPT::ClusterMedoid, perldoc, and the procedure examples distributed with this module.