yargraph 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7eaedaa62ff94b250c68ca0dfe9a4127e390b5d8
+  data.tar.gz: 757a7b6dfd85305d6df76963bd2ebc0d2bf863bc
+SHA512:
+  metadata.gz: d9a65b8e7038068406bf52ec4b248814c9d13dfffef5de3ba5cffceff5b2c644442e568dd13fd664a2f48f8610d3878823cfbd889c54446c7944bbbc84c217f1
+  data.tar.gz: d0e755409c82c0ad7cbb4d7528b6d39beb2a857c8966e72f83879a83a19c2cfff38b9e9e120f21ad940e31205176d3c3cd67094e313322a68e81d0638ab75a94

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem 'ds'
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", ">= 2.8.0"
+  gem "rdoc", ">= 3.12"
+  gem "bundler", ">= 1.0"
+  gem "jeweler", ">= 1.8.7"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Ben J. Woodcroft
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,18 @@
+# Yargraph
+
+Yet another Ruby graphing library. Implements some [graph](http://en.wikipedia.org/wiki/Graph_theory)/vertex/edge related algorithms. Currently operates only on undirected graphs.
+
+* find all [Hamiltonian cycles](http://en.wikipedia.org/wiki/Hamiltonian_cycle) in a graph using an exponential time algorithm (`hamiltonian_cycles`, dynamic programming method of Bellman, Held, and Karp).
+* find edges that are a part of all Hamiltonian cycles (```edges_in_all_hamiltonian_cycles```, requires exponential time so may be _very_ slow)
+* find only some edges that are a part of all Hamiltonian cycles (```some_edges_in_all_hamiltonian_cycles```, faster but may not find all edges)
+
+Soon to be implemented:
+* finding [bridges](http://en.wikipedia.org/wiki/Bridge_%28graph_theory%29) (```bridges```, requires linear time using Schmidt's [chain decompositions method](http://dx.doi.org/10.1016%2Fj.ipl.2013.01.016))
+* determining [3-edge-connectivity](http://en.wikipedia.org/wiki/K-edge-connected_graph) and if 3-edge-connected (but not 4- or more), determine pairs of edges whose removal disconnects the graph (```three_edge_connected?```, ```three_edge_connections```, algorithm runs in O(n^2))
+
+Contributions are most welcome.
+
+## Copyright
+Copyright (c) 2014 Ben J. Woodcroft. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "yargraph"
+  gem.homepage = "http://github.com/wwood/yargraph"
+  gem.license = "MIT"
+  gem.summary = %Q{Pure Ruby graph algorithms}
+  gem.description = %Q{Pure Ruby graph algorithms, particularly e.g. Hamiltonian cycles}
+  gem.email = "donttrustben near gmail.com"
+  gem.authors = ["Ben J. Woodcroft"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "yargraph #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/yargraph.rb

@@ -0,0 +1,454 @@
+require 'set'
+require 'ds'
+
+module Yargraph
+  class OperationalLimitReachedException < Exception; end
+
+  class UndirectedGraph
+    # vertices is a Set
+    attr_accessor :vertices
+
+    # edges is an EdgeSet
+    attr_accessor :edges
+    # Contained within is a Hash of vertex1 => Set: vertex2, vertex3, ..
+    # If vertex1 => Set: vertex2, then vertex2 => Set: vertex1, ..
+    class EdgeSet
+      include Enumerable
+
+      def initialize
+        @edges = {}
+      end
+
+      def add_edge(v1, v2)
+        @edges[v1] ||= Set.new
+        @edges[v2] ||= Set.new
+        @edges[v1] << v2
+        @edges[v2] << v1
+      end
+
+      # Return an array of neighbours
+      def neighbours(v)
+        e = @edges[v]
+        return [] if e.nil?
+        return e.to_a
+      end
+
+      # Return a Set of vertices that are neighbours of the given
+      # vertex, or an empty Set if there are none
+      def [](vertex)
+        e = @edges[vertex]
+        if e
+          return e
+        else
+          return Set.new
+        end
+      end
+
+      def each
+        already_seen_vertices = Set.new
+        @edges.each do |v1, neighbours|
+          neighbours.each do |v2|
+            yield v1, v2 unless already_seen_vertices.include?(v2)
+          end
+          already_seen_vertices << v1
+        end
+      end
+
+      def length
+        count = 0
+        each do
+          count += 1
+        end
+        return count
+      end
+
+      # Is there an edge between v1 and v2?
+      def edge?(v1,v2)
+        e = @edges[v1]
+        return false if e.nil?
+        return e.include?(v2)
+      end
+
+      def empty?
+        @edges.each do |v, neighbours|
+          return false unless neighbours.empty?
+        end
+        return true
+      end
+    end
+
+
+    def initialize
+      @vertices = Set.new
+      @edges = EdgeSet.new
+    end
+
+    # Add an edge between two vertices, adding the vertices in the
+    # edge to the graph if they aren't already contained within it.
+    def add_edge(vertex1, vertex2)
+      @vertices << vertex1
+      @vertices << vertex2
+      @edges.add_edge vertex1, vertex2
+      return
+    end
+
+    # Add a vertex to the graph
+    def add_vertex(vertex)
+      @vertices << vertex
+    end
+
+    # Return an Enumerable collection of vertices that
+    # are directly connected to the given vertex
+    def neighbours(vertex)
+      @edges.neighbours(vertex)
+    end
+
+    def delete_edge(v1,v2)
+      @edges[v1].delete v2
+      @edges[v2].delete v1
+    end
+
+    # Yield a pair of vertices for each edge
+    def each_edge
+      @edges.each do |v1, v2|
+        yield v1, v2
+      end
+    end
+
+    def edge?(v1,v2)
+      @edges.edge?(v1,v2)
+    end
+
+    def copy
+      another = UndirectedGraph.new
+      @vertices.each do |v|
+        another.add_vertex v
+      end
+      each_edge do |v1, v2|
+        another.add_edge v1, v2
+      end
+      return another
+    end
+
+    # Run depth first search, returning an array of Hamiltonian paths.
+    # Or, if a block is given, yield each Hamiltonian path that comes
+    # along (in no defined order), and don't return the array (to potentially
+    # save RAM).
+    #
+    # The operational limit is used to make sure this algorithm doesn't
+    # get out of hand - only this many 'operations' are used when traversing
+    # the graph, as in #hamiltonian_paths_brute_force. When nil, there is no operational
+    # limit
+    def hamiltonian_cycles_brute_force(operational_limit=nil)
+      stack = DS::Stack.new
+      return [] if @vertices.empty?
+
+      origin_vertex = @vertices.to_a[0]
+      hamiltonians = []
+      num_operations = 0
+
+      path = Path.new
+      path << origin_vertex
+      stack.push path
+      while path = stack.pop
+        last_vertex = path[path.length-1]
+        if last_vertex == origin_vertex and path.length > 1
+          # Cycle of some sort detected. Is it Hamiltonian?
+          if path.length == vertices.length + 1
+            # Found a Hamiltonian path. Yield or save it for later
+            hpath = path.copy[0...(path.length-1)]
+            if block_given?
+              yield hpath
+            else
+              hamiltonians << hpath
+            end
+          else
+            # non-Hamiltonian path found. Ignore
+          end
+
+        elsif path.find_index(last_vertex) != path.length - 1
+          # Found a loop, go no further
+
+        else
+          # No loop, just another regular thing.
+          neighbours(last_vertex).each do |neighbour|
+            unless operational_limit.nil?
+              num_operations += 1
+              if num_operations > operational_limit
+                raise OperationalLimitReachedException
+              end
+            end
+            new_path = Path.new(path.copy+[neighbour])
+            stack.push new_path
+          end
+        end
+      end
+
+      return hamiltonians
+    end
+
+    # Use dynamic programming to find all the Hamiltonian cycles in this graph
+    def hamiltonian_cycles_dynamic_programming(operational_limit=nil)
+      stack = DS::Stack.new
+      return [] if @vertices.empty?
+
+      origin_vertex = @vertices.to_a[0]
+      hamiltonians = []
+      num_operations = 0
+
+      # This hash keeps track of subproblems that have already been
+      # solved. ie is there a path through vertices that ends in the
+      # endpoint
+      # Hash of [vertex_set,endpoint] => Array of Path objects.
+      # If no path is found, then the key is false
+      # The endpoint is not stored in the vertex set to make the programming
+      # easier.
+      dp_cache = {}
+
+      # First problem is the whole problem. We get the Hamiltonian paths,
+      # and then after reject those paths that are not cycles.
+      initial_vertex_set = Set.new(@vertices.reject{|v| v==origin_vertex})
+      initial_problem = [initial_vertex_set, origin_vertex]
+      stack.push initial_problem
+
+      while next_problem = stack.pop
+        vertices = next_problem[0]
+        destination = next_problem[1]
+
+        if dp_cache[next_problem]
+          # No need to do anything - problem already solved
+
+        elsif vertices.empty?
+          # The bottom of the problem. Only return a path
+          # if there is an edge between the destination and the origin
+          # node
+          if edge?(destination, origin_vertex)
+            path = Path.new [destination]
+            dp_cache[next_problem] = [path]
+          else
+            # Reached dead end
+            dp_cache[next_problem] = false
+          end
+
+        else
+          # This is an unsolved problem and there are at least 2 vertices in the vertex set.
+          # Work out which vertices in the set are neighbours
+          neighs = Set.new neighbours(destination)
+          possibilities = neighs.intersection(vertices)
+          if possibilities.length > 0
+            # There is still the possibility to go further into this unsolved problem
+            subproblems_unsolved = []
+            subproblems = []
+
+            possibilities.each do |new_destination|
+              new_vertex_set = Set.new(vertices.to_a.reject{|v| v==new_destination})
+              subproblem = [new_vertex_set, new_destination]
+
+              subproblems.push subproblem
+              if !dp_cache.key?(subproblem)
+                subproblems_unsolved.push subproblem
+              end
+            end
+
+            # if solved all the subproblems, then we can make a decision about this problem
+            if subproblems_unsolved.empty?
+              answers = []
+              subproblems.each do |problem|
+                paths = dp_cache[problem]
+                if paths == false
+                  # Nothing to see here
+                else
+                  # Add the found sub-paths to the set of answers
+                  paths.each do |path|
+                    answers.push Path.new(path+[destination])
+                  end
+                end
+              end
+
+              if answers.empty?
+                # No paths have been found here
+                dp_cache[next_problem] = false
+              else
+                dp_cache[next_problem] = answers
+              end
+            else
+              # More problems to be solved before a decision can be made
+              stack.push next_problem #We have only delayed solving this problem, need to keep going in the future
+              subproblems_unsolved.each do |prob|
+                unless operational_limit.nil?
+                  num_operations += 1
+                  raise OperationalLimitReachedException if num_operations > operational_limit
+                end
+                stack.push prob
+              end
+            end
+
+          else
+            # No neighbours in the set, so reached a dead end, can go no further
+            dp_cache[next_problem] = false
+          end
+        end
+      end
+
+      if block_given?
+        dp_cache[initial_problem].each do |hpath|
+          yield hpath
+        end
+        return
+      else
+        return dp_cache[initial_problem]
+      end
+    end
+    alias_method :hamiltonian_cycles, :hamiltonian_cycles_dynamic_programming
+
+
+    # Return an array of edges (edges being an array of 2 vertices)
+    # that correspond to edges that are found in all Hamiltonian paths.
+    # This method might be quite slow because it requires finding all Hamiltonian
+    # paths, which implies solving the (NP-complete) Hamiltonian path problem.
+    #
+    # There is probably no polynomial time way to implement this method anyway, see
+    # http://cstheory.stackexchange.com/questions/20413/is-there-an-efficient-algorithm-for-finding-edges-that-are-part-of-all-hamiltoni
+    #
+    # The operational limit is used to make sure this algorithm doesn't
+    # get out of hand - only this many 'operations' are used when traversing
+    # the graph, as in #hamiltonian_cycles_brute_force
+    def edges_in_all_hamiltonian_cycles(operational_limit=nil)
+      hedges = nil
+      hamiltonian_cycles do |path|
+        # Convert the path to a hash v1->v2, v2->v3. Can't have collisions because the path is Hamiltonian
+        edge_hash = {}
+        path.each_with_index do |v, i|
+          unless i == path.length-1
+            edge_hash[v] = path[i+1]
+          end
+        end
+        edge_hash[path[path.length-1]] = path[0] #Add the final wrap around edge
+
+        if hedges.nil?
+          # First Hpath found
+          hedges = edge_hash
+        else
+          # Use a process of elimination, removing all edges that
+          # aren't in hedges or this new Hpath
+          hedges.select! do |v1, v2|
+            edge_hash[v1] == v2 or edge_hash[v2] = v1
+          end
+          # If no edges fit the bill, then we are done
+          return [] if hedges.empty?
+        end
+      end
+      return [] if hedges.nil? #no Hpaths found in the graph
+      return hedges.to_a
+    end
+
+    # If #edges_in_all_hamiltonian_cycles is too slow, the method
+    # here is faster, but is not guaranteed to find every edge that is
+    # part of Hamiltonian cycles. This method proceeds under the assumption
+    # that the graph has at least 1 Hamiltonian cycle, but may stumble
+    # across evidence to the contrary.
+    #
+    # Returns an instance of EdgeSearchResult where #edges_in_all are those
+    # edges that are in all hamiltonian cycles, and #edges_in_none are those
+    # edges that are not in any hamiltonian cycles. While
+    def some_edges_in_all_hamiltonian_cycles
+      stack = DS::Stack.new
+      result = EdgeSearchResult.new
+
+      # As we are deleting edges, make a deep copy to start with
+      g = copy
+
+      # Fill up the stack, in reverse to ease testing
+      g.vertices.to_a.reverse.each do |v|
+        stack.push v
+      end
+
+      while v = stack.pop
+        all_neighbours = g.neighbours(v)
+        ham_neighbours = result.hamiltonian_neighbours(v)
+#        p v
+#        p all_neighbours
+#        p ham_neighbours
+
+        # If a vertex contains 1 or 0 total neighbours, then the graph cannot contain
+        # any hamcycles (in contrast, degree 1 doesn't preclude hampaths).
+        if all_neighbours.length < 2
+          result.contains_hamcycle = false
+
+        elsif all_neighbours.length == 2
+          # If a vertex has degree 2 then both edges must be a part of the hamcycle
+          all_neighbours.each do |n|
+            unless result.edges_in_all.edge?(v,n)
+              result.edges_in_all.add_edge(v,n)
+              stack.push n #now need to re-evalute the neighbour, as its neighbourhood is changed
+            end
+
+            # if an edge be and must not be in all hamcycles, then the graph is not Hamiltonian.
+            # Are there any concrete examples of this? Possibly.
+            if result.edges_in_all[v].include?(n) and result.edges_in_none[v].include?(n)
+              result.contains_hamcycle = false
+            end
+          end
+
+        elsif ham_neighbours.length >= 2
+          # There cannot be any further hamcycle edges from this vertex, so the rest of the edges
+          # cannot be a part of _any_ hamcycle
+          all_neighbours.each do |n|
+            next if ham_neighbours.include?(n)
+
+            result.edges_in_none.add_edge(v,n)
+            g.delete_edge(v,n)
+            stack.push n #reconsider the neighbour
+          end
+
+        else
+          # Anything else that can be done cheaply?
+          # Maybe edges that create non-Hamiltonian cycles when only considering edges
+          # that are in all Hamiltonian cycles -> these cannot be in any hamcycle
+
+        end
+        #p stack
+      end
+      #p result
+
+      return result
+    end
+
+    class EdgeSearchResult
+      # EdgeSets of edges that are contained in, or not contained in all Hamiltonian cycles.
+      attr_accessor :edges_in_all, :edges_in_none
+
+      # True, false, or dunno (nil), does the graph contain one or more Hamiltonian cycles?
+      attr_accessor :contains_hamcycle
+
+      def initialize
+        @edges_in_all = EdgeSet.new
+        @edges_in_none = EdgeSet.new
+      end
+
+      # Return an Set of neighbours that must be next or previous in a hamiltonian cycle (& path?)
+      def hamiltonian_neighbours(vertex)
+        @edges_in_all[vertex]
+      end
+    end
+
+    class Path < Array
+      def copy
+        Path.new(self)
+      end
+    end
+
+#    # Return a "chain decomposition" as defined by Jens M. Schmidt, "A simple
+#    # test on 2-vertex- and 2-edge-connectivity"
+#    def chain_decomposition
+#    end
+#
+#    class ChainDecomposition
+#      # A Hash of edge objects (arrays of objects)objects. Each element of the array
+#      # is
+#      attr_accessor :edges_to_chainsets
+#
+#      def number_of_
+#    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'yargraph'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end

data/spec/yargraph_spec.rb

@@ -0,0 +1,228 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class GraphTesting
+  def self.generate_undirected(edges)
+    g = Yargraph::UndirectedGraph.new
+    edges.each do |edge|
+      g.add_edge edge[0], edge[1]
+    end
+    return g
+  end
+
+  def self.sorted_edges(edges)
+    edges.collect{|edge| edge.sort}.sort
+  end
+
+  # return an array of cycles the same as the original
+  # set, except that they have been rotated until so the min element
+  # is the first element
+  def self.sort_cycles(cycles)
+    cycles.collect do |cycle|
+      [cycle, cycle.reverse].collect do |cyc|
+        m = cyc.min
+        i = cyc.find_index(m)
+        cyc.rotate(i)
+      end.sort[0]
+    end
+  end
+end
+
+CYCLE_FINDING_METHODS = [
+  :hamiltonian_cycles_dynamic_programming,
+  :hamiltonian_cycles_brute_force,
+]
+
+describe "Yargraph" do
+  it 'should do neighbours' do
+    g = GraphTesting.generate_undirected([
+      [0,1],
+      [1,2],
+      [2,0]
+    ])
+    g.neighbours(0).sort.should == [1,2]
+    g.neighbours(1).sort.should == [0,2]
+
+    g = GraphTesting.generate_undirected([
+      [0,1],
+      [1,2],
+    ])
+    g.neighbours(2).sort.should == [1]
+  end
+
+  it "should find hamiltonian cycles 1" do
+    g = GraphTesting.generate_undirected([
+      [0,1],
+      [1,2],
+      [2,0]
+    ])
+    CYCLE_FINDING_METHODS.each do |method|
+      cycles = GraphTesting.sort_cycles(g.send(method))
+      cycles.should == GraphTesting.sort_cycles([
+        [1,2,0],
+        [2,1,0],
+      ])
+    end
+  end
+
+  it "should find hamiltonian cycles 2" do
+    g = GraphTesting.generate_undirected([
+      [1,2],
+      [1,3],
+      [2,4],
+      [2,3],
+      [3,6],
+      [4,5],
+      [4,6],
+      [5,6],
+    ])
+    paths = [
+      [2,4,5,6,3,1],
+    ]
+    revpaths = paths.collect do |path|
+      (path[1..path.length]+[path[0]]).reverse
+    end
+
+    CYCLE_FINDING_METHODS.each do |method|
+      GraphTesting.sort_cycles(g.send(method)).should ==
+        GraphTesting.sort_cycles(paths+revpaths)
+    end
+  end
+
+  it 'should operated within limits' do
+    g = GraphTesting.generate_undirected([
+      [1,2],
+      [1,3],
+      [2,4],
+      [2,3],
+      [3,6],
+      [4,5],
+      [4,6],
+      [5,6],
+    ])
+    CYCLE_FINDING_METHODS.each do |method|
+      expect {
+        g.send(method, 4)
+      }.to raise_error(Yargraph::OperationalLimitReachedException)
+    end
+  end
+
+  it 'should find edges in all hamiltonian cycles' do
+    g = GraphTesting.generate_undirected([
+      [1,2],
+      [1,3],
+      [2,4],
+      [2,3],
+      [3,6],
+      [4,5],
+      [4,6],
+      [5,6],
+    ])
+    GraphTesting.sorted_edges(g.edges_in_all_hamiltonian_cycles).should ==
+      GraphTesting.sorted_edges([
+      [1,2],
+      [2,4],
+      [4,5],
+      [5,6],
+      [6,3],
+      [3,1],
+    ])
+  end
+
+  it 'should find some all-hamiltonian edges first' do
+    g = GraphTesting.generate_undirected([
+      [0,1],
+      [1,2],
+      [2,0]
+    ])
+    edgeset_results = g.some_edges_in_all_hamiltonian_cycles
+    edgeset_results.contains_hamcycle.should == nil
+    GraphTesting.sorted_edges(edgeset_results.edges_in_all.to_a).should ==
+      GraphTesting.sorted_edges([
+        [0,1],
+        [1,2],
+        [2,0],
+      ])
+    GraphTesting.sorted_edges(edgeset_results.edges_in_none.to_a).should == []
+  end
+
+  it 'some all-hamiltonian edges should say when it falsifies the assumption' do
+    g = GraphTesting.generate_undirected([
+      [0,1],
+      [1,2],
+    ])
+    edgeset_results = g.some_edges_in_all_hamiltonian_cycles
+    edgeset_results.contains_hamcycle.should == false
+    GraphTesting.sorted_edges(edgeset_results.edges_in_all.to_a).should ==
+      GraphTesting.sorted_edges([
+        [0,1],
+        [1,2],
+      ])
+    GraphTesting.sorted_edges(edgeset_results.edges_in_none.to_a).should == []
+  end
+
+
+  it 'some all-hamiltonian edges should not choose all edges when not all are right' do
+    g = GraphTesting.generate_undirected([
+      [0,1],
+      [1,2],
+      [2,3],
+      [3,0],
+
+      [0,2],
+      [1,3],
+    ]) #This graph has hamiltonian paths but no edges are in every hamiltonian cycle
+    edgeset_results = g.some_edges_in_all_hamiltonian_cycles
+    edgeset_results.contains_hamcycle.should == nil
+    GraphTesting.sorted_edges(edgeset_results.edges_in_all.to_a).should == []
+    GraphTesting.sorted_edges(edgeset_results.edges_in_none.to_a).should == []
+  end
+
+  it 'some all-hamiltonian edges should choose none when none are right' do
+    g = GraphTesting.generate_undirected([
+      [0,1],
+      [1,2],
+      [2,3],
+      [3,0],
+
+      [0,2],
+      [1,3],
+    ]) #This graph has hamiltonian paths but no edges are in every hamiltonian cycle
+    edgeset_results = g.some_edges_in_all_hamiltonian_cycles
+    edgeset_results.contains_hamcycle.should == nil
+    GraphTesting.sorted_edges(edgeset_results.edges_in_all.to_a).should == []
+    GraphTesting.sorted_edges(edgeset_results.edges_in_none.to_a).should == []
+  end
+
+  it 'some all-hamiltonian edges should iterate properly' do
+    g = GraphTesting.generate_undirected([
+      [0,1],
+      [1,2],
+
+      [3,4],
+      [4,5],
+
+      [0,3],
+      [1,4],
+      [2,5],
+    ]) #This graph requires removal of edges to discover more h_edges
+    edgeset_results = g.some_edges_in_all_hamiltonian_cycles
+    edgeset_results.contains_hamcycle.should == nil
+
+    GraphTesting.sorted_edges(edgeset_results.edges_in_all.to_a).should ==
+      GraphTesting.sorted_edges([
+        [0,1],
+        [1,2],
+
+        [3,4],
+        [4,5],
+
+        [0,3],
+        #[1,4],
+        [2,5],
+      ])
+    GraphTesting.sorted_edges(edgeset_results.edges_in_none.to_a).should ==
+      GraphTesting.sorted_edges([
+        [1,4],
+      ])
+  end
+end

data/yargraph.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: yargraph 0.0.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "yargraph"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Ben J. Woodcroft"]
+  s.date = "2014-05-30"
+  s.description = "Pure Ruby graph algorithms, particularly e.g. Hamiltonian cycles"
+  s.email = "donttrustben near gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/yargraph.rb",
+    "spec/spec_helper.rb",
+    "spec/yargraph_spec.rb",
+    "yargraph.gemspec"
+  ]
+  s.homepage = "http://github.com/wwood/yargraph"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.2.2"
+  s.summary = "Pure Ruby graph algorithms"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<ds>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 2.8.0"])
+      s.add_development_dependency(%q<rdoc>, [">= 3.12"])
+      s.add_development_dependency(%q<bundler>, [">= 1.0"])
+      s.add_development_dependency(%q<jeweler>, [">= 1.8.7"])
+    else
+      s.add_dependency(%q<ds>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 2.8.0"])
+      s.add_dependency(%q<rdoc>, [">= 3.12"])
+      s.add_dependency(%q<bundler>, [">= 1.0"])
+      s.add_dependency(%q<jeweler>, [">= 1.8.7"])
+    end
+  else
+    s.add_dependency(%q<ds>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 2.8.0"])
+    s.add_dependency(%q<rdoc>, [">= 3.12"])
+    s.add_dependency(%q<bundler>, [">= 1.0"])
+    s.add_dependency(%q<jeweler>, [">= 1.8.7"])
+  end
+end
+

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: yargraph
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ben J. Woodcroft
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ds
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+description: Pure Ruby graph algorithms, particularly e.g. Hamiltonian cycles
+email: donttrustben near gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/yargraph.rb
+- spec/spec_helper.rb
+- spec/yargraph_spec.rb
+- yargraph.gemspec
+homepage: http://github.com/wwood/yargraph
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Pure Ruby graph algorithms
+test_files: []