public void Run() { Dictionary<string, string> cfg = new Dictionary<string, string>() { { "AUTO_CONFIG", "true" }, { "MODEL", "true" } }; using (Context ctx = new Context(cfg)) { EnumSort color = ctx.MkEnumSort("Color", new string[] { "red", "green", "blue" }); Expr red = color.Consts[0]; Expr green = color.Consts[1]; Expr blue = color.Consts[2]; Console.WriteLine(ctx.MkEq(green, blue)); Console.WriteLine(ctx.MkEq(green, blue).Simplify()); Expr c = ctx.MkConst("c", color); Solver s = ctx.MkSolver(); s.Assert(ctx.MkNot(ctx.MkEq(c, green))); s.Assert(ctx.MkNot(ctx.MkEq(c, blue))); Console.WriteLine(s.Check()); Console.WriteLine(s.Model); } }
internal static FuncDecl GetOrAddMemberAccessFunction(Context context, Environment environment, MemberInfo memberInfo) { FuncDecl memberFunc; if (!environment.Members.TryGetValue(memberInfo, out memberFunc)) { Sort memberTypeSort; if (!environment.Types.TryGetValue(memberInfo.DeclaringType, out memberTypeSort)) { throw new KeyNotFoundException(memberInfo.DeclaringType + " could not be found at environment.Types"); } Sort memberReturnTypeEnumSort; var propertyType = ((PropertyInfo)memberInfo).PropertyType; if (propertyType == typeof(bool)) memberReturnTypeEnumSort = context.MkBoolSort(); else if (propertyType == typeof(int)) memberReturnTypeEnumSort = context.MkIntSort(); else if (propertyType == typeof(long)) memberReturnTypeEnumSort = context.MkRealSort(); else if (propertyType == typeof(string)) memberReturnTypeEnumSort = environment.PossibleStringValues; else { if (propertyType.IsGenericType && propertyType.GetGenericTypeDefinition() == typeof(IEnumerable<>)) { var listItemType = propertyType.GenericTypeArguments[0]; var listSort = context.MkSetSort(environment.Types[listItemType]); memberReturnTypeEnumSort = listSort; // TODO: add TryGetValue environment.Types.Add(propertyType, listSort); } else if (propertyType.IsEnum) { EnumSort enumSort = context.MkEnumSort(propertyType.Name, Enum.GetNames(propertyType)); memberReturnTypeEnumSort = enumSort; // TODO: add TryGetValue environment.Types.Add(propertyType, enumSort); } else { // TODO throw exception if type is not supported memberReturnTypeEnumSort = environment.Types[propertyType]; } } memberFunc = context.MkFuncDecl(memberInfo.Name, memberTypeSort, memberReturnTypeEnumSort); environment.Members.Add(memberInfo, memberFunc); } return memberFunc; }
/// <summary> /// Create an enumeration data type. /// </summary> public static void EnumExample(Context ctx) { Console.WriteLine("EnumExample"); Symbol name = ctx.MkSymbol("fruit"); EnumSort fruit = ctx.MkEnumSort(ctx.MkSymbol("fruit"), new Symbol[] { ctx.MkSymbol("apple"), ctx.MkSymbol("banana"), ctx.MkSymbol("orange") }); Console.WriteLine("{0}", (fruit.Consts[0])); Console.WriteLine("{0}", (fruit.Consts[1])); Console.WriteLine("{0}", (fruit.Consts[2])); Console.WriteLine("{0}", (fruit.TesterDecls[0])); Console.WriteLine("{0}", (fruit.TesterDecls[1])); Console.WriteLine("{0}", (fruit.TesterDecls[2])); Expr apple = fruit.Consts[0]; Expr banana = fruit.Consts[1]; Expr orange = fruit.Consts[2]; /* Apples are different from oranges */ Prove(ctx, ctx.MkNot(ctx.MkEq(apple, orange))); /* Apples pass the apple test */ Prove(ctx, (BoolExpr)ctx.MkApp(fruit.TesterDecls[0], apple)); /* Oranges fail the apple test */ Disprove(ctx, (BoolExpr)ctx.MkApp(fruit.TesterDecls[0], orange)); Prove(ctx, (BoolExpr)ctx.MkNot((BoolExpr)ctx.MkApp(fruit.TesterDecls[0], orange))); Expr fruity = ctx.MkConst("fruity", fruit); /* If something is fruity, then it is an apple, banana, or orange */ Prove(ctx, ctx.MkOr(new BoolExpr[] { ctx.MkEq(fruity, apple), ctx.MkEq(fruity, banana), ctx.MkEq(fruity, orange) })); }
private Environment GenerateEnvironment(Context context) { var environment = new Environment(); // Class instances // TODO: support NULL values foreach (var instancesPerClassType in _instances.GroupBy(_ => _.Value.GetType())) { string classType = instancesPerClassType.Key.Name; EnumSort instancesEnumSort = context.MkEnumSort(classType + "_instances", instancesPerClassType.Select(_ => _.Key).ToArray()); environment.Types.Add(instancesPerClassType.Key, instancesEnumSort); Expr[] instancesEnumSortValues = instancesEnumSort.Consts; int instancesIndex = 0; foreach (KeyValuePair<string, object> instance in instancesPerClassType) { environment.Instances.Add(instance.Key, new InstanceInfo(instancesEnumSortValues[instancesIndex++], objectInstance: instance.Value)); } } // Super Types foreach (var superType in _superTypes) { var subTypeSorts = environment.Types.Where(t => t.Key.IsSubclassOf(superType)).Select(t => t.Value).ToList(); if (subTypeSorts.Count == 0) continue; var superTypeConstructors = new List<Constructor>(); foreach (var subTypeSort in subTypeSorts) { var subTypeConstr = context.MkConstructor( name: subTypeSort.Name.ToString(), recognizer: "Is" + subTypeSort.Name, fieldNames: new[] { subTypeSort.Name + "2" + superType.Name }, sorts: new[] { subTypeSort }, sortRefs: null); superTypeConstructors.Add(subTypeConstr); } DatatypeSort superTypeSort = context.MkDatatypeSort(superType.Name, superTypeConstructors.ToArray()); //DatatypeSort = context.MkDatatypeSort("Types", new Constructor[] { // context.MkConstructor("ValTypes", "isValType", new String[] {"Val2Type"}, new Sort[] {ValTypeSort}, null), // context.MkConstructor("RefTypes", "isRefType", new String[] {"Ref2Type"}, new Sort[] {RefTypeSort}, null) //}); environment.Types.Add(superType, superTypeSort); } // Strings if (_possibleStringValues.Any()) { EnumSort enumSort = context.MkEnumSort("Strings", _possibleStringValues.ToArray()); environment.PossibleStringValues = enumSort; } foreach (var member in _members) { LambdaExpressionToConstraintGenerator.GetOrAddMemberAccessFunction(context, environment, member); } return environment; }