search code

Author: epsalon

rule/rule.go

@@ -2,8 +2,12 @@ package rule
 
 import "github.com/epsalon/decryptid/board"
 
-type BoardRule []bool
-type Rule func (*board.Board) BoardRule
+type BoardRule struct {
+	RuleSpec
+	arr []bool
+}
+
+type Rule func (*board.Board) []bool
 
 type hexRule func (board.Hex) bool
 
@@ -23,16 +27,6 @@ type coord = struct {
 	Y int
 }
 
-//         -A-
-//       3 3 3 3
-// -F-  3 2 2 2 3  -B-
-//     3 2 1 1 2 3        1, 7, 19, 37
-//    3 2 1 0 1 2 3
-//     3 2 1 1 2 3 -C-
-// -E-  3 2 2 2 3
-//       3 3 3 3
-//         -D-
-
 func max(a int, b int) int {
 	if a > b {
 		return a
@@ -69,7 +63,7 @@ func rCoord (c coord) int {
 }
 
 func distanceRule(hr hexRule, d int) Rule {
-	return func (b *board.Board) BoardRule {
+	return func (b *board.Board) []bool {
 		out := make([]bool, 12 * 9)
 		for y, row := range *b {
 			for x, hex := range row {
@@ -85,7 +79,7 @@ func distanceRule(hr hexRule, d int) Rule {
 }
 
 func negate(r Rule) Rule {
-	return func (b *board.Board) BoardRule {
+	return func (b *board.Board) []bool {
 		br := r(b)
 		for i, v := range br {
 			br[i] = !v
@@ -94,16 +88,18 @@ func negate(r Rule) Rule {
 	}
 }
 
-func FromSpec(rs RuleSpec) Rule {
+func (rs RuleSpec) OnBoard(b *board.Board) BoardRule {
+	br := BoardRule{RuleSpec:rs}
 	r := distanceRule(rs.hr, rs.d)
 	if rs.neg {
 		r = negate(r)
 	}
-	return r
+	br.arr = r(b)
+	return br
 }
 
 func Apply(br BoardRule, b *board.Board, p int) {
-	for i, v := range br {
+	for i, v := range br.arr {
 		h := &b[i / 12][i % 12]
 		if v {
 			h.Discs = h.Discs | (1 << (p-1))
@@ -115,4 +111,8 @@ func Apply(br BoardRule, b *board.Board, p int) {
 			h.Cube = p
 		}
 	}
+}
+
+func (b BoardRule) ToBoolSlice() []bool {
+	return b.arr
 }

rules_main.go

@@ -1,8 +1,9 @@
 package main
 
 import "fmt"
-import "github.com/epsalon/decryptid/rule"
 import "github.com/epsalon/decryptid/board"
+import "github.com/epsalon/decryptid/rule"
+import "github.com/epsalon/decryptid/search"
 
 var testSpec = board.BoardSpec {
 	Tiles: [3][2]board.TileId {
@@ -23,17 +24,31 @@ var testSpec = board.BoardSpec {
 func main () {
 	b := board.MakeBoard(testSpec)
 	rs := rule.AllRules()
+	brs := make([]search.Rule, 0, len(rs))
 	fmt.Println(rs)
 	for _, r := range rs {
 		fmt.Println(r)
-		br := rule.FromSpec(r)(&b)
+		br := r.OnBoard(&b)
+		brs = append(brs, search.Rule(br))
 		rule.Apply(br, &b, 1)
 		fmt.Println(b)
 	}
-	rule.Apply(rule.FromSpec(rule.D1Landscape(board.Water))(&b), &b, 1)
-	rule.Apply(rule.FromSpec(rule.OnLandscapes(board.Forest, board.Mountain))(&b), &b, 2)
-	rule.Apply(rule.FromSpec(rule.D1Landscape(board.Swamp))(&b), &b, 3)
-	rule.Apply(rule.FromSpec(rule.OnLandscapes(board.Forest, board.Swamp))(&b), &b, 4)
-	rule.Apply(rule.FromSpec(rule.D3Color(board.Blue))(&b), &b, 5)
-	fmt.Println(b)
+	srs := search.RuleSet(brs)
+	fmt.Println(srs)
+	results := search.FindRuleSets(srs)
+	for _, r := range results {
+		b := board.MakeBoard(testSpec)
+		fmt.Printf("(%v) %v\n", len(r), r)
+		for p, rl := range r {
+			rule.Apply(rl.(rule.BoardRule), &b, p+1)
+		}
+		fmt.Println(b)
+	}
+	
+	//rule.Apply(rule.FromSpec(rule.D1Landscape(board.Water))(&b), &b, 1)
+	//rule.Apply(rule.FromSpec(rule.OnLandscapes(board.Forest, board.Mountain))(&b), &b, 2)
+	//rule.Apply(rule.FromSpec(rule.D1Landscape(board.Swamp))(&b), &b, 3)
+	//rule.Apply(rule.FromSpec(rule.OnLandscapes(board.Forest, board.Swamp))(&b), &b, 4)
+	//rule.Apply(rule.FromSpec(rule.D3Color(board.Blue))(&b), &b, 5)
+	//fmt.Println(b)
 }

search/search.go

@@ -0,0 +1,99 @@
+package search
+
+import "fmt"
+import "log"
+import "github.com/epsalon/decryptid/uint128"
+
+type Rule interface {
+	ToBoolSlice() []bool
+	fmt.Stringer
+}
+
+type RuleSet []Rule
+
+type rule = uint128.Uint128
+type ruleSet = []uint128.Uint128
+
+func FindRuleSets (xrs RuleSet) []RuleSet {
+	rs := make(ruleSet, 0, len(xrs))
+	for _, r := range xrs {
+		bs := r.ToBoolSlice()
+		u := uint128.FromBoolSlice(bs)
+		log.Printf("rule = %v slice = %v", bs, u)
+		rs = append(rs, u)
+	}
+	idxSet, posLoc := findRulesets(rs)
+	log.Printf("Possible locations = %v\n", posLoc)
+	out := make([]RuleSet, 0, len(idxSet))
+	for _, s := range idxSet {
+		ors := make([]Rule, 0, len(s))
+		for _, r := range s {
+		  ors = append(ors, xrs[r])
+		}
+		out = append(out, RuleSet(ors))
+	}
+	return out
+}
+
+func consistent(rs ruleSet, is []int) bool {
+	for i, _ := range is {
+		m := uint128.Ones(9 * 12)
+		for j, r := range is {
+			if i != j {
+				m = m.And(rs[r])
+			}
+		}
+		if m.OnesCount() == 1 {
+			return false
+		}
+	}
+	return true
+}
+
+func findRulesets (rs ruleSet) ([][]int, rule) {
+	log.Printf("ruleset = %v", rs)
+	out := [][]int{}
+	cur := []int{}
+	posloc := uint128.Uint128{}
+	mask := uint128.Ones(9 * 12)
+	masks := []rule{}
+	for i := 0; ; {
+		// log.Printf("External loop i=%v cur=%v mask=%v masks=%v", i, cur, mask, masks)
+		for ; i < len(rs); i++ {
+			cur = append(cur, i)
+			masks = append(masks, mask)
+			mask = mask.And(rs[i])
+			// log.Printf("  Inner loop i=%v cur=%v mask=%v masks=%v", i, cur, mask, masks)
+			if (mask.IsZero()) {
+				// Dead end
+				cur = cur[:len(cur) - 1]
+				mask, masks = masks[len(masks) - 1], masks[:len(masks) - 1]
+				// log.Printf("    Zero mask pop!")
+				continue
+			}
+			if (mask.OnesCount() == 1) {
+				// Found possible solution!
+				if consistent(rs, cur) {
+					// log.Printf("    Found solution: %v", cur)
+					posloc = posloc.Or(mask)
+					out = append(out, append([]int(nil), cur...))
+				}
+				cur = cur[:len(cur) - 1]
+				mask, masks = masks[len(masks) - 1], masks[:len(masks) - 1]
+				continue
+			}
+			if len(cur) > 4 {
+				cur = cur[:len(cur) - 1]
+				mask, masks = masks[len(masks) - 1], masks[:len(masks) - 1]
+				continue
+			}
+			// Recurse deeper
+		}
+		if len(cur) == 0 {
+			break
+		}
+		i, cur = cur[len(cur) - 1] + 1, cur[:len(cur) - 1] 
+		mask, masks = masks[len(masks) - 1], masks[:len(masks) - 1]
+	}
+	return out, posloc
+}

search/search_test.go

@@ -0,0 +1,46 @@
+package search
+
+import "log"
+import "reflect"
+import "testing"
+import "github.com/epsalon/decryptid/uint128"
+
+var consitencyTests = []struct {
+	idx []int
+	result bool
+}{
+	{[]int{0,1,2}, true},
+	{[]int{4,0,1,2}, false},
+	{[]int{4,2}, true},
+	{[]int{4,3}, true},
+	{[]int{1,4,2}, false},
+	{[]int{1,4,3}, false},
+}
+
+func getRuleSet() ruleSet {
+	var testSet = []uint64{0xf0, 0x33, 0x55, 0x0f, 0x81}
+	us := make([]rule, 0, len(testSet))
+	for _, tr := range(testSet) {
+		us = append(us, uint128.Uint128{Lo:tr})
+	}
+	log.Printf("us = %v", us)
+	return us
+}
+
+func TestConsistent (t *testing.T) {
+	us := getRuleSet()
+	for _, tc := range(consitencyTests) {
+		r := consistent(us, tc.idx)
+		if r != tc.result {
+			t.Errorf("consistent(%v). Want: %v, Got: %v", tc.idx, tc.result, r)
+		}
+	}
+}
+
+func TestFindRulesets (t *testing.T) {
+	us := findRulesets(getRuleSet())
+	expected := [][]int{{0,1,2},{0,4},{1,2,3},{1,4},{2,4},{3,4}}
+	if !reflect.DeepEqual(us, expected) {
+		t.Errorf("Rulesets: Want: %v, Got: %v", expected, us)
+	}
+}

uint128/uint128.go

@@ -1,5 +1,6 @@
 package uint128
 
+import "fmt"
 import "math/bits"
 
 type Uint128 struct {
@@ -18,6 +19,10 @@ func (u Uint128) And(o Uint128) Uint128 {
 	return Uint128{u.Hi & o.Hi, u.Lo & o.Lo}
 }
 
+func (u Uint128) Or(o Uint128) Uint128 {
+	return Uint128{u.Hi | o.Hi, u.Lo | o.Lo}
+}
+
 func (u Uint128) Not() Uint128 {
 	return Uint128{^u.Hi, ^u.Lo}
 }
@@ -30,6 +35,14 @@ func (u Uint128) Equals(o Uint128) bool {
 	return u.Hi == o.Hi && u.Lo == o.Lo
 }
 
+func Ones(l int) Uint128 {
+	if l < 64 {
+		return Uint128{0, (uint64(1) << l) - 1}
+	} else {
+		return Uint128{(uint64(1) << (l-64)) - 1, ^uint64(0)}
+	}
+}
+
 func FromBoolSlice(s []bool) Uint128 {
 	var sh, hi, lo uint64
 	sh = 1
@@ -67,4 +80,8 @@ func (u Uint128) ToBoolSlice(l int) []bool {
 		sh = sh << 1
 	}
 	return s
+}
+
+func (u Uint128) String() string {
+	return fmt.Sprintf("%016x%016x", u.Hi, u.Lo)
 }