ACI — mid-sem paper, fully solved.

Acting humanly (Turing-test view). Sana imitates a human: fluent speech, natural follow-ups, reading facial expressions. By this yardstick it “passes” as human-like. But acting humanly only measures resemblance to humans, not correctness.

Acting rationally (rational-agent view). The real question is whether Sana maximises a well-defined performance measure — hiring the best-suited candidate fairly, given its percepts. Speaking fluently and looking human do not guarantee the decisions are rational or correct.

Is human-like behaviour enough? No. Imitating a human interviewer (passing a Turing-style test) does not make a system intelligent in the engineering sense. Intelligence here = making rational, justifiable decisions. The claim “removes human bias” is also false: a learned model inherits bias from its training data, so it can encode bias while appearing neutral.

At least two risks.

1. Bias & discrimination. Facial-expression and speech scoring can systematically disadvantage candidates by ethnicity, accent, disability, or neurodivergence — bias learned from historical hiring data.
2. Lack of transparency / accountability. A black-box recommendation is hard to explain or contest, raising legal and ethical problems (who is responsible for a wrong rejection?).
3. (Extra) Privacy of biometric/facial data, and candidates gaming superficial cues the model rewards.

(A) PEAS.

(B) Task-environment dimensions.

(Also known map but partially unknown dynamics of people.)

Graph data. Heuristics: S=9, A=8, B=6, C=7, D=4, E=6, F=3, G=0. Edges (directed, cost): S→A 1, S→B 5, A→C 3, A→D 4, A→B 2, C→B 4, C→F 5, B→D 3, B→E 3, D→F 6, E→D 6, E→G 10, F→G 5.

(A) A* with \(f(n)=g(n)+h(n)\). Track the best g per node.

Expansion order: S, A, B, D, C, E, F, G.
Optimal path: S → A → C → F → G, cost 1+3+5+5 = 14. (Checks: S-A-D-F-G = 16, S-A-B-D-F-G = 17, so 14 is least-cost.)

(B) Disprove. Greedy Best-First uses only \(h(n)\) and ignores cost so far \(g(n)\), so it is neither optimal nor complete. On this very graph, greedy from S picks the lowest-h neighbour each time: S→B(6)→D(4)→F(3)→G(0), cost 5+3+6+5 = 19 — worse than A*’s 14. So “closest to goal” is not always smart; the heuristic can be misled. Babloo is wrong.

Grid (rows A–E = 1–5, cols 1–5; EXIT = D5):

(A) Search tree. From A1, only valid moves are Right→A2 and Down→B1 (up/left off-grid).

(A2→Down = B2 blocked; B1→Right = B2 blocked — both pruned.)

(B) Costs & heuristics. Total supplies on board at start = 4 (kits A4, D1; food B4, D3). None of A2/B1/A3/C1 are supply cells, so RemainingSupplies = 4 throughout. Smoke cells: A3, C2, D4.

Smoke entry cost = normal +1 plus extra +12 = 13, so A3’s g = 1 (A2) + 13 = 14. The cheapest-looking frontier node is B1/C1 — the drone should head down, not into the smoke.

Increase population size and generations for a wider blueprint/module search; add regularisation (dropout, batch-norm) and data augmentation to cut overfitting; train each candidate longer before scoring so fitness reflects true capacity; enrich the module search space (skip/residual connections, larger filters); and tune mutation/crossover rates plus weight inheritance. 60% suggests under-trained or too-small a search space, not a hopeless architecture. (~60 words)

What patterns are stored. A subset (abstraction) of the cube’s pieces — e.g. the positions+orientations of the 8 corner cubies (corner DB), or chosen groups of edge cubies (edge DBs). Each entry is one configuration of that sub-set, ignoring the other pieces.

How the database is generated. Run a backward breadth-first search from the solved state over the abstracted (projected) state space. For every reachable pattern, record the minimum number of moves needed to solve that sub-problem. Store these in a lookup table indexed by the pattern.

The heuristic. For a real cube state, project it to the pattern and look up the stored cost: \(h(s)=\) min moves to solve that sub-set. This is an admissible, consistent lower bound, because solving the whole cube needs at least as many moves as solving any sub-set. Multiple disjoint DBs are combined by taking the maximum (or summing if additive/disjoint).

How it guides search. Plugged into IDA*/A*, the admissible h prunes branches whose \(f=g+h\) exceeds the bound, focusing exploration toward the solved cube. Korf used corner + edge pattern databases to solve the cube optimally, cutting the search from astronomically many nodes to a feasible number.

Fitness numbers aren’t fixed by the question, so here is a fully worked illustrative run (state your assumptions in the exam). Lower penalty ⇒ higher fitness; use \(\text{fitness}=1/(1+\text{penalty})\).

Step 1 — initial population (4 chromosomes, each 4 genes = slots S1..S4):

Step 2 — roulette-wheel selection. Total fitness = 0.20+0.10+0.50+0.05 = 0.85. Selection probabilities: C1 = 0.235, C2 = 0.118, C3 = 0.588, C4 = 0.059. Spinning the wheel twice, the high-fitness C3 and C1 are selected as the two parents (C4 almost never survives — it violates hard constraints).

Step 3 — one-point crossover between Parent1 = C3 and Parent2 = C1, crossover point after gene 2:

Step 4 — (optional) mutation: flip one gene with small probability, e.g. Child2 slot-1 heater ON→OFF during peak tariff. Step 5 — evaluate children’s penalties and form the next generation. End of iteration 1.

Tree: root MAX over three MIN nodes M1(x1,x2,x3), M2(x4,x5,x6), M3(x7,x8,x9).

(a) No pruning. Leaves left→right: 3, 5, 8,   6, 7, 2,   9, 10, 1.
M1 has α=−∞ so all three leaves are examined → v(M1)=min(3,5,8)=3, α=3. At M2 a MIN node prunes only if a leaf ≤ α=3 before the last leaf; here x4=6>3, x5=7>3, so no cutoff until x6 (the last leaf) → all examined, v(M2)=2. At M3, α stays 3; x7=9>3, x8=10>3 → no cutoff before last leaf x9 → all examined. No node is ever pruned.

(b) Maximum pruning. Leaves: 8, 8, 8,   2, –, –,   2, –, – (e.g. 8,8,8,2,9,9,2,9,9).
M1 evaluated fully (α=−∞) → v(M1)=8, α=8. At M2, first leaf x4=2 ≤ α=8 → β-cutoff, prune x5,x6. At M3, first leaf x7=2 ≤ α=8 → prune x8,x9. Only 5 of 9 leaves examined; x5,x6,x8,x9 pruned — the maximum possible (M1’s three leaves are unavoidable).

(c) When is alpha-beta faster? With good move ordering (best successors examined first), alpha-beta explores \(O(b^{d/2})\) nodes vs minimax’s \(O(b^{d})\) — effective branching factor \(\sqrt{b}\), letting it search roughly twice as deep for the same cost. In the worst ordering it degrades to minimax \(O(b^{d})\). So it wins whenever pruning actually occurs (ordering is not adversarial).