Java Code

ChatGPTParsing/.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

ChatGPTParsing/.gitignore

+/bin/

ChatGPTParsing/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>ChatGPTParsing</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

ChatGPTParsing/src/auxiliary/ListofListContains.java

+package auxiliary;
+
+import java.util.List;
+
+public class ListofListContains {
+
+	public static boolean contains(List<List<String>> container, List<String> contained) {
+		for (List<String> c : container) {
+			if (c.equals(contained)) {
+				return true;
+			}
+		}
+		return false;
+	}
+}

ChatGPTParsing/src/co_reachable/CoReachability.java

+package co_reachable;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+public class CoReachability {
+
+	public static Set<String> coReachableSet(Map<String, List<List<String>>> rules) {
+		Set<String> coReachable = new HashSet<>();
+		int n = coReachable.size();
+		int m = Integer.MAX_VALUE;
+		while (n != m) {
+			m = n;
+			for (Entry<String, List<List<String>>> v : rules.entrySet()) {
+				if (!coReachable.contains(v.getKey())) {
+					for (List<String> conclusio : v.getValue()) {
+						boolean notCoReachable = false;
+						for (String c : conclusio) {
+							if (rules.keySet().contains(c) && !coReachable.contains(c)) {
+								notCoReachable = true;
+								break;
+							}
+						}
+						if (!notCoReachable) {
+							coReachable.add(v.getKey());
+							break;
+						}
+					}
+				}
+			}
+			n = coReachable.size();
+		}
+		return coReachable;
+	}
+
+	public static boolean emptyLanguage(Map<String, List<List<String>>> rules, String start) {
+		return !coReachableSet(rules).contains(start);
+	}
+
+}
\ No newline at end of file

ChatGPTParsing/src/module-info.java

+module GrammarGenerator {
+}
\ No newline at end of file

ChatGPTParsing/src/reachable/Reachability.java

+package reachable;
+
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+
+public class Reachability {
+
+	public static Set<String> reachableSet(Map<String, List<List<String>>> rules, String start) {
+		Queue<String> reachableQueue = new LinkedList<>();
+		Set<String> reachable = new HashSet<>();
+		reachable.add(start);
+		reachableQueue.add(start);
+		reachableSet(rules, reachableQueue, reachable);
+		return reachable;
+	}
+
+	private static void reachableSet(Map<String, List<List<String>>> rules, Queue<String> reachableQueue,
+			Set<String> reachable) {
+		String premise = reachableQueue.poll();
+		if (premise != null) {
+			for (List<String> conclusio : rules.get(premise)) {
+				for (String c : conclusio) {
+					if (rules.keySet().contains(c) && !reachable.contains(c)) {
+						reachableQueue.add(c);
+					}
+					reachable.add(c);
+				}
+			}
+			reachableSet(rules, reachableQueue, reachable);
+		}
+	}
+}

ChatGPTParsing/src/type2/Type2GrammarGenerator.java

+package type2;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+
+import auxiliary.ListofListContains;
+import co_reachable.CoReachability;
+import reachable.Reachability;
+
+public class Type2GrammarGenerator {
+
+	Random random = new Random();
+
+	private Map<String, List<List<String>>> genType2GrammarRuleSet(String[] vars, int alphaSize, int maxConclusios,
+			int maxConclusioSize) {
+		Map<String, List<List<String>>> rules = new HashMap<>();
+		for (String v : vars) {
+			List<List<String>> conclusios = genConclusios(alphaSize, vars, maxConclusios, maxConclusioSize);
+			rules.put(v, conclusios);
+		}
+		return rules;
+	}
+
+	private List<List<String>> genConclusios(int alphaSize, String[] vars, int maxConclusios, int maxConclusioSize) {
+		List<List<String>> conclusios = new LinkedList<>();
+		int numOfConclusios = random.nextInt(maxConclusios) + 1;
+		while (conclusios.size() < numOfConclusios) {
+			List<String> conclusio = genConclusio(alphaSize, vars, maxConclusioSize);
+			if (!ListofListContains.contains(conclusios, conclusio)) {
+				conclusios.add(conclusio);
+			}
+		}
+		return conclusios;
+	}
+
+	private List<String> genConclusio(int alphaSize, String[] vars, int maxConclusioSize) {
+		return (Math.random() <= 0.1) ? new LinkedList<>() : genRandomString(alphaSize, vars, maxConclusioSize);
+
+	}
+
+	private List<String> genRandomString(int alphaSize, String[] vars, int maxConclusioSize) {
+		List<String> s = new LinkedList<>();
+		int conclusioSize = random.nextInt(maxConclusioSize) + 1;
+		while (s.size() < conclusioSize) {
+			int i = random.nextInt(vars.length + alphaSize);
+			if (i < vars.length) {
+				if (i == 0) {
+					i = 83;
+				} else if (i > 0 && i <= 18) {
+					i += 64;
+				} else {
+					i += 65;
+				}
+			} else {
+				i += 97 - vars.length;
+			}
+			char c = (char) i;
+			s.add(c + "");
+		}
+		return s;
+	}
+
+	public List<Map<String, List<List<String>>>> genType2GrammarRuleSets(String[] vars, int alphaSize,
+			int maxConclusios, int maxConclusioSize, int n) {
+		List<Map<String, List<List<String>>>> grammarRuleSets = new LinkedList<>();
+		while (grammarRuleSets.size() < n) {
+			grammarRuleSets.add(genType2GrammarRuleSet(vars, alphaSize, maxConclusios, maxConclusioSize));
+		}
+		return grammarRuleSets;
+	}
+
+	public List<Map<String, List<List<String>>>> genType2GrammarRuleSets1(String[] vars, int alphaSize,
+			int maxConclusios, int maxConclusioSize, String s, int n) {
+		List<Map<String, List<List<String>>>> grammarRuleSets = new LinkedList<>();
+		while (grammarRuleSets.size() < n) {
+			Map<String, List<List<String>>> rules = genType2GrammarRuleSet(vars, alphaSize, maxConclusios,
+					maxConclusioSize);
+			if (!CoReachability.emptyLanguage(rules, s)) {
+				grammarRuleSets.add(rules);
+			}
+		}
+		return grammarRuleSets;
+	}
+
+	public List<Map<String, List<List<String>>>> genType2GrammarRuleSets2(String[] vars, int alphaSize,
+			int maxConclusios, int maxConclusioSize, int n) {
+		List<Map<String, List<List<String>>>> grammarRuleSets = new LinkedList<>();
+		while (grammarRuleSets.size() < n) {
+			Map<String, List<List<String>>> rules = genType2GrammarRuleSet(vars, alphaSize, maxConclusios,
+					maxConclusioSize);
+			if (CoReachability.coReachableSet(rules).containsAll(rules.keySet())) {
+				grammarRuleSets.add(rules);
+			}
+		}
+		return grammarRuleSets;
+	}
+
+	public List<Map<String, List<List<String>>>> genType2GrammarRuleSets3(String[] vars, int alphaSize,
+			int maxConclusios, int maxConclusioSize, String s, int n) {
+		List<Map<String, List<List<String>>>> grammarRuleSets = new LinkedList<>();
+		Set<String> varSet = new HashSet<>();
+		Set<String> alphaSet = new HashSet<>();
+		for (String v : vars) {
+			varSet.add(v);
+		}
+		for (int i = 0; i < alphaSize; i++) {
+			alphaSet.add(((char) (i + 97)) + "");
+		}
+		while (grammarRuleSets.size() < n) {
+			Map<String, List<List<String>>> rules = genType2GrammarRuleSet(vars, alphaSize, maxConclusios,
+					maxConclusioSize);
+			boolean allCoReachable = CoReachability.coReachableSet(rules).containsAll(rules.keySet());
+			boolean allReachable = Reachability.reachableSet(rules, s).containsAll(rules.keySet())
+					&& Reachability.reachableSet(rules, s).containsAll(alphaSet);
+			if (allCoReachable && allReachable) {
+				grammarRuleSets.add(rules);
+			}
+		}
+		return grammarRuleSets;
+	}
+
+	public static void main(String[] args) {
+		Map<String, List<List<String>>> ruleSet = new HashMap<>();
+		List<List<String>> l1 = List.of(List.of("A", "S"));
+		ruleSet.put("S", l1);
+		List<List<String>> l2 = List.of(List.of("a"), List.of("b", "A"));
+		ruleSet.put("A", l2);
+		System.out.println(ruleSet);
+		Set<String> crs = CoReachability.coReachableSet(ruleSet);
+		System.out.println(crs);
+	}
+
+}

ChatGPTParsing/src/type2/Type2Parser.java

+package type2;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import auxiliary.ListofListContains;
+import co_reachable.CoReachability;
+import reachable.Reachability;
+
+public class Type2Parser {
+
+	private static Map<String, List<List<String>>> createCNF(Map<String, List<List<String>>> rules, String start) {
+		Set<String> nullable = nullableSet(rules);
+		Map<String, List<List<String>>> newRules0 = new HashMap<>(rules);
+		if (nullable.contains(start)) {
+			List<List<String>> newStartRule = new LinkedList<>();
+			List<String> c0 = new LinkedList<>();
+			c0.add(start);
+			newStartRule.add(c0);
+			newStartRule.add(new LinkedList<>());
+			newRules0.put("S'", newStartRule);
+		}
+		Map<String, List<List<String>>> newRules1 = removeUselessSymbols(newRules0,
+				newRules0.keySet().contains("S'") ? "S'" : start);
+		List<List<String>> startRule = newRules1.remove("S'");
+		Map<String, List<List<String>>> newRules2 = removeEpsilonRules(newRules1, nullable);
+		if (startRule != null) {
+			newRules2.put("S'", startRule);
+		}
+		Map<String, List<List<String>>> newRules3 = normalize(newRules2);
+		Map<String, List<List<String>>> newRules4 = removeChainRules(newRules3);
+		Map<String, List<List<String>>> newRules5 = removeUselessSymbols(newRules4,
+				newRules4.keySet().contains("S'") ? "S'" : start);
+		return shortenConclusios(newRules5);
+	}
+
+	private static Set<String> nullableSet(Map<String, List<List<String>>> rules) {
+		Set<String> nullable = new HashSet<>();
+		int n = nullable.size();
+		int m = Integer.MAX_VALUE;
+		while (n != m) {
+			m = n;
+			for (Entry<String, List<List<String>>> rule : rules.entrySet()) {
+				if (!nullable.contains(rule.getKey())) {
+					for (List<String> conclusio : rule.getValue()) {
+						boolean notNullable = false;
+						for (String c : conclusio) {
+							if (!nullable.contains(c)) {
+								notNullable = true;
+								break;
+							}
+						}
+						if (!notNullable) {
+							nullable.add(rule.getKey());
+							break;
+						}
+					}
+				}
+			}
+			n = nullable.size();
+		}
+		return nullable;
+	}
+
+	private static Map<String, List<List<String>>> removeUselessSymbols(Map<String, List<List<String>>> rules,
+			String start) {
+		Map<String, List<List<String>>> rules1 = removeNonCoReachableVariables(rules, start);
+		if (rules1.isEmpty()) {
+			return rules1;
+		}
+		return removeNonReachableSymbols(rules1, start);
+	}
+
+	private static Map<String, List<List<String>>> removeNonCoReachableVariables(Map<String, List<List<String>>> rules,
+			String start) {
+		Set<String> coReachable = CoReachability.coReachableSet(rules);
+		if (!coReachable.contains(start)) {
+			return new HashMap<>();
+		}
+		Map<String, List<List<String>>> newRules = new HashMap<>();
+		for (Entry<String, List<List<String>>> rule : rules.entrySet()) {
+			if (coReachable.contains(rule.getKey())) {
+				List<List<String>> newConclusios = new LinkedList<>();
+				for (List<String> conclusio : rule.getValue()) {
+					boolean containsNonCoReachable = false;
+					for (String c : conclusio) {
+						if (rules.keySet().contains(c) && !coReachable.contains(c)) {
+							containsNonCoReachable = true;
+							break;
+						}
+					}
+					if (!containsNonCoReachable) {
+						newConclusios.add(conclusio);
+					}
+				}
+				newRules.put(rule.getKey(), newConclusios);
+			}
+		}
+		return newRules;
+	}
+
+	private static Map<String, List<List<String>>> removeNonReachableSymbols(Map<String, List<List<String>>> rules,
+			String start) {
+		Set<String> reachable = Reachability.reachableSet(rules, start);
+		Map<String, List<List<String>>> newRules = new HashMap<>();
+		for (Entry<String, List<List<String>>> rule : rules.entrySet()) {
+			if (reachable.contains(rule.getKey())) {
+				List<List<String>> newConclusios = new LinkedList<>();
+				for (List<String> conclusio : rule.getValue()) {
+					boolean containsNonReachable = false;
+					for (String c : conclusio) {
+						if (rules.keySet().contains(c) && !reachable.contains(c)) {
+							containsNonReachable = true;
+							break;
+						}
+					}
+					if (!containsNonReachable) {
+						newConclusios.add(conclusio);
+					}
+				}
+				newRules.put(rule.getKey(), newConclusios);
+			}
+		}
+		return newRules;
+	}
+
+	private static Map<String, List<List<String>>> removeEpsilonRules(Map<String, List<List<String>>> rules,
+			Set<String> nullable) {
+		Map<String, List<List<String>>> newRules = new HashMap<>();
+		for (Entry<String, List<List<String>>> rule : rules.entrySet()) {
+			List<List<String>> newConclusios = new LinkedList<>();
+			for (List<String> oldConclusio : rule.getValue()) {
+				List<List<String>> newCons = removeNullable(oldConclusio, nullable);
+				for (List<String> newCon : newCons) {
+					if ((!newCon.isEmpty() && !ListofListContains.contains(newConclusios, newCon))) {
+						newConclusios.add(newCon);
+					}
+				}
+
+			}
+			newRules.put(rule.getKey(), newConclusios);
+		}
+		return newRules;
+	}
+
+	private static List<List<String>> removeNullable(List<String> r, Set<String> nullable) {
+		List<String> lNull = new LinkedList<>();
+		List<Integer> posNull = new LinkedList<>();
+		Map<Integer, String> posNonNull = new HashMap<>();
+		for (int i = 0; i < r.size(); i++) {
+			if (nullable.contains(r.get(i))) {
+				lNull.add(r.get(i));
+				posNull.add(i);
+			} else {
+				posNonNull.put(i, r.get(i));
+			}
+		}
+		List<List<Integer>> ps = powerset(lNull.size() - 1);
+		List<Map<Integer, String>> newCons = new LinkedList<>();
+		for (List<Integer> s : ps) {
+			Map<Integer, String> newCon = new HashMap<>();
+			for (int i : s) {
+				newCon.put(posNull.get(i), lNull.get(i));
+			}
+			newCons.add(newCon);
+		}
+		List<List<String>> newConsAdded = new LinkedList<>();
+		for (Map<Integer, String> newCon : newCons) {
+			List<String> newConAdded = new LinkedList<>();
+			for (int i = 0; i < r.size(); i++) {
+				String s0 = newCon.get(i);
+				String s1 = posNonNull.get(i);
+				if (s0 != null) {
+					newConAdded.add(s0);
+				} else if (s1 != null) {
+					newConAdded.add(s1);
+				}
+			}
+			newConsAdded.add(newConAdded);
+		}
+		return newConsAdded;
+	}
+
+	private static List<List<Integer>> powerset(int n) {
+		List<List<Integer>> ps = new ArrayList<>();
+		if (n < 0) {
+			ps.add(new ArrayList<>());
+		} else {
+			for (List<Integer> s : powerset(n - 1)) {
+				ps.add(s);
+				List<Integer> s1 = new ArrayList<>(s);
+				s1.add(n);
+				ps.add(s1);
+			}
+		}
+		return ps;
+	}
+
+	private static Map<String, List<List<String>>> normalize(Map<String, List<List<String>>> rules) {
+		Map<String, List<List<String>>> newRules = new HashMap<>();
+		Map<String, String> vars = new HashMap<>();
+		for (Entry<String, List<List<String>>> rule : rules.entrySet()) {
+			List<List<String>> newConclusios = new LinkedList<>();
+			for (List<String> conclusio : rule.getValue()) {
+				if (conclusio.size() > 1) {
+					List<String> newConclusio = new LinkedList<>();
+					for (int i = 0; i < conclusio.size(); i++) {
+						String s = conclusio.get(i);
+						if (!rules.keySet().contains(s)) {
+							vars.computeIfAbsent(s, k -> "V" + k);
+							newConclusio.add(vars.get(s));
+						} else {
+							newConclusio.add(s);
+						}
+					}
+					newConclusios.add(newConclusio);
+				} else {
+					newConclusios.add(conclusio);
+				}
+			}
+			newRules.put(rule.getKey(), newConclusios);
+		}
+		for (Entry<String, String> entry : vars.entrySet()) {
+			List<List<String>> ll = new LinkedList<>();
+			List<String> l = new LinkedList<>();
+			l.add(entry.getKey());
+			ll.add(l);
+			newRules.put(entry.getValue(), ll);
+		}
+		return newRules;
+	}
+
+	private static Map<String, List<List<String>>> removeChainRules(Map<String, List<List<String>>> rules) {
+		Map<String, List<List<String>>> newRules = new HashMap<>();
+		Map<String, Set<String>> chainProdMap = findChainProductions(rules);
+		Map<String, List<List<String>>> chainRulesDeleted = deleteChainRules(rules);
+		for (String premise : rules.keySet()) {
+			List<List<String>> newConclusios = new LinkedList<>();
+			for (String s : chainProdMap.get(premise)) {
+				for (List<String> newConclusio : chainRulesDeleted.get(s)) {
+					if (!ListofListContains.contains(newConclusios, newConclusio)) {
+						newConclusios.add(newConclusio);
+					}
+				}
+
+			}
+			newRules.put(premise, newConclusios);
+		}
+		return newRules;
+	}
+
+	private static Map<String, List<List<String>>> deleteChainRules(Map<String, List<List<String>>> rules) {
+		Map<String, List<List<String>>> newRules = new HashMap<>();
+		for (Entry<String, List<List<String>>> rule : rules.entrySet()) {
+			List<List<String>> newConclusios = new LinkedList<>();
+			for (List<String> conclusio : rule.getValue()) {
+				if (conclusio.size() == 1 && rules.keySet().contains(conclusio.get(0))) {
+					continue;
+				}
+				newConclusios.add(conclusio);
+			}
+			newRules.put(rule.getKey(), newConclusios);
+		}
+		return newRules;
+	}
+
+	private static Map<String, Set<String>> findChainProductions(Map<String, List<List<String>>> rules) {
+		Map<String, Set<String>> chainProdMap = new HashMap<>();
+		for (Entry<String, List<List<String>>> rule : rules.entrySet()) {
+			Set<String> chainProds = new HashSet<>();
+			chainProds.add(rule.getKey());
+			findChainProductions(rules, rule.getKey(), chainProds);
+			chainProdMap.put(rule.getKey(), chainProds);
+		}
+		return chainProdMap;
+	}
+
+	private static void findChainProductions(Map<String, List<List<String>>> rules, String key,
+			Set<String> chainProds) {
+		for (List<String> conclusio : rules.get(key)) {
+			if (conclusio.size() == 1 && rules.keySet().contains(conclusio.get(0))
+					&& !chainProds.contains(conclusio.get(0))) {
+				chainProds.add(conclusio.get(0));
+				findChainProductions(rules, conclusio.get(0), chainProds);
+			}
+		}
+	}
+
+	private static Map<String, List<List<String>>> shortenConclusios(Map<String, List<List<String>>> rules) {
+		Map<String, List<List<String>>> newRules = new HashMap<>();
+		Map<String, List<List<String>>> addNewRules = new HashMap<>();
+		int i = 0;
+		for (Entry<String, List<List<String>>> rule : rules.entrySet()) {
+			List<List<String>> newConclusios = new LinkedList<>();
+			for (List<String> conclusio : rule.getValue()) {
+				if (conclusio.size() > 2) {
+					List<String> c0 = new LinkedList<>();
+					c0.add(conclusio.get(0));
+					c0.add("@" + i);
+					newConclusios.add(c0);
+					int k = conclusio.size() - 2;
+					for (int j = 1; j < k; j++) {
+						List<List<String>> csj = new LinkedList<>();
+						List<String> cj = new LinkedList<>();
+						cj.add(conclusio.get(j));
+						cj.add("@" + (i + 1));
+						csj.add(cj);
+						addNewRules.put("@" + i++, csj);
+					}
+					List<List<String>> csn = new LinkedList<>();
+					List<String> cn = new LinkedList<>();
+					cn.add(conclusio.get(k));
+					cn.add(conclusio.get(k + 1));
+					csn.add(cn);
+					addNewRules.put("@" + i++, csn);
+				} else {
+					newConclusios.add(conclusio);
+				}
+			}
+			newRules.put(rule.getKey(), newConclusios);
+		}
+		newRules.putAll(addNewRules);
+		return newRules;
+	}
+
+	private static boolean cyk(Map<String, List<List<String>>> rules, String word, String start) {
+		int n = word.length();
+		String[][][] table = new String[n][n][rules.keySet().size()];
+		Map<String, Integer> indexMap = indexMap(rules.keySet());
+		for (int i = 0; i < n; i++) {
+			Set<String> producesTerminal = producesTerminal(rules, word.charAt(i) + "");
+			for (String premise : producesTerminal) {
+				table[i][i][indexMap.get(premise)] = premise;
+			}
+		}
+		for (int j = 1; j < n; j++) {
+			for (int i = 0; i < n - j; i++) {
+				Set<String> s = new HashSet<>();
+				for (int k = i; k < i + j; k++) {
+					Set<String> s0 = producesVariable(table[i][k], table[k + 1][i + j], rules);
+					s.addAll(s0);
+				}
+				for (String v : s) {
+					table[i][i + j][indexMap.get(v)] = v;
+				}
+			}
+		}
+		return table[0][n - 1][indexMap.get(start)] != null;
+	}
+
+	private static Set<String> producesTerminal(Map<String, List<List<String>>> rules, String charAt) {
+		Set<String> pt = new HashSet<>();
+		for (Entry<String, List<List<String>>> rule : rules.entrySet()) {
+			for (List<String> conclusio : rule.getValue()) {
+				if (conclusio.size() == 1 && conclusio.get(0).equals(charAt)) {
+					pt.add(rule.getKey());
+				}
+			}
+		}
+		return pt;
+	}
+
+	private static Set<String> producesVariable(String[] v1, String[] v2, Map<String, List<List<String>>> rules) {
+		Set<String> pv = new HashSet<>();
+		for (String s1 : v1) {
+			if (s1 != null) {
+				for (String s2 : v2) {
+					if (s2 != null) {
+						pv.addAll(producesVariable(rules, s1, s2));
+					}
+				}
+			}
+
+		}
+		return pv;
+	}
+
+	private static Set<String> producesVariable(Map<String, List<List<String>>> rules, String v1, String v2) {
+		Set<String> pv = new HashSet<>();
+		List<String> varPair = new LinkedList<>();
+		varPair.add(v1);
+		varPair.add(v2);
+		for (Entry<String, List<List<String>>> rule : rules.entrySet()) {
+			for (List<String> conclusio : rule.getValue()) {
+				if (conclusio.equals(varPair)) {
+					pv.add(rule.getKey());
+				}
+			}
+		}
+		return pv;
+	}
+
+	private static Map<String, Integer> indexMap(Set<String> vars) {
+		Map<String, Integer> indexMap = new HashMap<>();
+		int i = 0;
+		for (String v : vars) {
+			indexMap.put(v, i);
+			i++;
+		}
+		return indexMap;
+	}
+
+	public static boolean isPartOfLanguage(Map<String, List<List<String>>> rules, String word, String start) {
+		Map<String, List<List<String>>> cnf = createCNF(rules, start);
+		if (word.isEmpty()) {
+			return ListofListContains.contains(cnf.get("S'"), new LinkedList<>());
+		}
+		return cyk(cnf, word, cnf.keySet().contains("S'") ? "S'" : start);
+	}
+
+	public static void main(String[] args) {
+		Map<String, List<List<String>>> rules = new HashMap<>();
+		List<List<String>> s = List.of(List.of("a", "A", "b", "B"), List.of("a", "A", "c"), List.of("B", "C"),
+				List.of("B", "D", "a"));
+		rules.put("S", s);
+		List<List<String>> a = List.of(List.of("c", "A", "a"), List.of("b"), List.of("D", "c", "F"),
+				List.of("B", "C", "a"));
+		rules.put("A", a);
+		List<List<String>> b = List.of(List.of("C", "B"), List.of("A"), List.of("C"), List.of("a"), List.of());
+		rules.put("B", b);
+		List<List<String>> c = List.of(List.of("c", "c", "c"), List.of("A", "B", "C"), List.of("B", "C", "F"),
+				List.of());
+		rules.put("C", c);
+		List<List<String>> d = List.of(List.of("a", "D", "b"), List.of("A", "F", "c"));
+		rules.put("D", d);
+		List<List<String>> e = List.of(List.of("A", "a", "C"), List.of("C", "E", "b"), List.of("a", "b"), List.of());
+		rules.put("E", e);
+		List<List<String>> f = List.of(List.of("B", "D", "c"), List.of("a", "F"), List.of("B", "C", "D"));
+		rules.put("F", f);
+		System.out.println(isPartOfLanguage(rules, "", "S"));
+	}
+
+}

ChatGPTParsing/src/type3/FiniteStateMachine.java

+package type3;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class FiniteStateMachine {
+
+	private Set<State> current;
+
+	public FiniteStateMachine(State initial) {
+		this.current = Set.of(initial);
+	}
+
+	public FiniteStateMachine(Set<State> current) {
+		this.current = current;
+	}
+
+	public FiniteStateMachine switchStates(String c) {
+		return new FiniteStateMachine(
+				this.current.stream().map(s -> s.transit(c)).flatMap(Set::stream).collect(Collectors.toSet()));
+	}
+
+	public boolean canStop() {
+		return this.current.stream().anyMatch(State::isFinal);
+	}
+
+	@Override
+	public String toString() {
+		return this.current.toString();
+	}
+
+}

ChatGPTParsing/src/type3/State.java

+package type3;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class State {
+
+	private String name;
+	private List<Transition> transitions;
+	private boolean isFinal;
+
+	public State(String name) {
+		this(name, false);
+	}
+
+	public State(String name, boolean isFinal) {
+		this.name = name;
+		this.transitions = new ArrayList<>();
+		this.isFinal = isFinal;
+	}
+
+	public State with(Transition tr) {
+		this.transitions.add(tr);
+		return this;
+	}
+
+	public Set<State> transit(String c) {
+		return transitions.stream().filter(t -> t.isPossible(c)).map(Transition::state).collect(Collectors.toSet());
+	}
+
+	public boolean isFinal() {
+		return this.isFinal;
+	}
+
+	@Override
+	public String toString() {
+		return this.name;
+	}
+
+}

ChatGPTParsing/src/type3/Transition.java

+package type3;
+
+public class Transition {
+
+	private String rule;
+	private State next;
+
+	public Transition(String rule, State next) {
+		this.rule = rule;
+		this.next = next;
+	}
+
+	public boolean isPossible(CharSequence c) {
+		return this.rule.equals(c.toString());
+	}
+
+	public State state() {
+		return this.next;
+	}
+
+}

ChatGPTParsing/src/type3/Type3GrammarGenerator.java

+package type3;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+
+import auxiliary.ListofListContains;
+import co_reachable.CoReachability;
+import reachable.Reachability;
+
+public class Type3GrammarGenerator {
+
+	Random random = new Random();
+
+	public Map<String, List<List<String>>> genType3GrammarRuleSet(String[] vars, int alphaSize, int maxConclusios,
+			String s) {
+		Map<String, List<List<String>>> rules = new HashMap<>();
+		List<List<String>> conclusios0 = genConclusios(alphaSize, vars, maxConclusios, true);
+		rules.put(s, conclusios0);
+		for (int i = 1; i < vars.length; i++) {
+			List<List<String>> conclusios1 = genConclusios(alphaSize, vars, maxConclusios, false);
+			rules.put(vars[i], conclusios1);
+		}
+		return rules;
+	}
+
+	private List<List<String>> genConclusios(int alphaSize, String[] vars, int maxConclusios, boolean start) {
+		List<List<String>> conclusios = new LinkedList<>();
+		if (start && Math.random() <= 0.5) {
+			conclusios.add(new LinkedList<>());
+		}
+		int numOfConclusios = random.nextInt(maxConclusios) + 1;
+		while (conclusios.size() < numOfConclusios || ListofListContains.contains(conclusios, new LinkedList<>())
+				&& conclusios.size() < numOfConclusios + 1) {
+			List<String> conclusio = genConclusio(alphaSize, vars);
+			if (!ListofListContains.contains(conclusios, conclusio)) {
+				conclusios.add(conclusio);
+			}
+		}
+		return conclusios;
+	}
+
+	private List<String> genConclusio(int alphaSize, String[] vars) {
+		List<String> c = new LinkedList<>();
+		String s = ((char) (random.nextInt(alphaSize) + 97)) + "";
+		c.add(s);
+		if (Math.random() < 0.7) {
+			c.add(vars[random.nextInt(vars.length)]);
+		}
+		return c;
+	}
+
+	public List<Map<String, List<List<String>>>> genType3GrammarRuleSets0(String[] vars, int alphaSize,
+			int maxConclusios, String s, int n) {
+		List<Map<String, List<List<String>>>> grammarRuleSets = new LinkedList<>();
+		while (grammarRuleSets.size() < n) {
+			Map<String, List<List<String>>> rules = genType3GrammarRuleSet(vars, alphaSize, maxConclusios, s);
+			grammarRuleSets.add(rules);
+		}
+		return grammarRuleSets;
+	}
+
+	public List<Map<String, List<List<String>>>> genType3GrammarRuleSets1(String[] vars, int alphaSize,
+			int maxConclusios, String s, int n) {
+		List<Map<String, List<List<String>>>> grammarRuleSets = new LinkedList<>();
+		while (grammarRuleSets.size() < n) {
+			Map<String, List<List<String>>> rules = genType3GrammarRuleSet(vars, alphaSize, maxConclusios, s);
+			if (!CoReachability.emptyLanguage(rules, s)) {
+				grammarRuleSets.add(rules);
+			}
+		}
+		return grammarRuleSets;
+	}
+
+	public List<Map<String, List<List<String>>>> genType3GrammarRuleSets2(String[] vars, int alphaSize,
+			int maxConclusios, String s, int n) {
+		List<Map<String, List<List<String>>>> grammarRuleSets = new LinkedList<>();
+		while (grammarRuleSets.size() < n) {
+			Map<String, List<List<String>>> rules = genType3GrammarRuleSet(vars, alphaSize, maxConclusios, s);
+			if (CoReachability.coReachableSet(rules).containsAll(rules.keySet())) {
+				grammarRuleSets.add(rules);
+			}
+		}
+		return grammarRuleSets;
+	}
+
+	public List<Map<String, List<List<String>>>> genType3GrammarRuleSets3(String[] vars, int alphaSize,
+			int maxConclusios, String s, int n) {
+		List<Map<String, List<List<String>>>> grammarRuleSets = new LinkedList<>();
+		Set<String> alphaSet = new HashSet<>();
+		for (int i = 0; i < alphaSize; i++) {
+			alphaSet.add(((char) (i + 97)) + "");
+		}
+		while (grammarRuleSets.size() < n) {
+			Map<String, List<List<String>>> rules = genType3GrammarRuleSet(vars, alphaSize, maxConclusios, s);
+			boolean allCoReachable = CoReachability.coReachableSet(rules).containsAll(rules.keySet());
+			boolean allReachable = Reachability.reachableSet(rules, s).containsAll(rules.keySet())
+					&& Reachability.reachableSet(rules, s).containsAll(alphaSet);
+			if (allCoReachable && allReachable) {
+				grammarRuleSets.add(rules);
+			}
+		}
+		return grammarRuleSets;
+	}
+
+	public static void main(String[] args) {
+		Type3GrammarGenerator gen = new Type3GrammarGenerator();
+		String[] vars = { "S", "A", "B", "C", "D" };
+		List<Map<String, List<List<String>>>> ruleSets = gen.genType3GrammarRuleSets3(vars, 4, 3, "S", 10);
+		System.out.println(ruleSets);
+	}
+}

ChatGPTParsing/src/type3/Type3Parser.java

+package type3;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import auxiliary.ListofListContains;
+
+public class Type3Parser {
+
+	private static FiniteStateMachine grammarToFSM(Map<String, List<List<String>>> rules, String start) {
+		Map<String, State> states = new HashMap<>();
+		for (Entry<String, List<List<String>>> entry : rules.entrySet()) {
+			if (entry.getKey().equals(start) && ListofListContains.contains(entry.getValue(), new LinkedList<>())) {
+				states.put(start, new State(start, true));
+			} else {
+				states.put(entry.getKey(), new State(entry.getKey()));
+			}
+		}
+		String stop = "qStop";
+		states.put(stop, new State(stop, true));
+		for (Entry<String, List<List<String>>> entry : rules.entrySet()) {
+			for (List<String> c : entry.getValue()) {
+				if (c.equals(new LinkedList<>())) {
+					continue;
+				}
+				if (c.size() == 2) {
+					states.get(entry.getKey()).with(new Transition(c.get(0), states.get(c.get(1))));
+				} else {
+					states.get(entry.getKey()).with(new Transition(c.get(0), states.get(stop)));
+				}
+
+			}
+		}
+		return new FiniteStateMachine(states.get(start + ""));
+	}
+
+	public static boolean isPartOfLanguage(Map<String, List<List<String>>> rules, String word, String start) {
+		FiniteStateMachine fsm = grammarToFSM(rules, start);
+		for (char c : word.toCharArray()) {
+			fsm = fsm.switchStates(c + "");
+		}
+		return fsm.canStop();
+	}
+
+	public static void main(String[] args) {
+		Map<String, List<List<String>>> rules = new HashMap<>();
+		List<List<String>> s = List.of(List.of(), List.of("a", "A"), List.of("b", "B"), List.of("a", "C"),
+				List.of("a"));
+		rules.put("S", s);
+		List<List<String>> a = List.of(List.of("b", "Q"));
+		rules.put("A", a);
+		List<List<String>> q = List.of(List.of("b", "B"));
+		rules.put("Q", q);
+		List<List<String>> b = List.of(List.of("a", "A"), List.of("b"), List.of("a"));
+		rules.put("B", b);
+		List<List<String>> c = List.of(List.of("b", "B"), List.of("c", "C"));
+		rules.put("C", c);
+		System.out.println(isPartOfLanguage(rules, "", "S"));
+	}
+
+}