// Match only if both symbols are same private static IEnumerable <Match> matchSymbolSymbol(SymbolicString s1, SymbolicString s2) { if (s2.atomic_symbol == s1.atomic_symbol) { yield return(Match.FullMatch(LogicalExpression.True())); } }
public static string NonRegularCheckWord(ArithmeticLanguage lang, int n, string word) { if (word.Length < n) { return("<false>Word is too short.</false>"); } foreach (char c in word) { if (!lang.alphabet.Contains(c + "")) { return("<false>Word contains illegal letters.</false>"); } } if (lang.symbolic_string.isFlat()) { SymbolicString wordSS = Parser.parseSymbolicString(word, lang.alphabet.ToList()); if (ProofChecker.checkContainment(wordSS, lang, LogicalExpression.True())) { return("<true></true>"); } else { return("<false>Word is not in the language.</false>"); } } else { throw new PumpingLemmaException("Arithmetic Language must be flat!"); } }
public static Tuple <string, string, string> NonRegularGetPumpableSplit(ArithmeticLanguage language, string word, int n) { foreach (var split in possibleSplits(word, n)) { SymbolicString str = splitToSymbStr(language.alphabet.ToList(), split.Item1, split.Item2, split.Item3); if (ProofChecker.checkContainment(str, language, LogicalExpression.True())) { return(split); } } return(null); }
public static bool NonRegularCheckI(ArithmeticLanguage language, string start, string mid, string end, int i) { string fullWord = pumpMid(start, mid, end, i); if (language.symbolic_string.isFlat()) { SymbolicString wordSS = Parser.parseSymbolicString(fullWord.ToString(), language.alphabet.ToList()); return(ProofChecker.checkContainment(wordSS, language, LogicalExpression.True())); } else { throw new PumpingLemmaException("Arithmetic Language must be flat!"); } }
private static IEnumerable <Match> matchConcatConcat(SymbolicString s1, SymbolicString s2) { if (s1.isEpsilon() || s2.isEpsilon()) { yield return(Match.MakeMatch(LogicalExpression.True(), s1, s2)); yield break; } // Quick match prefix symbols int i; for (i = 0; i < s1.sub_strings.Count && i < s2.sub_strings.Count; i++) { if (s1.sub_strings[i].expression_type != SymbolicString.SymbolicStringType.Symbol || s2.sub_strings[i].expression_type != SymbolicString.SymbolicStringType.Symbol) { break; } if (s1.sub_strings[i].atomic_symbol != s2.sub_strings[i].atomic_symbol) { yield break; } } var sub1 = s1.sub_strings.Skip(i); var sub2 = s2.sub_strings.Skip(i); // If we have consumed something fully, just return the remaining bits if (i == s1.sub_strings.Count || i == s2.sub_strings.Count) { yield return(Match.MakeMatch( LogicalExpression.True(), SymbolicString.Concat(sub1), SymbolicString.Concat(sub2))); yield break; } var rest1 = SymbolicString.Concat(sub1.Skip(1)); var rest2 = SymbolicString.Concat(sub2.Skip(1)); foreach (var m in match(sub1.First(), sub2.First())) { foreach (var mp in m.continueMatch(rest1, rest2)) { yield return(mp); } } }
public static string NonRegularGetUnpumpableWord(ArithmeticLanguage language, SymbolicString unpumpableWord, int n) { Dictionary <VariableType, int> assignment = new Dictionary <VariableType, int>(); assignment.Add(VariableType.Variable("n"), n); string word = pumpedWord(unpumpableWord, assignment); SymbolicString ss = SymbolicString.FromTextDescription(language.alphabet.ToList(), word); while (!ProofChecker.checkContainment(ss, language, LogicalExpression.True())) { assignment[VariableType.Variable("n")]++; word = pumpedWord(unpumpableWord, assignment); ss = SymbolicString.FromTextDescription(language.alphabet.ToList(), word); } return(word); }
private static IEnumerable <Match> matchSymbolConcat(SymbolicString s1, SymbolicString s2) { if (s2.isEpsilon()) { yield return(Match.PartialFirst(LogicalExpression.True(), s1)); yield break; } var rest = SymbolicString.Concat(s2.sub_strings.Skip(1)); foreach (var m in match(s1, s2.sub_strings.First())) { foreach (var mp in m.continueMatch(SymbolicString.Epsilon(), rest)) { yield return(mp); } } }
public Match forceFinish() { BooleanExpression additionalConstraint = LogicalExpression.True(); if (FirstRemaining) { additionalConstraint = LogicalExpression.And( additionalConstraint, ComparisonExpression.Equal(remaining1.length(), 0) ); } if (SecondRemaining) { additionalConstraint = LogicalExpression.And( additionalConstraint, ComparisonExpression.Equal(remaining2.length(), 0) ); } return(FullMatch(LogicalExpression.And(this.constraint, additionalConstraint))); }
public static int NonRegularGetI(ArithmeticLanguage language, string start, string mid, string end) { SymbolicString matchingString = splitToSymbStr(language.alphabet.ToList(), start, mid, end); if (ProofChecker.checkContainment(matchingString, language, LogicalExpression.True())) { return(1); // AI surrenders } else { int i = 0; do { string word = pumpMid(start, mid, end, i); SymbolicString ss = SymbolicString.FromTextDescription(language.alphabet.ToList(), word); if (!ProofChecker.checkContainment(ss, language, LogicalExpression.True())) { return(i); } i++; } while (i < 99); //for debugging purposes return(-1); } }
public static ArithmeticLanguage FromTextDescriptions(List <String> alphabet, string symbolicStringText, string constraintText) { var symbolPattern = new Regex(@"^[a-zA-Z0-9]$"); var illegalSymbols = alphabet.FindAll(s => !symbolPattern.IsMatch(s)); if (illegalSymbols.Count > 0) { var message = string.Format( "Found illegal symbols {0} in alphabet. Symbols should match [a-zA-Z0-9]", string.Join(", ", illegalSymbols) ); throw new PumpingLemmaException(message); } // Parse the language var ss = PumpingLemma.Parser.parseSymbolicString(symbolicStringText, alphabet); if (ss == null) { throw new PumpingLemmaException("Unable to parse language"); } // Parse the constraintDesc var constraint = PumpingLemma.Parser.parseCondition(constraintText); if (constraint == null) { throw new PumpingLemmaException("Unable to parse constraint"); } // Make sure all the variables are bound var boundVariables = ss.GetIntegerVariables(); var constraintVariables = constraint.GetVariables(); // Console.WriteLine("Bound variables: " + String.Join(", ", boundVariables)); // Console.WriteLine("Constriant variables: " + String.Join(", ", constraintVariables)); foreach (var consVar in constraintVariables) { if (!boundVariables.Contains(consVar)) { throw new PumpingLemmaException( string.Format("Constraint variable {0} not bound", consVar)); } } // Add constraints saying that all variables are >= 0 BooleanExpression defaultConstraint = LogicalExpression.True(); foreach (var consVar in constraintVariables) { defaultConstraint = LogicalExpression.And( defaultConstraint, ComparisonExpression.GreaterThanOrEqual( LinearIntegerExpression.SingleTerm(1, consVar), LinearIntegerExpression.Constant(0) ) ); } return(new ArithmeticLanguage(alphabet, ss, constraint)); }
// Generate TwoSplit's where either one may be empty // Generates the splits in order, i.e., by length of the prefix // So, for s being symbol and concat, first one will always be (\epsilon, s) and last one always (s, \epsilon) // So, for s being repeat (abc)^n, first will be ((abc)^i,(abc)^j) and last one always ((abc)^i ab, c(abc)^j) // Requires a flat symbolic string public IEnumerable <TwoSplit> TwoSplits() { SymbolicString prefix, suffix; // Contract.Requires(this.isFlat()); switch (this.expression_type) { case SymbolicStringType.Symbol: yield return(TwoSplit.MakeSplit(SymbolicString.Epsilon(), this, LogicalExpression.True())); yield return(TwoSplit.MakeSplit(this, SymbolicString.Epsilon(), LogicalExpression.True())); break; case SymbolicStringType.Concat: yield return(TwoSplit.MakeSplit(SymbolicString.Epsilon(), this, LogicalExpression.True())); for (int i = 0; i < this.sub_strings.Count; i++) { prefix = SymbolicString.Concat(this.sub_strings.Take(i).ToList()); suffix = SymbolicString.Concat(this.sub_strings.Skip(i + 1).ToList()); foreach (var split in this.sub_strings[i].TwoSplits()) { if (!split.start.isEpsilon()) { yield return(split.extend(prefix, suffix)); } } } break; case SymbolicStringType.Repeat: var v1 = LinearIntegerExpression.FreshVariable(); var v2 = LinearIntegerExpression.FreshVariable(); var sanityConstraint = LogicalExpression.And( ComparisonExpression.GreaterThanOrEqual(v1, 0), ComparisonExpression.GreaterThanOrEqual(v2, 0) ); prefix = SymbolicString.Repeat(this.root, v1); suffix = SymbolicString.Repeat(this.root, v2); yield return(TwoSplit.MakeSplit( prefix, suffix, LogicalExpression.And(sanityConstraint, ComparisonExpression.Equal(v1 + v2, this.repeat)) )); if (this.root.expression_type != SymbolicStringType.Concat) { break; } for (int i = 1; i < this.root.sub_strings.Count; i++) { var split = TwoSplit.MakeSplit( SymbolicString.Concat(this.root.sub_strings.Take(i)), SymbolicString.Concat(this.root.sub_strings.Skip(i)), LogicalExpression.And( ComparisonExpression.Equal(v1 + v2 + 1, this.repeat), sanityConstraint ) ); yield return(split.extend(prefix, suffix)); } break; default: throw new ArgumentOutOfRangeException(); } }
// Generates splits where all three parts may be empty public IEnumerable <Split> Splits() { // Contract.Requires<ArgumentException>(this.isFlat()); switch (this.expression_type) { case SymbolicStringType.Symbol: yield return(Split.MakeSplit(this, SymbolicString.Epsilon(), SymbolicString.Epsilon(), LogicalExpression.True())); yield return(Split.MakeSplit(SymbolicString.Epsilon(), this, SymbolicString.Epsilon(), LogicalExpression.True())); yield return(Split.MakeSplit(SymbolicString.Epsilon(), SymbolicString.Epsilon(), this, LogicalExpression.True())); break; case SymbolicStringType.Repeat: var v1 = LinearIntegerExpression.FreshVariable(); var v2 = LinearIntegerExpression.FreshVariable(); var v3 = LinearIntegerExpression.FreshVariable(); var sanityConstraint = LogicalExpression.And( ComparisonExpression.GreaterThanOrEqual(v1, 0), ComparisonExpression.GreaterThanOrEqual(v2, 0), ComparisonExpression.GreaterThanOrEqual(v3, 0) ); // Suppose the word w = a_0 a_1 \ldots a_{n-1} // All splits are of the form // BEG: (a_0 \ldots a_{n-1})^i (a_0 \ldots a_p) = w^i . w_1 // MID: (a_{p+1} \ldots a_{n-1} a_0 \ldots a_p)^j (a_{p+1} \ldots a_q) = (w_2 w_1)^j w_3 // END: (a_{q+1} \ldots a_{n-1}) (a_0 \ldots a_{n-1})^k = w_4 w^k var w = this.root.wordSymbols(); var ww = w.Concat(w); int n = w.Count(); for (int w1len = 0; w1len < n; w1len++) { var w_1 = w.Take(w1len); var w_2 = w.Skip(w1len); var beg = SymbolicString.Concat( SymbolicString.Repeat(this.root, v1), SymbolicString.Concat(w_1)); var mid_root = SymbolicString.Concat( SymbolicString.Concat(w_2), SymbolicString.Concat(w_1)); var mid_beg = SymbolicString.Repeat(mid_root, v2); for (int w3len = 0; w3len < n; w3len++) { var w_3 = ww.Skip(w1len).Take(w3len); var mid = SymbolicString.Concat(mid_beg, SymbolicString.Concat(w_3.ToList())); IEnumerable <SymbolicString> w_4; if (w1len + w3len == 0) { w_4 = new List <SymbolicString>(); } else if (w1len + w3len <= n) { w_4 = w.Skip(w1len).Skip(w3len); } else { w_4 = ww.Skip(w1len).Skip(w3len); } var end = SymbolicString.Concat( SymbolicString.Concat(w_4.ToList()), SymbolicString.Repeat(this.root, v3) ); var consumed = (w_1.Count() + w_3.Count() + w_4.Count()) / w.Count(); yield return(Split.MakeSplit( beg, mid, end, LogicalExpression.And( ComparisonExpression.Equal(v1 + v2 + v3 + consumed, this.repeat), sanityConstraint ) )); } } break; case SymbolicStringType.Concat: foreach (var beg_midend in this.TwoSplits()) { foreach (var mid_end in beg_midend.end.TwoSplits()) { yield return(Split.MakeSplit( beg_midend.start, mid_end.start, mid_end.end, LogicalExpression.And(beg_midend.constraints, mid_end.constraints))); } } break; default: throw new ArgumentOutOfRangeException(); } }
public static BooleanExpression And(IEnumerable <BooleanExpression> ops) { return(ops.Aggregate(LogicalExpression.True() as BooleanExpression, (x, y) => And(x, y))); }
public static BooleanExpression And(params BooleanExpression[] ops) { return(ops.Aggregate(LogicalExpression.True() as BooleanExpression, (x, y) => And(x, y))); }