Guess-then-Refine Framework

• The framework is a multi-level design paradigm that begins with a coarse abstract ‘guess’ and iteratively refines models to ensure alignment with overarching functional requirements.
• It integrates with John Gero’s FBS framework, employing sequential operators to synthesize function, behaviour, structure, and documentation in a systematic abstraction process.
• The method supports complex systems engineering and incremental prototyping by managing design complexity via rigorous abstraction and iterative evaluation loops.

The Guess-then-Refine Framework is a design paradigm for systematically managing complexity and abstraction in the engineering of artifacts, processes, or concepts. Central to this framework is the iterative progression from a coarse initial "guess"—an abstract model or solution—toward a successively refined operational realization, repeatedly verifying at each stage that the increased detail faithfully implements higher-level intentions. The technique is formalized within design science by its integration into John Gero’s Function–Behaviour–Structure (FBS) framework for design, and extended to support layered abstraction (Diertens, 2013).

1. Function–Behaviour–Structure (FBS) Foundations

The original FBS framework represents core elements of engineered artifact design:

• Function (F): High-level requirements and intended objectives.
• Expected Behaviour (Be): Behaviours hypothesized to satisfy functional requirements.
• Structure (S): Configuration and interrelation of components realizing the behaviour.
• Structure Behaviour (Bs): Behaviour emergent from the chosen structure.
• Description (D): Supplemental specifications required for implementation.

The process flows in stages: formulation (F → Be), synthesis (Be → S), analysis (S → Bs), evaluation (Be, Bs), and documentation (S → D), with reformulation loops for iterative improvement.

2. Abstraction and Refinement Across Multiple Design Layers

To control design complexity, the framework introduces explicit multi-level refinement:

• Define Model M (abstract) and Model M′ (refined), both equipped with the FBS process but at distinct abstraction levels.
• Every element in M′ (F′, S′, D′, etc.) is constructed as a detailed refinement of its counterpart in M (F, S, D, etc.).
• The relationship is depicted as:

Model M	Model M′
F	F′
S	S′
D	D′

Here, "refining" arrows indicate the directed development of detailed representations from abstract ones.

3. Sequential Guess and Refinement Operators

Refinement comprises four interlinked operators:

• Functionality Refinement:

$F' = \mathrm{refine}(F, D)$ F′ combines abstract function F and details from D. This forms the initial design "guess".

• Expected Behaviour Refinement:

$Be' = \mathrm{refine}(Be, F')$ Be′ merges top-level behaviour Be and new expectations in F′.

• Structure Refinement:

$S' = \mathrm{synthesize}(S, Be')$ S′ is synthesized from S (the abstract structure) considering refined behavioural requirements Be′.

• Description Refinement:

$D' = \mathrm{document}(D, S')$ D′ contains all original and newly derived description elements from S′.

This process is layerwise recursive, accommodating any number of abstraction levels:

$M \rightarrow M' \rightarrow M'' \rightarrow \dots$

4. Behaviour Evaluation and Iterative Correction

Verification is conducted via abstraction of refined behaviour:

• Derive abstract behaviour Bs from S.
• Derive refined behaviour Bs′ from S′.
• Employ an abstraction mapping: if $\mathrm{abstraction}(Bs') \neq Bs$, reformulation is triggered at one or both levels.

Reformulation loops ensure consistency; if an implementation modification in M′ breaks fidelity with M, corresponding changes must propagate upward to maintain coherence.

5. Architectural Diagram and Mathematical Formalization

The refinement workflow is captured in the following LaTeX diagram, explicitly mapping abstract and refined elements and their interrelations:

\documentclass{article} \usepackage{tikz} \begin{document} \begin{tikzpicture}[node distance=2cm, auto] \node (F) [draw, rectangle] {F}; \node (Be) [draw, rectangle, right of=F, xshift=1.5cm] {Be}; \node (S) [draw, rectangle, right of=Be, xshift=1.5cm] {S}; \node (D) [draw, rectangle, right of=S, xshift=1.5cm] {D}; \node (Fprime) [draw, rectangle, below of=F] {F'}; \node (Beprime) [draw, rectangle, below of=Be] {Be'}; \node (Sprime) [draw, rectangle, below of=S] {S'}; \node (Dprime) [draw, rectangle, below of=D] {D'}; \draw[->] (F) -- node {+ D} (Fprime); \draw[->] (Be) -- node {+ F'} (Beprime); \draw[->] (S) -- node {+ Be'} (Sprime); \draw[->] (D) -- node {+ S'} (Dprime); \draw[->, dashed] (Sprime) -- node[swap]{abstraction} (S); \end{tikzpicture} %%%%6%%%% \end{document}

These formal operators define the systematic evolution of design elements.

6. Extension to Multi-Level Abstraction

The process generalizes to arbitrary abstraction depths—chains of design models—thus supporting highly complex systems via gradual, controllable refinement of solutions. At each level, the refinement operators maintain fidelity, satisfying requirements while introducing new implementation detail.

At each refinement:

• The refined function, behaviour, structure, and documentation are produced using combinations of their respective abstract counterparts and local, more detailed information.
• Evaluation ensures that each lower-level realization remains a faithful implementation of its higher-level abstract intention.

7. Applications and Context Significance

The Guess-then-Refine Framework, as embedded in the refined FBS architecture (R-FBS), is critical for:

• Complex systems engineering, where strict multi-level traceability is required.
• Incremental prototyping, allowing design teams to validate implementations at arbitrary abstraction.
• Managing reformulation among levels, enabling adaptive design in response to failed abstraction fidelity.

By supporting explicit relationships among all design artifacts through rigorous abstraction/refinement operators and iterative evaluation, the framework delivers scalable control over complexity, fidelity, and traceability.

Summary Table: Key Operators

Step	Inputs	Output
Function	D, F	F′
Behaviour	Be, F′	Be′
Structure	S, Be′	S′
Documentation	D, S′	D′

This framework provides a robust foundation upon which multiple layers of system design can be constructed and verified, forming a principled basis for iterative, complexity-conscious engineering and design.