aima | Python code from Peter Norvig | Machine Learning library

As far as I can see, you first create a list of clauses in the clause array. This you then use to initialise the knowledge base KB.

With the tell() method, you can add further expressions/clauses to the knowledge base.

In principle they are equivalent, in that both ways of doing this result in clauses being added to the knowledge base, only some at initialisation, others afterwards.

You might have a particular setting/domain which is fixed, and different expressions for different problems, so you can put all the common expressions in at the beginning, and add others later during processing.

Without any Javascript, you can use the so-called 'checkbox-hack', which basically means that you use a hidden HTML checkbox and (ab)use its :checked state to hide/show some other element(s).

Base logic:

I know this answer does not produce a minimal reproducible sample, but this provides a solution for the OP needings.

Code:

You aren't using any constructor because links and page are pointers. Pointers do not have constructors.

Maybe you want this?

It seems the neighbour is not optimal.

You can find the div and then get the text:

You need to clone the whole Github repo, not only download (or copy from) the Notebook.

See utils.py is a separate file.

https://github.com/aimacode/aima-python/blob/master/utils.py

Also refer to Installation Guide

Your teacher seems to be (mostly) right.

This does not necessarily seem like a problem that has to be addressed programmatically, it can also be solved mathematically (which is probably what your teacher did and why he could say your code must be bugged without looking at it).

Let V(S, C) denote the value of choosing color C in a state S. We trivially have V(S2, C) = 0 for all colors C.

It is easy to write down the true values V(S0, R) and V(S1, R) for selecting the red action in S0 or S1, because they don't depend on the values of any other states (technically they do depend on the values of S2, but those are 0 so we can leave them out):

• V(S0, R) = 0.9 * (-2 + gamma * V(S0, R))
• V(S1, R) = 0.6 * (-5 + gamma * V(S1, R))

With a bit of arithmetic, these can be rewritten as:

• V(S0, R) = -1.8 / (1 - 0.9 * gamma)
• V(S1, R) = -3 / (1 - 0.6 * gamma)

It is also useful to observe that a policy that selects B (blue) in both states S0 as well as S1 will never ever be optimal. Such a policy would never reach S2 and simply keep collecting an infinite number of negative rewards.

Knowing that, we can easily write V(S0, B) in terms of V(S0, B) and V(S1, R). We don't have to consider a V(S1, B) term in the value V(S0, B) because it would never be optimal to play B in S1 when we're considering the case where we also play B in S0 already:

V(S0, B) = 0.5 * (-2 + gamma * V(S0, B)) + 0.5 * (-5 + gamma * V(S1, R))

which simplifies to:

V(S0, B) = -3.5 + 0.5 * gamma * V(S0, B) + 0.5 * gamma * (-3 / (1 - 0.6 * gamma))

Now that we have nice expressions for V(S0, R) and V(S0, B), we can subtract one from the other: if the expression V(S0, B) - V(S0, R) is positive, the optimal policy will play B in S0. If it is negative, R will be played instead.

With a whole lot more of arithmetic, it should be possible to solve an inequality like V(S0, B) > V(S0, R) now. A much easier solution (albeit one that your teacher probably wouldn't like you trying on an exam) is to plug the deduction of the two values (= (-3.5 + (-1.5x / (1 - 0.6x))) / (1 - 0.5x) + (1.8 / (1 - 0.9x))) into google and see where the plot intersects the x-axis: this is at x = 0.96 (e.g. gamma = 0.96). So, it appears like your teacher made a small mistake in that solution (b) actually holds for any gamma > 0.96, rather than any gamma > 0.98.

Of course, the same kind of reasoning and arithmetic will work for other value functions which I did not consider yet, such as V(S1, B).

As for why your programming-based solution doesn't work, there does indeed appear to be a small bug; in the Policy Evaluation step, you only loop through all the states once. Multiple such loops in a row may be required. See how the Russel and Norvig book indeed mentions that a modified version of Value Iteration can be used for this function, which itself keeps looping until the utilities hardly change.

Based on the pseudocode in Sutton and Barto's Reinforcement Learning book, the Policy Evaluation function can be fixed as follows:

The function is defined in utilities/utilities.lisp: