diff --git a/pkg/solver/solver.go b/pkg/solver/solver.go
index c01f32a0..3f7b9998 100644
--- a/pkg/solver/solver.go
+++ b/pkg/solver/solver.go
@@ -25,10 +25,8 @@ import (
 type State interface{ Encode() string }
 
 type PackageSolver interface {
-	BuildFormula() (bf.Formula, error)
-	Solve() ([]PackageAssert, error)
-	Apply() (map[string]bool, bf.Formula, error)
 	SetWorld(p []pkg.Package)
+	Install(p []pkg.Package) ([]PackageAssert, error)
 }
 type Solver struct {
 	Wanted    []pkg.Package
@@ -36,17 +34,14 @@ type Solver struct {
 	World     []pkg.Package
 }
 
-func NewSolver(pcoll []pkg.Package, init []pkg.Package, w []pkg.Package) PackageSolver {
+func NewSolver(init []pkg.Package, w []pkg.Package) PackageSolver {
 	for _, v := range init {
 		v.IsFlagged(true)
 	}
-	for _, v := range pcoll {
-		v.IsFlagged(false)
-	}
 	for _, v := range w {
 		v.IsFlagged(true)
 	}
-	return &Solver{Wanted: pcoll, Installed: init, World: w}
+	return &Solver{Installed: init, World: w}
 }
 
 func (s *Solver) SetWorld(p []pkg.Package) {
@@ -108,19 +103,27 @@ func (s *Solver) solve(f bf.Formula) (map[string]bool, bf.Formula, error) {
 	return model, f, nil
 }
 
-func (s *Solver) Apply() (map[string]bool, bf.Formula, error) {
-	f, err := s.BuildFormula()
-	if err != nil {
-		return map[string]bool{}, nil, err
-	}
-	return s.solve(f)
-}
-
 func (s *Solver) Solve() ([]PackageAssert, error) {
-	model, _, err := s.Apply()
+
+	f, err := s.BuildFormula()
+
+	if err != nil {
+		return nil, err
+	}
+
+	model, _, err := s.solve(f)
 	if err != nil {
 		return nil, err
 	}
 
 	return DecodeModel(model)
 }
+
+func (s *Solver) Install(coll []pkg.Package) ([]PackageAssert, error) {
+	for _, v := range coll {
+		v.IsFlagged(false)
+	}
+	s.Wanted = coll
+
+	return s.Solve()
+}
diff --git a/pkg/solver/solver_test.go b/pkg/solver/solver_test.go
index 6124cc8f..b774014a 100644
--- a/pkg/solver/solver_test.go
+++ b/pkg/solver/solver_test.go
@@ -32,8 +32,8 @@ var _ = Describe("Solver", func() {
 			A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
 			C := pkg.NewPackage("C", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
 
-			s := NewSolver([]pkg.Package{A}, []pkg.Package{C}, []pkg.Package{A, B, C}) // XXX: goes fatal with odd numbers of cnf ?
-			solution, err := s.Solve()
+			s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C}) // XXX: goes fatal with odd numbers of cnf ?
+			solution, err := s.Install([]pkg.Package{A})
 			Expect(err).ToNot(HaveOccurred())
 			Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
 			Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true}))
@@ -47,9 +47,9 @@ var _ = Describe("Solver", func() {
 			A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
 			C.IsFlagged(true) // installed
 
-			s := NewSolver([]pkg.Package{A.IsFlagged(true)}, []pkg.Package{C}, []pkg.Package{A, B, C, D})
+			s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C, D})
 
-			solution, err := s.Solve()
+			solution, err := s.Install([]pkg.Package{A})
 			Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
 			Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true}))
 			Expect(solution).To(ContainElement(PackageAssert{Package: D.IsFlagged(true), Value: true}))
@@ -66,9 +66,9 @@ var _ = Describe("Solver", func() {
 			B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{D}, []*pkg.DefaultPackage{})
 			A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
 
-			s := NewSolver([]pkg.Package{A}, []pkg.Package{}, []pkg.Package{A, B, C, D})
+			s := NewSolver([]pkg.Package{}, []pkg.Package{A, B, C, D})
 
-			solution, err := s.Solve()
+			solution, err := s.Install([]pkg.Package{A})
 			Expect(solution).To(ContainElement(PackageAssert{Package: A.IsFlagged(true), Value: true}))
 			Expect(solution).To(ContainElement(PackageAssert{Package: B.IsFlagged(true), Value: true}))
 			Expect(solution).To(ContainElement(PackageAssert{Package: D.IsFlagged(true), Value: true}))
@@ -86,9 +86,9 @@ var _ = Describe("Solver", func() {
 			B := pkg.NewPackage("B", "", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{C})
 			A := pkg.NewPackage("A", "", []*pkg.DefaultPackage{B}, []*pkg.DefaultPackage{})
 
-			s := NewSolver([]pkg.Package{A}, []pkg.Package{C}, []pkg.Package{A, B, C})
+			s := NewSolver([]pkg.Package{C}, []pkg.Package{A, B, C})
 
-			solution, err := s.Solve()
+			solution, err := s.Install([]pkg.Package{A})
 			Expect(len(solution)).To(Equal(0))
 			Expect(err).To(HaveOccurred())
 		})