Intelligent agents

3.

4. Decision tree provided by homework.

Is this a better decision tree?

#include <limits.h>

struct State {
	long long min;
	long long max;
	unsigned char response;
};

/*@
   requires LLONG_MIN < environment < LLONG_MAX;
   assigns \nothing;
   ensures \result \in {1,2,4,5,6,7};
   ensures environment == -20 ==> \result == 1;
   ensures environment == 40 ==> \result == 6;
   ensures environment == 2 ==> \result == 1;
   ensures environment == 35 ==> \result == 6;
   ensures environment == 14 ==> \result == 4;
   ensures environment == 45 ==> \result == 7;
   ensures environment == 6 ==> \result == 2;
   ensures environment == 22 ==> \result == 5;
   ensures environment == 9 ==> \result == 2;
*/
int choose_best_decision(int environment) {
	struct State states[6] = {
		{.min=LLONG_MIN,.max=2,.response=1},
		{.min=3,.max=9,.response=2},
		{.min=10,.max=14,.response=4},
		{.min=15,.max=22,.response=5},
		{.min=23,.max=40,.response=6},
		{.min=41,.max=LLONG_MAX,.response=7},
	};
	int n = sizeof(states)/sizeof(states[0]);
	//@ assert \exists int j; 0 <= j < n ==> states[j].min <= environment <= states[j].max;
	int j = 0;
	/*@ loop invariant 0 <= j < n;
	    loop invariant \forall int i; 0 <= i < j ==> !(states[i].min <= environment <= states[i].max);
	    loop assigns j;
	    loop variant n-j;
	 */
	while((states[j].min > environment || environment > states[j].max) && j++<n-1);
	return states[j].response;
}

/*@ 
 assigns \nothing; 
*/
int main() {
	return 0;
}

5.

1. Our decision tree uses accuracy as a performance measure, that is, which measures are correctly categorized.

2. Formally, accuracy is

where TP=True positive; FP=False positive; TN=True negative; FN=False negative.

but our case is multiclass classification so

c.

The following is the confusion matrix from the decision tree that was provided by the instructor.

The following is the confusion matrix from the decision tree that was provided by me.

d. Our performance measure can’t measure true negative and false negative, so it is misleading.

8. Simplex reflex agent

Note it’s not practical to build such an agent because it occupies a lot of memory, in fact, $O(ln)$ where $n$ is the number of solutions and $l$ is the number of equations in our database.

It doesn’t solve all cases because our memory is limited.

Another reflex agent can be a one-solution solver from Numerical analysis fitting our needs.

9.

Where environment provides ‘Dirty’ and ‘Clean’ which are perceptions. Our agent has the current state when it percepts a new state, it transits to a new state and save cells.

class Agent:
   current_state = "A"
   cell = 1
   cells = 4
   states = {
      'A': {
         'dirty': 'A',
         'clean': 'B',
         'response': 'Suck' 
      },
      'B': {
         'dirty': 'A',
         'clean': 'B',
         'response': 'Move forward & turn 90 degrees' 
      }
   }
 def choose_decision(perception: 'dirty' | 'clean'):
     if cell == 4:
        return 'FINISH'
     current_state = states[current_state][perception]
     cell++
     return states[current_state]['response']

Agent Program.

Search for solutions with a path-finder algorithm (DFS, A*, BFS, …), generate a new $q_{n}$ location from a $q_{n-1}$ location where $q_0$ is free, and test the position with chess queen movements.

11.

Agent Program.

Search for solutions with a path-finder algorithm, generate a new $q_{n}$ location from a $q_{n-1}$ location where $q_0$ is the initial puzzle, and test the position with the puzzle goal.