noshot 0.1.0__py3-none-any.whl

noshot/data/AIDS CN NLP/NLP/NLP 3/CYK-algorithm.ipynb

@@ -0,0 +1,1067 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "465112ff-5cd0-4b7b-9722-da197d0593d7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Span 0-0 -> NP: Probability = 0.100000\n",
+      "Span 1-1 -> V: Probability = 1.000000\n",
+      "Span 2-2 -> NP: Probability = 0.180000\n",
+      "Span 3-3 -> P: Probability = 1.000000\n",
+      "Span 4-4 -> NP: Probability = 0.180000\n",
+      "Span 1-2 -> VP: Probability = 0.126000\n",
+      "Span 3-4 -> PP: Probability = 0.180000\n",
+      "Span 0-2 -> S: Probability = 0.012600\n",
+      "Span 1-4 -> VP: Probability = 0.006804\n",
+      "Span 0-4 -> S: Probability = 0.000680\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "# Grammar rules with probabilities\n",
+    "pcfg = {\n",
+    "    ('S', 'NP', 'VP'): 1.0,\n",
+    "    ('VP', 'V', 'NP'): 0.7,\n",
+    "    ('VP', 'VP', 'PP'): 0.3,\n",
+    "    ('PP', 'P', 'NP'): 1.0,\n",
+    "    ('NP', 'astronomers'): 0.1,\n",
+    "    ('NP', 'ears'): 0.18,\n",
+    "    ('NP', 'stars'): 0.18,\n",
+    "    ('NP', 'telescopes'): 0.18,\n",
+    "    ('V', 'saw'): 1.0,\n",
+    "    ('P', 'with'): 1.0\n",
+    "}\n",
+    "\n",
+    "# The sentence we want to parse\n",
+    "sentence = \"astronomers saw stars with ears\".split()\n",
+    "\n",
+    "# Function to perform CYK algorithm\n",
+    "def cyk_algorithm(pcfg, sentence):\n",
+    "    n = len(sentence)\n",
+    "    # Create a table to store probabilities\n",
+    "    table = defaultdict(float)\n",
+    "    \n",
+    "    # Initialize for the single words (length 1 spans)\n",
+    "    for i, word in enumerate(sentence):\n",
+    "        for rule in pcfg:\n",
+    "            if len(rule) == 2 and rule[1] == word:\n",
+    "                table[(i, i, rule[0])] = pcfg[rule]\n",
+    "    \n",
+    "    # Filling the table for larger spans (length > 1)\n",
+    "    for span in range(2, n+1):  # span length\n",
+    "        for i in range(n - span + 1):  # starting point of the span\n",
+    "            j = i + span - 1  # ending point of the span\n",
+    "            for k in range(i, j):  # split point\n",
+    "                for rule in pcfg:\n",
+    "                    if len(rule) == 3:  # binary rules\n",
+    "                        A, B, C = rule\n",
+    "                        if (i, k, B) in table and (k + 1, j, C) in table:\n",
+    "                            prob = table[(i, k, B)] * table[(k + 1, j, C)] * pcfg[rule]\n",
+    "                            if prob > table[(i, j, A)]:\n",
+    "                                table[(i, j, A)] = prob\n",
+    "\n",
+    "    # Print the table with inside probabilities\n",
+    "    return table\n",
+    "\n",
+    "# Run the CYK algorithm\n",
+    "table = cyk_algorithm(pcfg, sentence)\n",
+    "\n",
+    "# Print the resulting probabilities\n",
+    "for key, prob in table.items():\n",
+    "    print(f\"Span {key[0]}-{key[1]} -> {key[2]}: Probability = {prob:.6f}\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "693d06f1-9161-44e5-9c9d-98c9da850b67",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Inside probability of the sequence the cat eats: 0.018000000000000002\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from collections import defaultdict\n",
+    "\n",
+    "class PCFG:\n",
+    "    def __init__(self):\n",
+    "        # Non-terminal production rules and their probabilities\n",
+    "        self.productions = defaultdict(list)\n",
+    "        self.terminals = defaultdict(list)\n",
+    "\n",
+    "    def add_production(self, lhs, rhs, prob):\n",
+    "        \"\"\" Adds a production rule with its probability \"\"\"\n",
+    "        if len(rhs) == 1 and rhs[0].islower():  # Terminal rule\n",
+    "            self.terminals[rhs[0]].append((lhs, prob))\n",
+    "        else:  # Non-terminal rule\n",
+    "            self.productions[lhs].append((rhs, prob))\n",
+    "\n",
+    "def cyk_pcfg(pcfg, words):\n",
+    "    \"\"\" Applies the CYK algorithm to find the inside probability of a word sequence \"\"\"\n",
+    "    n = len(words)\n",
+    "    non_terminals = list(pcfg.productions.keys())\n",
+    "    \n",
+    "    # Initialize a 3D table for inside probabilities\n",
+    "    P = defaultdict(lambda: np.zeros((n, n)))\n",
+    "    \n",
+    "    # Fill the diagonal with terminal production probabilities\n",
+    "    for i, word in enumerate(words):\n",
+    "        if word in pcfg.terminals:\n",
+    "            for lhs, prob in pcfg.terminals[word]:\n",
+    "                P[lhs][i, i] = prob\n",
+    "\n",
+    "    # Fill the table for subsequences\n",
+    "    for span in range(2, n + 1):  # span length from 2 to n\n",
+    "        for i in range(n - span + 1):\n",
+    "            j = i + span - 1\n",
+    "            for k in range(i, j):  # midpoint\n",
+    "                for lhs in non_terminals:\n",
+    "                    for rhs, prob in pcfg.productions[lhs]:\n",
+    "                        if len(rhs) == 2:\n",
+    "                            left, right = rhs\n",
+    "                            P[lhs][i, j] += prob * P[left][i, k] * P[right][k + 1, j]\n",
+    "\n",
+    "    # The inside probability for the start symbol S to derive the entire sequence\n",
+    "    return P['S'][0, n - 1]\n",
+    "\n",
+    "# Example Usage:\n",
+    "\n",
+    "# Define a PCFG\n",
+    "pcfg = PCFG()\n",
+    "pcfg.add_production('S', ['NP', 'VP'], 0.9)\n",
+    "pcfg.add_production('S', ['VP'], 0.1)\n",
+    "pcfg.add_production('NP', ['Det', 'N'], 0.5)\n",
+    "pcfg.add_production('VP', ['V', 'NP'], 0.5)\n",
+    "pcfg.add_production('VP', ['eats'], 0.1)\n",
+    "pcfg.add_production('Det', ['the'], 0.8)\n",
+    "pcfg.add_production('N', ['cat'], 0.5)\n",
+    "pcfg.add_production('N', ['food'], 0.5)\n",
+    "pcfg.add_production('V', ['eats'], 1.0)\n",
+    "\n",
+    "# Example word sequence\n",
+    "words = ['the', 'cat', 'eats']\n",
+    "\n",
+    "# Calculate inside probability using CYK algorithm\n",
+    "inside_prob = cyk_pcfg(pcfg, words)\n",
+    "\n",
+    "print(f\"Inside probability of the sequence {' '.join(words)}: {inside_prob}\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "92685c0a-36e5-4092-b415-17a39190bf31",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Final Probability of the sentence: 0.000680\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "# Grammar rules with probabilities\n",
+    "pcfg = {\n",
+    "    ('S', 'NP', 'VP'): 1.0,\n",
+    "    ('VP', 'V', 'NP'): 0.7,\n",
+    "    ('VP', 'VP', 'PP'): 0.3,\n",
+    "    ('PP', 'P', 'NP'): 1.0,\n",
+    "    ('NP', 'astronomers'): 0.1,\n",
+    "    ('NP', 'ears'): 0.18,\n",
+    "    ('NP', 'stars'): 0.18,\n",
+    "    ('NP', 'telescopes'): 0.18,\n",
+    "    ('V', 'saw'): 1.0,\n",
+    "    ('P', 'with'): 1.0\n",
+    "}\n",
+    "\n",
+    "# The sentence we want to parse\n",
+    "sentence = \"astronomers saw stars with ears\".split()\n",
+    "\n",
+    "# Function to perform CYK algorithm\n",
+    "def cyk_algorithm(pcfg, sentence):\n",
+    "    n = len(sentence)\n",
+    "    # Create a table to store probabilities\n",
+    "    table = defaultdict(float)\n",
+    "    \n",
+    "    # Initialize for the single words (length 1 spans)\n",
+    "    for i, word in enumerate(sentence):\n",
+    "        for rule in pcfg:\n",
+    "            if len(rule) == 2 and rule[1] == word:\n",
+    "                table[(i, i, rule[0])] = pcfg[rule]\n",
+    "    \n",
+    "    # Filling the table for larger spans (length > 1)\n",
+    "    for span in range(2, n+1):  # span length\n",
+    "        for i in range(n - span + 1):  # starting point of the span\n",
+    "            j = i + span - 1  # ending point of the span\n",
+    "            for k in range(i, j):  # split point\n",
+    "                for rule in pcfg:\n",
+    "                    if len(rule) == 3:  # binary rules\n",
+    "                        A, B, C = rule\n",
+    "                        if (i, k, B) in table and (k + 1, j, C) in table:\n",
+    "                            prob = table[(i, k, B)] * table[(k + 1, j, C)] * pcfg[rule]\n",
+    "                            if prob > table[(i, j, A)]:\n",
+    "                                table[(i, j, A)] = prob\n",
+    "\n",
+    "    # Return the final result for the whole sentence\n",
+    "    return table[(0, n-1, 'S')]  # The probability of the sentence being an S (sentence)\n",
+    "\n",
+    "# Run the CYK algorithm\n",
+    "final_prob = cyk_algorithm(pcfg, sentence)\n",
+    "\n",
+    "# Print the final probability of the sentence\n",
+    "print(f\"Final Probability of the sentence: {final_prob:.6f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "12d3ba54-fec7-492b-b967-371f607b5f1d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Final Probability of the sentence: 0.000680\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "# Probabilistic context-free grammar (PCFG) rules with probabilities\n",
+    "pcfg = {\n",
+    "    ('S', 'NP', 'VP'): 1.0,         # S -> NP VP\n",
+    "    ('VP', 'V', 'NP'): 0.7,         # VP -> V NP\n",
+    "    ('VP', 'VP', 'PP'): 0.3,        # VP -> VP PP\n",
+    "    ('PP', 'P', 'NP'): 1.0,         # PP -> P NP\n",
+    "    ('NP', 'astronomers'): 0.1,     # NP -> astronomers\n",
+    "    ('NP', 'ears'): 0.18,           # NP -> ears\n",
+    "    ('NP', 'stars'): 0.18,          # NP -> stars\n",
+    "    ('NP', 'telescopes'): 0.18,     # NP -> telescopes\n",
+    "    ('V', 'saw'): 1.0,              # V -> saw\n",
+    "    ('P', 'with'): 1.0              # P -> with\n",
+    "}\n",
+    "\n",
+    "# The sentence we want to parse\n",
+    "sentence = \"astronomers saw stars with ears\".split()\n",
+    "\n",
+    "# Function to perform the CYK algorithm and calculate inside probabilities\n",
+    "def cyk_algorithm(pcfg, sentence):\n",
+    "    n = len(sentence)  # Length of the sentence (number of words)\n",
+    "    \n",
+    "    # Table to store probabilities: (start_index, end_index, non-terminal) -> probability\n",
+    "    table = defaultdict(float)\n",
+    "    \n",
+    "    # Step 1: Initialize the table for single words (length 1 spans)\n",
+    "    for i, word in enumerate(sentence):\n",
+    "        for rule in pcfg:\n",
+    "            if len(rule) == 2 and rule[1] == word:  # Match terminal rules like NP -> astronomers\n",
+    "                table[(i, i, rule[0])] = pcfg[rule]\n",
+    "    \n",
+    "    # Step 2: Fill the table for larger spans (length > 1)\n",
+    "    for span in range(2, n + 1):  # span length\n",
+    "        for i in range(n - span + 1):  # start index of the span\n",
+    "            j = i + span - 1  # end index of the span\n",
+    "            for k in range(i, j):  # split point\n",
+    "                for rule in pcfg:\n",
+    "                    if len(rule) == 3:  # binary rule like S -> NP VP\n",
+    "                        A, B, C = rule  # A -> B C\n",
+    "                        if (i, k, B) in table and (k + 1, j, C) in table:\n",
+    "                            prob = table[(i, k, B)] * table[(k + 1, j, C)] * pcfg[rule]\n",
+    "                            if prob > table[(i, j, A)]:\n",
+    "                                table[(i, j, A)] = prob\n",
+    "\n",
+    "    # Step 3: Return the final result for the whole sentence as an 'S' (complete sentence)\n",
+    "    # The final probability for the entire sentence to be an S should be in table[(0, n-1, 'S')]\n",
+    "    return table[(0, n-1, 'S')]  # Probability of the whole sentence being an S (sentence)\n",
+    "\n",
+    "# Run the CYK algorithm and get the final probability\n",
+    "final_prob = cyk_algorithm(pcfg, sentence)\n",
+    "\n",
+    "# Print the final probability of the sentence\n",
+    "if final_prob > 0:\n",
+    "    print(f\"Final Probability of the sentence: {final_prob:.6f}\")\n",
+    "else:\n",
+    "    print(\"The sentence could not be parsed with the given grammar.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "acadf0b1-acd3-420e-9ea8-04ec2046b694",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Parse t1: Probability = 0.000680, Derivation = ('NP', 'astronomers', 'VP', ('VP', ('V', 'saw', 'NP', 'stars'), 'PP', ('P', 'with', 'NP', 'ears')))\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "# Probabilistic context-free grammar (PCFG) rules with probabilities\n",
+    "pcfg = {\n",
+    "    ('S', 'NP', 'VP'): 1.0,         # S -> NP VP\n",
+    "    ('VP', 'V', 'NP'): 0.7,         # VP -> V NP\n",
+    "    ('VP', 'VP', 'PP'): 0.3,        # VP -> VP PP\n",
+    "    ('PP', 'P', 'NP'): 1.0,         # PP -> P NP\n",
+    "    ('NP', 'astronomers'): 0.1,     # NP -> astronomers\n",
+    "    ('NP', 'ears'): 0.18,           # NP -> ears\n",
+    "    ('NP', 'stars'): 0.18,          # NP -> stars\n",
+    "    ('NP', 'telescopes'): 0.18,     # NP -> telescopes\n",
+    "    ('V', 'saw'): 1.0,              # V -> saw\n",
+    "    ('P', 'with'): 1.0              # P -> with\n",
+    "}\n",
+    "\n",
+    "# The sentence we want to parse\n",
+    "sentence = \"astronomers saw stars with ears\".split()\n",
+    "\n",
+    "# Function to perform the CYK algorithm and calculate inside probabilities\n",
+    "def cyk_algorithm(pcfg, sentence):\n",
+    "    n = len(sentence)  # Length of the sentence (number of words)\n",
+    "    \n",
+    "    # Table to store probabilities: (start_index, end_index, non-terminal) -> list of (prob, derivation)\n",
+    "    table = defaultdict(list)\n",
+    "    \n",
+    "    # Step 1: Initialize the table for single words (length 1 spans)\n",
+    "    for i, word in enumerate(sentence):\n",
+    "        for rule in pcfg:\n",
+    "            if len(rule) == 2 and rule[1] == word:  # Match terminal rules like NP -> astronomers\n",
+    "                table[(i, i, rule[0])].append((pcfg[rule], word))\n",
+    "    \n",
+    "    # Step 2: Fill the table for larger spans (length > 1)\n",
+    "    for span in range(2, n + 1):  # span length\n",
+    "        for i in range(n - span + 1):  # start index of the span\n",
+    "            j = i + span - 1  # end index of the span\n",
+    "            for k in range(i, j):  # split point\n",
+    "                for rule in pcfg:\n",
+    "                    if len(rule) == 3:  # binary rule like S -> NP VP\n",
+    "                        A, B, C = rule  # A -> B C\n",
+    "                        if (i, k, B) in table and (k + 1, j, C) in table:\n",
+    "                            for prob1, derivation1 in table[(i, k, B)]:\n",
+    "                                for prob2, derivation2 in table[(k + 1, j, C)]:\n",
+    "                                    prob = prob1 * prob2 * pcfg[rule]\n",
+    "                                    table[(i, j, A)].append((prob, (B, derivation1, C, derivation2)))\n",
+    "\n",
+    "    # Step 3: Return the list of possible derivations for the whole sentence as 'S' (complete sentence)\n",
+    "    # The final probability for the entire sentence to be an S should be in table[(0, n-1, 'S')]\n",
+    "    return table[(0, n-1, 'S')]  # List of all parses (each with a probability and derivation)\n",
+    "\n",
+    "# Run the CYK algorithm and get all possible parses\n",
+    "parses = cyk_algorithm(pcfg, sentence)\n",
+    "\n",
+    "# Print the final probabilities and derivations of the sentence\n",
+    "if parses:\n",
+    "    for idx, (prob, derivation) in enumerate(parses, start=1):\n",
+    "        print(f\"Parse t{idx}: Probability = {prob:.6f}, Derivation = {derivation}\")\n",
+    "else:\n",
+    "    print(\"The sentence could not be parsed with the given grammar.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "990ba565-bf59-49b3-aef9-355a6785e6dc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Parse t1: Probability = 0.000680, Derivation = ('NP', 'astronomers', 'VP', ('VP', ('V', 'saw', 'NP', 'stars'), 'PP', ('P', 'with', 'NP', 'ears')))\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "# Probabilistic context-free grammar (PCFG) rules with probabilities\n",
+    "pcfg = {\n",
+    "    ('S', 'NP', 'VP'): 1.0,         # S -> NP VP\n",
+    "    ('VP', 'V', 'NP'): 0.7,         # VP -> V NP\n",
+    "    ('VP', 'VP', 'PP'): 0.3,        # VP -> VP PP\n",
+    "    ('PP', 'P', 'NP'): 1.0,         # PP -> P NP\n",
+    "    ('NP', 'astronomers'): 0.1,     # NP -> astronomers\n",
+    "    ('NP', 'ears'): 0.18,           # NP -> ears\n",
+    "    ('NP', 'stars'): 0.18,          # NP -> stars\n",
+    "    ('NP', 'telescopes'): 0.18,     # NP -> telescopes\n",
+    "    ('V', 'saw'): 1.0,              # V -> saw\n",
+    "    ('P', 'with'): 1.0              # P -> with\n",
+    "}\n",
+    "\n",
+    "# The sentence we want to parse\n",
+    "sentence = \"astronomers saw stars with ears\".split()\n",
+    "\n",
+    "# Function to perform the CYK algorithm and calculate inside probabilities\n",
+    "def cyk_algorithm(pcfg, sentence):\n",
+    "    n = len(sentence)  # Length of the sentence (number of words)\n",
+    "    \n",
+    "    # Table to store probabilities: (start_index, end_index, non-terminal) -> list of (prob, derivation)\n",
+    "    table = defaultdict(list)\n",
+    "    \n",
+    "    # Step 1: Initialize the table for single words (length 1 spans)\n",
+    "    for i, word in enumerate(sentence):\n",
+    "        for rule in pcfg:\n",
+    "            if len(rule) == 2 and rule[1] == word:  # Match terminal rules like NP -> astronomers\n",
+    "                table[(i, i, rule[0])].append((pcfg[rule], word))\n",
+    "    \n",
+    "    # Step 2: Fill the table for larger spans (length > 1)\n",
+    "    for span in range(2, n + 1):  # span length\n",
+    "        for i in range(n - span + 1):  # start index of the span\n",
+    "            j = i + span - 1  # end index of the span\n",
+    "            for k in range(i, j):  # split point\n",
+    "                for rule in pcfg:\n",
+    "                    if len(rule) == 3:  # binary rule like S -> NP VP\n",
+    "                        A, B, C = rule  # A -> B C\n",
+    "                        if (i, k, B) in table and (k + 1, j, C) in table:\n",
+    "                            for prob1, derivation1 in table[(i, k, B)]:\n",
+    "                                for prob2, derivation2 in table[(k + 1, j, C)]:\n",
+    "                                    prob = prob1 * prob2 * pcfg[rule]\n",
+    "                                    table[(i, j, A)].append((prob, (B, derivation1, C, derivation2)))\n",
+    "\n",
+    "    # Step 3: Return the list of possible derivations for the whole sentence as 'S' (complete sentence)\n",
+    "    # The final probability for the entire sentence to be an S should be in table[(0, n-1, 'S')]\n",
+    "    return table[(0, n-1, 'S')]  # List of all parses (each with a probability and derivation)\n",
+    "\n",
+    "# Run the CYK algorithm and get all possible parses\n",
+    "parses = cyk_algorithm(pcfg, sentence)\n",
+    "\n",
+    "# Print the final probabilities and derivations of the sentence\n",
+    "if parses:\n",
+    "    for idx, (prob, derivation) in enumerate(parses, start=1):\n",
+    "        print(f\"Parse t{idx}: Probability = {prob:.6f}, Derivation = {derivation}\")\n",
+    "else:\n",
+    "    print(\"The sentence could not be parsed with the given grammar.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "03b70885-e274-4f15-b617-9ce8cbea6ff9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Parse t1: Probability = 0.000680, Derivation = ('NP', 'astronomers', 'VP', ('VP', ('V', 'saw', 'NP', 'stars'), 'PP', ('P', 'with', 'NP', 'ears')))\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "# Probabilistic context-free grammar (PCFG) rules with probabilities\n",
+    "pcfg = {\n",
+    "    ('S', 'NP', 'VP'): 1.0,         # S -> NP VP\n",
+    "    ('VP', 'V', 'NP'): 0.7,         # VP -> V NP\n",
+    "    ('VP', 'VP', 'PP'): 0.3,        # VP -> VP PP\n",
+    "    ('PP', 'P', 'NP'): 1.0,         # PP -> P NP\n",
+    "    ('NP', 'astronomers'): 0.1,     # NP -> astronomers\n",
+    "    ('NP', 'ears'): 0.18,           # NP -> ears\n",
+    "    ('NP', 'stars'): 0.18,          # NP -> stars\n",
+    "    ('NP', 'telescopes'): 0.18,     # NP -> telescopes\n",
+    "    ('V', 'saw'): 1.0,              # V -> saw\n",
+    "    ('P', 'with'): 1.0              # P -> with\n",
+    "}\n",
+    "\n",
+    "# The sentence we want to parse\n",
+    "sentence = \"astronomers saw stars with ears\".split()\n",
+    "\n",
+    "# Function to perform the CYK algorithm and calculate inside probabilities\n",
+    "def cyk_algorithm(pcfg, sentence):\n",
+    "    n = len(sentence)  # Length of the sentence (number of words)\n",
+    "    \n",
+    "    # Table to store probabilities: (start_index, end_index, non-terminal) -> list of (prob, derivation)\n",
+    "    table = defaultdict(list)\n",
+    "    \n",
+    "    # Step 1: Initialize the table for single words (length 1 spans)\n",
+    "    for i, word in enumerate(sentence):\n",
+    "        for rule in pcfg:\n",
+    "            if len(rule) == 2 and rule[1] == word:  # Match terminal rules like NP -> astronomers\n",
+    "                table[(i, i, rule[0])].append((pcfg[rule], word))\n",
+    "    \n",
+    "    # Step 2: Fill the table for larger spans (length > 1)\n",
+    "    for span in range(2, n + 1):  # span length\n",
+    "        for i in range(n - span + 1):  # start index of the span\n",
+    "            j = i + span - 1  # end index of the span\n",
+    "            for k in range(i, j):  # split point\n",
+    "                for rule in pcfg:\n",
+    "                    if len(rule) == 3:  # binary rule like S -> NP VP\n",
+    "                        A, B, C = rule  # A -> B C\n",
+    "                        if (i, k, B) in table and (k + 1, j, C) in table:\n",
+    "                            for prob1, derivation1 in table[(i, k, B)]:\n",
+    "                                for prob2, derivation2 in table[(k + 1, j, C)]:\n",
+    "                                    prob = prob1 * prob2 * pcfg[rule]\n",
+    "                                    table[(i, j, A)].append((prob, (B, derivation1, C, derivation2)))\n",
+    "\n",
+    "    # Step 3: Return the list of possible derivations for the whole sentence as 'S' (complete sentence)\n",
+    "    # The final probability for the entire sentence to be an S should be in table[(0, n-1, 'S')]\n",
+    "    return table[(0, n-1, 'S')]  # List of all parses (each with a probability and derivation)\n",
+    "\n",
+    "# Run the CYK algorithm and get all possible parses\n",
+    "parses = cyk_algorithm(pcfg, sentence)\n",
+    "\n",
+    "# Print the final probabilities and derivations of the sentence\n",
+    "if parses:\n",
+    "    for idx, (prob, derivation) in enumerate(parses, start=1):\n",
+    "        print(f\"Parse t{idx}: Probability = {prob:.6f}, Derivation = {derivation}\")\n",
+    "    #print(parses)\n",
+    "else:\n",
+    "    print(\"The sentence could not be parsed with the given grammar.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a36738d7-23a5-4a27-a58e-b0df0ee7132b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Parse t1: Probability = 0.000680\n",
+      "(NP\n",
+      "  astronomers\n",
+      "  (VP\n",
+      "    (V\n",
+      "      saw\n",
+      "      stars\n",
+      "    )\n",
+      "    (P\n",
+      "      with\n",
+      "      ears\n",
+      "    )\n",
+      "  )\n",
+      ")\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "# Probabilistic context-free grammar (PCFG) rules with probabilities\n",
+    "pcfg = {\n",
+    "    ('S', 'NP', 'VP'): 1.0,         # S -> NP VP\n",
+    "    ('VP', 'V', 'NP'): 0.7,         # VP -> V NP\n",
+    "    ('VP', 'VP', 'PP'): 0.3,        # VP -> VP PP\n",
+    "    ('PP', 'P', 'NP'): 1.0,         # PP -> P NP\n",
+    "    ('NP', 'astronomers'): 0.1,     # NP -> astronomers\n",
+    "    ('NP', 'ears'): 0.18,           # NP -> ears\n",
+    "    ('NP', 'stars'): 0.18,          # NP -> stars\n",
+    "    ('NP', 'telescopes'): 0.18,     # NP -> telescopes\n",
+    "    ('V', 'saw'): 1.0,              # V -> saw\n",
+    "    ('P', 'with'): 1.0              # P -> with\n",
+    "}\n",
+    "\n",
+    "# The sentence we want to parse\n",
+    "sentence = \"astronomers saw stars with ears\".split()\n",
+    "\n",
+    "# Function to perform the CYK algorithm and calculate inside probabilities\n",
+    "def cyk_algorithm(pcfg, sentence):\n",
+    "    n = len(sentence)  # Length of the sentence (number of words)\n",
+    "    \n",
+    "    # Table to store probabilities: (start_index, end_index, non-terminal) -> list of (prob, derivation)\n",
+    "    table = defaultdict(list)\n",
+    "    \n",
+    "    # Step 1: Initialize the table for single words (length 1 spans)\n",
+    "    for i, word in enumerate(sentence):\n",
+    "        for rule in pcfg:\n",
+    "            if len(rule) == 2 and rule[1] == word:  # Match terminal rules like NP -> astronomers\n",
+    "                table[(i, i, rule[0])].append((pcfg[rule], word))\n",
+    "    \n",
+    "    # Step 2: Fill the table for larger spans (length > 1)\n",
+    "    for span in range(2, n + 1):  # span length\n",
+    "        for i in range(n - span + 1):  # start index of the span\n",
+    "            j = i + span - 1  # end index of the span\n",
+    "            for k in range(i, j):  # split point\n",
+    "                for rule in pcfg:\n",
+    "                    if len(rule) == 3:  # binary rule like S -> NP VP\n",
+    "                        A, B, C = rule  # A -> B C\n",
+    "                        if (i, k, B) in table and (k + 1, j, C) in table:\n",
+    "                            for prob1, derivation1 in table[(i, k, B)]:\n",
+    "                                for prob2, derivation2 in table[(k + 1, j, C)]:\n",
+    "                                    prob = prob1 * prob2 * pcfg[rule]\n",
+    "                                    table[(i, j, A)].append((prob, (B, derivation1, C, derivation2)))\n",
+    "\n",
+    "    # Step 3: Return the list of possible derivations for the whole sentence as 'S' (complete sentence)\n",
+    "    # The final probability for the entire sentence to be an S should be in table[(0, n-1, 'S')]\n",
+    "    return table[(0, n-1, 'S')]  # List of all parses (each with a probability and derivation)\n",
+    "\n",
+    "# Helper function to print the parse tree in a readable format\n",
+    "def print_parse_tree(derivation, indent=0):\n",
+    "    if isinstance(derivation, tuple):\n",
+    "        A, derivation1, B, derivation2 = derivation\n",
+    "        print(' ' * indent + f\"({A}\")\n",
+    "        print_parse_tree(derivation1, indent + 2)\n",
+    "        print_parse_tree(derivation2, indent + 2)\n",
+    "        print(' ' * indent + f\")\")\n",
+    "    else:\n",
+    "        print(' ' * indent + derivation)\n",
+    "\n",
+    "# Run the CYK algorithm and get all possible parses\n",
+    "parses = cyk_algorithm(pcfg, sentence)\n",
+    "\n",
+    "# Print the final probabilities and derivations of the sentence\n",
+    "if parses:\n",
+    "    for idx, (prob, derivation) in enumerate(parses, start=1):\n",
+    "        print(f\"Parse t{idx}: Probability = {prob:.6f}\")\n",
+    "        print_parse_tree(derivation)\n",
+    "        print()  # Print a blank line between parses\n",
+    "else:\n",
+    "    print(\"The sentence could not be parsed with the given grammar.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "ab75fa9e-9ab1-43f5-9045-e1d7354b4aaa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Parse t1: Probability = 0.000680\n",
+      "(NP\n",
+      "  astronomers\n",
+      "  (VP\n",
+      "    (V\n",
+      "      saw\n",
+      "      stars\n",
+      "    )\n",
+      "    (P\n",
+      "      with\n",
+      "      ears\n",
+      "    )\n",
+      "  )\n",
+      ")\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "# Probabilistic context-free grammar (PCFG) rules with probabilities\n",
+    "pcfg = {\n",
+    "    ('S', 'NP', 'VP'): 1.0,         # S -> NP VP\n",
+    "    ('VP', 'V', 'NP'): 0.7,         # VP -> V NP\n",
+    "    ('VP', 'VP', 'PP'): 0.3,        # VP -> VP PP\n",
+    "    ('PP', 'P', 'NP'): 1.0,         # PP -> P NP\n",
+    "    ('NP', 'astronomers'): 0.1,     # NP -> astronomers\n",
+    "    ('NP', 'ears'): 0.18,           # NP -> ears\n",
+    "    ('NP', 'stars'): 0.18,          # NP -> stars\n",
+    "    ('NP', 'telescopes'): 0.18,     # NP -> telescopes\n",
+    "    ('V', 'saw'): 1.0,              # V -> saw\n",
+    "    ('P', 'with'): 1.0              # P -> with\n",
+    "}\n",
+    "\n",
+    "# The sentence we want to parse\n",
+    "sentence = \"astronomers saw stars with ears\".split()\n",
+    "\n",
+    "# Function to perform the CYK algorithm and calculate inside probabilities\n",
+    "def cyk_algorithm(pcfg, sentence):\n",
+    "    n = len(sentence)  # Length of the sentence (number of words)\n",
+    "    \n",
+    "    # Table to store probabilities: (start_index, end_index, non-terminal) -> list of (prob, derivation)\n",
+    "    table = defaultdict(list)\n",
+    "    \n",
+    "    # Step 1: Initialize the table for single words (length 1 spans)\n",
+    "    for i, word in enumerate(sentence):\n",
+    "        for rule in pcfg:\n",
+    "            if len(rule) == 2 and rule[1] == word:  # Match terminal rules like NP -> astronomers\n",
+    "                table[(i, i, rule[0])].append((pcfg[rule], word))\n",
+    "    \n",
+    "    # Step 2: Fill the table for larger spans (length > 1)\n",
+    "    for span in range(2, n + 1):  # span length\n",
+    "        for i in range(n - span + 1):  # start index of the span\n",
+    "            j = i + span - 1  # end index of the span\n",
+    "            for k in range(i, j):  # split point\n",
+    "                for rule in pcfg:\n",
+    "                    if len(rule) == 3:  # binary rule like S -> NP VP\n",
+    "                        A, B, C = rule  # A -> B C\n",
+    "                        if (i, k, B) in table and (k + 1, j, C) in table:\n",
+    "                            for prob1, derivation1 in table[(i, k, B)]:\n",
+    "                                for prob2, derivation2 in table[(k + 1, j, C)]:\n",
+    "                                    prob = prob1 * prob2 * pcfg[rule]\n",
+    "                                    table[(i, j, A)].append((prob, (B, derivation1, C, derivation2)))\n",
+    "\n",
+    "    # Step 3: Return the list of possible derivations for the whole sentence as 'S' (complete sentence)\n",
+    "    # The final probability for the entire sentence to be an S should be in table[(0, n-1, 'S')]\n",
+    "    return table[(0, n-1, 'S')]  # List of all parses (each with a probability and derivation)\n",
+    "\n",
+    "# Helper function to print the parse tree in a readable format\n",
+    "def print_parse_tree(derivation, indent=0):\n",
+    "    if isinstance(derivation, tuple):\n",
+    "        A, derivation1, B, derivation2 = derivation\n",
+    "        print(' ' * indent + f\"({A}\")\n",
+    "        print_parse_tree(derivation1, indent + 2)\n",
+    "        print_parse_tree(derivation2, indent + 2)\n",
+    "        print(' ' * indent + f\")\")\n",
+    "    else:\n",
+    "        print(' ' * indent + derivation)\n",
+    "\n",
+    "# Run the CYK algorithm and get all possible parses\n",
+    "parses = cyk_algorithm(pcfg, sentence)\n",
+    "\n",
+    "# Sort parses by probability in descending order\n",
+    "parses.sort(key=lambda x: x[0], reverse=True)\n",
+    "\n",
+    "# Print the final probabilities and derivations of the sentence\n",
+    "if parses:\n",
+    "    for idx, (prob, derivation) in enumerate(parses, start=1):\n",
+    "        print(f\"Parse t{idx}: Probability = {prob:.6f}\")\n",
+    "        print_parse_tree(derivation)\n",
+    "        print()  # Print a blank line between parses\n",
+    "else:\n",
+    "    print(\"The sentence could not be parsed with the given grammar.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "b6de0644-7729-499b-a5f5-e687b20f3e57",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Parse t1: Probability = 0.000680\n",
+      "(NP astronomers (VP (V saw stars) (P with ears)))\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "# Probabilistic context-free grammar (PCFG) rules with probabilities\n",
+    "pcfg = {\n",
+    "    ('S', 'NP', 'VP'): 1.0,         # S -> NP VP\n",
+    "    ('VP', 'V', 'NP'): 0.7,         # VP -> V NP\n",
+    "    ('VP', 'VP', 'PP'): 0.3,        # VP -> VP PP\n",
+    "    ('PP', 'P', 'NP'): 1.0,         # PP -> P NP\n",
+    "    ('NP', 'astronomers'): 0.1,     # NP -> astronomers\n",
+    "    ('NP', 'ears'): 0.18,           # NP -> ears\n",
+    "    ('NP', 'stars'): 0.18,          # NP -> stars\n",
+    "    ('NP', 'telescopes'): 0.18,     # NP -> telescopes\n",
+    "    ('V', 'saw'): 1.0,              # V -> saw\n",
+    "    ('P', 'with'): 1.0              # P -> with\n",
+    "}\n",
+    "\n",
+    "# The sentence we want to parse\n",
+    "sentence = \"astronomers saw stars with ears\".split()\n",
+    "\n",
+    "# Function to perform the CYK algorithm and calculate inside probabilities\n",
+    "def cyk_algorithm(pcfg, sentence):\n",
+    "    n = len(sentence)  # Length of the sentence (number of words)\n",
+    "    \n",
+    "    # Table to store probabilities: (start_index, end_index, non-terminal) -> list of (prob, derivation)\n",
+    "    table = defaultdict(list)\n",
+    "    \n",
+    "    # Step 1: Initialize the table for single words (length 1 spans)\n",
+    "    for i, word in enumerate(sentence):\n",
+    "        for rule in pcfg:\n",
+    "            if len(rule) == 2 and rule[1] == word:  # Match terminal rules like NP -> astronomers\n",
+    "                table[(i, i, rule[0])].append((pcfg[rule], rule[1]))\n",
+    "    \n",
+    "    # Step 2: Fill the table for larger spans (length > 1)\n",
+    "    for span in range(2, n + 1):  # span length\n",
+    "        for i in range(n - span + 1):  # start index of the span\n",
+    "            j = i + span - 1  # end index of the span\n",
+    "            for k in range(i, j):  # split point\n",
+    "                for rule in pcfg:\n",
+    "                    if len(rule) == 3:  # binary rule like S -> NP VP\n",
+    "                        A, B, C = rule  # A -> B C\n",
+    "                        if (i, k, B) in table and (k + 1, j, C) in table:\n",
+    "                            for prob1, derivation1 in table[(i, k, B)]:\n",
+    "                                for prob2, derivation2 in table[(k + 1, j, C)]:\n",
+    "                                    prob = prob1 * prob2 * pcfg[rule]\n",
+    "                                    table[(i, j, A)].append((prob, (B, derivation1, C, derivation2)))\n",
+    "\n",
+    "    # Step 3: Return the list of possible derivations for the whole sentence as 'S' (complete sentence)\n",
+    "    # The final probability for the entire sentence to be an S should be in table[(0, n-1, 'S')]\n",
+    "    return table[(0, n-1, 'S')]  # List of all parses (each with a probability and derivation)\n",
+    "\n",
+    "# Helper function to convert the parse tree into a string\n",
+    "def build_parse_tree(derivation):\n",
+    "    if isinstance(derivation, tuple):\n",
+    "        A, derivation1, B, derivation2 = derivation\n",
+    "        return f\"({A} {build_parse_tree(derivation1)} {build_parse_tree(derivation2)})\"\n",
+    "    else:\n",
+    "        return derivation\n",
+    "\n",
+    "# Run the CYK algorithm and get all possible parses\n",
+    "parses = cyk_algorithm(pcfg, sentence)\n",
+    "\n",
+    "# Function to sort parses by probability (optional, for better readability)\n",
+    "def sort_parses(parses):\n",
+    "    return sorted(parses, key=lambda x: x[0], reverse=True)\n",
+    "\n",
+    "# Sort the parses (optional)\n",
+    "sorted_parses = sort_parses(parses)\n",
+    "\n",
+    "# Print the final probabilities and derivations of the sentence\n",
+    "if sorted_parses:\n",
+    "    for idx, (prob, derivation) in enumerate(sorted_parses, start=1):\n",
+    "        tree_str = build_parse_tree(derivation)\n",
+    "        print(f\"Parse t{idx}: Probability = {prob:.6f}\")\n",
+    "        print(tree_str)\n",
+    "        print()  # Print a blank line between parses\n",
+    "else:\n",
+    "    print(\"The sentence could not be parsed with the given grammar.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b8b18f54-377d-4288-8511-a283d619c590",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Parse t1: Probability = 0.000680\n",
+      "(NP\n",
+      "  astronomers\n",
+      "  (VP\n",
+      "    (V\n",
+      "      saw\n",
+      "      stars\n",
+      "    )\n",
+      "    (P\n",
+      "      with\n",
+      "      ears\n",
+      "    )\n",
+      "  )\n",
+      ")\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "# Probabilistic context-free grammar (PCFG) rules with probabilities\n",
+    "pcfg = {\n",
+    "    ('S', 'NP', 'VP'): 1.0,         # S -> NP VP\n",
+    "    ('VP', 'V', 'NP'): 0.7,         # VP -> V NP\n",
+    "    ('VP', 'VP', 'PP'): 0.3,        # VP -> VP PP\n",
+    "    ('PP', 'P', 'NP'): 1.0,         # PP -> P NP\n",
+    "    ('NP', 'astronomers'): 0.1,     # NP -> astronomers\n",
+    "    ('NP', 'ears'): 0.18,           # NP -> ears\n",
+    "    ('NP', 'stars'): 0.18,          # NP -> stars\n",
+    "    ('NP', 'telescopes'): 0.18,     # NP -> telescopes\n",
+    "    ('V', 'saw'): 1.0,              # V -> saw\n",
+    "    ('P', 'with'): 1.0              # P -> with\n",
+    "}\n",
+    "\n",
+    "# The sentence we want to parse\n",
+    "sentence = \"astronomers saw stars with ears\".split()\n",
+    "\n",
+    "# Function to perform the CYK algorithm and calculate inside probabilities\n",
+    "def cyk_algorithm(pcfg, sentence):\n",
+    "    n = len(sentence)  # Length of the sentence (number of words)\n",
+    "    \n",
+    "    # Table to store probabilities: (start_index, end_index, non-terminal) -> list of (prob, derivation)\n",
+    "    table = defaultdict(list)\n",
+    "    \n",
+    "    # Step 1: Initialize the table for single words (length 1 spans)\n",
+    "    for i, word in enumerate(sentence):\n",
+    "        for rule in pcfg:\n",
+    "            if len(rule) == 2 and rule[1] == word:  # Match terminal rules like NP -> astronomers\n",
+    "                table[(i, i, rule[0])].append((pcfg[rule], word))\n",
+    "    \n",
+    "    # Step 2: Fill the table for larger spans (length > 1)\n",
+    "    for span in range(2, n + 1):  # span length\n",
+    "        for i in range(n - span + 1):  # start index of the span\n",
+    "            j = i + span - 1  # end index of the span\n",
+    "            for k in range(i, j):  # split point\n",
+    "                for rule in pcfg:\n",
+    "                    if len(rule) == 3:  # binary rule like S -> NP VP\n",
+    "                        A, B, C = rule  # A -> B C\n",
+    "                        if (i, k, B) in table and (k + 1, j, C) in table:\n",
+    "                            for prob1, derivation1 in table[(i, k, B)]:\n",
+    "                                for prob2, derivation2 in table[(k + 1, j, C)]:\n",
+    "                                    prob = prob1 * prob2 * pcfg[rule]\n",
+    "                                    table[(i, j, A)].append((prob, (B, derivation1, C, derivation2)))\n",
+    "\n",
+    "    # Step 3: Return the list of possible derivations for the whole sentence as 'S' (complete sentence)\n",
+    "    # The final probability for the entire sentence to be an S should be in table[(0, n-1, 'S')]\n",
+    "    return table[(0, n-1, 'S')]  # List of all parses (each with a probability and derivation)\n",
+    "\n",
+    "# Helper function to print the parse tree in a readable format\n",
+    "def print_parse_tree(derivation, indent=0):\n",
+    "    if isinstance(derivation, tuple):\n",
+    "        A, derivation1, B, derivation2 = derivation\n",
+    "        print(' ' * indent + f\"({A}\")\n",
+    "        print_parse_tree(derivation1, indent + 2)\n",
+    "        print_parse_tree(derivation2, indent + 2)\n",
+    "        print(' ' * indent + f\")\")\n",
+    "    else:\n",
+    "        print(' ' * indent + derivation)\n",
+    "\n",
+    "# Run the CYK algorithm and get all possible parses\n",
+    "parses = cyk_algorithm(pcfg, sentence)\n",
+    "\n",
+    "# Sort parses by probability in descending order\n",
+    "parses.sort(key=lambda x: x[0], reverse=True)\n",
+    "\n",
+    "# Print the final probabilities and derivations of the sentence\n",
+    "if parses:\n",
+    "    for idx, (prob, derivation) in enumerate(parses, start=1):\n",
+    "        print(f\"Parse t{idx}: Probability = {prob:.6f}\")\n",
+    "        print_parse_tree(derivation)\n",
+    "        print()  # Print a blank line between parses\n",
+    "else:\n",
+    "    print(\"The sentence could not be parsed with the given grammar.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "66fec238-991f-4ded-906e-0f558e8630ea",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Final Probability of the sentence: 0.000680\n",
+      "Parse Tree: (S NP (VP (VP V NP) (PP P NP)))\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "# Probabilistic context-free grammar (PCFG) rules with probabilities\n",
+    "pcfg = {\n",
+    "    ('S', 'NP', 'VP'): 1.0,         # S -> NP VP\n",
+    "    ('VP', 'V', 'NP'): 0.7,         # VP -> V NP\n",
+    "    ('VP', 'VP', 'PP'): 0.3,        # VP -> VP PP\n",
+    "    ('PP', 'P', 'NP'): 1.0,         # PP -> P NP\n",
+    "    ('NP', 'astronomers'): 0.1,     # NP -> astronomers\n",
+    "    ('NP', 'ears'): 0.18,           # NP -> ears\n",
+    "    ('NP', 'stars'): 0.18,          # NP -> stars\n",
+    "    ('NP', 'telescopes'): 0.18,     # NP -> telescopes\n",
+    "    ('V', 'saw'): 1.0,              # V -> saw\n",
+    "    ('P', 'with'): 1.0              # P -> with\n",
+    "}\n",
+    "\n",
+    "# The sentence we want to parse\n",
+    "sentence = \"astronomers saw stars with ears\".split()\n",
+    "\n",
+    "# Function to perform the CYK algorithm and calculate inside probabilities\n",
+    "def cyk_algorithm(pcfg, sentence):\n",
+    "    n = len(sentence)  # Length of the sentence (number of words)\n",
+    "    \n",
+    "    # Table to store probabilities\n",
+    "    table = defaultdict(float)\n",
+    "    backpointer = defaultdict(lambda: None)\n",
+    "\n",
+    "    # Step 1: Initialize the table for single words (length 1 spans)\n",
+    "    for i, word in enumerate(sentence):\n",
+    "        for rule in pcfg:\n",
+    "            if len(rule) == 2 and rule[1] == word:  # Match terminal rules like NP -> astronomers\n",
+    "                table[(i, i, rule[0])] = pcfg[rule]\n",
+    "\n",
+    "    # Step 2: Fill the table for larger spans (length > 1)\n",
+    "    for span in range(2, n + 1):  # span length\n",
+    "        for i in range(n - span + 1):  # start index of the span\n",
+    "            j = i + span - 1  # end index of the span\n",
+    "            for k in range(i, j):  # split point\n",
+    "                for rule in pcfg:\n",
+    "                    if len(rule) == 3:  # binary rule like S -> NP VP\n",
+    "                        A, B, C = rule  # A -> B C\n",
+    "                        if (i, k, B) in table and (k + 1, j, C) in table:\n",
+    "                            prob = table[(i, k, B)] * table[(k + 1, j, C)] * pcfg[rule]\n",
+    "                            if prob > table[(i, j, A)]:\n",
+    "                                table[(i, j, A)] = prob\n",
+    "                                backpointer[(i, j, A)] = (B, C, i, k, j)\n",
+    "\n",
+    "    # Step 3: Return the final result for the whole sentence as an 'S'\n",
+    "    return table[(0, n-1, 'S')], backpointer\n",
+    "\n",
+    "# Function to build the parse tree from the backpointer\n",
+    "def build_parse_tree(backpointer, i, j, A):\n",
+    "    if (i, j, A) not in backpointer or backpointer[(i, j, A)] is None:\n",
+    "        return A  # Base case: return the non-terminal if no children\n",
+    "\n",
+    "    B, C, left_start, split, right_end = backpointer[(i, j, A)]\n",
+    "    left_tree = build_parse_tree(backpointer, left_start, split, B)\n",
+    "    right_tree = build_parse_tree(backpointer, split + 1, right_end, C)\n",
+    "    return f'({A} {left_tree} {right_tree})'\n",
+    "\n",
+    "# Run the CYK algorithm and get the final probability and backpointer\n",
+    "final_prob, backpointer = cyk_algorithm(pcfg, sentence)\n",
+    "\n",
+    "# Print the final probability of the sentence\n",
+    "if final_prob > 0:\n",
+    "    print(f\"Final Probability of the sentence: {final_prob:.6f}\")\n",
+    "    parse_tree = build_parse_tree(backpointer, 0, len(sentence) - 1, 'S')\n",
+    "    print(\"Parse Tree:\", parse_tree)\n",
+    "else:\n",
+    "    print(\"The sentence could not be parsed with the given grammar.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c4a04fbc-be02-4f88-9147-7b2b4497ace3",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}