Exemple #1
0
 public override TrsTermBase CreateCopyAndReplaceSubTerm(TrsTermBase termToReplace, TrsTermBase replacementTerm)
 {
     if (this.Equals(termToReplace))
     {
         return(replacementTerm);
     }
     else
     {
         // Cant directly invoke child constructor ... otherwise lots of code duplication has to take place, or ugly reflection
         if (this is TrsNumber)
         {
             return(new TrsNumber(Value));
         }
         else if (this is TrsConstant)
         {
             return(new TrsConstant(Value));
         }
         else if (this is TrsString)
         {
             return(new TrsString(Value));
         }
         else
         {
             throw new ArgumentException("this");
         }
     }
 }
Exemple #2
0
        /// <summary>
        /// Applies a set of substitutions to this term, swapping variables. If no substitution applies to a term,
        /// the term is returned.
        /// </summary>
        /// <param name="substitutions"></param>
        /// <returns></returns>
        public TrsTermBase ApplySubstitutions(IEnumerable <Substitution> substitutions)
        {
            TrsTermBase retVal = this;

            foreach (var substitution in substitutions)
            {
                retVal = retVal.ApplySubstitution(substitution);
            }
            return(retVal);
        }
Exemple #3
0
 public override TrsTermBase CreateCopyAndReplaceSubTerm(TrsTermBase termToReplace, TrsTermBase replacementTerm)
 {
     TrsTermProduct product = new TrsTermProduct(new List<TrsTermBase>());
       foreach (var term in TermList)
       {
     if (term.Equals(termToReplace)) product.TermList.Add(replacementTerm);
     else product.TermList.Add(term.CreateCopyAndReplaceSubTerm(termToReplace, replacementTerm));
       }
       return product;
 }
Exemple #4
0
 public override TrsTermBase CreateCopyAndReplaceSubTerm(TrsTermBase termToReplace, TrsTermBase replacementTerm)
 {
     if (this.Equals(termToReplace))
       {
     return replacementTerm;
       }
       else
       {
     return new TrsTerm(Name, Arguments.Select(arg => arg.CreateCopyAndReplaceSubTerm(termToReplace, replacementTerm)));
       }
 }
Exemple #5
0
 public override TrsTermBase CreateCopyAndReplaceSubTerm(TrsTermBase termToReplace, TrsTermBase replacementTerm)
 {
     if (this.Equals(termToReplace))
     {
         return(replacementTerm);
     }
     else
     {
         return(new TrsVariable(Name));
     }
 }
Exemple #6
0
 public override TrsTermBase CreateCopyAndReplaceSubTerm(TrsTermBase termToReplace, TrsTermBase replacementTerm)
 {
     if (this.Equals(termToReplace))
       {
     return replacementTerm;
       }
       else
       {
     return new TrsVariable(Name);
       }
 }
   public InterpreterEvaluationTerm(TrsTermBase root, TrsTermBase subterm, InterpreterTerm cacheSourceTerm, 
 UnificationResult currentUnifier)
       : base(root)
   {
       if (subterm == null) throw new ArgumentException("subterm");
         if (cacheSourceTerm == null) throw new ArgumentException("cacheSourceTerm");
         if (currentUnifier == null) throw new ArgumentException("currentUnifier");
         CurrentSubTerm = subterm;
         CacheSourceTerm = cacheSourceTerm;
         Unifier = currentUnifier;
   }
Exemple #8
0
 public override TrsTermBase CreateCopyAndReplaceSubTerm(TrsTermBase termToReplace, TrsTermBase replacementTerm)
 {
     if (this.Equals(termToReplace))
     {
         return(replacementTerm);
     }
     else
     {
         return(new TrsTerm(Name, Arguments.Select(arg => arg.CreateCopyAndReplaceSubTerm(termToReplace, replacementTerm))));
     }
 }
Exemple #9
0
 public override TrsTermBase CreateCopyAndReplaceSubTerm(TrsTermBase termToReplace, TrsTermBase replacementTerm)
 {
     if (this.Equals(termToReplace))
       {
     return replacementTerm;
       }
       else
       {
     // Cant directly invoke child constructor ... otherwise lots of code duplication has to take place, or ugly reflection
     if (this is TrsNumber) return new TrsNumber(Value);
     else if (this is TrsConstant) return new TrsConstant(Value);
     else if (this is TrsString) return new TrsString(Value);
     else throw new ArgumentException("this");
       }
 }
Exemple #10
0
 public override TrsTermBase CreateCopyAndReplaceSubTerm(TrsTermBase termToReplace, TrsTermBase replacementTerm)
 {
     if (termToReplace != null && this.Equals(termToReplace))
     {
         return((TrsTermBase)replacementTerm.CreateCopy());
     }
     else
     {
         return(new TrsAcTerm(Name, OnfArguments.Select(rankedPair => new TrsOnfAcTermArgument
         {
             Term = (TrsTermBase)(rankedPair.Term.Equals(termToReplace) ? replacementTerm.CreateCopy() : rankedPair.Term.CreateCopy()),
             Cardinality = rankedPair.Cardinality
         })));
     }
 }
Exemple #11
0
        public override TrsTermBase CreateCopyAndReplaceSubTerm(TrsTermBase termToReplace, TrsTermBase replacementTerm)
        {
            TrsTermProduct product = new TrsTermProduct(new List <TrsTermBase>());

            foreach (var term in TermList)
            {
                if (term.Equals(termToReplace))
                {
                    product.TermList.Add(replacementTerm);
                }
                else
                {
                    product.TermList.Add(term.CreateCopyAndReplaceSubTerm(termToReplace, replacementTerm));
                }
            }
            return(product);
        }
Exemple #12
0
        public TrsTermBase Evaluate(TrsTermBase termIn)
        {
            var tIn = termIn as TrsTerm;
              var tInAc = termIn as TrsAcTerm;

              if (tIn != null)
              {
            if (tIn.Arguments.Count != 2) return termIn;
            if (!(tIn.Arguments[0] is TrsNumber) || !(tIn.Arguments[1] is TrsNumber)) return termIn;
            var numLhs = Convert.ToDouble(((TrsNumber)tIn.Arguments[0]).Value);
            var numRhs = Convert.ToDouble(((TrsNumber)tIn.Arguments[1]).Value);
            double retVal;
            switch (tIn.Name.ToLower())
            {
              case Subtraction:
            retVal = numLhs - numRhs;
            break;
              case Divide:
            if (numRhs == 0) return tIn;
            else retVal = numLhs / numRhs;
            break;
              default:
            return tIn;
            }
            return new TrsNumber(retVal.ToString());
              }
              else if (tInAc != null)
              {
            if (tInAc.TotalCardinality < 2) throw new InvalidProgramException("AC term with less than 2 arguments");
            if (tInAc.OnfArguments.Where(arg => arg.Term is TrsNumber).Select(arg => arg.Cardinality).Count() != tInAc.TotalCardinality)
              return tInAc;
            if (tInAc.Name == Addition)
            {
              return new TrsNumber(tInAc.ExpandedArguments.Select(arg => Convert.ToDouble(((TrsNumber)arg).Value)).Sum().ToString());
            }
            else if (tInAc.Name == Multiply)
            {
              double retVal = 1.0;
              foreach (var number in tInAc.ExpandedArguments.Select(arg => Convert.ToDouble(((TrsNumber)arg).Value)))
            retVal *= number;
              return new TrsNumber(retVal.ToString());
            }
            else return tInAc;
              }
              else return termIn;
        }
Exemple #13
0
 public InterpreterTerm(TrsTermBase root)
 {
     if (root == null) throw new ArgumentException("Root may not be null","root");
       RootTerm = root;
 }
Exemple #14
0
 /// <summary>
 /// Creates a copy of this term, replacing the termToReplace with the replacementTerm.
 /// Term equality is defined using the overloaded equals method.
 /// </summary>
 /// <returns></returns>
 public abstract TrsTermBase CreateCopyAndReplaceSubTerm(TrsTermBase termToReplace, TrsTermBase replacementTerm);
Exemple #15
0
        /// <summary>
        /// Checks that the given unifier is valid in terms of the type definitions.
        /// </summary>
        private bool IsUnifierValid(UnificationResult unifier, TrsTermBase matchedRuleHead)
        {
            // Variables at this level must be validated in a way that is sensitive to AC term type definitions
              // to account for semantics. If it is not add[:x,:y] will not match add[1,2,3] with limit :x,:y to $TrsNumber
              if (!unifier.Succeed) return false;
              if (unifier.Unifier.Count == 0) return true; // equal terms, nothing to validate

              // Keep track of variable parent cases
              Stack<TrsTermBase> evalStack = new Stack<TrsTermBase>();
              Dictionary<TrsVariable, bool> isAcParent = new Dictionary<TrsVariable, bool>();
              Dictionary<TrsVariable, bool> isNonAcParent = new Dictionary<TrsVariable, bool>();
              Dictionary<TrsVariable, HashSet<string>> variableTermNames = new Dictionary<TrsVariable, HashSet<string>>();

              evalStack.Push(matchedRuleHead);
              Action<TrsVariable, bool, Dictionary<TrsVariable, bool>> updateLookups =
            delegate(TrsVariable v, bool b, Dictionary<TrsVariable, bool> target)
            {
              if (target.ContainsKey(v)) target[v] = b;
              else target.Add(v, b);
            };
              while (evalStack.Count > 0)
              {
            var current = evalStack.Pop();
            // Variable only case ... this should not happen unless variable only reduction rule heads are allowed in the future
            var currentVariable = current as TrsVariable;
            if (currentVariable != null)
            {
              updateLookups(currentVariable, false, isAcParent);
              updateLookups(currentVariable, false, isNonAcParent);
            }
            else
            {
              // Check arguments
              var curTerm = current as TrsTerm;
              var curAcTerm = current as TrsAcTerm;
              foreach (var variable in Enumerable.Concat(curTerm == null ? new TrsVariable[0] : curTerm.Arguments.Where(arg => arg is TrsVariable).Cast<TrsVariable>(),
            curAcTerm == null ? new TrsVariable[0] : curAcTerm.OnfArguments.Where(arg => arg.Term is TrsVariable).Select(arg => arg.Term).Cast<TrsVariable>()))
              {
            updateLookups(variable, curTerm != null, isNonAcParent);
            updateLookups(variable, curAcTerm != null, isAcParent);
            if (curAcTerm != null)
            {
              HashSet<string> termNames;
              if (!variableTermNames.TryGetValue(variable, out termNames))
                variableTermNames.Add(variable, termNames = new HashSet<string>());
              termNames.Add(curAcTerm.Name);
            }
              }
            }
              }

              bool isValid = true;
              foreach (var substitution in unifier.Unifier)
              {
            // It is possible that the variable being tested does not occur in the term head ...
            if (!isNonAcParent.ContainsKey(substitution.Variable)
              && !isAcParent.ContainsKey(substitution.Variable))
            {
              isValid = isValid && typeChecker.IsSubstitutionValid(substitution);
              continue;
            }

            // AC term case
            if (isNonAcParent.ContainsKey(substitution.Variable) &&
              isNonAcParent[substitution.Variable])
              isValid = isValid && typeChecker.IsSubstitutionValid(substitution);

            // Non-AC term case
            if (isAcParent.ContainsKey(substitution.Variable)
              && isAcParent[substitution.Variable])
            {
              var acSubstitutionTerm = substitution.SubstitutionTerm as TrsAcTerm;
              if (acSubstitutionTerm == null
            || !variableTermNames[substitution.Variable].Contains(acSubstitutionTerm.Name))
              {
            isValid = isValid && typeChecker.IsSubstitutionValid(substitution);
              }
              else
              {
            // In this case, test each nested argument of the AC substitution term to match the term head variable.
            // This is due to the ONF convertion for AC terms. It keeps type checking in line with AC semantics.
            foreach (var argTerm in acSubstitutionTerm.OnfArguments.Select(arg => arg.Term))
            {
              var testSubstitution = new Substitution { Variable = substitution.Variable, SubstitutionTerm = argTerm };
              isValid = isValid && typeChecker.IsSubstitutionValid(testSubstitution);
            }
              }
            }
              }
              return isValid;
        }
Exemple #16
0
 public TrsReductionRule(TrsTermBase head, TrsTermBase tail) : this(head, tail, null)
 {
 }
Exemple #17
0
        /// <summary>
        /// NB: this is not a general solution, only for c = b + x where + can be -, / or * and, b and x can be swapped arround.
        /// c is the match term. The rest is the head term. 
        /// </summary>
        public List<UnificationResult> GetUnifier(TrsTermBase termHead, TrsTermBase matchTerm)
        {
            UnificationResult result = new UnificationResult();
              result.Succeed = false;

              // Check input
              Substitution sRhs = new Substitution
              {
            Variable = new TrsVariable("exp_r"),
            SubstitutionTerm = termHead
              };
              Substitution sLhs = new Substitution
              {
            Variable = new TrsVariable("exp_l"),
            SubstitutionTerm = matchTerm
              };
              var headTerm = termHead as TrsTerm;
              if (!interpreter.TypeChecker.IsSubstitutionValid(sLhs) ||
            !interpreter.TypeChecker.IsSubstitutionValid(sRhs))
              {
            return new List<UnificationResult> { result };
              }

              // Load problem
              interpreter.ClearExecutionCache();
              interpreter.LoadTerms(new []
              {
            new TrsTerm("rhs",new [] { termHead }),
            new TrsTerm("lhs",new [] { matchTerm })
              });

              // Solve
              while (interpreter.ExecuteRewriteStep()) { };

              // Extract answer
              var runResults = interpreter.GetCurrentRewriteResult();
              foreach (var stm in runResults.ProgramOut.Statements)
              {
            var resEq = stm as TrsTerm;
            if (resEq != null
              && resEq.Name == "eq"
              && resEq.Arguments.Count == 2
              && resEq.Arguments[0] is TrsNumber
              && resEq.Arguments[1] is TrsVariable)
            {
              result.Succeed = true;
              result.Unifier = new List<Substitution>();
              result.Unifier.Add(new Substitution()
              {
            Variable = resEq.Arguments[1] as TrsVariable,
            SubstitutionTerm = resEq.Arguments[0]
              });
            }
              }
              return new List<UnificationResult> { result };
        }
Exemple #18
0
 public TrsReductionRule(TrsTermBase head, TrsTermBase tail)
     : this(head, tail, null)
 {
 }
Exemple #19
0
 public override TrsTermBase CreateCopyAndReplaceSubTerm(TrsTermBase termToReplace, TrsTermBase replacementTerm)
 {
     if (termToReplace != null && this.Equals(termToReplace)) return (TrsTermBase)replacementTerm.CreateCopy();
       else
       {
     return new TrsAcTerm(Name, OnfArguments.Select(rankedPair => new TrsOnfAcTermArgument
     {
       Term = (TrsTermBase)(rankedPair.Term.Equals(termToReplace) ? replacementTerm.CreateCopy() : rankedPair.Term.CreateCopy()),
       Cardinality = rankedPair.Cardinality
     }));
       }
 }
Exemple #20
0
 public List<UnificationResult> GetUnifier(TrsTermBase termHead, TrsTermBase matchTerm)
 {
     return GetMgu(new Equation { Lhs = termHead, Rhs = matchTerm }, matchTerm.GetVariables());
 }
Exemple #21
0
 public override TrsTermBase CreateCopyAndReplaceSubTerm(TrsTermBase termToReplace, TrsTermBase replacementTerm)
 {
     return this;
 }
Exemple #22
0
 /// <summary>
 /// Creates a copy of this term, replacing the termToReplace with the replacementTerm.
 /// Term equality is defined using the overloaded equals method.
 /// </summary>
 /// <returns></returns>
 public abstract TrsTermBase CreateCopyAndReplaceSubTerm(TrsTermBase termToReplace, TrsTermBase replacementTerm);
Exemple #23
0
 public TrsReductionRule(TrsTermBase head, TrsTermBase tail, AstReductionRule astSource)
 {
     Head = head;
       Tail = tail;
       AstSource = astSource;
 }
Exemple #24
0
 public TrsReductionRule(TrsTermBase head, TrsTermBase tail, AstReductionRule astSource)
 {
     Head      = head;
     Tail      = tail;
     AstSource = astSource;
 }