Skill: Means End Analysis

Skill Description: A general-purpose problem-solving method that allows us to look at our goal and continually move towards it by choosing the next state with the least delta to the goal.

--------------------------------------------------
Problem: Blocks World

Problem Description: The Blocks World problem involves a block arrangement, each represented by a block(e.g., A, B, C, D) and its position, and a table surface. The valid rules are simple: Blocks can be placed on top of each other. Only one block can be placed on top of another block. To move a block that has other blocks placed on top of it, you must first remove the blocks above it until the desired block is free to move. Blocks can also be placed on the table. The primary objective of the Blocks World problem is to select a series of valid moves to go from an initial block arrangement into the goal block arrangement.

Nouns: block arrangement, block, position, table, valid rules, valid moves, goal block arrangement

Verb phrases: place on top, place directly, remove

Stative verbs:  has other blocks on top, free

--------------------------------------------------

Knowledge

Concepts and Instances:

block description:
Concept(movable) //Boolean property of a block, resolve to stative verbs
Concept(block {Property(name), Property(movable});
Instance(block, BlockA, True);
Instance(block, BlockB, True);
Instance(block, BlockC, True);
Instance(block, BlockD, True);

table description:
Concept(table {Property(name));
Instance(table, Table1);

delta description:
Concept(delta {Property(name});
Instance(delta, Delta);

block arrangement description:
Concept(block_arrangement, block_arrangement_name, [block instances], table_instance, [block_table_triples]);


Relations and Triples:

on description:
Relation(on, block, block);
Relation(on, block, table);

goal state description:
Instance(block_arrangement, Goal, [BlockA, BlockB, BlockC, BlockD], Table1, 
	[on(BlockA, BlockB), on(BlockB, BlockC), on(BlockC, BlockD), on(BlockD, Table)])

initial states description:
Instance(block_arrangement, Block_Arrangement_1, [BlockA, BlockB, BlockC, BlockD], Table2, 
	[on(BlockA, BlockD), on(BlockB, BlockC), on(BlockC, Table), on(BlockD, BlockB)])

Instance(block_arrangement, Block_Arrangement_2, [BlockA, BlockB, BlockC, BlockD], Table3, 
	[on(BlockA, Table), on(BlockB, BlockC), on(BlockC, Table), on(BlockD, BlockA)])
	
Instance(block_arrangement, Block_Arrangement_3, [BlockA, BlockB, BlockC, BlockD], Table4, 
	[on(BlockA, Table), on(BlockB, BlockC), on(BlockC, Table), on(BlockD, Table)])


--------------------------------------------------
Methods

Operations:

Compare Current to Goal:
Operation(Compare_Current_to_Goal(current_block_arrangement: block_arrangement, goal_block_arrangement: block_arrangement),
    true, current_block_arrangement != goal_block_arrangement);


Select Next Block Move:
Operation(Select_Next_Block_Move(validated_block_arrangements: [block_arrangement]), 
    true, selected_move != none);

Update Current Arrangement:
Operation(Update_Current_Arrangement(current_block_arrangement: block_arrangement, selected_move: move),
    true, updated_block_arrangement != current_block_arrangement);

Generate Move List:
Operation(Generate_Move_List(current_block_arrangement: block_arrangement), 
    true,move_list != []);

Apply and Validate Move:
Operation(Apply_and_Validate_Move(move_list: [move], current_block_arrangement: block_arrangement), 
    true, valid_moves != []);

Count Delta Difference:
Operation(Count_Delta_Difference(validated_block_arrangements: [block_arrangement]), 
    true, delta_values != []);

Organizer/FSM:
Top Level Transition:
- Compare Current to Goal -> Generate Valid Block Moves* -> Select Next Block Move -> Update Current Arrangement.

Sub Level Transition(Generate Valid Block Moves*):
- Generate Move List -> Apply and Validate Move -> Count Delta Difference

--------------------------------------------------
Tasks

solve using means ends analysis description:
Solves a Block World problem using Means End Analysis by selecting valid moves to transform an initial block arrangement into the goal block arrangement. The task involves comparing positions, generating valid block moves, and choosing the move with the lowest delta.