Supplementary · Task 1

SoftSky — Apartment MCDA

Designing a tolerant-Pareto, constellation-finding workflow for ~12,800 Leipzig rental offers, under four scaffold conditions.

1The shared design brief

Every variant for this task received the identical brief below; only the ATWL scaffold material in the context differed.

The design brief (click to expand)

I am developing a visual analytics approach for supporting multi-criteria decision analysis. I search for a publicly available data set consisting of at least 1,000 decision options characterized by at least 7-12 criteria. I selected data set: https://www.kaggle.com/datasets/corrieaar/apartment-rental-offers-in-germany (used in paper https://diglib.eg.org/handle/10.2312/evs20261003, attached). A cleaned subset for Leipzig (12845 georeferenced options) has the following header: regio1,serviceCharge,heatingType,newlyConst,balcony,totalRent,yearConstructed,hasKitchen,cellar,baseRent,livingSpace,condition,interiorQual,lift,typeOfFlat,geo_plz,noRooms,floor,numberOfFloors,garden,regio2,regio3,date,pricePerSqm,lat,lng,geoLevel Sachsen,346.0,central_heating,0,1,1946.0,,0,0,1600.0,140.0,first_time_use_after_refurbishment,,1,roof_storey,04229,4.0,0.0,,1,Leipzig,Lindenau,Oct19,11.43,51.331742,12.327071,house ...

The key area of implementation: 1. User selects geo center, the system shows a graph of N items depending on the distance (say, up to 50km) 2. After loading the selected set, user selects which attributes are to be used as criteria. At this stage of development, we’ll use only numeric features. 3. The user defined utility functions, seeing distribution histograms as a background. 4. The system computes Pareto frontier and adds distance to it as an extra feature for all options. 5. To find groups of options with similar property and utility, (a) clustering and (b) NMF topic modelling are used. The overall idea is to separate search into stages: identifying relevant sectors of interest, and then ranking and sensitivity analysis. Please critically assess this plan. I worked on spatial MCDA for many years, see https://geoanalytics.net/and/papers/ivs03.pdf and https://geoanalytics.net/and/papers/jds03.pdf and https://geoanalytics.net/and/papers/ijgis01.pdf. Now I want to extend traditional approaches by (1) identifying subgroups of interest based on multiple features (e.g. separating palaces from house from apartments from studios etc), defining them flexibly using criteria of interest; and (2) tolerating Pareto optimally because of data imperfections and potential incompleteness. Please design a Visual Analytics workflow. Our focus is scientific novelty, we have no goal to provide a comprehensive system for end-users. Implementation will be only a demonstrator.

2Cross-variant comparison

After the four single-pass runs, the model was asked to compare them. Its full assessment, including the summary tables, is reproduced verbatim.

Comparison prompt

Critically assess and compare 4 variants that differ in starting conditions (no ATWL, ATWL landg description, ATWL library, both). I need a summary table contrasting obtained results

Model’s internal reasoning (think block)

The user wants me to critically assess and compare 4 variants of a Visual Analytics workflow design for spatial MCDA, where the variants differ in their starting conditions regarding ATWL (Analytical Task and Workflow Language):

1. **No ATWL** (fhgeniechat_1782295355521.json) - No ATWL language definition or library provided
2. **ATWL language description** (fhgeniechat_1782295362504.json) - Only the ATWL language definition attached
3. **ATWL library** (fhgeniechat_1782295369832.json) - Only the ATWL workflow descriptors library attached


4. **Both** (fhgeniechat_1782295374448.json) - Both ATWL language definition and library attached

The user wants a summary table contrasting the results. Now I'm examining each variant to understand how the presence or absence of ATWL resources shaped the workflow designs—starting with the baseline where no ATWL was provided, which produced a free-form design with ASCII diagrams, structured phases, implementation suggestions, and usage scenarios.

With just the ATWL language definition, the output became much more formal and systematic, using YAML-like notation to specify artifacts, transforms, and loops with detailed feature specifications and value types. The presentation was more verbose but clearly organized across seven phases with a novelty assessment table included.

When I add the library of workflow descriptors on top of that, the structure shifts slightly—I'm still using ATWL notation but now with a workflow template at the top, different loop structures like L_utility_definition and L_decomposition, and a visual ASCII diagram showing the progressive narrowing concept. The dual decomposition approach (feature-based clustering plus utility-based NMF) becomes more explicit here.

Combining both the language definition and the library together produces the most comprehensive version—a formal ATWL specification with a workflow template, critical assessment section upfront, and five clearly defined phases with detailed artifact and transform definitions throughout.

Now I'm systematically comparing all these variants across key dimensions like structure, critical assessment quality, how well they articulate scientific novelty, workflow completeness, formalization level, practical implementation guidance, iterativeness, and overall length and detail.

Critical Comparison of 4 Workflow Design Variants

Variant Overview

ID	File	Starting Condition	ATWL Scaffold
V1	`…355521.json`	No ATWL	None
V2	`…362504.json`	ATWL language definition only	Language grammar/syntax
V3	`…369832.json`	ATWL library only	Example workflow descriptors
V4	`…374448.json`	Both language + library	Language + examples

Summary Comparison Table

Dimension	V1 (No ATWL)	V2 (ATWL Lang)	V3 (ATWL Library)	V4 (Both)
Output format	Free-form prose, ASCII diagrams, tables	Formal ATWL YAML spec	Formal ATWL YAML spec + ASCII summary diagram	Formal ATWL YAML spec
Critical assessment depth	Compact table (6 issues), direct	Detailed table (8 issues) with mitigations	Extended table (6 issues) with detailed recommendations	Structured table (6 issues) with "Concerns and Recommendations"
Workflow phases	5 phases (Spatial → Utility → Subgroup → Pareto → Ranking)	7 phases (Spatial → Criteria → Utility loop → Pareto → Decomposition loop → Subgroup selection → Synthesis)	8 steps (Spatial → Criteria → Utility loop → Pareto → Dual decomposition loop → Subgroup selection → Ranking → Synthesis)	5 phases (Spatial → Criteria/Prep → Main loop → Within-subgroup → Synthesis)
Formalization level	Low — informal descriptions	High — full ATWL with typed artifacts, features, value structures	High — full ATWL with typed artifacts, embedment, etc.	High — full ATWL with typed artifacts
Loop/iteration structure	Implicit (diagram shows arrows back)	2 explicit loops: `L_criteria_utility`, `L_explore`	2 explicit loops: `L_utility_definition`, `L_decomposition`	1 large loop `L_analysis` with nested conditional
NMF framing	"Archetypal property profiles" (strongest justification table: NMF vs. PCA vs. k-means vs. AA)	"Latent topics / property profiles" with soft membership	"Trade-off archetypes" with dual role (clustering = structural, NMF = evaluative)	"Topic-like apartment profiles" (latent types as weighted feature combinations)
Pareto treatment	Pareto depth layers + ε-dominance; most detailed formulation (3 steps)	ε-dominance + continuous distance-to-frontier; missing-value handling via partial dominance	ε-dominance + Pareto distance + aggregate score; handles partial dominance	ε-dominance depth layers + distance-to-ideal; within-cluster and global
Distance role clarity	Treated as first-class criterion with own utility	Explicit choice: criterion vs. filter (stated in S_criteria)	Explicit choice: criterion vs. filter (in S_criteria)	Raises the issue but leaves it partially ambiguous
Dual decomposition concept	Not explicit (NMF only; clustering mentioned briefly)	Separation: clustering = hard partitions for map; NMF = soft memberships for understanding	Strongest: explicit "dual decomposition" — clustering in feature space (what IS it?) vs. NMF in utility space (how GOOD is it?)	Both present but relationship less articulated; both operate on utility space
Visualization specifications	Informal (radar charts, maps, bump charts listed)	Formal ATWL visualization artifacts with layout/form/encoding	Formal ATWL with detailed encoding specs	Formal ATWL with detailed encoding specs
Sensitivity analysis	Included: weight perturbation → bump chart	Included: weight perturbation + utility perturbation, stability indices	Included: weight perturbation + utility perturbation, critical thresholds	Included: parameter perturbation with robustness indicators
Usage scenario	Yes — full "Anna" narrative	No	No	No
Implementation guidance	Yes — tech stack (D3, FastAPI, scikit-learn)	No	No	No
Novelty claims	4 numbered contributions	Table mapping novelty → workflow elements	Table mapping novelty → workflow elements → key artifacts	Table mapping novelty → workflow location → extension of prior work
Handling of categoricals	Acknowledges limitation; suggests ordinal encoding	Suggests ordinal encoding; defines ordinal type in artifacts	Suggests encoding as binary dummies; notes demonstrator would benefit	Suggests min-max scaling; raises issue but defers
Missing values	Mentioned briefly	Explicit: partial dominance rule in S_pareto_tolerance	Explicit: impute or flag; partial dominance for Pareto	Mentions imputation; partial dominance
Workflow ordering concern	Not raised	Not raised	Not explicitly raised	Raised: utility before subgroups creates chicken-and-egg problem; recommends iteration
Overall length	~950 words	~3,200 words	~3,500 words	~3,000 words

Detailed Assessment by Quality Dimension

1. Conceptual Clarity & Scientific Framing

Variant	Assessment
V1	Best high-level conceptual clarity. The free-form format allowed a clearer narrative arc. The NMF justification table (NMF vs. PCA vs. k-means vs. Archetypal Analysis) is the most rigorous methodological argument across all variants. The usage scenario grounds abstract concepts.
V2	Good scientific framing but the formalization absorbs attention. The separation of "criteria selection" as its own loop is logically clean.
V3	Best articulation of dual decomposition — the explicit distinction between feature-space clustering ("what IS the apartment?") and utility-space NMF ("how GOOD is it for the user?") is the strongest conceptual contribution unique to this variant.
V4	Identifies the workflow ordering problem (utility before subgroups), which no other variant raises. However, the single large loop obscures the progressive narrowing logic.

2. Formalization & Reproducibility

Variant	Assessment
V1	Insufficient for formal workflow specification. Another researcher could not re-implement from this alone.
V2	Most comprehensive formal specification. Every artifact has typed features, every transform has input/output/actor. The conditional branching is clearly expressed.
V3	Comparable to V2 in formalization. Adds a helpful ASCII summary diagram bridging the formal spec and intuitive understanding.
V4	Well-formalized but slightly less detailed on individual artifact features than V2.

3. Novelty Identification

Variant	Unique Novelty Points Raised
V1	Pareto depth as parameter-free quality stratification; ε linked explicitly to data quality (not just preference imprecision)
V2	Progressive narrowing workflow architecture; explicit handling of missing data via partial dominance rules
V3	Dual decomposition (structural vs. evaluative); cluster–topic cross-tabulation as an analytical view
V4	Iterative utility↔subgroup co-refinement (most explicit about the chicken-and-egg problem)

4. Practical Weaknesses

Variant	Key Weakness
V1	No formal specification — difficult to validate completeness or translate to implementation without interpretation
V2	Over-specifies early phases (spatial filter, criteria selection) at the expense of later ones; Phase 7 (synthesis) is thin
V3	The dual decomposition is conceptually strong but operationally heavy — running both clustering and NMF on different spaces doubles the analytical/visual complexity for the demonstrator
V4	The single-loop structure conflates utility definition, subgroup discovery, and Pareto analysis into one iteration, making it harder to tell which sub-problem drives each refinement

Key Differentiators Attributable to Starting Conditions

Effect	Explanation
No ATWL → most creative, least formal	V1 produced the broadest conceptual exploration (usage scenario, tech stack, method comparison table). Freed from scaffolding constraints, the response explored the design space rather than filling a template.
Language definition → most rigorous specification	V2 followed the ATWL grammar most faithfully, producing maximally typed and structured artifacts. The language definition constrained but also disciplined the output.
Library examples → best conceptual architecture	V3 drew structural inspiration from example workflows, producing the dual-decomposition concept and the most architecturally sophisticated workflow design. Examples prompted pattern-level thinking.
Both → most self-critical but somewhat constrained	V4, receiving both scaffolds, produced a competent specification but showed slight "template-filling" behavior — less conceptual freshness than V1 or V3. The chicken-and-egg observation is its unique insight.

Recommendation

For a scientific paper, the optimal strategy would combine:

V1's critical assessment framing + usage scenario + method comparison table
V3's dual decomposition concept (feature-space clustering vs. utility-space NMF)
V2's formalization rigor for the actual workflow specification
V4's observation about iterative co-refinement of utilities and subgroups

No single variant is sufficient alone. V1 is strongest for motivation and positioning, V3 for conceptual architecture, and V2 for formal specification. V4 adds a critical design insight but contributes least independently.

3The four variant transcripts

The complete single-pass output under each condition. Expand a panel to read it; the model’s internal reasoning is nested inside.

V1 · no ATWL Variant V1 — no scaffold

Model’s internal reasoning (think block)

The user is an experienced researcher in spatial MCDA (Multi-Criteria Decision Analysis) who wants to design a Visual Analytics workflow for a scientific demonstrator. They have a specific dataset (apartment rentals in Germany, Leipzig subset) and a clear vision of what they want to achieve. Let me critically assess their plan and then design a comprehensive VA workflow.

Let me analyze their background:
- They have papers on spatial MCDA from early 2000s (Andrienko et al.)
- They want to extend traditional approaches with: (1) flexible subgroup identification, and (2) tolerance of Pareto optimality due to data imperfections
- This is for a scientific paper/demonstrator, not a production system


- Their dataset is well-suited with 12,845 georeferenced apartments and 7-12+ usable criteria, and the spatial filtering approach provides a natural entry point
- The utility function definition with histogram backgrounds and Pareto frontier computation are solid foundations, though using NMF for topic modeling on numeric apartment data is unconventional and might need rethinking
- The high-dimensional Pareto frontier will likely include a large fraction of data points due to the curse of dimensionality, which aligns with their tolerance concept but needs formalization—perhaps through ε-dominance or Pareto depth layers
- The workflow feels somewhat linear when it should be iterative, and the connection between clustering results and actual decision-making needs clearer articulation
- I should design a VA workflow that emphasizes scientific novelty, particularly around flexible criteria-driven subgroup identification rather than predefined categories

, tolerant Pareto analysis with ε-dominance or layering, spatial context integration through progressive refinement, and using NMF to decompose options into archetypal property profiles

I'm structuring this into five phases: spatial scoping and data loading, feature selection with utility definition, subgroup identification as the novel core, tolerant Pareto analysis, and comparative ranking with sensitivity testing.

Critical Assessment

Strengths

Dataset suitability: 12,845 options × 12+ attributes is a good scale — large enough to necessitate visual analytics, small enough for interactive exploration.
Two-stage search (subgroup identification → ranking) is a genuine conceptual advance over flat MCDA lists.
Tolerating Pareto optimality addresses a real and underexplored problem: in 7–12 dimensions, the Pareto shell typically contains 60–90% of all points, making it nearly useless as a filter.

Concerns

Issue	Detail	Suggested Mitigation
Pareto curse of dimensionality	With 7–12 criteria, almost everything is non-dominated	Use Pareto depth layers (shells) or ε-dominance
NMF justification	NMF assumes additive non-negative generative model — reasonable for prices/areas, but semantics of "topics" in apartment data must be argued carefully	Frame as archetypal property profiles, not topics; compare with PCA/Archetypal Analysis
Linearity of workflow	Plan reads sequentially; VA strength is iteration	Design explicit feedback loops
Numeric-only restriction	`condition`, `interiorQual`, `heatingType` are ordinal/categorical and often decision-critical	Encode ordinals numerically; note limitation for categoricals
Utility function elicitation	Piecewise-linear utility per criterion assumes preferential independence	Acceptable for demonstrator, but state the assumption
Clustering stability	k-means/DBSCAN on mixed utility+property space can be sensitive to normalization	Use utility-transformed space; report silhouette/stability

Proposed Visual Analytics Workflow

Conceptual Architecture

┌─────────────────────────────────────────────────────────────┐
│                   ITERATIVE VA LOOP                          │
│                                                             │
│  ┌──────────┐    ┌──────────────┐    ┌────────────────┐    │
│  │ SPATIAL  │───▶│  SUBGROUP    │───▶│   TOLERANT     │    │
│  │ SCOPING  │    │  DISCOVERY   │    │   PARETO       │    │
│  └──────────┘    └──────────────┘    └────────────────┘    │
│       ▲                                      │              │
│       │          ┌──────────────┐            │              │
│       └──────────│  SENSITIVITY │◀───────────┘              │
│                  │  & RANKING   │                           │
│                  └──────────────┘                           │
└─────────────────────────────────────────────────────────────┘

Phase 1: Spatial Scoping & Feature Selection

Goal: Define the option set and criteria space.

Interactions: - Select geo-center on map + distance slider → dynamic count indicator - Toggle/select numeric attributes as criteria (show completeness %) - Distance itself becomes a meta-criterion (auto-added)

Views: - Map with point density heatmap - Attribute completeness matrix (to justify exclusions)

Novelty note: Distance is not merely a filter but a criterion with user-defined utility (e.g., non-linear decay).

Phase 2: Utility Definition with Distributional Context

Goal: Transform raw criteria into commensurate utility scales [0, 1].

Interactions: - For each selected criterion, display a histogram (or KDE) of the current spatial subset - User draws/adjusts piecewise-linear utility function overlaid on the histogram - Support three presets: minimize, maximize, target-value (tent function)

Views: - Small-multiple panel: one histogram + utility curve per criterion - Parallel coordinates of raw values (before transformation) to show correlations

Output: Utility matrix U ∈ [0,1]^{n×m} where n = options, m = criteria.

Phase 3: Subgroup Discovery (Scientific Core — Novelty 1)

Goal: Identify structurally distinct segments of the option space, defined flexibly by the criteria the user chose — not by predefined flat types.

3a. NMF Archetypal Decomposition

Decompose U ≈ W · H where: - H ∈ ℝ^{k×m}: k archetypal utility profiles (interpretable as "what a good palace looks like" vs. "what a good studio looks like") - W ∈ ℝ^{n×k}: soft membership (each option is a mixture of archetypes)

Key design choices: - Apply NMF to the utility-transformed matrix (not raw), so archetypes reflect user preferences - Use k = 3–7 (selectable via reconstruction-error elbow plot) - Visualize H rows as stacked bar profiles: immediately interpretable

Rationale vs. alternatives:

Method	Advantage	Disadvantage
k-means	Hard clusters, simple	No profile interpretation, spherical assumption
PCA	Orthogonal factors	Allows negatives → uninterpretable mixing
NMF	Parts-based, non-negative, additive	Needs non-negativity (satisfied by utility space)
Archetypal Analysis	Extreme points	Sensitive to outliers

3b. Soft Clustering via W Thresholding

Assign dominant archetype: cluster(i) = argmax_j W[i,j]
Retain mixture coefficient for opacity/saturation encoding on map
Allow user to merge or split archetypes interactively

Views (Phase 3):

Archetype profile panel: radar charts or stacked bars for each archetype's H row
Map: options colored by dominant archetype, saturation ∝ membership strength
Scatterplot (UMAP/t-SNE of U): colored by archetype, supports lasso selection
Parallel coordinates of U: one color per archetype, user can brush

Interaction loop: User inspects archetypes → decides one or two are of interest → narrows the working set → returns to Phase 2 or proceeds to Phase 4.

Phase 4: Tolerant Pareto Analysis (Scientific Core — Novelty 2)

Goal: Replace binary dominated/non-dominated with a graded notion of optimality.

Formal approach: Pareto Depth + ε-Bands

Compute Pareto depth layers (shell 0 = frontier, shell 1 = frontier of remainder, etc.)
Introduce ε-dominance: option a ε-dominates b iff ∀j: u_j(a) ≥ u_j(b) − ε_j - ε per criterion is user-controllable (slider linked to histogram showing how many options survive)
Define Pareto grade ∈ [0, 1]: normalized depth / max depth (0 = frontier, 1 = worst layer)

Why this is novel in VA context: - Classical spatial MCDA (including your earlier work) uses weighted sums or outranking — Pareto depth layers give a parameter-free quality stratification - ε-tolerance explicitly models data imprecision: if rent is ±30€ unreliable, set ε_rent = 30/range

Views (Phase 4):

Depth-layer map: choropleth-style coloring by Pareto grade, within each archetype
Depth histogram: how many options per layer — user sets a "tolerance cut" to select top-k layers
Pairwise scatterplot matrix (of top criteria): color by depth, Pareto frontier curve drawn

Interaction: User adjusts ε-sliders and observes how the "acceptable set" grows/shrinks on map and scatterplots.

Phase 5: Comparative Ranking & Sensitivity

Goal: Within the narrowed set (archetype × Pareto-grade filter), rank and validate.

Methods: - Weighted-sum with user weights (traditional, baseline) - TOPSIS on the utility matrix subset - Sensitivity: perturb weights ±10% → show rank-reversal instability via bump chart

Views: 1. Ranked list with sparklines per criterion 2. Bump chart: rank vs. weight perturbation scenario 3. Map highlight: top-5/10 options with detail-on-demand

Summary of Scientific Contributions

#	Contribution	How demonstrated
1	Criteria-driven flexible subgrouping via NMF on utility space	Archetypes correspond to meaningful housing segments without predefined categories
2	Tolerant Pareto analysis via depth layers + ε-dominance	Overcomes Pareto curse; ε linked to data quality
3	Integrated spatial–multivariate VA loop	Subgroups have spatial coherence visible on map; distance is a first-class criterion
4	Two-stage decision narrowing	Demonstrably reduces cognitive load vs. flat ranking of 12,845 options

Suggested Implementation Stack (Demonstrator)

Frontend:  D3.js / Vega-Lite (plots) + Leaflet/MapLibre (map)
Backend:   Python (FastAPI)
Analytics: scikit-learn (NMF, clustering), NumPy (Pareto depth computation)
Data:      Pre-cleaned CSV loaded in-memory; spatial index via scipy.spatial.cKDTree

One Final Recommendation

Consider a usage scenario narrative structured as:

"Anna is searching for a 3–4 room apartment in Leipzig within 8 km of the university. She cares about low rent, large living space, good condition, and a balcony. The system identifies 4 archetypes: luxury large flats, renovated mid-range, old unrenovated cheap, and small modern studios. Anna selects the 'renovated mid-range' archetype. Within it, ε-tolerant Pareto analysis surfaces 23 near-optimal options across 3 depth layers. She adjusts ε for rent (±50€) recognizing advertised prices are negotiable, and examines sensitivity of her top-5 to weight changes."

This grounds the novelty claims in a reproducible, publishable case study with clear before/after comparison to flat weighted-sum baseline.

V2 · language Variant V2 — ATWL language definition only

Model’s internal reasoning (think block)

The user is asking me to:

1. Critically assess their plan for a visual analytics approach for multi-criteria decision analysis (MCDA) applied to apartment rental data
2. Design a Visual Analytics workflow using ATWL (Artifact-Transform Workflow Language) as a scaffold

Let me first critically assess the plan, then design the ATWL workflow.

**Critical Assessment:**

The plan has several strengths and some areas that need attention:

Strengths:
- The dataset is well-suited (12,845 options, many criteria)
- Spatial MCDA is well-motivated
- The idea of separating search into stages (identifying sectors, then ranking) is sound


- Using a Pareto frontier with tolerance for imperfect data is a thoughtful approach
- Combining clustering and NMF for subgroup identification adds depth

Now looking at potential concerns: the geo-center and distance filtering in step 1 is solid, but step 2's restriction to numeric features might lose valuable information from ordinal and categorical attributes like condition or heating type. Step 3's utility function approach is transparent but I'm wondering about cognitive load—defining utility functions across 7-12 criteria could overwhelm users. For step 4, with that many criteria, the Pareto frontier will likely become quite large, which could undermine the filtering benefit.

The scientific novelty here centers on combining flexible subgroup identification with Pareto analysis, tolerating Pareto optimality when data imperfections arise, and using a staged approach across sectors and ranking. Now I'm mapping out the actual workflow: spatial selection where users pick a geo-center and filter by distance, then criteria configuration for numeric features, utility function definition with histogram support, Pareto frontier computation, clustering and NMF for identifying subgroups, and finally ranking with sensitivity analysis within those subgroups.

Writing the ATWL workflow... I'm mapping out the remaining workflow phases: spatial filtering to extract relevant options, then criteria selection where the user defines utility functions and visualizes their distributions, followed by Pareto analysis that computes distances to the frontier with configurable tolerance levels, and finally subgroup identification through clustering and topic modeling to discover natural groupings within the data.

Now I need to write out the full ATWL specification, starting with a critical assessment before laying out the complete workflow.

Critical Assessment

Strengths

Well-chosen dataset: 12,845 options with 12+ attributes is a solid testbed — large enough for meaningful Pareto analysis and subgroup discovery, yet manageable for interactive exploration.
Staged analysis is scientifically sound: Separating "identify relevant sectors" from "rank and refine within a sector" addresses a genuine cognitive scalability problem in MCDA. With 12 criteria, virtually all items become Pareto-optimal (the well-known "curse of dimensionality in Pareto analysis"), so any mechanism that reduces the effective comparison set before ranking is valuable.
Building on your prior work: The spatial MCDA foundations (CommonGIS-based interactive maps with criterion weighting, Pareto-based filtering, sensitivity analysis) provide a rigorous baseline from which to advance.
Tolerance of Pareto optimality: This is a genuine and under-explored scientific contribution. Real-world data has measurement noise, missing values (e.g., yearConstructed is often blank), and subjective criteria — treating the Pareto frontier as a hard boundary is epistemologically questionable.

Concerns and Suggestions

#	Issue	Recommendation
1	Pareto inflation: With 7–12 criteria, the Pareto frontier will contain 60–90% of all options, rendering it uninformative as a filter.	Use ε-dominance or distance-to-frontier as a continuous ranking signal rather than a binary membership. This becomes your "tolerance" mechanism and should be a primary novelty claim.
2	Restricting to numeric features loses important structure. Attributes like `heatingType`, `condition`, `interiorQual`, `typeOfFlat` carry strong preference information.	Allow ordinal encoding (user-defined ordering of categorical levels, which is itself a utility specification) so that ordinal/categorical criteria can participate without full generality.
3	NMF on what matrix? The method requires a non-negative matrix — are you applying it to the raw feature matrix, the utility matrix, or a binary indicator matrix? Each choice yields different "topics."	Clarify the semantics: NMF on the utility-transformed feature matrix would yield interpretable "property profiles" (e.g., a "luxury" topic = high rent + good condition + lift + new construction). This is more meaningful than raw features.
4	Relationship between clustering and NMF is unclear. Both produce groupings — how do they complement each other?	Position clustering as producing hard partitions (for spatial/map views) and NMF as producing soft topic memberships (for understanding what drives similarity within/across clusters). The mixed-membership property of NMF is the differentiator.
5	Utility function definition for 7–12 criteria is cognitively demanding.	Provide defaults (monotone increasing/decreasing based on common sense) and let users refine only those they disagree with. Histogram backgrounds are excellent; add cumulative distribution option for threshold-based utilities.
6	Distance to geo-center as "extra feature" conflates spatial preference with property preference.	Keep distance as a separate filtering/weighting dimension visible on the map, rather than injecting it into the Pareto computation (which changes dominance semantics). Alternatively, let the user choose whether distance participates in Pareto analysis or remains a filter.
7	Missing values are pervasive (yearConstructed, numberOfFloors, serviceCharge).	Explicitly address this in the workflow: either impute, exclude incomplete options from Pareto computation, or use partial dominance (only compare on shared non-missing criteria). This connects to your "tolerance" narrative.
8	Validation/evaluation for a demonstrator paper.	Since there is no ground-truth "best apartment," consider (a) synthetic scenarios with known Pareto structure, (b) usage scenarios with domain reasoning, (c) comparison against naïve approaches (full Pareto, simple weighted sum).

On Scientific Novelty

Your strongest novelty claims are: - Subgroup-first MCDA: defining flexible typologies before ranking (inverting the traditional "weight → rank → explore" pipeline). - Pareto tolerance: continuous distance-to-frontier with explicit handling of data imperfections. - NMF-based property profiles: mixed-membership decomposition as a complement to hard clustering for characterising option "types."

A weaker novelty claim would be the interactive histogram-based utility definition (well-established in decision support) or the spatial filtering (standard GIS operation).

ATWL Workflow Specification

workflow spatial-mcda-subgroups
template: define-unit (spatial selection) →
  loop(generate-knowledge (criteria & utility specification) →
       characterise (utility computation) →
       characterise (Pareto analysis) →
       define-unit (subgroup identification) →
       build-model (NMF topic modelling) →
       visualise → abstract → assess) →
  generate-knowledge
description: "Visual analytics workflow for multi-criteria decision analysis
  of geo-referenced apartment rental options. Supports flexible subgroup
  identification via clustering and NMF, Pareto-tolerant ranking, and
  iterative refinement of criteria and subgroup definitions."

Exogenous Artifacts

artifact D_all : entities
  origin: given
  internal structure: elementary
  embedment: {set, space}
  features:
    - id: baseRent
      value structure: atomic
      value type: numeric
      description: "Base monthly rent (EUR)"
    - id: totalRent
      value structure: atomic
      value type: numeric
      description: "Total monthly rent including service charges (EUR)"
    - id: livingSpace
      value structure: atomic
      value type: numeric
      description: "Living area in square metres"
    - id: noRooms
      value structure: atomic
      value type: numeric
      description: "Number of rooms"
    - id: floor
      value structure: atomic
      value type: numeric
      description: "Floor number"
    - id: numberOfFloors
      value structure: atomic
      value type: numeric
      description: "Total floors in building"
    - id: yearConstructed
      value structure: atomic
      value type: numeric
      description: "Year of construction"
    - id: pricePerSqm
      value structure: atomic
      value type: numeric
      description: "Rent per square metre (EUR)"
    - id: serviceCharge
      value structure: atomic
      value type: numeric
      description: "Monthly service charge (EUR)"
    - id: balcony
      value structure: atomic
      value type: categorical
      description: "Balcony presence (binary)"
    - id: hasKitchen
      value structure: atomic
      value type: categorical
      description: "Kitchen presence (binary)"
    - id: cellar
      value structure: atomic
      value type: categorical
      description: "Cellar presence (binary)"
    - id: lift
      value structure: atomic
      value type: categorical
      description: "Lift presence (binary)"
    - id: garden
      value structure: atomic
      value type: categorical
      description: "Garden presence (binary)"
    - id: newlyConst
      value structure: atomic
      value type: categorical
      description: "Newly constructed (binary)"
    - id: condition
      value structure: atomic
      value type: ordinal
      description: "Apartment condition (ordinal categories)"
    - id: interiorQual
      value structure: atomic
      value type: ordinal
      description: "Interior quality (ordinal categories)"
    - id: typeOfFlat
      value structure: atomic
      value type: categorical
      description: "Type of flat (e.g., roof_storey, ground_floor, apartment)"
    - id: heatingType
      value structure: atomic
      value type: categorical
      description: "Heating type"
    - id: lat
      value structure: atomic
      value type: spatial
      description: "Latitude"
    - id: lng
      value structure: atomic
      value type: spatial
      description: "Longitude"
    - id: geo_plz
      value structure: atomic
      value type: categorical
      description: "Postal code"
  description: "Apartment rental offers in Leipzig, Germany (12,845
    georeferenced options from Kaggle dataset)"

artifact D_map_context : entities
  origin: given
  internal structure: elementary
  embedment: space
  features:
    - id: geometry
      value structure: atomic
      value type: spatial
      description: "Map tile/region geometries for Leipzig area"
  description: "Geographic base map providing spatial context for
    arrangement of apartment options"

artifact K_domain : knowledge(D_all)
  origin: given
  representation form: "domain assumptions"
  description: "Common-sense preference directions for apartment criteria:
    lower rent is better, more space is better, newer construction is
    better, etc. Used to initialise default utility functions."

Phase 1: Spatial Selection

artifact S_spatial : specification
  origin: given
  representation form: "parameter settings"
  description: "User-specified geographic centre point (lat, lng) and
    maximum distance radius (e.g., up to 50 km)"

transform T1_spatial_filter :
  intent: define-unit
  manner: "filter"
  input: D_all, S_spatial
  output: D_spatial, F_distance
  actor: machine
  description: "Select all apartment options within the specified distance
    from the user-defined geographic centre. Compute geodesic distance
    from centre for each retained option."

artifact D_spatial : entities
  internal structure: elementary
  embedment: {set, space}
  features:
    - id: baseRent
      value structure: atomic
      value type: numeric
    - id: totalRent
      value structure: atomic
      value type: numeric
    - id: livingSpace
      value structure: atomic
      value type: numeric
    - id: noRooms
      value structure: atomic
      value type: numeric
    - id: floor
      value structure: atomic
      value type: numeric
    - id: numberOfFloors
      value structure: atomic
      value type: numeric
    - id: yearConstructed
      value structure: atomic
      value type: numeric
    - id: pricePerSqm
      value structure: atomic
      value type: numeric
    - id: serviceCharge
      value structure: atomic
      value type: numeric
    - id: balcony
      value structure: atomic
      value type: categorical
    - id: hasKitchen
      value structure: atomic
      value type: categorical
    - id: lift
      value structure: atomic
      value type: categorical
    - id: garden
      value structure: atomic
      value type: categorical
    - id: condition
      value structure: atomic
      value type: ordinal
    - id: interiorQual
      value structure: atomic
      value type: ordinal
    - id: typeOfFlat
      value structure: atomic
      value type: categorical
    - id: lat
      value structure: atomic
      value type: spatial
    - id: lng
      value structure: atomic
      value type: spatial
  description: "Subset of apartment options within specified distance
    from selected geographic centre (N items depending on radius)"

artifact F_distance : feature(D_spatial)
  value structure: atomic
  value type: numeric
  description: "Geodesic distance from each apartment to the
    user-specified geographic centre (km)"

transform T1_map_view :
  intent: visualise
  manner: "map-view"
  input: D_spatial, F_distance, D_map_context
  output: V_spatial_overview
  actor: machine
  description: "Display selected apartments on an interactive map, with
    distance-based encoding (e.g., concentric rings or colour gradient)
    and count indicator showing N items loaded."

artifact V_spatial_overview : visualisation(D_spatial, F_distance)
  layout: "geographic map"
  form: "point markers"
  encoding: "position: lat/lng; colour or opacity: distance from centre;
    size: optional encoding of a selected attribute"
  description: "Map overview showing spatial distribution of selected
    apartment options relative to the chosen centre point"

Phase 2: Criteria Selection and Utility Definition (iterative)

assign:
  S_criteria_current := S_criteria_init

artifact S_criteria_init : specification
  representation form: "parameter settings"
  description: "Initial default criteria selection: all available numeric
    features selected as criteria with default preference directions
    derived from K_domain"

loop L_criteria_utility:
  purpose: "Iteratively refine criteria selection and utility function
    definitions until the analyst is satisfied with the decision model
    configuration"
  until: "Analyst confirms that criteria selection and utility functions
    adequately capture their preferences"
  body:

    transform T2_select_criteria :
      intent: generate-knowledge
      manner: "formulate-specification"
      input: D_spatial, K_domain, V_histograms
      output: S_criteria
      actor: human
      description: "User selects which numeric (and optionally ordinal-encoded)
        attributes to use as decision criteria. At this stage of development,
        primarily numeric features. User also specifies preference direction
        (minimise/maximise) for each criterion."

    artifact S_criteria : specification
      representation form: "criteria list with preference directions"
      description: "Ordered list of selected criteria with indication of
        whether each should be minimised or maximised, and whether
        distance is included as a criterion or treated as a separate filter"

    transform T2_show_distributions :
      intent: visualise
      manner: "histogram-array"
      input: D_spatial, S_criteria
      output: V_histograms
      actor: machine
      description: "Display distribution histograms for each selected criterion,
        showing marginal distributions of the current spatial subset.
        Histograms serve as background for utility function definition."

    artifact V_histograms : visualisation(D_spatial, S_criteria)
      layout: "small-multiple grid"
      form: "histograms with overlaid utility curves"
      encoding: "x-axis: criterion value; y-axis (bars): frequency;
        y-axis (curve): utility value [0,1]; interactive control points
        for piecewise-linear or parametric utility function"
      description: "Array of histograms showing value distributions for
        each selected criterion, with superimposed editable utility
        function curves"

    transform T2_define_utility :
      intent: generate-knowledge
      manner: "formulate-specification"
      input: V_histograms, S_criteria, K_domain
      output: S_utility
      actor: human
      description: "User defines utility functions for each criterion by
        manipulating control points on the histogram background.
        Functions map raw criterion values to [0,1] utility scale.
        Supports piecewise-linear, step, and sigmoid shapes.
        Defaults provided based on K_domain preference directions."

    artifact S_utility : specification
      representation form: "utility function definitions"
      description: "Set of utility functions u_i: R → [0,1] for each
        selected criterion i, defining how raw attribute values map to
        desirability scores. Includes specification of whether distance
        participates as a criterion or remains a filter."

    transform T2_assess_config :
      intent: assess
      manner: "judge-configuration-adequacy"
      input: V_histograms, S_criteria, S_utility
      output: K_config_assessment
      actor: human
      description: "Analyst evaluates whether the current criteria selection
        and utility function definitions adequately capture their
        decision preferences."

    artifact K_config_assessment : knowledge(S_criteria, S_utility)
      representation form: "quality judgment"
      description: "Analyst's judgment on whether criteria and utility
        functions are satisfactory or need further refinement"

    if K_config_assessment indicates refinement needed:
      then:
        assign:
          S_criteria_current := S_criteria
      else:
        exit loop L_criteria_utility

end loop L_criteria_utility

Phase 3: Utility Computation and Pareto Analysis

transform T3_compute_utility :
  intent: characterise
  manner: "encode"
  input: D_spatial, S_criteria, S_utility
  output: F_utility_values
  actor: machine
  description: "Apply user-defined utility functions to transform raw
    criterion values into normalised utility scores [0,1] for each
    option and each criterion. Handle missing values by marking them
    as incomplete (supporting partial dominance in Pareto computation)."

artifact F_utility_values : feature(D_spatial)
  value structure: vector
  value type: numeric
  representation form: "utility vector per option (one component per criterion)"
  description: "Multi-criteria utility profile for each apartment option.
    Each component is the utility score for one criterion, in [0,1].
    Missing values flagged for partial dominance handling."

transform T3_pareto :
  intent: characterise
  manner: "compute-pareto-frontier"
  input: D_spatial, F_utility_values, S_pareto_tolerance
  output: F_pareto_membership, F_pareto_distance
  actor: machine
  description: "Compute Pareto frontier in utility space. Determine for
    each option: (a) whether it is Pareto-optimal, (b) its distance to
    the Pareto frontier (continuous measure), (c) whether it falls within
    the epsilon-tolerance band. Use partial dominance for options with
    missing criteria values. Options with fewer missing values get
    priority in ambiguous cases."

artifact S_pareto_tolerance : specification
  origin: given
  representation form: "parameter settings"
  description: "Epsilon-dominance threshold defining the tolerance band
    around the Pareto frontier. Options within epsilon of the frontier
    are treated as near-optimal. Also specifies the partial dominance
    rule for handling missing values."

artifact F_pareto_membership : feature(D_spatial)
  value structure: atomic
  value type: categorical
  description: "Pareto classification for each option: 'optimal',
    'near-optimal' (within epsilon-band), or 'dominated'. Encodes
    tolerant Pareto membership."

artifact F_pareto_distance : feature(D_spatial)
  value structure: atomic
  value type: numeric
  description: "Continuous distance from each option to the Pareto
    frontier in utility space. Zero for Pareto-optimal options,
    positive for dominated options. Provides a smooth ranking signal
    complementing hard Pareto membership."

Phase 4: Subgroup Identification

transform T4_cluster :
  intent: define-unit
  manner: "cluster-by-similarity"
  input: D_spatial, F_utility_values, F_distance, S_clustering
  output: D_clusters, F_cluster_labels
  actor: machine
  description: "Cluster apartment options based on their utility profiles
    (and optionally distance). Produces groups of options with similar
    multi-criteria properties. Algorithm choice (e.g., k-means,
    DBSCAN, hierarchical) specified in S_clustering. The goal is to
    separate structurally different option types (e.g., studios vs.
    family apartments vs. luxury flats) based on their criterion values."

artifact S_clustering : specification
  origin: given
  representation form: "parameter settings"
  description: "Clustering parameters: algorithm choice, number of
    clusters (or density threshold), feature weighting, whether to
    include spatial distance as a clustering dimension"

artifact D_clusters : entities
  internal structure: group/cluster
  embedment: set
  features:
    - id: cluster_size
      value structure: atomic
      value type: numeric
      description: "Number of options in cluster"
    - id: centroid
      value structure: vector
      value type: numeric
      description: "Cluster centroid in utility space"
  description: "Groups of apartment options with similar multi-criteria
    utility profiles. Each cluster represents a 'type' of option
    (e.g., affordable small flats, spacious suburban houses, central
    luxury apartments)"

artifact F_cluster_labels : feature(D_spatial)
  value structure: atomic
  value type: categorical
  description: "Hard cluster assignment for each apartment option"

transform T4_nmf :
  intent: build-model
  manner: "fit-topic-model"
  input: D_spatial, F_utility_values
  output: M_nmf, F_topic_loadings, F_option_memberships
  actor: machine
  description: "Non-negative Matrix Factorisation on the utility-transformed
    feature matrix. Decomposes options × criteria matrix into
    W (options × topics) and H (topics × criteria). Topics represent
    interpretable 'property profiles' (e.g., a 'luxury' topic with high
    loadings on quality, space, and new construction; a 'budget' topic
    with high loading on low rent). Unlike hard clustering, NMF provides
    mixed membership — each option can participate in multiple topics."

artifact M_nmf : model(D_spatial, F_utility_values)
  model type: "topic model"
  representation form: "matrix factorisation (W, H) with k topics"
  description: "NMF decomposition of the utility matrix. H matrix rows
    define topic profiles over criteria; W matrix columns define option
    memberships in each topic. Non-negativity ensures additive
    interpretability."

artifact F_topic_loadings : feature(D_clusters)
  value structure: matrix
  value type: numeric
  representation form: "topics × criteria matrix (H)"
  description: "Each row defines a topic as a non-negative combination
    of criterion utilities. Interpretable as 'what property profile
    does this topic represent?'"

artifact F_option_memberships : feature(D_spatial)
  value structure: vector
  value type: numeric
  representation form: "options × topics membership vector (row of W)"
  description: "Soft membership of each option in each NMF topic.
    Higher values indicate stronger participation in that property
    profile. Allows an option to be e.g., 60% 'family-friendly' and
    40% 'central-urban'."

Phase 5: Integrated Visualisation and Exploration

transform T5_vis_map :
  intent: visualise
  manner: "map-view"
  input: D_spatial, F_cluster_labels, F_pareto_membership, D_map_context
  output: V_map_clusters
  actor: machine
  description: "Map view showing apartment options coloured by cluster
    membership, with Pareto-optimal and near-optimal options visually
    distinguished (e.g., by shape or border). Supports interactive
    selection of spatial regions and cluster-based filtering."

artifact V_map_clusters : visualisation(D_spatial, F_cluster_labels, F_pareto_membership)
  layout: "geographic map"
  form: "coloured point markers with shape encoding"
  encoding: "position: lat/lng; colour: cluster ID; shape/border:
    Pareto membership (optimal/near-optimal/dominated);
    interactive: brushing, lasso selection, cluster toggle"
  description: "Spatial view integrating cluster structure and Pareto
    status, supporting geographic exploration of option types"

transform T5_vis_pareto :
  intent: visualise
  manner: "parallel-coordinates"
  input: D_spatial, F_utility_values, F_cluster_labels, F_pareto_membership
  output: V_pareto_parallel
  actor: machine
  description: "Parallel coordinates plot of utility values across all
    criteria, with lines coloured by cluster membership and
    Pareto-optimal options highlighted. Supports brushing to select
    subsets and identify trade-off patterns."

artifact V_pareto_parallel : visualisation(F_utility_values, F_cluster_labels)
  layout: "parallel axes (one per criterion)"
  form: "polylines with colour and opacity encoding"
  encoding: "each axis: one criterion utility [0,1]; line colour:
    cluster; line opacity/thickness: Pareto distance (closer to
    frontier = more prominent); brushing on axes for filtering"
  description: "Multi-criteria trade-off view showing utility profiles
    of all options, visually stratified by cluster and Pareto status"

transform T5_vis_topics :
  intent: visualise
  manner: "stacked-bar-and-heatmap"
  input: F_topic_loadings, F_option_memberships, F_cluster_labels
  output: V_topic_view
  actor: machine
  description: "Visualise NMF topics: (a) heatmap of topic × criteria
    loadings showing what each topic 'means'; (b) stacked bars or
    ternary plot showing mixed membership of options/clusters in topics.
    Supports understanding what property profiles exist and how
    clusters relate to them."

artifact V_topic_view : visualisation(F_topic_loadings, F_option_memberships)
  layout: "composite: heatmap + membership bars"
  form: "heatmap cells and stacked bars"
  encoding: "heatmap: rows=topics, columns=criteria, colour=loading
    magnitude; bars: per-cluster average topic membership composition"
  description: "Topic interpretation view showing the multi-criteria
    meaning of each discovered property profile and how options/clusters
    participate in them"

Phase 6: Subgroup Selection, Ranking, and Sensitivity (iterative)

loop L_explore:
  purpose: "Iteratively select subgroups of interest, rank options within
    them, and perform sensitivity analysis to understand robustness of
    rankings to utility function and weight changes"
  until: "Analyst has identified satisfactory options or concluded that
    preferences need fundamental revision (return to L_criteria_utility)"
  body:

    transform T6_select_subgroup :
      intent: define-unit
      manner: "filter"
      input: D_spatial, F_cluster_labels, F_option_memberships,
             F_pareto_membership, V_map_clusters, V_pareto_parallel
      output: D_subgroup
      actor: human
      description: "Analyst selects a subgroup of interest via:
        (a) clicking a cluster in the map or parallel coordinates;
        (b) defining a topic membership threshold (e.g., >50% in
        'family-friendly' topic);
        (c) brushing a region in the Pareto/parallel coordinates view;
        (d) combining spatial and feature-based selections.
        This is the key 'sector identification' step that narrows the
        decision space before detailed ranking."

    artifact D_subgroup : entities
      internal structure: elementary
      embedment: {set, space}
      features:
        - id: all_criteria
          value structure: vector
          value type: numeric
          description: "Inherited criterion values"
      description: "User-selected subset of options forming the current
        focus of detailed analysis. Represents a coherent 'sector' of
        the decision space (e.g., all spacious suburban options near
        Pareto frontier)."

    transform T6_rank :
      intent: characterise
      manner: "compute-statistics"
      input: D_subgroup, F_utility_values, S_weights
      output: F_ranking
      actor: machine
      description: "Compute weighted-sum or other aggregation ranking
        within the selected subgroup. Uses analyst-specified criterion
        weights. Also computes within-subgroup Pareto frontier for
        the reduced criterion set relevant to this subgroup."

    artifact S_weights : specification
      origin: given
      representation form: "parameter settings"
      description: "Criterion weights for aggregation ranking within
        the subgroup. May differ from global weights, reflecting that
        within a specific subgroup some trade-offs are more relevant
        than others."

    artifact F_ranking : feature(D_subgroup)
      value structure: atomic
      value type: numeric
      description: "Aggregate ranking score for each option in the
        selected subgroup, based on weighted utility combination"

    transform T6_vis_ranking :
      intent: visualise
      manner: "sorted-bar-and-detail"
      input: D_subgroup, F_ranking, F_utility_values, F_pareto_distance
      output: V_ranking
      actor: machine
      description: "Ranked list of options in the subgroup with
        multi-criteria profile detail. Shows individual utility
        components, aggregate score, and distance to Pareto frontier.
        Supports drill-down to individual option details."

    artifact V_ranking : visualisation(D_subgroup, F_ranking)
      layout: "sorted list with embedded profiles"
      form: "bar chart + inline sparkline profiles"
      encoding: "sort order: ranking score; bar length: aggregate utility;
        inline profiles: per-criterion utility; colour border: Pareto
        distance; interaction: hover for full detail"
      description: "Detailed ranking view for the selected subgroup"

    transform T6_sensitivity :
      intent: characterise
      manner: "sensitivity-analysis"
      input: D_subgroup, F_utility_values, S_weights, S_utility
      output: F_sensitivity
      actor: machine
      description: "Compute sensitivity of rankings to: (a) changes in
        criterion weights; (b) perturbations of utility function
        parameters; (c) inclusion/exclusion of criteria. Identifies
        options whose rank is robust vs. fragile. Connects to Pareto
        tolerance: options near the frontier that are sensitive to
        small parameter changes are less reliable recommendations."

    artifact F_sensitivity : feature(D_subgroup)
      value structure: vector
      value type: numeric
      representation form: "sensitivity indices per option"
      description: "For each option: stability of its rank under weight
        and utility perturbations. High sensitivity = rank changes
        easily; low sensitivity = robustly good or robustly poor."

    transform T6_vis_sensitivity :
      intent: visualise
      manner: "interactive-weight-sliders"
      input: D_subgroup, F_ranking, F_sensitivity, S_weights
      output: V_sensitivity
      actor: machine
      description: "Interactive sensitivity display: weight sliders that
        dynamically update ranking; highlighting of rank crossovers;
        stability indicators per option. Similar in spirit to the
        CommonGIS weight sensitivity bars but applied within a
        subgroup context."

    artifact V_sensitivity : visualisation(F_ranking, F_sensitivity)
      layout: "weight sliders + dynamic ranking"
      form: "interactive sliders with linked sorted list"
      encoding: "sliders: criterion weights; sorted list updates in
        real-time; colour/saturation: sensitivity (stable=saturated,
        fragile=desaturated); animation: rank crossover highlights"
      description: "Interactive sensitivity analysis view showing how
        rankings within the subgroup respond to preference changes"

    transform T6_interpret :
      intent: abstract
      manner: "perception-and-interpretation"
      input: V_ranking, V_sensitivity, V_map_clusters, V_topic_view
      output: P_subgroup_insights
      actor: human
      description: "Analyst interprets the ranking and sensitivity results
        for the current subgroup. Identifies: (a) robustly top-ranked
        options; (b) interesting trade-off patterns; (c) whether the
        subgroup definition needs refinement; (d) whether to explore
        a different sector."

    artifact P_subgroup_insights : pattern(D_subgroup, F_ranking, F_sensitivity)
      representation form: "observations about trade-offs and robustness"
      description: "Analyst's observations about the current subgroup:
        which options are reliably good, which trade-offs dominate,
        whether the subgroup is coherent or should be split/expanded"

    transform T6_assess :
      intent: assess
      manner: "judge-adequacy"
      input: P_subgroup_insights, D_subgroup
      output: K_exploration_assessment
      actor: human
      description: "Analyst decides whether satisfactory options have been
        identified, whether to explore another subgroup, or whether to
        revise the overall criteria/utility setup."

    artifact K_exploration_assessment : knowledge(P_subgroup_insights)
      representation form: "quality judgment"
      description: "Decision on next step: (a) satisfactory result found;
        (b) explore another subgroup; (c) revise criteria/utilities"

    if K_exploration_assessment indicates satisfactory:
      then:
        exit loop L_explore
      else:
        # Continue loop: analyst will select a different subgroup
        # or the workflow returns to L_criteria_utility

end loop L_explore

Phase 7: Knowledge Generation

transform T7_conclude :
  intent: generate-knowledge
  manner: "formulate-statements"
  input: P_subgroup_insights, F_ranking, F_sensitivity,
         F_pareto_membership, D_clusters, M_nmf
  output: K_decision_support
  actor: human
  description: "Analyst formulates final conclusions: recommended options,
    identified subgroups of interest, key trade-offs discovered,
    robustness assessment of recommendations, and insights about the
    structure of the decision space (e.g., 'the Leipzig rental market
    separates into 4 distinct property profiles; within the suburban
    family segment, options X and Y are robustly Pareto-near-optimal')."

artifact K_decision_support : knowledge(D_spatial, D_clusters, M_nmf)
  representation form: "structured recommendations and insights"
  description: "Final output: (a) shortlist of recommended options with
    robustness qualifiers; (b) characterisation of discovered property
    profiles/types; (c) identified trade-off structures; (d) assessment
    of how data completeness affects confidence in recommendations"

Summary: Novelty Contributions Mapped to Workflow Elements

Novelty Claim	Workflow Element	Key Artifacts
Subgroup-first MCDA (sectors before ranking)	T4_cluster, T4_nmf, T6_select_subgroup	D_clusters, F_option_memberships, D_subgroup
Flexible subgroup definition (not predefined categories)	T6_select_subgroup via multiple interaction modalities	S_clustering, F_cluster_labels, F_option_memberships
Pareto tolerance (ε-dominance + continuous distance)	T3_pareto, S_pareto_tolerance	F_pareto_distance, F_pareto_membership
NMF-based property profiles (mixed membership)	T4_nmf	M_nmf, F_topic_loadings, F_option_memberships
Sensitivity-aware ranking within subgroups	T6_sensitivity, T6_vis_sensitivity	F_sensitivity, V_sensitivity
Handling data imperfections (missing values → partial dominance)	T3_pareto	S_pareto_tolerance, F_pareto_membership

Recommendations for the Demonstrator

Implement Phase 4 and Phase 6 as the core novelty demonstration — these distinguish your approach from existing MCDA tools.
Use 3–4 NMF topics for interpretability in the demonstrator; show that they recover meaningful apartment types.
Include a synthetic validation scenario where you inject known structure (e.g., 3 planted Pareto-optimal clusters with controlled dominance) to demonstrate that the workflow correctly identifies them.
For the paper, emphasise the workflow loop structure — the ability to move between subgroup exploration and criteria refinement is the analytical advantage over linear MCDA pipelines.

V3 · library Variant V3 — ATWL library only

Model’s internal reasoning (think block)

The user is asking me to design a Visual Analytics workflow for their spatial multi-criteria decision analysis (MCDA) system for apartment rental selection. Let me carefully analyze their plan, critically assess it, and then design a formal ATWL workflow.

Let me first critically assess their plan:

**Strengths:**
1. Good dataset choice - 12,845 georeferenced options with 7+ numeric criteria
2. Spatial filtering by distance to a user-selected center is practical
3. Distribution histograms for utility function definition is good practice
4. Pareto frontier computation is standard and appropriate for MCDA
5. The two-stage approach (subgroup identification → ranking/sensitivity) is novel

6. The 50km distance threshold works for a demonstrator, though it's quite large for actual apartment hunting

**Limitations to address:**
The approach focuses only on numeric features, which excludes important categorical criteria like heating type, condition, interior quality, and flat type. Including these categorical dimensions would strengthen the novelty of the subgroup identification phase. I'm also noticing the utility function definition needs clarification—whether they're using piecewise linear functions or another approach matters for the workflow design.

**Pareto frontier challenges:**
With 7-12 criteria, the Pareto frontier will likely contain 80-90%+ of all options due to the curse of dimensionality. The insight about tolerating Pareto optimality given data imperfections is solid, but it needs formalization—perhaps through approximate Pareto dominance or layered Pareto depth analysis.

**Clustering and NMF integration:**
I need to think through how these techniques actually work together. The clustering space (utility vs. feature space), the NMF matrix structure (options × criteria or options × utilities), and how they complement each other all need clarification. The topic modeling analogy is intriguing but underdeveloped.

**Articulating the novelty:**
The staged search approach (subgroups then ranking), tolerating Pareto optimality due to data imperfections, and applying NMF topic modeling to MCDA are all potentially novel contributions, but I need to be more precise about what makes each one distinct.

**Practical concerns:**
With nearly 13,000 options and multiple criteria, visualization becomes critical. The NMF-to-decision pipeline needs clearer logic, and I'm wondering why distance is treated as a post-Pareto feature rather than incorporated as a criterion upfront. I also need to map how the user actually moves from identified subgroups to a final choice.

Now I'm designing the ATWL workflow to capture spatial selection starting with geographic center...

Structuring the workflow template...

Critical Assessment of Your Plan

Strengths

Two-stage search (subgroups → ranking) is a genuinely novel contribution to spatial MCDA. Traditional approaches rank all alternatives simultaneously, which overwhelms users when N is large.
Tolerating Pareto optimality is well-motivated — with imperfect/incomplete apartment data (missing yearConstructed, interiorQual, etc.), strict dominance is unreliable. This connects to your earlier work on imprecision in spatial decision-making.
NMF as "topic modeling" over decision options is an original re-purposing — treating criteria profiles analogously to word distributions in documents. It provides soft assignment (an apartment can partially belong to multiple "types"), unlike hard clustering.
Dataset fit is excellent: 12,845 options × sufficiently many numeric criteria, georeferenced, with enough messiness (missing values, mixed quality) to motivate your tolerance argument.

Critical Issues

Issue	Concern	Mitigation
Pareto curse of dimensionality	With 7–12 criteria, 70–95% of options are Pareto-optimal, making the frontier uninformative	Use ε-dominance or Pareto depth layers; compute distance-to-ideal as a continuous relaxation
Distance as "extra feature" vs. criterion	Adding distance after Pareto changes the dominance structure retroactively; unclear semantics	Either include distance as a criterion from the start (with its own utility), or use it purely for spatial arrangement — not both
Numeric-only limitation	Key discriminators (`typeOfFlat`, `heatingType`, `condition`) are categorical; "separating palaces from studios" requires them	For NMF/clustering, encode categoricals as binary/ordinal dummies; keep the utility functions numeric-only as stated
Clustering vs. NMF relationship unclear	What does each contribute? If both operate on the same feature matrix, results may be redundant	Assign distinct roles: clustering on raw feature space (property types), NMF on utility space (preference profiles). This gives structural vs. evaluative decomposition
Scalability of utility definition	Defining 7–12 utility functions interactively is tedious even for experts	Provide sensible defaults (monotone increasing for space, decreasing for rent), let user adjust only when the histogram suggests non-monotonicity
Missing novelty articulation	The combination is novel, but each component (Pareto, clustering, NMF, utility functions) exists independently	The novelty is the workflow architecture — progressive narrowing from spatial context → utility-aware decomposition → tolerant ranking. Frame it as a progressive decision support framework

Recommendations for Scientific Positioning

Your earlier work (IVS'03, JDS'03, IJGIS'01) established the integration of geovisualization with MCDA. The new contribution should be framed as:

From ranking to structuring: replacing the single ranked list with an exploratory decomposition of the decision space, where Pareto tolerance acknowledges data imperfection, and dual decomposition (feature-based clustering + utility-based NMF) enables progressive focus.

ATWL Workflow Design

workflow spatial-mcda-with-progressive-decomposition

template: define-unit (spatial) → characterise (select criteria) →
  loop(generate-knowledge (define utilities) → characterise (compute utilities) →
    visualise → assess) →
  characterise (Pareto + tolerance) →
  loop(define-unit (decompose) → visualise → abstract → assess →
    generate-knowledge (refine decomposition)) →
  define-unit (select subgroup) →
  characterise (rank within subgroup) → visualise → abstract →
  generate-knowledge

description: "Progressive spatial multi-criteria decision analysis combining
  utility-aware Pareto tolerance with dual decomposition (clustering on
  feature space, NMF on utility space) to structure large decision sets
  into interpretable subgroups before within-group ranking and sensitivity
  analysis"

# ============================================================================
# INPUT: Apartment rental offers
# ============================================================================

artifact D_apartments : entities
  origin: given
  internal structure: elementary
  embedment: {set, space}
  features:
    - id: f_numeric
      value structure: vector
      value type: numeric
      description: "Numeric attributes: totalRent, livingSpace, noRooms,
        floor, numberOfFloors, serviceCharge, baseRent, yearConstructed,
        pricePerSqm"
    - id: f_categorical
      value structure: vector
      value type: categorical
      description: "Categorical attributes: heatingType, condition,
        interiorQual, typeOfFlat"
    - id: f_binary
      value structure: vector
      value type: binary
      description: "Binary attributes: balcony, hasKitchen, cellar, lift,
        garden, newlyConst"
    - id: f_geo
      value structure: vector
      value type: spatial
      description: "Geographic coordinates: lat, lng, geo_plz"
  description: "Cleaned apartment rental offers for Leipzig with
    12,845 georeferenced options"

# ============================================================================
# STEP 1: SPATIAL SELECTION
# ============================================================================

artifact S_spatial : specification
  origin: given
  representation form: "geographic center coordinates and maximum distance"
  description: "User-specified geographic center point and distance
    radius defining the spatial search area"

transform T_spatial_filter :
  intent: define-unit
  manner: "distance-based spatial filtering from user-specified center"
  input: D_apartments, S_spatial
  output: D_spatial_subset, F_distance
  actor: hybrid
  description: "User selects geographic center on map; system computes
    distances and retains apartments within specified radius;
    N shown as function of distance for threshold selection"

artifact D_spatial_subset : entities
  internal structure: elementary
  embedment: {set, space}
  features:
    - id: f_all_attributes
      value structure: vector
      value type: {numeric, categorical, binary, spatial}
      description: "All original attributes retained"
  description: "Spatially filtered subset of apartments within
    user-specified distance from center"

artifact F_distance : feature(D_spatial_subset)
  value structure: atomic
  value type: numeric
  description: "Euclidean or network distance from each apartment
    to the user-specified center point"

transform T_visualise_spatial :
  intent: visualise
  manner: "map display with distance rings and count graph"
  input: D_spatial_subset, F_distance, S_spatial
  output: V_spatial
  actor: machine
  description: "Display apartments on map with distance bands;
    show graph of cumulative count vs. distance for threshold guidance"

artifact V_spatial : visualisation(D_spatial_subset, F_distance)
  layout: "geographic map with distance-count side panel"
  form: "point markers with distance rings; line graph"
  encoding: "position from coordinates; ring radius from distance;
    line graph x-axis: distance, y-axis: cumulative count"
  description: "Map showing spatial distribution of options with
    interactive distance threshold selection"

# ============================================================================
# STEP 2: CRITERIA SELECTION
# ============================================================================

transform T_select_criteria :
  intent: characterise
  manner: "interactive selection of numeric attributes as criteria"
  input: D_spatial_subset
  output: D_criteria_matrix, S_criteria
  actor: human
  description: "User selects which numeric attributes serve as
    decision criteria; system presents attribute overview with
    completeness and distribution summaries to guide selection"

artifact S_criteria : specification
  representation form: "list of selected attribute identifiers with
    optimization directions"
  description: "User-specified set of criteria with indication of
    whether each is to be maximised or minimised"

artifact D_criteria_matrix : feature(D_spatial_subset)
  value structure: matrix
  value type: numeric
  description: "Decision matrix: apartments × selected criteria,
    with optimization directions annotated"

# ============================================================================
# STEP 3: UTILITY FUNCTION DEFINITION (iterative)
# ============================================================================

artifact S_utility_specs : specification
  origin: given
  representation form: "piecewise-linear utility function definitions"
  description: "Initial utility function specifications: default
    monotone functions matching optimization directions;
    one function per criterion mapping raw values to [0,1]"

loop L_utility_definition:
  purpose: "Iteratively define and refine utility functions for each
    criterion, guided by distribution histograms showing data context"
  until: "User is satisfied that utility functions reflect their
    preferences across all criteria"

  body:
    # ====================================================================
    # Step 3a: Compute utility values
    # ====================================================================
    transform T_compute_utilities :
      intent: characterise
      manner: "apply piecewise-linear utility functions to criteria values"
      input: D_criteria_matrix, S_utility_specs
      output: F_utilities
      actor: machine
      description: "Transform raw criterion values to utility scores
        in [0,1] using current utility function specifications"

    artifact F_utilities : feature(D_spatial_subset)
      value structure: matrix
      value type: numeric
      description: "Utility matrix: apartments × criteria, values
        in [0,1] reflecting user preferences"

    # ====================================================================
    # Step 3b: Visualise utility functions with distributions
    # ====================================================================
    transform T_visualise_utilities :
      intent: visualise
      manner: "utility function editors with distribution histograms
        as background and utility distribution previews"
      input: D_criteria_matrix, S_utility_specs, F_utilities
      output: V_utilities
      actor: machine
      description: "Display each utility function overlaid on criterion
        value histogram; show resulting utility distributions;
        highlight how function shape affects discrimination"

    artifact V_utilities : visualisation(D_criteria_matrix, F_utilities)
      layout: "small multiples: one panel per criterion"
      form: "histogram background with utility curve overlay;
        output distribution panel"
      encoding: "x-axis: raw criterion values; left y-axis: frequency
        (histogram bars); right y-axis: utility [0,1] (curve);
        output panel shows utility value distribution"
      description: "Interactive utility function editors showing
        data distribution context and resulting utility distributions
        for each criterion"

    # ====================================================================
    # Step 3c: Assess utility functions
    # ====================================================================
    transform T_assess_utilities :
      intent: assess
      manner: "evaluate utility function shapes against data distributions
        and preference intentions"
      input: V_utilities, S_utility_specs
      output: K_utility_assessment
      actor: human
      description: "Assess whether utility functions appropriately
        reflect preferences: adequate discrimination, appropriate
        thresholds, no unintended value compression"

    artifact K_utility_assessment : knowledge(S_utility_specs)
      representation form: "quality judgment"
      description: "Assessment of utility function adequacy:
        discrimination quality, threshold appropriateness,
        and whether refinement is needed"

    if K_utility_assessment indicates refinement needed:
      then:
        transform T_adjust_utilities :
          intent: generate-knowledge
          manner: "interactively modify utility function breakpoints"
          input: V_utilities, K_utility_assessment, S_utility_specs
          output: S_utility_specs'
          actor: human
          description: "Adjust utility function shapes by moving
            breakpoints, adding inflection points, or modifying
            slopes to better reflect preferences"

        artifact S_utility_specs' : specification
          representation form: "piecewise-linear utility function
            definitions"
          description: "Updated utility function specifications"

        assign:
          S_utility_specs := S_utility_specs'
      else:
        exit loop L_utility_definition

end loop L_utility_definition

# ============================================================================
# STEP 4: PARETO ANALYSIS WITH TOLERANCE
# ============================================================================

artifact S_pareto : specification
  origin: given
  representation form: "tolerance parameters"
  description: "Pareto analysis parameters: epsilon-dominance threshold
    for tolerance, whether distance is included as criterion,
    criteria weights for aggregate scoring"

transform T_compute_pareto :
  intent: characterise
  manner: "epsilon-dominance Pareto analysis with distance integration"
  input: F_utilities, F_distance, S_pareto
  output: F_pareto_layer, F_pareto_distance, F_aggregate_score
  actor: machine
  description: "Compute Pareto depth layers using epsilon-dominance
    to tolerate data imperfections; compute distance-to-ideal-point
    as continuous dominance relaxation; integrate geographic distance
    as additional criterion in the utility space"

artifact F_pareto_layer : feature(D_spatial_subset)
  value structure: atomic
  value type: ordinal
  description: "Pareto depth layer: 1 = frontier, 2 = second layer, etc.
    Using epsilon-dominance for tolerance"

artifact F_pareto_distance : feature(D_spatial_subset)
  value structure: atomic
  value type: numeric
  description: "Continuous distance to ideal point in utility space;
    provides ranking relaxation beyond binary Pareto membership"

artifact F_aggregate_score : feature(D_spatial_subset)
  value structure: atomic
  value type: numeric
  description: "Weighted aggregate utility score incorporating all
    criteria including distance utility"

# ============================================================================
# STEP 5: DUAL DECOMPOSITION (iterative)
# ============================================================================

artifact S_decomposition : specification
  origin: given
  representation form: "parameter settings"
  description: "Decomposition parameters: number of clusters for
    feature-based clustering, number of topics for utility-based NMF,
    feature weighting for clustering"

loop L_decomposition:
  purpose: "Iteratively decompose the decision space through clustering
    (feature-based: what IS the apartment) and NMF (utility-based:
    how GOOD is it for the user), refining until subgroups are
    interpretable and actionable"
  until: "Subgroups provide interpretable separation of structurally
    different property types with distinct utility profiles"

  body:
    # ====================================================================
    # Step 5a: Feature-based clustering (structural decomposition)
    # ====================================================================
    transform T_cluster_features :
      intent: define-unit
      manner: "clustering by feature similarity including categorical
        encodings"
      input: D_spatial_subset, D_criteria_matrix, S_decomposition
      output: D_feature_clusters, F_cluster_labels
      actor: machine
      description: "Group apartments by structural similarity in
        feature space (numeric + encoded categorical attributes)
        to identify property types: e.g., studios, family apartments,
        luxury flats, houses"

    artifact D_feature_clusters : entities
      internal structure: group/cluster
      embedment: set
      features:
        - id: f_cluster_size
          value structure: atomic
          value type: numeric
          description: "Number of apartments per cluster"
        - id: f_cluster_centroid
          value structure: vector
          value type: numeric
          description: "Average feature values characterizing cluster"
      description: "Groups of structurally similar apartments
        representing distinct property types"

    artifact F_cluster_labels : feature(D_spatial_subset)
      value structure: atomic
      value type: categorical
      description: "Feature-cluster membership for each apartment"

    # ====================================================================
    # Step 5b: Utility-based NMF (evaluative decomposition)
    # ====================================================================
    transform T_nmf_utilities :
      intent: define-unit
      manner: "non-negative matrix factorization of utility matrix"
      input: F_utilities, S_decomposition
      output: D_utility_topics, F_topic_weights, F_topic_profiles
      actor: machine
      description: "Decompose utility matrix into latent topics:
        each topic represents a characteristic utility profile
        (e.g., 'cheap but small', 'spacious and modern but expensive',
        'well-located compromise'); apartments have soft membership
        across topics"

    artifact D_utility_topics : entities
      internal structure: elementary
      embedment: set
      features:
        - id: f_topic_id
          value structure: atomic
          value type: categorical
          description: "Topic identifier"
      description: "Latent utility topics: characteristic patterns
        of criterion performance representing distinct trade-off
        archetypes in the decision space"

    artifact F_topic_weights : feature(D_spatial_subset)
      value structure: vector
      value type: numeric
      description: "Soft topic membership weights per apartment:
        how strongly each apartment exhibits each utility profile"

    artifact F_topic_profiles : feature(D_utility_topics)
      value structure: vector
      value type: numeric
      description: "Per-topic criterion loadings: which criteria
        are strong/weak in each topic archetype"

    # ====================================================================
    # Step 5c: Visualise dual decomposition
    # ====================================================================
    transform T_visualise_decomposition :
      intent: visualise
      manner: "coordinated views: map with cluster colours, parallel
        coordinates with topic overlays, topic-cluster cross-tabulation,
        projection scatterplot"
      input: D_spatial_subset, F_cluster_labels, F_topic_weights,
        F_topic_profiles, D_feature_clusters, D_utility_topics,
        F_pareto_layer, F_distance
      output: V_decomposition
      actor: machine
      description: "Display dual decomposition results through
        coordinated views linking structural clusters to utility
        topics with spatial context"

    artifact V_decomposition : visualisation(D_spatial_subset,
      F_cluster_labels, F_topic_weights, F_topic_profiles)
      layout: "coordinated multi-panel: map, parallel coordinates,
        cross-tabulation, 2D projection"
      form: "coloured points on map; parallel coordinate polylines;
        heatmap cross-tab; scatterplot with topic/cluster encoding"
      encoding: "map position from coordinates, colour from cluster;
        parallel coordinates: axes from criteria, colour from dominant
        topic; cross-tab: rows=clusters, columns=topics, cell
        intensity=count; projection: position from utility similarity,
        marker from cluster, colour from dominant topic;
        Pareto layer encoded by opacity or outline"
      description: "Multi-view display showing structural property
        types (clusters), evaluative profiles (topics), their
        spatial distribution, and Pareto layering"

    # ====================================================================
    # Step 5d: Interpret decomposition
    # ====================================================================
    transform T_interpret_decomposition :
      intent: abstract
      manner: "assign semantic labels to clusters and topics;
        identify cluster-topic correspondences and distinctions"
      input: V_decomposition, D_feature_clusters, D_utility_topics,
        F_topic_profiles
      output: P_subgroups
      actor: human
      description: "Interpret clusters as property types and topics
        as trade-off archetypes; identify which property types
        excel at which trade-offs; label groups meaningfully"

    artifact P_subgroups : pattern(D_feature_clusters, D_utility_topics)
      representation form: "labeled subgroups with semantic descriptions"
      description: "Interpreted property types (from clustering) and
        trade-off archetypes (from NMF) with semantic labels and
        identified correspondences between structural and evaluative
        groupings"

    # ====================================================================
    # Step 5e: Assess decomposition quality
    # ====================================================================
    transform T_assess_decomposition :
      intent: assess
      manner: "evaluate interpretability, separation, and actionability
        of identified subgroups"
      input: V_decomposition, P_subgroups, D_feature_clusters,
        D_utility_topics, S_decomposition
      output: K_decomposition_quality
      actor: human
      description: "Assess whether subgroups are interpretable,
        well-separated, and provide actionable narrowing of the
        decision space; evaluate cluster-topic alignment"

    artifact K_decomposition_quality : knowledge(D_feature_clusters,
      D_utility_topics)
      representation form: "quality judgment"
      description: "Assessment of decomposition quality:
        interpretability of clusters and topics, separation,
        coverage, and whether parameter adjustment is needed"

    if K_decomposition_quality indicates refinement needed:
      then:
        transform T_adjust_decomposition :
          intent: generate-knowledge
          manner: "adjust clustering and NMF parameters based on
            visual assessment"
          input: K_decomposition_quality, V_decomposition,
            S_decomposition
          output: S_decomposition'
          actor: human
          description: "Modify number of clusters/topics, adjust
            feature weighting, or change distance metrics based
            on decomposition assessment"

        artifact S_decomposition' : specification
          representation form: "parameter settings"
          description: "Updated decomposition parameters"

        assign:
          S_decomposition := S_decomposition'
      else:
        exit loop L_decomposition

end loop L_decomposition

# ============================================================================
# STEP 6: SUBGROUP SELECTION
# ============================================================================

transform T_select_subgroup :
  intent: define-unit
  manner: "interactive selection of interest subgroup(s) based on
    cluster membership, topic dominance, or combined criteria"
  input: D_spatial_subset, P_subgroups, F_cluster_labels,
    F_topic_weights, V_decomposition
  output: D_focus_set
  actor: human
  description: "User selects one or more subgroups of interest for
    detailed ranking and sensitivity analysis; selection can combine
    structural type (cluster) with evaluative profile (topic)"

artifact D_focus_set : entities
  internal structure: elementary
  embedment: {set, space}
  features:
    - id: f_selection_criteria
      value structure: vector
      value type: {categorical, numeric}
      description: "Membership criteria defining the focus set"
  description: "User-selected subset of apartments for detailed
    within-group ranking and sensitivity analysis"

# ============================================================================
# STEP 7: WITHIN-SUBGROUP RANKING AND SENSITIVITY ANALYSIS
# ============================================================================

transform T_rank_within_subgroup :
  intent: characterise
  manner: "compute rankings using aggregate score, Pareto distance,
    and per-criterion ranks; compute sensitivity to weight changes"
  input: D_focus_set, F_utilities, F_aggregate_score,
    F_pareto_distance, S_utility_specs, S_pareto
  output: F_rankings, F_sensitivity
  actor: machine
  description: "Rank apartments within the focus set by multiple
    scoring methods; compute sensitivity of rankings to criterion
    weight perturbations"

artifact F_rankings : feature(D_focus_set)
  value structure: vector
  value type: numeric
  description: "Multiple ranking scores: weighted sum, TOPSIS distance,
    Pareto depth, with agreement/disagreement indicators"

artifact F_sensitivity : feature(D_focus_set)
  value structure: matrix
  value type: numeric
  description: "Sensitivity measures: rank stability under weight
    perturbation, critical weight thresholds where rank changes occur"

transform T_visualise_ranking :
  intent: visualise
  manner: "ranked list with criteria profiles, sensitivity indicators,
    and map highlighting"
  input: D_focus_set, F_rankings, F_sensitivity, F_utilities,
    F_distance
  output: V_ranking
  actor: machine
  description: "Display ranked alternatives with per-criterion
    performance profiles, sensitivity indicators, geographic
    positions, and interactive weight adjustment"

artifact V_ranking : visualisation(D_focus_set, F_rankings,
  F_sensitivity)
  layout: "coordinated views: ranked table, sensitivity display,
    map with ranked alternatives"
  form: "sortable table with bar profiles, sensitivity bands,
    map markers sized/coloured by rank"
  encoding: "table rows sorted by rank; criterion bars show utility
    values; sensitivity bands show rank stability; map markers
    coloured by rank position with size from aggregate score"
  description: "Ranking view with sensitivity context enabling
    identification of robust top alternatives and understanding
    of rank stability"

# ============================================================================
# STEP 8: KNOWLEDGE SYNTHESIS
# ============================================================================

transform T_explore_ranking :
  intent: abstract
  manner: "identify robust top alternatives and sensitivity patterns"
  input: V_ranking, F_rankings, F_sensitivity
  output: P_decision
  actor: human
  description: "Identify alternatives that rank consistently well
    across scoring methods and are robust to weight changes;
    recognise trade-off patterns within the focus set"

artifact P_decision : pattern(D_focus_set, F_rankings)
  representation form: "identified decision-relevant patterns"
  description: "Robust top alternatives, weight sensitivity patterns,
    and key trade-offs within the selected subgroup"

transform T_synthesise :
  intent: generate-knowledge
  manner: "formulate decision insights combining subgroup understanding
    with within-group ranking"
  input: P_decision, P_subgroups, K_decomposition_quality
  output: K_decision
  actor: human
  description: "Synthesise understanding: which property type best
    matches preferences, which specific alternatives are robust
    candidates, what trade-offs are inherent, and how sensitive
    conclusions are to preference specifications"

artifact K_decision : knowledge(P_decision, P_subgroups)
  representation form: "decision insights and shortlist"
  description: "Structured decision support output: identified
    property type of interest, shortlist of robust alternatives,
    key trade-offs acknowledged, sensitivity assessment, and
    identified data gaps affecting confidence"

Workflow Summary Diagram (Conceptual)

┌─────────────────────────────────────────────────────────────────────┐
│  SPATIAL SELECTION                                                    │
│  [Map + Distance Graph] → D_spatial_subset + F_distance             │
└──────────────────────────────────┬──────────────────────────────────┘
                                   ▼
┌─────────────────────────────────────────────────────────────────────┐
│  CRITERIA SELECTION                                                   │
│  [Attribute overview] → S_criteria + D_criteria_matrix              │
└──────────────────────────────────┬──────────────────────────────────┘
                                   ▼
┌─────────────────────────────────────────────────────────────────────┐
│  ╔═══════════════════════════════════════════════════════╗           │
│  ║ LOOP: UTILITY FUNCTION DEFINITION                     ║           │
│  ║ [Histograms + Utility Curves] → assess → refine      ║           │
│  ╚═══════════════════════════════════════════════════════╝           │
└──────────────────────────────────┬──────────────────────────────────┘
                                   ▼
┌─────────────────────────────────────────────────────────────────────┐
│  PARETO ANALYSIS WITH ε-TOLERANCE                                    │
│  → F_pareto_layer + F_pareto_distance + F_aggregate_score           │
└──────────────────────────────────┬──────────────────────────────────┘
                                   ▼
┌─────────────────────────────────────────────────────────────────────┐
│  ╔═══════════════════════════════════════════════════════╗           │
│  ║ LOOP: DUAL DECOMPOSITION                             ║           │
│  ║                                                       ║           │
│  ║  ┌──────────────┐    ┌──────────────────┐            ║           │
│  ║  │  Clustering  │    │  NMF on Utility   │            ║           │
│  ║  │  (feature    │    │  Matrix (what     │            ║           │
│  ║  │   space:     │    │   trade-off       │            ║           │
│  ║  │   what IS    │    │   archetypes      │            ║           │
│  ║  │   it?)       │    │   exist?)         │            ║           │
│  ║  └──────┬───────┘    └────────┬──────────┘            ║           │
│  ║         └──────────┬──────────┘                       ║           │
│  ║                    ▼                                   ║           │
│  ║  [Map + ParCoords + CrossTab + Projection]            ║           │
│  ║         → interpret → assess → refine                 ║           │
│  ╚═══════════════════════════════════════════════════════╝           │
└──────────────────────────────────┬──────────────────────────────────┘
                                   ▼
┌─────────────────────────────────────────────────────────────────────┐
│  SUBGROUP SELECTION                                                   │
│  [Interactive selection from decomposition views]                     │
└──────────────────────────────────┬──────────────────────────────────┘
                                   ▼
┌─────────────────────────────────────────────────────────────────────┐
│  WITHIN-SUBGROUP RANKING + SENSITIVITY                               │
│  [Ranked table + Sensitivity bands + Map]                            │
│         → identify robust alternatives → synthesise                  │
└──────────────────────────────────┬──────────────────────────────────┘
                                   ▼
                          K_decision (Insights + Shortlist)

Key Design Decisions & Scientific Contributions

Design Decision	Rationale	Novelty
Dual decomposition with distinct spaces (features vs. utilities)	Clustering answers "what type of property?", NMF answers "what trade-off profile?" — these are complementary questions	Novel in MCDA context; inspired by topic-modeling literature but applied to decision matrices
ε-dominance Pareto instead of strict dominance	With 7–12 criteria and imperfect data, strict Pareto is nearly universal; ε-dominance restores discriminative power	Addresses the identified "tolerance" requirement formally
Pareto distance as continuous relaxation	Overcomes binary Pareto membership; enables ranking even among non-dominated options	Connects to TOPSIS but computed relative to ideal in utility space
Progressive narrowing (spatial → structural → evaluative → ranking)	Cognitively manageable stages; each reduces decision complexity	Novel workflow architecture for spatial MCDA
Soft assignment from NMF	Unlike hard clustering, allows apartments to partially belong to multiple "types" — matches reality (e.g., a loft can be both "spacious budget" and "modern central")	Novel application of NMF to decision option characterization

This workflow scaffold can be directly translated to an implementation plan. The ATWL representation ensures that the scientific contribution is clearly situated within the visual analytics methodology.

V4 · both Variant V4 — language + library

Model’s internal reasoning (think block)

The user is asking me to design a Visual Analytics workflow for their spatial multi-criteria decision analysis (MCDA) system for apartment rental selection, using the ATWL language. Let me carefully analyze their plan, critically assess it, and then design the workflow.

First, let me critically assess the plan:

1. **Geo-center selection and distance-based filtering** - Good starting point. Spatial constraint is natural for apartment search.

2. **Attribute selection for criteria** - Reasonable. Using only numeric features for this demonstrator is pragmatic.

3. **User-defined utility functions with distribution histograms** - This is a well-established approach in MCDA. Good visual support.

4. **Pareto frontier computation with distance as an additional criterion** - Adding geographic distance alongside other criteria and allowing for "tolerant" Pareto optimality acknowledges real-world data imperfections rather than enforcing strict dominance.

5. **Clustering and NMF for grouping** - The two-stage approach is scientifically sound: first identify sectors of interest through unsupervised grouping, then rank and analyze within those subgroups, which addresses a real limitation of single-stage ranking.

The strengths are compelling: treating subgroups separately rather than uniformly, tolerating Pareto optimality given noisy apartment data, and using NMF to uncover latent apartment types without predefined categories. The geographic component ties back to their prior spatial work.

But there are practical concerns with the approach. NMF requires non-negative inputs and typically works on count or proportion data, so applying it to mixed numeric features like rent, area, and floor number needs careful preprocessing and justification.

With 7-12 criteria, the Pareto frontier will likely contain a huge portion of the options due to the curse of dimensionality—a known issue they mention tolerating, but it's unclear how they'll actually handle it. There's also a workflow sequencing problem: they define utility functions before grouping, but if grouping is meant to identify relevant sectors first, shouldn't that happen earlier or at least inform the utility definition? And the missing values in the dataset—like yearConstructed or interior quality—could complicate both Pareto computation and NMF. They mention mixing categorical and numeric data, which adds another layer of complexity.

The core novelty here is combining flexible subgroup identification through NMF and clustering with tolerant Pareto optimality, but they need to be more precise about what "tolerating" actually means computationally—whether that's epsilon-dominance, probabilistic dominance, or something fuzzy. Now I'm sketching out the ATWL workflow itself, which should flow through data loading and spatial filtering, feature selection and preprocessing, interactive utility definition, subgroup identification via clustering and NMF, Pareto analysis with tolerance built in, within-group ranking with sensitivity analysis, and finally knowledge synthesis.

Defining the workflow template...

Critical Assessment of the Plan

Strengths

Two-stage search (subgroups → ranking) is scientifically well-motivated. Traditional MCDA treats all alternatives uniformly; identifying structurally different option types first addresses a real analytical limitation.
Tolerant Pareto optimality is a genuine contribution. With 7–12 criteria, the Pareto frontier often contains 50–90% of options (curse of dimensionality), making strict dominance nearly useless. Acknowledging data imperfections (missing yearConstructed, empty interiorQual) further justifies relaxation.
NMF for "topic-like" apartment profiles is creative—it can reveal latent types (studios, family flats, luxury penthouses) as weighted combinations of feature patterns, analogous to document topics.
Strong dataset: 12,845 georeferenced options with ~12 usable criteria is sufficient for demonstrating all components.

Concerns and Recommendations

Issue	Impact	Suggestion
NMF requires non-negativity; features like `floor=0`, standardised values, or centred utilities violate this	NMF will fail or produce artefacts	Use min-max scaling to [0,1] before NMF; alternatively, consider applying NMF to the utility-transformed values (which can be constrained to [0,1])
Workflow ordering: utility functions are defined (step 3) before subgroups (step 5), but subgroups should inform which criteria matter	Chicken-and-egg problem	Make the process iterative—initial grouping on raw features, then utility definition informed by group structure, then refined grouping on utility space
Pareto in 7–12 dimensions yields near-universal non-dominance	Pareto frontier loses discriminative power	Define ε-dominance or "Pareto depth" layers; use distance-to-ideal-point within subgroups
"Only numeric features" excludes `typeOfFlat`, `heatingType`, `condition`, `interiorQual`—precisely the features that distinguish palaces from studios	Subgroup identification will be impoverished	Encode categoricals as ordinal or binary dummies for clustering/NMF; even a demonstrator benefits from this
Missing values (~15–20% for `yearConstructed`, `interiorQual`, `numberOfFloors`)	Pareto computation undefined for incomplete vectors	Impute or exclude per-criterion; define dominance only on shared non-missing criteria (partial dominance)
Distance as "extra feature" added after Pareto	Inconsistent—distance was not part of dominance test	Either include distance in Pareto from the start, or compute Pareto on non-spatial criteria and use distance only for arrangement/visualisation. Clarify the role.
Scientific novelty articulation	Reviewers will ask "what exactly is new?"	The novelty is: (a) flexible, data-driven subgroup identification via NMF/clustering within MCDA, replacing rigid predefined categories; (b) tolerant Pareto (ε-dominance or Pareto depth) for imperfect data; (c) visual analytics loop connecting both

Revised Conceptual Flow

I recommend restructuring into three interlocked phases:

Spatial scoping + feature preparation (data-driven)
Subgroup discovery loop (clustering/NMF on utility-transformed features, with visual assessment of group interpretability)
Within-group Pareto analysis + sensitivity (tolerant dominance, ranking, what-if)

ATWL Workflow Specification

workflow spatial-mcda-with-subgroup-discovery

template: define-unit (spatial filter) →
  generate-knowledge (select criteria) →
  characterise (preprocess) →
  loop(generate-knowledge (define utilities) →
    characterise (compute utilities) →
    define-unit (subgroup discovery) →
    characterise (Pareto depth) →
    contextualise →visualise →abstract →assess) →
  generate-knowledge (synthesise findings)

description: "Visual analytics workflow for multi-criteria decision analysis
  of geo-referenced alternatives (apartment rentals). Extends traditional
  spatial MCDA by (1) flexible identification of subgroups of interest via
  clustering and NMF topic modelling on utility-transformed features, and
  (2) tolerant Pareto analysis (epsilon-dominance / Pareto depth layers)
  accommodating data imperfections. The two-phase approach—identify sectors
  of interest, then rank within sectors—is iterated with visual assessment
  guiding refinement of utility functions, subgroup structure, and
  dominance tolerance."

# ============================================================================
# INPUT: Apartment rental dataset (Leipzig subset)
# ============================================================================

artifact D_apartments : entities
  origin: given
  internal structure: elementary
  embedment: {set, space}
  features:
    - id: baseRent
      value structure: atomic
      value type: numeric
      description: "Base monthly rent in EUR"
    - id: livingSpace
      value structure: atomic
      value type: numeric
      description: "Living area in square metres"
    - id: noRooms
      value structure: atomic
      value type: numeric
      description: "Number of rooms"
    - id: totalRent
      value structure: atomic
      value type: numeric
      description: "Total monthly rent including service charges"
    - id: serviceCharge
      value structure: atomic
      value type: numeric
      description: "Monthly service charge in EUR"
    - id: yearConstructed
      value structure: atomic
      value type: numeric
      description: "Year of construction (partially missing)"
    - id: floor
      value structure: atomic
      value type: numeric
      description: "Floor number (0-based)"
    - id: numberOfFloors
      value structure: atomic
      value type: numeric
      description: "Total floors in building (partially missing)"
    - id: pricePerSqm
      value structure: atomic
      value type: numeric
      description: "Rent per square metre"
    - id: lat
      value structure: atomic
      value type: spatial
      description: "Latitude"
    - id: lng
      value structure: atomic
      value type: spatial
      description: "Longitude"
    - id: balcony
      value structure: atomic
      value type: numeric
      description: "Balcony presence (binary)"
    - id: hasKitchen
      value structure: atomic
      value type: numeric
      description: "Kitchen presence (binary)"
    - id: cellar
      value structure: atomic
      value type: numeric
      description: "Cellar presence (binary)"
    - id: lift
      value structure: atomic
      value type: numeric
      description: "Elevator presence (binary)"
    - id: garden
      value structure: atomic
      value type: numeric
      description: "Garden presence (binary)"
    - id: newlyConst
      value structure: atomic
      value type: numeric
      description: "Newly constructed (binary)"
    - id: condition
      value structure: atomic
      value type: categorical
      description: "Apartment condition category"
    - id: interiorQual
      value structure: atomic
      value type: categorical
      description: "Interior quality category (partially missing)"
    - id: typeOfFlat
      value structure: atomic
      value type: categorical
      description: "Apartment type (roof_storey, ground_floor, etc.)"
    - id: heatingType
      value structure: atomic
      value type: categorical
      description: "Type of heating system"
  description: "Georeferenced apartment rental offers in Leipzig (12,845
    records) with numeric, binary, and categorical attributes describing
    rent, size, amenities, building characteristics, and location"

artifact D_map_context : entities
  origin: given
  internal structure: elementary
  embedment: space
  features:
    - id: geometry
      value structure: atomic
      value type: spatial
      description: "Map base layer geometry"
  description: "Geographic base map of Leipzig area providing spatial
    context for apartment locations"

# ============================================================================
# PHASE 1: SPATIAL SCOPING
# ============================================================================

artifact S_spatial_query : specification
  origin: given
  representation form: "parameter settings"
  description: "User-specified geographic centre point (lat, lng) and
    maximum distance radius (up to 50 km) defining the spatial scope
    of analysis"

transform T_spatial_filter :
  intent: define-unit
  manner: "filter by spatial distance from user-specified centre"
  input: D_apartments, S_spatial_query
  output: D_scoped, F_distance
  actor: hybrid
  description: "Select apartments within the specified radius from the
    user-defined centre; compute geodesic distance from centre for each
    retained apartment"

artifact D_scoped : entities
  internal structure: elementary
  embedment: {set, space}
  features:
    - id: all_original_features
      value structure: vector
      value type: {numeric, categorical}
      description: "All original features retained"
  description: "Subset of apartments within the user-specified spatial
    scope (N items depending on distance threshold)"

artifact F_distance : feature(D_scoped)
  value structure: atomic
  value type: numeric
  description: "Geodesic distance from each apartment to the user-specified
    centre point, in kilometres"

# ============================================================================
# PHASE 2: CRITERIA SELECTION AND FEATURE PREPARATION
# ============================================================================

transform T_visualise_overview :
  intent: visualise
  manner: "geographic map with attribute overview panels"
  input: D_scoped, F_distance, D_map_context
  output: V_overview
  actor: machine
  description: "Display scoped apartments on map with coordinated panels
    showing distributions of all available numeric and categorical
    attributes; support brushing and linking for spatial-attribute
    exploration"

artifact V_overview : visualisation(D_scoped, F_distance, D_map_context)
  layout: "geographic map with coordinated distribution panels"
  form: "point markers on map; histograms and bar charts in panels"
  encoding: "map position from coordinates; marker colour by
    pricePerSqm; panels show per-attribute distributions with
    missing-value indicators"
  description: "Overview of spatially scoped apartment set showing
    geographic distribution and attribute summaries including
    data completeness"

transform T_select_criteria :
  intent: generate-knowledge
  manner: "interactive selection of attributes to serve as decision criteria"
  input: V_overview, D_scoped
  output: S_criteria_selection
  actor: human
  description: "User selects which numeric attributes to use as decision
    criteria (7–12 from available features); inspects distributions and
    completeness to inform selection; decides whether to include
    distance as a criterion or treat it separately"

artifact S_criteria_selection : specification
  representation form: "ordered list of selected criteria with roles"
  description: "User-selected criteria: list of attribute IDs designated
    as decision criteria, indication of optimisation direction
    (minimise/maximise) for each, and decision on distance role
    (included in criteria set vs. used only for arrangement)"

transform T_preprocess :
  intent: characterise
  manner: "handle missing values; normalise features to [0,1] for NMF
    compatibility; encode selected categoricals as ordinal where
    applicable"
  input: D_scoped, S_criteria_selection
  output: F_normalised
  actor: machine
  description: "Prepare selected criteria for utility computation and
    NMF: impute or flag missing values, apply min-max normalisation
    to ensure non-negativity, encode ordinal categoricals numerically"

artifact F_normalised : feature(D_scoped)
  value structure: vector
  value type: numeric
  description: "Normalised feature vectors for selected criteria;
    all values in [0,1]; missing values handled by imputation or
    exclusion flag"

# ============================================================================
# PHASE 3: MAIN ANALYSIS LOOP
# ============================================================================

artifact S_utility_functions : specification
  origin: given
  representation form: "piecewise-linear utility function definitions"
  description: "Initial utility functions mapping each criterion's raw
    value range to [0,1] utility scale; default: linear mapping
    aligned with optimisation direction"

artifact S_subgroup_params : specification
  origin: given
  representation form: "parameter settings"
  description: "Parameters for subgroup discovery: number of NMF
    components (topics), number of clusters, clustering method
    (k-means, DBSCAN), and tolerance parameter epsilon for
    Pareto dominance"

loop L_analysis:
  purpose: "Iteratively refine utility definitions, subgroup structure,
    and Pareto tolerance until interpretable subgroups with meaningful
    within-group rankings emerge"
  until: "Subgroups are interpretable as distinct apartment types;
    within-group Pareto layers provide actionable discrimination;
    analyst has sufficient understanding for decision support"

  body:

    # ======================================================================
    # Step 3a: Define/refine utility functions interactively
    # ======================================================================

    transform T_define_utilities :
      intent: generate-knowledge
      manner: "interactive piecewise-linear utility function editing with
        distribution histograms as background"
      input: F_normalised, S_utility_functions, S_criteria_selection
      output: S_utility_functions_r
      actor: human
      description: "User defines or adjusts utility functions for each
        criterion by manipulating control points on a function editor;
        background shows the value distribution histogram to inform
        threshold and shape choices; supports linear, concave, convex,
        and step functions"

    artifact S_utility_functions_r : specification
      representation form: "piecewise-linear utility function definitions"
      description: "Updated utility functions reflecting user preferences:
        control points, breakpoints, and resulting mapping from criterion
        values to [0,1] utility"

    assign:
      S_utility_functions := S_utility_functions_r

    # ======================================================================
    # Step 3b: Compute utility values
    # ======================================================================

    transform T_compute_utilities :
      intent: characterise
      manner: "apply utility functions to normalised criteria values"
      input: D_scoped, F_normalised, S_utility_functions
      output: F_utility_vectors
      actor: machine
      description: "Transform each apartment's criterion values through
        the user-defined utility functions to obtain utility vectors;
        all values in [0,1] where 1 = maximum desirability"

    artifact F_utility_vectors : feature(D_scoped)
      value structure: vector
      value type: numeric
      description: "Per-apartment utility vectors: one utility value per
        selected criterion, all in [0,1]; serves as input for both
        subgroup discovery and Pareto analysis"

    # ======================================================================
    # Step 3c: Subgroup discovery via clustering
    # ======================================================================

    transform T_cluster_apartments :
      intent: define-unit
      manner: "cluster-by-similarity in utility space"
      input: D_scoped, F_utility_vectors, S_subgroup_params
      output: D_clusters, F_cluster_labels
      actor: machine
      description: "Group apartments by similarity of utility profiles
        using specified clustering method; reveals natural groupings
        of apartments with similar multi-criteria characteristics"

    artifact D_clusters : entities
      internal structure: group/cluster
      embedment: set
      features:
        - id: cluster_size
          value structure: atomic
          value type: numeric
          description: "Number of apartments in cluster"
        - id: cluster_centroid
          value structure: vector
          value type: numeric
          description: "Mean utility vector of cluster"
      description: "Groups of apartments with similar utility profiles;
        each group potentially corresponds to an apartment type
        (e.g., large family flats, cheap studios, luxury units)"

    artifact F_cluster_labels : feature(D_scoped)
      value structure: atomic
      value type: categorical
      description: "Cluster membership identifier for each apartment"

    # ======================================================================
    # Step 3d: NMF topic modelling for latent profile discovery
    # ======================================================================

    transform T_nmf_topics :
      intent: define-unit
      manner: "non-negative matrix factorisation for latent profile extraction"
      input: D_scoped, F_utility_vectors, S_subgroup_params
      output: D_topics, F_topic_weights, F_topic_compositions
      actor: machine
      description: "Decompose the utility matrix (apartments × criteria)
        via NMF into K latent topics (apartment profiles) and per-apartment
        topic weights; each topic is a characteristic combination of
        utility values representing a latent apartment type"

    artifact D_topics : entities
      internal structure: elementary
      embedment: set
      features:
        - id: topic_id
          value structure: atomic
          value type: categorical
          description: "Topic identifier"
      description: "Latent apartment profile topics discovered by NMF;
        each topic represents a characteristic combination of criterion
        utilities (e.g., 'spacious but expensive', 'compact and central',
        'old but well-equipped')"

    artifact F_topic_weights : feature(D_scoped)
      value structure: vector
      value type: numeric
      description: "Per-apartment weights indicating affinity to each
        latent topic; soft assignment allowing apartments to partially
        belong to multiple types"

    artifact F_topic_compositions : feature(D_topics)
      value structure: vector
      value type: numeric
      description: "Per-topic criterion utility loadings (H matrix from
        NMF); each entry indicates how strongly a criterion contributes
        to defining the topic"

    # ======================================================================
    # Step 3e: Tolerant Pareto analysis
    # ======================================================================

    transform T_pareto_analysis :
      intent: characterise
      manner: "compute epsilon-dominance Pareto layers with distance
        integration"
      input: D_scoped, F_utility_vectors, F_distance, S_subgroup_params,
        F_cluster_labels
      output: F_pareto_depth, F_pareto_distance
      actor: machine
      description: "Compute Pareto depth layers using epsilon-dominance:
        apartment A epsilon-dominates B if A is better by at least epsilon
        on all criteria where A exceeds B. Compute within each cluster
        and globally. Add distance-to-ideal-point as summary score.
        Tolerant dominance accounts for measurement imprecision and
        missing data by requiring dominance margin epsilon."

    artifact F_pareto_depth : feature(D_scoped)
      value structure: vector
      value type: numeric
      description: "Pareto layer assignment for each apartment: layer 0 =
        non-dominated frontier, layer 1 = dominated only by layer 0, etc.
        Computed both globally and within each cluster. Includes count of
        dominators and dominated options."

    artifact F_pareto_distance : feature(D_scoped)
      value structure: atomic
      value type: numeric
      description: "Distance to ideal point in utility space (Euclidean or
        weighted); provides continuous ranking complementing discrete
        Pareto layers"

    # ======================================================================
    # Step 3f: Spatial contextualisation
    # ======================================================================

    transform T_contextualise_spatial :
      intent: contextualise
      manner: "map-based arrangement with subgroup encoding"
      input: D_scoped, D_map_context, F_cluster_labels, F_distance
      output: A_spatial
      actor: machine
      description: "Arrange apartments in geographic context with distance
        rings from user centre; enables spatial reading of subgroup
        distribution"

    artifact A_spatial : arrangement(D_scoped)
      context: D_map_context
      principle: "geographic coordinates with distance-ring overlay from
        user-specified centre"
      description: "Geographic arrangement of apartments with concentric
        distance rings and cluster membership for spatial pattern reading"

    # ======================================================================
    # Step 3g: Multi-view visualisation
    # ======================================================================

    transform T_visualise_analysis :
      intent: visualise
      manner: "coordinated multi-view display: map, parallel coordinates,
        topic composition chart, Pareto layer scatter, utility histograms"
      input: A_spatial, F_utility_vectors, F_cluster_labels,
        F_topic_weights, F_topic_compositions, F_pareto_depth,
        F_pareto_distance, D_topics, D_clusters
      output: V_analysis
      actor: machine
      description: "Render coordinated views supporting simultaneous
        exploration of spatial distribution, multi-criteria trade-offs,
        subgroup structure, topic compositions, and Pareto layers;
        brushing and linking across all views"

    artifact V_analysis : visualisation(A_spatial, F_utility_vectors,
      F_cluster_labels, F_topic_weights, F_pareto_depth)
      layout: "coordinated multi-panel: geographic map, parallel
        coordinates, NMF topic bar chart, Pareto layer scatterplot,
        per-criterion utility histograms by cluster"
      form: "coloured point markers on map; polylines in parallel
        coordinates; stacked bars for topic compositions; layered
        scatter for Pareto depth; grouped histograms"
      encoding: "map position from A_spatial; colour from cluster or
        dominant topic; parallel coordinate axes from utility criteria;
        vertical position in Pareto scatter from depth layer; bar
        segment width from topic criterion loadings; histogram fill
        by cluster; opacity modulated by Pareto depth"
      description: "Comprehensive analytical display enabling
        simultaneous assessment of spatial patterns, subgroup
        interpretability, topic meaningfulness, Pareto discrimination,
        and utility trade-offs across all apartments"

    # ======================================================================
    # Step 3h: Pattern identification
    # ======================================================================

    transform T_interpret_subgroups :
      intent: abstract
      manner: "interpret cluster and topic meanings; identify apartment
        types and trade-off patterns"
      input: V_analysis, D_clusters, D_topics, F_topic_compositions,
        F_pareto_depth
      output: P_subgroup_patterns
      actor: human
      description: "Interpret discovered subgroups as meaningful apartment
        types (e.g., 'affordable small flats near centre', 'spacious
        suburban family homes', 'renovated old-building flats with
        character'); identify within-group Pareto trade-off structures;
        assess correspondence between clusters and NMF topics"

    artifact P_subgroup_patterns : pattern(D_clusters, D_topics)
      representation form: "labelled subgroup descriptions with
        characteristic trade-off structures"
      description: "Interpreted apartment types with semantic labels,
        characteristic utility profiles, spatial tendencies, and
        within-type Pareto trade-off descriptions"

    # ======================================================================
    # Step 3i: Assessment and refinement decision
    # ======================================================================

    transform T_assess_analysis :
      intent: assess
      manner: "evaluate subgroup interpretability, Pareto discrimination
        power, and utility function adequacy"
      input: V_analysis, P_subgroup_patterns, F_pareto_depth,
        D_clusters, D_topics
      output: K_assessment
      actor: human
      description: "Assess: (1) Are subgroups interpretable as distinct
        apartment types? (2) Does Pareto depth provide meaningful
        discrimination within groups (not all on frontier)? (3) Do
        utility functions reflect actual preferences? (4) Is the number
        of topics/clusters appropriate? Identify what needs refinement."

    artifact K_assessment : knowledge(D_clusters, D_topics)
      representation form: "quality judgment with refinement guidance"
      description: "Assessment of analysis quality: subgroup
        interpretability, Pareto discrimination power, utility function
        adequacy, and identification of what requires adjustment
        (utility shapes, number of components, epsilon tolerance,
        criteria selection)"

    if K_assessment indicates refinement needed:
      then:
        transform T_adjust_parameters :
          intent: generate-knowledge
          manner: "adjust analysis parameters based on assessment"
          input: K_assessment, S_subgroup_params, S_utility_functions,
            S_criteria_selection
          output: S_subgroup_params_r, S_criteria_selection_r
          actor: human
          description: "Adjust parameters based on assessment: change
            number of clusters/topics, modify epsilon tolerance, revise
            criteria selection, or flag need for utility function
            redesign in next iteration"

        artifact S_subgroup_params_r : specification
          representation form: "parameter settings"
          description: "Updated subgroup discovery parameters: number of
            NMF components, cluster count, epsilon value, clustering
            method"

        artifact S_criteria_selection_r : specification
          representation form: "ordered list of selected criteria with roles"
          description: "Potentially revised criteria selection"

        assign:
          S_subgroup_params := S_subgroup_params_r
          S_criteria_selection := S_criteria_selection_r

      else:
        exit loop L_analysis

end loop L_analysis

# ============================================================================
# PHASE 4: WITHIN-SUBGROUP EXPLORATION AND SENSITIVITY
# ============================================================================

transform T_select_subgroup :
  intent: define-unit
  manner: "interactive selection of subgroup of interest"
  input: D_scoped, D_clusters, D_topics, F_cluster_labels,
    F_topic_weights, P_subgroup_patterns, V_analysis
  output: D_focus_group
  actor: human
  description: "User selects one or more subgroups (clusters or
    topic-dominant sets) for detailed within-group ranking and
    sensitivity analysis"

artifact D_focus_group : entities
  internal structure: elementary
  embedment: {set, space}
  features:
    - id: focus_features
      value structure: vector
      value type: numeric
      description: "Utility values and Pareto metrics for focused subset"
  description: "Selected subset of apartments belonging to the
    user-chosen subgroup(s) for detailed ranking analysis"

transform T_sensitivity_analysis :
  intent: characterise
  manner: "compute ranking sensitivity to utility function parameters
    and criterion weights"
  input: D_focus_group, F_utility_vectors, F_pareto_depth,
    S_utility_functions
  output: F_sensitivity
  actor: machine
  description: "Assess how apartment rankings change under perturbation
    of utility function control points and relative criterion weights;
    identify robust top-performers vs. sensitive alternatives"

artifact F_sensitivity : feature(D_focus_group)
  value structure: vector
  value type: numeric
  description: "Ranking stability indicators: range of rank positions
    under parameter perturbation; identification of robust vs.
    sensitive alternatives"

transform T_visualise_ranking :
  intent: visualise
  manner: "within-group ranking display with sensitivity indicators"
  input: D_focus_group, F_utility_vectors, F_pareto_depth,
    F_pareto_distance, F_sensitivity, A_spatial
  output: V_ranking
  actor: machine
  description: "Display within-group ranking with Pareto layers,
    distance-to-ideal scores, sensitivity bands, and spatial context;
    support individual apartment inspection"

artifact V_ranking : visualisation(D_focus_group, F_pareto_depth,
  F_sensitivity)
  layout: "ranked list with coordinated map and sensitivity display"
  form: "ranked cards with utility radar charts; map with highlighted
    subset; sensitivity band chart"
  encoding: "vertical position by rank (distance-to-ideal); radar chart
    shows per-criterion utility; card border colour by Pareto layer;
    band width shows ranking sensitivity; map highlights focus group
    with Pareto-layer colour"
  description: "Within-subgroup ranking view enabling comparison of
    top alternatives with sensitivity awareness and spatial context"

# ============================================================================
# PHASE 5: KNOWLEDGE SYNTHESIS
# ============================================================================

transform T_identify_candidates :
  intent: abstract
  manner: "identify promising candidates and characterise trade-offs"
  input: V_ranking, V_analysis, P_subgroup_patterns
  output: P_candidates
  actor: human
  description: "Identify most promising apartment candidates within
    selected subgroup(s); characterise their trade-off profiles and
    robustness; note alternatives in other subgroups worth considering"

artifact P_candidates : pattern(D_focus_group)
  representation form: "ranked candidate descriptions with trade-off
    characterisations"
  description: "Identified top candidates with descriptions of their
    strengths, weaknesses, trade-offs, and ranking robustness"

transform T_synthesise :
  intent: generate-knowledge
  manner: "formulate decision support statements"
  input: P_candidates, P_subgroup_patterns, K_assessment,
    F_sensitivity
  output: K_decision_support
  actor: human
  description: "Synthesise findings into decision support knowledge:
    which apartment types exist in the search area, which subgroup
    best matches user needs, which specific apartments are robust
    top performers, and what trade-offs are unavoidable"

artifact K_decision_support : knowledge(P_candidates, P_subgroup_patterns)
  representation form: "statements, rankings, and trade-off explanations"
  description: "Decision support output: identified apartment market
    segments in the area, recommended subgroup(s) matching user profile,
    ranked shortlist of robust candidates with trade-off explanations,
    sensitivity caveats, and identified data gaps"

Summary of Scientific Novelty Captured in This Workflow

Novel Element	Where in Workflow	How It Extends Prior Work
Utility-space subgroup discovery	T_cluster_apartments + T_nmf_topics	Replaces rigid predefined categories with data-driven, preference-aware grouping
NMF "topics" as apartment profiles	T_nmf_topics → D_topics, F_topic_compositions	Soft assignment reveals latent types as interpretable criterion combinations
Tolerant Pareto (ε-dominance layers)	T_pareto_analysis → F_pareto_depth	Addresses dimensionality curse + data imperfections; provides depth layers instead of binary frontier membership
Iterative utility↔subgroup co-refinement	Loop L_analysis (utility definition informs grouping; grouping informs utility revision)	Traditional MCDA fixes utilities before analysis; here structure and preference co-evolve
Dual grouping (clustering + NMF)	Comparing F_cluster_labels vs F_topic_weights	Hard vs. soft assignment reveals different structural aspects; their agreement/disagreement is informative
Within-group sensitivity analysis	T_sensitivity_analysis	Ranking robustness assessed within identified subgroups rather than globally

This workflow extends your earlier spatial MCDA work (IVS'03, JDS'03, IJGIS'01) by adding the subgroup discovery phase before traditional weighting/ranking, and by relaxing strict Pareto dominance into layered ε-dominance—both motivated by the practical reality of heterogeneous option spaces and imperfect data.