public SingletonEmbedding(TypeEmbedder owner, Symbol symbol) { Contract.Requires(owner != null); Contract.Requires(symbol != null && symbol.IsNonVarConstant); Owner = owner; bool wasAdded; if (symbol.Kind == SymbolKind.BaseCnstSymb) { var bc = (BaseCnstSymb)symbol; if (bc.CnstKind == CnstKind.Numeric && ((Rational)bc.Raw).IsInteger) { var r = Index.MkApply(symbol, TermIndex.EmptyArgs, out wasAdded); Type = Index.MkApply(Index.RangeSymbol, new Term[] { r, r }, out wasAdded); } else { Type = Index.MkApply(symbol, TermIndex.EmptyArgs, out wasAdded); } } else { Type = Index.MkApply(symbol, TermIndex.EmptyArgs, out wasAdded); } singletonCon = Context.MkConstructor( string.Format(CreatorName, symbol.PrintableName), string.Format(TesterName, symbol.PrintableName)); Representation = Context.MkDatatypeSort(string.Format(SortName, symbol.PrintableName), new Z3Con[] { singletonCon }); CreationFun = singletonCon.ConstructorDecl; TesterFun = singletonCon.TesterDecl; DefaultMember = new Tuple <Term, Z3Expr>(Value, CreationFun.Apply()); }
public StringEmbedding(TypeEmbedder owner, uint cost) { Contract.Requires(owner != null); Owner = owner; EncodingCost = cost; bool wasAdded; Type = Index.MkApply(Index.SymbolTable.GetSortSymbol(BaseSortKind.String), TermIndex.EmptyArgs, out wasAdded); charSort = Context.MkBitVecSort(CharWidth); //// Converts bit vectors to strings. charBoxing = Context.MkConstructor( CharBoxingName, IsCharName, new string[] { CharUnboxingName }, new Z3Sort[] { charSort }); //// Append a char to a string appStr = Context.MkConstructor( AppStrName, IsMultiStrName, new string[] { AppPrefixName, AppSuffixName }, new Z3Sort[] { null, charSort }, new uint[] { 0, 0 }); neStrSort = Context.MkDatatypeSort(NeStrSortName, new Z3Con[] { charBoxing, appStr }); isChar = charBoxing.TesterDecl; charUnboxing = charBoxing.AccessorDecls[0]; isMultiStr = appStr.TesterDecl; appPrefix = appStr.AccessorDecls[0]; appSuffix = appStr.AccessorDecls[1]; //// Functions for building strings. strBoxing = Context.MkConstructor( StrBoxingName, IsNeStrName, new string[] { StrUnboxingName }, new Z3Sort[] { neStrSort }); emptyStr = Context.MkConstructor( EmptyStrName, IsEmptyStrName, null, null, null); strSort = Context.MkDatatypeSort(StrSortName, new Z3Con[] { emptyStr, strBoxing }); isNeStr = strBoxing.TesterDecl; strUnboxing = strBoxing.AccessorDecls[0]; isEmptyStr = emptyStr.TesterDecl; Representation = strSort; DefaultMember = new Tuple <Term, Z3Expr>(Index.EmptyStringValue, emptyStr.ConstructorDecl.Apply()); }
public ConstructorEmbedding(TypeEmbedder owner, UserSymbol conOrMap, Map <Term, Tuple <uint, UserSymbol> > sortIndices) { Contract.Requires(owner != null && conOrMap != null); Contract.Requires(conOrMap.IsDataConstructor); Constructor = conOrMap; Owner = owner; bool wasAdded; Type = Index.MkApply( conOrMap.Kind == SymbolKind.ConSymb ? ((ConSymb)conOrMap).SortSymbol : ((MapSymb)conOrMap).SortSymbol, TermIndex.EmptyArgs, out wasAdded); var fldNames = new string[conOrMap.Arity]; var fldSorts = new Z3Sort[conOrMap.Arity]; var fldRefs = new uint[conOrMap.Arity]; IEnumerable <Field> flds; if (conOrMap.Kind == SymbolKind.ConSymb) { flds = ((ConDecl)(conOrMap.Definitions.First().Node)).Fields; } else { var mapDecl = (MapDecl)(conOrMap.Definitions.First().Node); flds = mapDecl.Dom.Concat(mapDecl.Cod); } int i = 0; Tuple <uint, UserSymbol> sortData; Term argType; foreach (var f in flds) { argType = Index.GetCanonicalTerm(conOrMap, i); fldNames[i] = string.Format("Get_{0}_{1}", conOrMap.FullName, string.IsNullOrEmpty(f.Name) ? i.ToString() : f.Name); if (sortIndices.TryFindValue(argType, out sortData)) { fldSorts[i] = null; fldRefs[i] = sortData.Item1; } else { fldSorts[i] = owner.GetEmbedding(argType).Representation; fldRefs[i] = 0; } ++i; } Z3Constructor = Context.MkConstructor(conOrMap.FullName, "Is" + conOrMap.FullName, fldNames, fldSorts, fldRefs); }
public IntegerEmbedding(TypeEmbedder owner, uint cost) { Contract.Requires(owner != null); Owner = owner; EncodingCost = cost; Representation = Context.MkIntSort(); bool wasAdded; Type = Index.MkApply(Index.SymbolTable.GetSortSymbol(BaseSortKind.Integer), TermIndex.EmptyArgs, out wasAdded); DefaultMember = new Tuple <Term, Z3Expr>(Index.MkCnst(Rational.Zero, out wasAdded), Context.MkNumeral(0, Representation)); }
public PosIntegerEmbedding(TypeEmbedder owner, uint cost) { Contract.Requires(owner != null); Owner = owner; EncodingCost = cost; bool wasAdded; Type = Index.MkApply(Index.SymbolTable.GetSortSymbol(BaseSortKind.PosInteger), TermIndex.EmptyArgs, out wasAdded); boxingCon = Context.MkConstructor(BoxingName, TesterName, new string[] { UnboxingName }, new Z3Sort[] { Context.MkIntSort() }); Representation = Context.MkDatatypeSort(SortName, new Z3Con[] { boxingCon }); BoxingFun = boxingCon.ConstructorDecl; UnboxingFun = boxingCon.AccessorDecls[0]; TesterFun = boxingCon.TesterDecl; DefaultMember = new Tuple <Term, Z3Expr>(Index.MkCnst(Rational.One, out wasAdded), BoxingFun.Apply(Context.MkInt(1))); }
public EnumEmbedding(TypeEmbedder owner, Term type, string name) { Contract.Requires(owner != null); Contract.Requires(type != null); Owner = owner; uint id; Type = type; foreach (var t in type.Enumerate(x => x.Args)) { if (t.Symbol.Arity == 0) { Contract.Assert(t.Symbol.Kind == SymbolKind.BaseCnstSymb || t.Symbol.Kind == SymbolKind.UserCnstSymb); id = (uint)valToSymb.Count; valToSymb.Add(id, t.Symbol); symbToVal.Add(t.Symbol, id); } } var size = ((uint)valToSymb.Count).MostSignificantOne(); Contract.Assert(((uint)valToSymb.Count).PopulationCount() == 1); bvSort = Context.MkBitVecSort(size); bool wasAdded; boxingCon = Context.MkConstructor( string.Format(BoxingName, name), string.Format(TesterName, name), new string[] { string.Format(UnboxingName, name) }, new Z3Sort[] { bvSort }); Representation = Context.MkDatatypeSort(string.Format(SortName, name), new Z3Con[] { boxingCon }); BoxingFun = boxingCon.ConstructorDecl; UnboxingFun = boxingCon.AccessorDecls[0]; TesterFun = boxingCon.TesterDecl; DefaultMember = new Tuple <Term, Z3Expr>( Index.MkApply(valToSymb[0], TermIndex.EmptyArgs, out wasAdded), BoxingFun.Apply(Context.MkBV(0, size))); }
public IntRangeEmbedding(TypeEmbedder owner, BigInteger lower, BigInteger upper) { Contract.Requires(owner != null); Contract.Requires(lower <= upper); Owner = owner; Lower = lower; Upper = upper; var width = upper - lower + 1; Contract.Assert(width > 1 && width.IsPowerOfTwo); bvSort = Context.MkBitVecSort(width.MostSignificantOne()); bool wasAdded; Type = Index.MkApply(Index.RangeSymbol, new Term[] { Index.MkCnst(new Rational(lower, BigInteger.One), out wasAdded), Index.MkCnst(new Rational(upper, BigInteger.One), out wasAdded) }, out wasAdded); boxingCon = Context.MkConstructor( string.Format(BoxingName, lower, upper), string.Format(TesterName, lower, upper), new string[] { string.Format(UnboxingName, lower, upper) }, new Z3Sort[] { bvSort }); Representation = Context.MkDatatypeSort(string.Format(SortName, lower, upper), new Z3Con[] { boxingCon }); BoxingFun = boxingCon.ConstructorDecl; UnboxingFun = boxingCon.AccessorDecls[0]; TesterFun = boxingCon.TesterDecl; DefaultMember = new Tuple <Term, Z3Expr>( Index.MkCnst(new Rational(lower, BigInteger.One), out wasAdded), BoxingFun.Apply(Context.MkBV(0, bvSort.Size))); z3Lower = Context.MkInt(Lower.ToString()); }
public UnionEmbedding(TypeEmbedder owner, Term unnType, Map <Term, Tuple <uint, UserSymbol> > sortIndices) { Contract.Requires(owner != null); Owner = owner; Name = string.Format("Unn_{0}", sortIndices[unnType].Item1); Type = unnType; CanonicalUnion = new AppFreeCanUnn(unnType); var unn = CanonicalUnion; Z3Con con; LinkedList <ITypeEmbedding> intFacts, cnstFacts; LinkedList <Z3Con> allConstructors = new LinkedList <Z3Con>(); owner.GetFactorizations(unnType, out intFacts, out cnstFacts); foreach (var te in intFacts) { rngBoxings.Add( te.Type, con = Context.MkConstructor( string.Format("Box_{0}_{1}", Name, te.Representation.Name), string.Format("IsBox_{0}_{1}", Name, te.Representation.Name), new string[] { string.Format("Unbox_{0}_{1}", Name, te.Representation.Name) }, new Z3Sort[] { te.Representation })); allConstructors.AddLast(con); } foreach (var te in cnstFacts) { con = Context.MkConstructor( string.Format("Box_{0}_{1}", Name, te.Representation.Name), string.Format("IsBox_{0}_{1}", Name, te.Representation.Name), new string[] { string.Format("Unbox_{0}_{1}", Name, te.Representation.Name) }, new Z3Sort[] { te.Representation }); allConstructors.AddLast(con); foreach (var t in te.Type.Enumerate(x => x.Args)) { if (t.Symbol.Arity == 0) { otherBoxings.Add(t.Symbol, con); } } } bool wasAdded; foreach (var m in unn.NonRangeMembers) { if (m.Kind == SymbolKind.BaseSortSymb) { var te = Owner.GetEmbedding(Index.MkApply(m, TermIndex.EmptyArgs, out wasAdded)); otherBoxings.Add( m, con = Context.MkConstructor( string.Format("Box_{0}_{1}", Name, te.Representation.Name), string.Format("IsBox_{0}_{1}", Name, te.Representation.Name), new string[] { string.Format("Unbox_{0}_{1}", Name, te.Representation.Name) }, new Z3Sort[] { te.Representation })); allConstructors.AddLast(con); } else if (m.Kind == SymbolKind.UserSortSymb) { otherBoxings.Add( m, con = Context.MkConstructor( string.Format("Box_{0}_{1}", Name, ((UserSortSymb)m).DataSymbol.FullName), string.Format("IsBox_{0}_{1}", Name, ((UserSortSymb)m).DataSymbol.FullName), new string[] { string.Format("Unbox_{0}_{1}", Name, ((UserSortSymb)m).DataSymbol.FullName) }, new Z3Sort[] { null }, new uint[] { sortIndices[Index.MkApply(m, TermIndex.EmptyArgs, out wasAdded)].Item1 })); allConstructors.AddLast(con); } } Boxers = allConstructors.ToArray(allConstructors.Count); }
private void CreateTypeEmbedder() { var conf = (Configuration)Source.Config.CompilerData; Cnst value; var costMap = new Map <BaseSortKind, uint>((x, y) => (int)x - (int)y); if (conf.TryGetSetting(Configuration.Solver_RealCostSetting, out value)) { costMap[BaseSortKind.Real] = (uint)((Rational)value.Raw).Numerator; } else { costMap[BaseSortKind.Real] = 10; } if (conf.TryGetSetting(Configuration.Solver_StringCostSetting, out value)) { costMap[BaseSortKind.String] = (uint)((Rational)value.Raw).Numerator; } else { costMap[BaseSortKind.String] = 10; } if (conf.TryGetSetting(Configuration.Solver_IntegerCostSetting, out value)) { costMap[BaseSortKind.Integer] = (uint)((Rational)value.Raw).Numerator; } else { costMap[BaseSortKind.Integer] = 11; } if (conf.TryGetSetting(Configuration.Solver_NaturalCostSetting, out value)) { costMap[BaseSortKind.Natural] = (uint)((Rational)value.Raw).Numerator; } else { costMap[BaseSortKind.Natural] = 12; } if (conf.TryGetSetting(Configuration.Solver_PosIntegerCostSetting, out value)) { costMap[BaseSortKind.PosInteger] = (uint)((Rational)value.Raw).Numerator; } else { costMap[BaseSortKind.PosInteger] = 13; } if (conf.TryGetSetting(Configuration.Solver_NegIntegerCostSetting, out value)) { costMap[BaseSortKind.NegInteger] = (uint)((Rational)value.Raw).Numerator; } else { costMap[BaseSortKind.NegInteger] = 13; } TypeEmbedder = new TypeEmbedder(PartialModel.Index, Context, costMap); }