graphmatcher 0.3.5 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a07b061aee6d3c909fa21e7dcc3ed815c556b358f0e233338614f97dc26d90f
-  data.tar.gz: ac1149e8f375be540ba8d77d77276f9d309df1dc44c7e7057eef9def8ff38be8
+  metadata.gz: 825a8f82e234efc81b2de40f274f2dd60619bdaa797e65c303675a1b5a3c2a69
+  data.tar.gz: f9e114404851c37c7cd3bfefc84fe04ec8e3e11c63d21c7dd695ebff1a02e959
 SHA512:
-  metadata.gz: be30bea5f4045cefb90288e632e43e4ea9d2472879c2e4d339fef667ddf842f863601064052e969bb1f7e6afa8f3d17daa5457ed52208e311faf76575ada5ca4
-  data.tar.gz: 6ce6b7bd8a89fbc44c06079c014353220ed8f5cc3e938040bb7da9eb9b2226d967c11eadef2e1fe50c95989fbfd303d637d90cb057ea948adc3c785ba48ad142
+  metadata.gz: 37ff3e5e04a316849cb1f343b5f701b082a49a2582626cafa2ac51f88c9bb72bb0a04bec352833b1725abda7eb970f822688a2da538fa63b352c571fadd1fb65
+  data.tar.gz: 2d181382e180ca3cb8c888f1ce55db75cdfd8c2d27c1c8dfbccff3304bb0814c25f31514b9e36841509412d2e59b87bc96739b3b91f61b68ec71f482e07204de

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Emre Unlu
+
+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,179 @@
+# Graphmatcher
+
+Labeled **subgraph matching** for Ruby: find all embeddings of a query graph
+inside a larger data graph, respecting vertex labels and edge direction.
+
+Two implementations are provided:
+
+| Class | Algorithm | Notes |
+|-------|-----------|-------|
+| `Graphmatcher` | DualIso (graph simulation + backtracking), after M. Saltz et al. | Original implementation. Fast on DAGs; **does not match cyclic queries** (see Known issues). |
+| `GraphmatcherVF2pp` | VF2++ (Jüttner & Madarasi, 2018) | Drop-in alternative with the same I/O. Handles cycles and self-loops; substantially faster on the bundled benchmarks. |
+
+Both expose the same constructor and the same `getMatches` output shape, so they
+are interchangeable behind that interface.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'graphmatcher'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install graphmatcher
+
+## Graph representation
+
+A graph is a two-row array `[adjacency, labels]` (an optional third row of ids is
+ignored by the matchers):
+
+```ruby
+g = [
+  [[1, 2], [], [0]],   # adjacency: OUTGOING edges. vertex 0 -> {1,2}, vertex 2 -> {0}
+  ["x",    "y", "y"]   # labels:    vertex 0 is "x", vertices 1 and 2 are "y"
+]
+```
+
+- `adjacency[i]` is the list of **outgoing** edge targets of vertex `i`.
+- `labels[i]` is the label of vertex `i`; labels are compared with `==`.
+- Both rows must be the same length (enforced by `validate!`).
+
+## Usage
+
+```ruby
+require 'graphmatcher'          # DualIso
+require 'graphmatcher_vf2pp'    # VF2++
+
+query = [[[1, 2], [], [0]], ["T0", "T0", "T0"]]
+data  = [[[1, 2], [], [0]], ["T0", "T0", "T0"]]
+
+matcher = GraphmatcherVF2pp.new(
+  query:            query,
+  data:             data,
+  limit:            100,    # max matches to return (0 => unlimited)
+  max_allowed_time: 4.0,    # wall-clock budget in seconds (0 => unlimited)
+  self_loops:       true
+)
+
+matcher.getMatches
+# => [[[0], [1], [2]]]
+```
+
+### Output shape
+
+`getMatches` returns an array of matches. Each match has one entry per query
+vertex, narrowed to a single data vertex:
+
+```
+[[d0], [d1], ..., [dn]]   # query vertex i  ->  data vertex di
+```
+
+For example `[[0], [1], [2]]` means query vertices `0,1,2` map to data vertices
+`0,1,2` respectively. When several data vertices are interchangeable (e.g. two
+children sharing a label) each distinct embedding is returned separately.
+
+## Testing
+
+The project uses [`just`](https://github.com/casey/just) as the task runner on
+top of RSpec. From the repo root:
+
+```sh
+just              # list all recipes
+just test         # full RSpec suite (equivalent to `rake spec`)
+just test-vf2     # VF2++ examples only
+just verify       # curated correctness check vs a brute-force oracle
+just fuzz         # 400 random graphs checked against the oracle
+just fixtures     # run JSON fixtures through the oracle-backed checker
+just check        # test + verify + fuzz + fixtures
+```
+
+Plain RSpec (`rspec` / `bundle exec rake spec`) still works if you prefer not to
+use `just`.
+
+Test harnesses:
+
+- **RSpec** (`spec/`) — behavioural examples for both matchers.
+- **`verify_vf2pp.rb`** — curated cases run through VF2++, DualIso, and an
+  independent brute-force **oracle**; reports where each implementation agrees.
+- **`fuzz_vf2pp.rb`** — randomized differential testing against the oracle.
+- **`run_fixtures.rb`** — loads JSON fixtures and checks VF2++ against the oracle.
+
+The oracle enumerates every injective labeled mapping and keeps those where every
+query edge maps to a data edge. It is the ground truth, so a test case only needs
+to supply the graphs — the expected answer is derived automatically.
+
+## Submitting your own fixtures
+
+Fixtures are JSON. Drop entries into any `*.json` file under `spec/fixtures/`
+(picked up automatically by `just fixtures`), or keep your own file anywhere and
+pass it explicitly:
+
+```sh
+just fixtures path/to/my_cases.json
+# or run several
+ruby run_fixtures.rb spec/fixtures/matcher_cases.json path/to/mine.json
+```
+
+Fixture format:
+
+```json
+{
+  "fixtures": [
+    {
+      "name": "triangle (cyclic) identity",
+      "self_loops": true,
+      "query": [[[1, 2], [], [0]], ["T0", "T0", "T0"]],
+      "data":  [[[1, 2], [], [0]], ["T0", "T0", "T0"]]
+    },
+    {
+      "name": "DAG identity",
+      "self_loops": false,
+      "expect_count": 2,
+      "query": [[[1, 2], [], []], ["A", "A", "A"]],
+      "data":  [[[1, 2], [], []], ["A", "A", "A"]]
+    }
+  ]
+}
+```
+
+- `query` / `data` (required) — graphs in `[adjacency, labels]` form.
+- `self_loops` (optional, default `true`) — passed through to the matcher.
+- `expect_count` (optional) — asserts the number of matches in addition to the
+  oracle comparison.
+
+You do **not** need to provide expected matches; the oracle computes them.
+
+## Known issues
+
+- `Graphmatcher` (DualIso) returns **zero matches for cyclic queries** — including
+  the identity mapping of a simple triangle. `GraphmatcherVF2pp` handles these
+  correctly. If your queries contain cycles, use the VF2++ implementation.
+- `spec/regression.rb` uses a positional constructor
+  (`Graphmatcher.new(graph, query, limit)`) while the library uses keyword
+  arguments; that spec does not currently run against the shipped API.
+
+## Development
+
+After checking out the repo, run `bundle` to install dependencies, then
+`just test` (or `rake spec`) to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `lib/graphmatcher.rb`, and
+then run `bundle exec rake release`.
+
+## Contributing
+
+Bug reports and merge requests are welcome on GitLab at
+https://gitlab.com/forvelin/graphmatcher.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](http://opensource.org/licenses/MIT).

data/lib/graphmatcher.rb

@@ -0,0 +1,224 @@
+require 'logger'
+#require 'ruby-prof'
+class Graphmatcher
+
+	VERSION = "0.4.0"
+
+	@@logger = Logger.new(STDOUT)
+	@@logger.level = Logger::INFO
+
+	####################################################################################################
+	# Instantiation with query_graph and data_graph for Graphmatcher class.				 			   #
+	# 																	  				 			   #
+	# @query_graph & @data_graph: Arrays which are represented as an		   			 			   #
+	# array such as g=[[[1,2],[3],[3],[]],['x','y','y','z']]. g[0] is			   		 			   #
+	# adjacency array which points children of given vertex of array index,	   			 			   #
+	# -e.g. vertex 0 has 1 and 2 as children- and g[1] is labels for vertices.	   		 			   #
+	# -e.g. vertex 0 has label 'x'.											   			 			   #
+	# 																								   #
+	# @limit: Upper limit for number of matches. Procedure terminates after							   #
+	# reaching to an upper limit.																	   #
+	# @max_allowed_time: Maximum allowed time for procedure to run.									   #
+	# @self_loops: Boolean value for representing if query is cyclic or not.						   #
+	####################################################################################################
+
+
+	def initialize(args)
+
+		@query_graph = args[:query].to_a
+ 		@data_graph = args[:data].to_a
+		@limit = args[:limit].to_i
+		@max_allowed_time = args[:max_allowed_time].to_f
+		@self_loops = args[:self_loops]
+		validate!
+
+	end
+
+	def getQueryGraph
+		@query_graph
+	end
+
+	def getDataGraph
+		@data_graph
+	end
+
+
+	########################################################################
+	# Public interface for Graphmatcher class.							   #
+	# 																	   #
+	# @matches: Array of matching indices of query graph in data graph.	   #
+	########################################################################
+
+	def getMatches
+		@matches = []
+		@t0 = Time.now.to_f
+		phi = self.labelMatch()
+		self.dualIso(self.dualSim(phi),0)
+		@@logger.info("FINISH matches=#{@matches}")
+		@matches
+	end
+
+	#Function for generating feasible matches for query
+	#graph based on labels of vertices of data graph.
+
+	def labelMatch()
+		data_labels=@data_graph[1]
+		query_labels=@query_graph[1]
+		feasible = query_labels.map.with_index { |ql,index|
+			data_labels.each_index.select {|i| data_labels[i] == ql }}
+				@@logger.info('Label matches(phi) are: '+feasible.to_s)
+		feasible
+	end
+
+
+	#INFO: Function that uses parameter phi -which is generated by labelMatch-
+	#to determine which matches of data graph have expected relations in query graph.
+	#phi = ...
+
+	def dualSim(phi)
+
+		# One directional adjacency array for data graph and query graphs.
+		data_children = @data_graph[0]
+		query_children = @query_graph[0]
+
+		@@logger.info("Data children: #{data_children.to_s}")
+		@@logger.info("Query children: #{query_children.to_s}")
+
+		changed = true
+		while (changed)
+			if (Time.now.to_f-@t0) > @max_allowed_time then return nil end
+			changed = false
+			# children = query_edges
+			# q_index = query_vertex_index
+			query_children.each_with_index { |children,q_index| ##loop 1
+				#query_child = query_edge_target
+				children.each { |query_child| ##loop 2
+					# Create a temporary phi object.
+					newPhi = []
+					# Loop over candidates of each vertex in data graph.
+
+					to_delete = []
+					phi[q_index].map { |child| #loop 3
+
+						@@logger.debug("Find intersection for u=#{q_index}, u_c=#{query_child}, child=#{child}")
+						@@logger.debug("LOOP OF #{q_index}-#{query_child}-#{child}")
+						# Find intersection of children of 'child' in data graph and
+						# candidates of 'query child' in data graph.
+						phiInt = data_children[child] & phi[query_child]
+						@@logger.debug("datachildren[child]=#{data_children[child]}")
+						@@logger.debug("phi[query_child]=#{phi[query_child]}")
+						@@logger.debug("Intersection=#{phiInt}")
+
+						if (phiInt.nil? || phiInt.empty?)
+							@@logger.debug("Before delete=#{phi[q_index]}")
+							phi[q_index].delete (child)
+							to_delete = [q_index,child]
+							@@logger.debug("After delete=#{phi[q_index]}")
+							@@logger.debug("After delete phi=#{phi}")
+							if phi[q_index].empty? then return phi end
+							changed = true
+						end
+						newPhi = newPhi | phiInt
+					} ##phi[q_index].each
+					if !to_delete.empty?
+						phi[to_delete[0]].delete(to_delete[1])
+						to_delete = []
+					end
+					if newPhi.flatten.empty? then ; return phi end
+					if newPhi.size < phi[query_child].size then
+						@@logger.debug("#{newPhi.flatten} <- newphi and #{phi[query_child]} <- phi_query_child - #{newPhi.flatten.size} vs #{phi[query_child].size}")
+						changed = true
+					end
+					if (@self_loops && query_child == q_index)
+						phi[query_child] &= newPhi;
+					else
+						@@logger.debug("phi=#{phi} and phi[#{query_child}]=#{newPhi}")
+						phi[query_child] = newPhi;
+					end
+				} ##children.each { |query_child|
+			}##query_children.each_with_index { |children,q_index|
+		end ##while
+		@@logger.info("Returning phi=#{phi}")
+		return phi
+	end
+
+	# INFO: Function call to collect matches from phi object.
+	# phi = ...
+	# depth = ...
+	# matches = ...
+
+	def dualIso(phi,depth)
+		if depth == @query_graph[0].length
+			@@logger.info("STATUS depth=#{depth}, matches=#{@matches}")
+			if not (phi.nil? || phi.empty?)
+				if phi.include?([]) #Unable to match this vertex in graph.
+					@matches << [nil]
+				else
+					@matches << phi
+				end
+			end
+		elsif not (phi.nil? || phi.empty?)
+			phi[depth].each_with_index { |value,index|
+				if not contains(phi,depth,value)
+					#keys are indices 0...n, values are possible values for that index
+					phicopy = phi.map { |i| i.clone }
+					@@logger.info("INSERT phicopy=#{phicopy},depth=#{depth},value=#{value},matches=#{@matches}")
+					phicopy[depth] = [value]
+					if (@matches.length >= @limit)
+						@@logger.info("FINISH matches=#{@matches}")
+						return @matches
+					end
+					dualIso(dualSim(phicopy),depth+1)
+				end
+			}
+		end
+	end
+
+	# INFO: Function that checks if vertex J is contained in any of previous matches.
+	# TODO: Change with find method.
+
+	def contains(phi,depth,j)
+		if not depth > 0 then false end
+		(0..depth-1).each { |i|
+			@@logger.info("phi[#{i}]=#{phi[i]},depth=#{depth},j=#{j}")
+			if phi[i].include?(j)
+				return true
+			end
+		}
+		return false
+	end
+
+	#EXPERIMENTAL
+	#INFO: Produce a GraphViz-compliant directed graph syntax.
+	#INFO: Needs dot/graphviz tools installed as a dependency.
+	#TODO: It is not able to handle multiple results, color each result different.
+	#Indices are IDs, labels are labels adjencency array is outgoing edges.
+
+	def dotGraph(data,subgraph=nil,prefix='')
+		tstamp = Time.now.to_i
+		output = ["digraph {"]
+		data.transpose.each_with_index { |node,id|
+			output << "#{id} [label=\"#{node[1]}\"]" #vertex
+			output << "#{id}->{#{node[0].join(' ')}}" #edge
+		}
+		if subgraph
+			subgraph.transpose.each_with_index { |node,id|
+				output << "#{node.flatten.first} [fontcolor=\"Red\"]" #vertex
+			}
+		end
+		output << "}"
+		File.write("#{prefix}#{tstamp}.dot",output.join("\n"))
+		dot_produce = ["dot","-Tpng","#{prefix}#{tstamp}.dot","-o","#{prefix}#{tstamp}.png"].join(" ")
+		`#{dot_produce}`
+	end
+
+	def validate!
+		if !(@query_graph.length>=2 && @data_graph.length>=2)
+			raise ArgumentError.new("Input graphs must have at least two dimensions !")
+		end
+		if !(@query_graph.map {|s| s.length}.uniq.length==1 && @data_graph.map {|s|s.length}.uniq.length==1)
+			raise ArgumentError.new("Input graphs adjencency and label arrays must be sized equal !")
+		end
+	end
+
+end

data/lib/graphmatcher_vf2pp.rb

@@ -0,0 +1,217 @@
+require 'logger'
+require 'set'
+
+# GraphmatcherVF2pp
+#
+# A drop-in alternative to Graphmatcher (the DualIso implementation) that solves
+# the same labeled subgraph-isomorphism problem using the VF2++ algorithm
+# (Jüttner & Madarasi, 2018), which is itself a refinement of VF2
+# (Cordella et al., 2004).
+#
+# -------------------------------------------------------------------------------
+# I/O CONTRACT (identical to Graphmatcher)
+# -------------------------------------------------------------------------------
+# Construction (keyword args):
+#   GraphmatcherVF2pp.new(query:, data:, limit:, max_allowed_time:, self_loops:)
+#
+#   query / data : [adjacency, labels] (an optional 3rd row of ids is ignored).
+#                  adjacency[i] = array of OUTGOING edge targets of vertex i.
+#                  labels[i]    = label of vertex i (compared with ==).
+#   limit        : upper bound on number of matches to return (0/nil => unlimited).
+#   max_allowed_time : wall-clock budget in seconds (0/nil => unlimited).
+#   self_loops   : accepted for API compatibility; VF2++ handles self-loops and
+#                  cycles natively regardless of this flag.
+#
+# getMatches returns an Array of matches. Each match has one entry per query
+# vertex, narrowed to a single data vertex:
+#   [[d0],[d1],...,[dn]]   meaning query vertex i -> data vertex di.
+# This is byte-compatible with the successful output shape of Graphmatcher.
+#
+# SEMANTICS: subgraph isomorphism under an injective mapping f where
+#   * labels match: query_labels[u] == data_labels[f(u)]
+#   * every query edge u->v maps to a data edge f(u)->f(v)
+# (Extra edges in the data graph are allowed; this matches the DAG behaviour of
+#  the original Graphmatcher, but — unlike it — also works on cyclic queries.)
+class GraphmatcherVF2pp
+
+	VERSION = "0.1.0".freeze
+
+	@@logger = Logger.new(STDOUT)
+	@@logger.level = Logger::INFO
+
+	def self.logger
+		@@logger
+	end
+
+	def initialize(args)
+		@query_graph = args[:query].to_a
+		@data_graph  = args[:data].to_a
+		@limit = args[:limit].to_i
+		@max_allowed_time = args[:max_allowed_time].to_f
+		@self_loops = args[:self_loops]
+		validate!
+
+		@q_adj = @query_graph[0]
+		@q_lab = @query_graph[1]
+		@d_adj = @data_graph[0]
+		@d_lab = @data_graph[1]
+		@qn = @q_adj.length
+		@dn = @d_adj.length
+
+		# Reverse adjacency (incoming edges) for both graphs — VF2++ checks
+		# consistency in both directions.
+		@q_pred = build_predecessors(@q_adj, @qn)
+		@d_pred = build_predecessors(@d_adj, @dn)
+
+		# Out/in degree of data vertices, used as a cheap candidate filter.
+		@d_outdeg = @d_adj.map(&:length)
+		@d_indeg  = @d_pred.map(&:length)
+	end
+
+	def getMatches
+		@matches = []
+		@t0 = Time.now.to_f
+
+		# Precompute per-query-vertex candidate lists (label + degree pruning).
+		@candidates = precompute_candidates
+		# If any query vertex has no candidate, there can be no match.
+		return @matches if @candidates.any?(&:empty?)
+
+		# VF2++ matching order: process the most constrained query vertices first.
+		@order = matching_order
+
+		# core_q[u] = data vertex mapped to query vertex u (or nil).
+		# core_d[d] = query vertex mapped to data vertex d (or nil).
+		@core_q = Array.new(@qn, nil)
+		@core_d = Array.new(@dn, nil)
+
+		backtrack(0)
+		@@logger.info("FINISH matches=#{@matches.size}")
+		@matches
+	end
+
+	private
+
+	def timed_out?
+		@max_allowed_time > 0 && (Time.now.to_f - @t0) > @max_allowed_time
+	end
+
+	def limit_reached?
+		@limit > 0 && @matches.length >= @limit
+	end
+
+	def build_predecessors(adj, n)
+		pred = Array.new(n) { [] }
+		adj.each_with_index do |children, u|
+			children.each { |v| pred[v] << u }
+		end
+		pred
+	end
+
+	# Candidate set for each query vertex: same label, and enough out/in degree
+	# in the data graph to possibly satisfy the query vertex's edges.
+	def precompute_candidates
+		@q_adj.each_index.map do |u|
+			qout = @q_adj[u].length
+			qin  = @q_pred[u].length
+			ql   = @q_lab[u]
+			(0...@dn).select do |d|
+				@d_lab[d] == ql && @d_outdeg[d] >= qout && @d_indeg[d] >= qin
+			end
+		end
+	end
+
+	# VF2++ node ordering: greedily build an order that keeps each next vertex
+	# maximally connected to the already-ordered set, breaking ties by fewest
+	# candidates then highest degree. This front-loads the most constraining
+	# vertices and prunes the search tree early.
+	def matching_order
+		remaining = (0...@qn).to_a
+		order = []
+		connectivity = Array.new(@qn, 0) # edges (either direction) to ordered set
+
+		until remaining.empty?
+			best = remaining.min_by do |u|
+				[
+					-connectivity[u],          # most connections to ordered set first
+					@candidates[u].length,     # fewest candidates first
+					-(@q_adj[u].length + @q_pred[u].length) # highest total degree first
+				]
+			end
+			order << best
+			remaining.delete(best)
+			# Increase connectivity of best's neighbours still to be ordered.
+			(@q_adj[best] + @q_pred[best]).each do |nb|
+				connectivity[nb] += 1 if remaining.include?(nb)
+			end
+		end
+		order
+	end
+
+	def backtrack(depth)
+		return if timed_out? || limit_reached?
+
+		if depth == @qn
+			record_match
+			return
+		end
+
+		u = @order[depth]
+		@candidates[u].each do |d|
+			break if timed_out? || limit_reached?
+			next unless @core_d[d].nil?           # injective: d not already used
+			next unless feasible?(u, d)
+
+			@core_q[u] = d
+			@core_d[d] = u
+			backtrack(depth + 1)
+			@core_q[u] = nil
+			@core_d[d] = nil
+		end
+	end
+
+	# Feasibility: with u tentatively mapped to d, every query edge incident to u
+	# whose other endpoint is already mapped must have a corresponding data edge.
+	def feasible?(u, d)
+		# Self-loop consistency.
+		if @q_adj[u].include?(u)
+			return false unless @d_adj[d].include?(d)
+		end
+
+		# Outgoing query edges u -> v (v already mapped) require d -> f(v).
+		@q_adj[u].each do |v|
+			next if v == u
+			fv = @core_q[v]
+			next if fv.nil?
+			return false unless @d_adj[d].include?(fv)
+		end
+
+		# Incoming query edges w -> u (w already mapped) require f(w) -> d.
+		@q_pred[u].each do |w|
+			next if w == u
+			fw = @core_q[w]
+			next if fw.nil?
+			return false unless @d_adj[fw].include?(d)
+		end
+
+		true
+	end
+
+	def record_match
+		# Emit in the Graphmatcher phi shape: one [d] per query vertex, indexed by
+		# query vertex (NOT by matching order).
+		phi = Array.new(@qn) { |u| [@core_q[u]] }
+		@@logger.info("INSERT match=#{phi}")
+		@matches << phi
+	end
+
+	def validate!
+		if !(@query_graph.length >= 2 && @data_graph.length >= 2)
+			raise ArgumentError.new("Input graphs must have at least two dimensions !")
+		end
+		if !(@query_graph.map { |s| s.length }.uniq.length == 1 && @data_graph.map { |s| s.length }.uniq.length == 1)
+			raise ArgumentError.new("Input graphs adjencency and label arrays must be sized equal !")
+		end
+	end
+
+end # GraphmatcherVF2pp

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphmatcher
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.4.0
 platform: ruby
 authors:
 - Emre Unlu
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-20 00:00:00.000000000 Z
+date: 2026-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,69 +16,92 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: ruby-prof
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: rspec-prof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: An effective subgraph matching gem based on DualIso algorithm of M. Saltz
-  et al.
+        version: 0.0.7
+description: 'A subgraph matching library offering two interchangeable matchers over
+  the same [adjacency, labels] input: a DualIso implementation (after M. Saltz et
+  al.) and a VF2++ implementation (Juttner & Madarasi) that also handles cyclic queries
+  and self-loops.'
 email:
 - emre@eunlu.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
-homepage: https://github.com/forvelin/graphmatcher
+files:
+- LICENSE.txt
+- README.md
+- lib/graphmatcher.rb
+- lib/graphmatcher_vf2pp.rb
+homepage: https://gitlab.com/forvelin/graphmatcher
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  homepage_uri: https://gitlab.com/forvelin/graphmatcher
+  source_code_uri: https://gitlab.com/forvelin/graphmatcher
+  bug_tracker_uri: https://gitlab.com/forvelin/graphmatcher/-/issues
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -86,15 +109,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.4.9
+signing_key:
 specification_version: 4
-summary: Subgraph matching based on DualIso algorithm.
+summary: Labeled subgraph matching (DualIso and VF2++).
 test_files: []