; a buggy attempt on synthesis (declare-datatypes () ((TriangleType EQUILATERAL ISOSCELES ACUTE OBTUSE RIGHT ILLEGAL))) ; Define the elementary holes. The assertions, which restrict the ranges ; of holes are optional. They are needed to eliminate identical solutions ; (eg, h1=1 and h1=-1 denote the same solution) but they may also make the solver ; more efficient. (declare-const h0 Int)(assert (and (<= 0 h0)(< h0 2))) (declare-const h1 Int)(assert (and (<= 0 h1)(< h1 7))) (declare-const h2 Int)(assert (and (<= 0 h2)(< h2 3))) (declare-const h3 Int)(assert (and (<= 0 h3)(< h3 3))) (declare-const h4 Int)(assert (and (<= 0 h4)(< h4 7))) (declare-const h5 Int)(assert (and (<= 0 h5)(< h5 3))) (declare-const h6 Int)(assert (and (<= 0 h6)(< h6 3))) (define-fun synth-var ((h Int)(a Int)(b Int)(c Int)) Int (if (= h 0) a (if (= h 1) b c))) (define-fun synth-connective ((h Int)(v1 Bool)(v2 Bool)) Bool (if (= h 0) (and v1 v2) (or v1 v2))) (define-fun synth-comparator ((h Int)(v1 Int)(v2 Int)) Bool (if (= h 0) (= v1 v2) (if (= h 1) (<= v1 v2) (if (= h 2) (< v1 v2) (if (= h 3) (>= v1 v2) (if (= h 4) (> v1 v2) (if (= h 5) true false))))))) ; Now we can define the hole that will be synthesized. ; Technically, the hole is a grammar and the synthesizer ; finds a derivation. The derivation is identified by the ; values of h0, ..., h6. (define-fun hole((a Int)(b Int)(c Int)) Bool (synth-connective h0 (synth-comparator h1 (synth-var h2 a b c) (synth-var h3 a b c)) (synth-comparator h4 (synth-var h5 a b c) (synth-var h6 a b c)))) (define-fun classify ((a Int)(b Int)(c Int)) TriangleType (if (and (>= a b) (>= b c)) (if (hole a b c) (if (and (= a b) (= a c)) EQUILATERAL ISOSCELES) (if (not (= (* a a) (+ (* b b) (* c c)))) (if (< (* a a) (+ (* b b) (* c c))) ACUTE OBTUSE) RIGHT)) ILLEGAL)) ; Our spec is a set of eight test cases. (assert (= (classify 2 12 27) ILLEGAL)) (assert (= (classify 5 4 3) RIGHT)) (assert (= (classify 26 14 14) ISOSCELES)) (assert (= (classify 19 19 19) EQUILATERAL)) (assert (= (classify 9 6 4) OBTUSE)) (assert (= (classify 24 23 21) ACUTE)) (assert (= (classify 7 5 6) ILLEGAL)) (assert (= (classify 26 26 7) ISOSCELES)) ; Uncomment these asserts to force the synthesizer to produce alternative solutions. ; Once all four assertions are turned on, no more solutions remain. ;(assert (not (and (= h0 1)(= h1 0)(= h2 0)(= h3 1)(= h4 0)(= h5 1)(= h6 2)))) ; (or ( = a b)( = b c)) ;(assert (not (and (= h0 1)(= h1 0)(= h2 0)(= h3 1)(= h4 1)(= h5 1)(= h6 2)))) ; (or ( = a b)(<= b c)) ;(assert (not (and (= h0 1)(= h1 1)(= h2 0)(= h3 1)(= h4 1)(= h5 1)(= h6 2)))) ; (or (<= a b)(<= b c)) ;(assert (not (and (= h0 1)(= h1 1)(= h2 0)(= h3 1)(= h4 0)(= h5 1)(= h6 2)))) ; (or (<= a b)( = b c)) ; Here we suppress equivalent expressions by insisting on lexicograohic ordering of variables. ; These assertions, known in model checking as "symmetry reduction", are useful both to reduce the ; search space and to suppress enumeration of equivalent solutions to holes. ; i) enfore lexicographic ordering on h2, h3, and on h5, h6 (assert (and (< h2 h3)(< h5 h6))) ; example a=b is legal but b=a is not ; ii) lexicographic ordering on h2, h5 (assert (<= h2 h5)) ; ensures that only one of these is a valid solution: (or ( = a b)( = b c)), (or ( = b c)( = a b)) (check-sat) (get-model)