qdfca 1

data/README.rdoc

@@ -0,0 +1,58 @@
+= Quick-Deploy Formal Concept Analysis
+
+Version::    1.0
+Author::     David Flater <dflater@nist.gov>
+Copyright::  Public domain
+License::    Unlicense
+
+qdfca (Quick-Deploy Formal Concept Analysis) is a command-line filter that
+implements Formal Concept Analysis (FCA).  It is small, scriptable, and easy
+to install, with no external requirements other than the standard Ruby
+library.  It is not designed to be efficient or scalable, but to ensure that
+simple FCA tasks can be accomplished simply.
+
+Usage: qdfca < context.csv > lattice.dot
+
+The input is a formal context in comma-separated values (CSV) table format.
+For example:
+
+          , A1, A2
+  Object 1,  x,
+  Object 2,  x, x
+
+Attribute names are given by the first row.  Object names are given by the
+first column.  An object is considered to have an attribute iff any
+non-whitespace value appears in the corresponding table cell.  The assumed
+character encoding is UTF-8.
+
+Most any spreadsheet application can be used to create and save a table in
+this format.  However, any use of escape characters or quoting to attempt to
+allow values to contain commas is unsupported.
+
+Output is produced in .dot file format to stdout.
+Graphviz[http://www.graphviz.org/] and
+xdot.py[https://github.com/jrfonseca/xdot.py] or other applications
+supporting the DOT language can be used to view the output or render it into
+various image formats.
+
+The lattice is produced with reduced labelling.  Concept labels list
+attributes on the top line and objects on the bottom line if both are
+applicable to a given node.  Object names are parenthesized to avoid
+ambiguity when only one line appears.
+
+Four examples are installed along with the gem.  On Linux they would show up
+in /usr/lib64/ruby/gems/*/gems/qdfca-1/examples or a similar location.
+
+== Legalese
+
+Specific software products are identified in this documentation to support
+reproducibility of results.  Such identification does not imply
+recommendation or endorsement by the National Institute of Standards and
+Technology, nor does it imply that the products identified are necessarily
+the best available for the purpose.
+
+This software was developed at the National Institute of Standards and
+Technology by an employee of the U.S. federal government in the course of his
+official duties.  Pursuant to Title 17 Section 105 of the United States Code,
+this software is not subject to copyright protection and is in the public
+domain.

data/bin/qdfca

@@ -0,0 +1,206 @@
+#!/usr/bin/ruby
+# 2015-02-20
+#
+# qdfca version 1.0
+#
+# A simple FCA tool for small problems.  The input is a formal context in CSV
+# table format.  The output is a dot format digraph rendering of the concept
+# lattice with reduced labelling.
+
+
+# Internal data organization:
+#
+# Objects and attributes are identified by integers >= 0.
+#
+# Two different representations of objects and concepts are used.  One is a
+# set of attributes (integers >= 0).  The other is a boolean array.  The
+# latter array's element i is true iff the former set includes i.
+#
+# Collections of objects and concepts are stored as arrays of sets.
+
+
+unless ARGV.length==0
+  abort("Usage: qdfca < context.csv > lattice.dot")
+end
+
+require 'set'
+
+
+# ---------------- Read the CSV format input ----------------
+
+# First line of input:  get attribute names and fix number of attributes.
+line = gets
+abort("qdfca: failed to read first line of input") unless line
+columns = line.chomp.split(',',-1)
+unless columns.length > 1
+  abort("qdfca: no attribute names found on first line of input")
+end
+attribute_names = columns[1..-1].map(&:strip)
+$na1 = attribute_names.length
+$na0 = $na1 - 1
+
+# Remaining lines of input:  get objects.
+$objects = Array.new
+object_names = Array.new
+lineno = 2
+line = gets
+while line
+  columns = line.chomp.split(',',-1)
+  unless columns.length == $na1 + 1
+    abort("qdfca: wrong number of attributes found on line " + lineno.to_s)
+  end
+  object_names.push(columns[0].strip)
+  $objects.push(Set.new((0..$na0).find_all{|i| columns[i+1].strip.length > 0}))
+  lineno += 1
+  line = gets
+end
+$no1 = $objects.length
+abort("qdfca: zero objects read") if $no1==0
+$no0 = $no1-1
+
+
+# ---------------- Define FCbO functions ----------------
+
+# The FCbO functions computeClosure and generateFrom are translated from the
+# sequential algorithm given in Petr Krajca, Jan Outrata, and Vilem Vychodil,
+# "Parallel Recursive Algorithm for FCA," in Radim Belohlavek and Sergei
+# O. Kuznetsov (eds.), Proceedings of the Sixth International Conference on
+# Concept Lattices and their Applications (CLA 2008), pp. 71-82, October
+# 2008.
+
+# The following variables are comparable to those appearing in the cited FCbO
+# functions:
+# a, c   ... boolean vector giving an extent.
+# b, d   ... boolean vector giving an intent.
+# y      ... an attribute number.
+
+# The following variables appearing in the cited FCbO functions were replaced
+# by equivalents:
+# table  ... 2D array of booleans:  substituted references to objects.
+# rows   ... table slices:  substituted an equivalent reference to objects.
+# m      ... number of objects/rows minus 1:  substituted no0.
+# n      ... number of attributes/columns minus 1:  substituted na0.
+
+# Finally, the variable concepts was added to allow the results of
+# generateFrom to be returned.
+
+def computeClosure(a, b, y)
+  c = Array.new($no1, false)
+  d = Array.new($na1, true)
+  for i in 0..$no0
+    if a[i] and $objects[i].include?(y)
+      c[i] = true
+      for j in 0..$na0
+        unless $objects[i].include?(j)
+          d[j] = false
+        end
+      end
+    end
+  end
+  return c,d
+end
+
+def generateFrom(a, b, y)
+  concepts = Array.new(1){Set.new((0..$na0).find_all{|i| b[i]})}
+  if b.any?{|x| !x} and y<=$na0
+    for j in y..$na0
+      unless b[j]
+        c,d = computeClosure(a,b,j)
+        skip = false
+        for k in 0..(j-1)
+          if d[k] != b[k]
+            skip = true
+            break
+          end
+        end
+        unless skip
+          concepts += generateFrom(c,d,j+1)
+        end
+      end
+    end
+  end
+  return concepts
+end
+
+
+# ---------------- Find concepts ----------------
+
+# Find all concepts using FCbO, starting with the infimum.
+# Infimum extent = all objects.
+# Infimum intent = what attributes all objects have.
+infimum = $objects.reduce(&:&)
+concepts = generateFrom(Array.new($no1,true),
+			Array.new($na1){|i| infimum.include?(i)},
+			0)
+nc1 = concepts.length
+abort("Zero concepts") if nc1==0
+nc0 = nc1-1
+
+
+# ---------------- Apply reduced labelling ----------------
+
+concept_o = Array.new(nc1){|i| Set.new}
+for oi in 0..$no0
+  oci = -1
+  for ci in 0..nc0
+    if concepts[ci].subset?($objects[oi])
+      if oci<0 or concepts[oci].subset?(concepts[ci])
+        oci = ci
+      end
+    end
+  end
+  abort("qdfca: failure finding object concept") if oci<0
+  concept_o[oci].add(oi)
+end
+concept_a = Array.new(nc1){|i| Set.new}
+for ai in 0..$na0
+  aci = -1
+  for ci in 0..nc0
+    if concepts[ci].include?(ai)
+      if aci<0 or concepts[ci].subset?(concepts[aci])
+        aci = ci
+      end
+    end
+  end
+  abort("qdfca: failure finding attribute concept") if aci<0
+  concept_a[aci].add(ai)
+end
+concept_names = Array.new(nc1){|ci|
+  onames = concept_o[ci].map{|i| object_names[i]}.sort.join(",")
+  anames = concept_a[ci].map{|i| attribute_names[i]}.sort.join(",")
+  anames + ((onames.length>0 and anames.length>0) ? "\\n" : "") +
+    (onames.length>0 ? "(" + onames + ")" : "")
+}
+
+
+# ---------------- Generate dot format output ----------------
+
+# Although we don't use arrows, we still need a directed graph to keep the
+# "lattice" properly sorted.
+print "digraph {\n"
+print "  rankdir=TB\n"
+print "  node [style=filled, fillcolor=skyblue]\n"
+
+# Define node IDs and labels.  With reduced labelling there will be many
+# nodes with neither objects nor attributes to indicate, and consequently
+# empty labels, which cannot be distinguished without a separate ID.
+for ci in 0..nc0
+  print "  ", ci.to_s, " [label=\"", concept_names[ci], "\"]\n"
+end
+
+# Nodes (concepts) were found by FCbO, but we now use brute force and
+# ignorance to find the lines.  The lines correspond to the transitive
+# reduction of the subset relationships.  An alternative approach is to
+# dumbly output every single subset relationship and then run the (maybe very
+# large) result through graphviz's transitive reduction filter, tred.
+for src in 0..nc0
+  for dst in 0..nc0
+    if concepts[src].proper_subset?(concepts[dst]) and
+      not concepts.any?{|spoiler|
+	concepts[src].proper_subset?(spoiler) and
+        spoiler.proper_subset?(concepts[dst])}
+      print "  ", src.to_s, " -> ", dst.to_s, " [dir=none]\n"
+    end
+  end
+end
+print "}\n"

data/examples/Makefile

@@ -0,0 +1,5 @@
+examples:
+	qdfca < e1/e1.csv > e1/e1.dot
+	qdfca < e2/e2.csv > e2/e2.dot
+	qdfca < e3/e3.csv > e3/e3.dot
+	qdfca < e4/e4.csv > e4/e4.dot

data/examples/e1/e1.csv

@@ -0,0 +1,5 @@
+,∼◇p,∼p,◇∼p,◇p,p,◽p
+Contradiction,x,x,x,,,
+Counterfactual,,x,x,x,,
+Fact,,,x,x,x,
+Tautology,,,,x,x,x

data/examples/e1/e1.dot

@@ -0,0 +1,31 @@
+digraph {
+  rankdir=TB
+  node [style=filled, fillcolor=skyblue]
+  0 [label=""]
+  1 [label="∼◇p\n(Contradiction)"]
+  2 [label=""]
+  3 [label="∼p"]
+  4 [label="(Counterfactual)"]
+  5 [label="◇∼p"]
+  6 [label=""]
+  7 [label="(Fact)"]
+  8 [label="◇p"]
+  9 [label="p"]
+  10 [label="◽p\n(Tautology)"]
+  0 -> 5 [dir=none]
+  0 -> 8 [dir=none]
+  1 -> 2 [dir=none]
+  3 -> 1 [dir=none]
+  3 -> 4 [dir=none]
+  4 -> 2 [dir=none]
+  5 -> 3 [dir=none]
+  5 -> 6 [dir=none]
+  6 -> 4 [dir=none]
+  6 -> 7 [dir=none]
+  7 -> 2 [dir=none]
+  8 -> 6 [dir=none]
+  8 -> 9 [dir=none]
+  9 -> 7 [dir=none]
+  9 -> 10 [dir=none]
+  10 -> 2 [dir=none]
+}

data/examples/e2/e2.csv

@@ -0,0 +1,11 @@
+,Know ∼◇p,Know ∼p,Know ◇∼p,Know ◇p,Know p,Know ◽p
+Unknown,,,,,,
+Negative possibility,,,x,,,
+Possibility,,,,x,,
+Falsehood,,x,x,,,
+Uncertainty,,,x,x,,
+Truth,,,,x,x,
+Contradiction,x,x,x,,,
+Counterfactual,,x,x,x,,
+Fact,,,x,x,x,
+Tautology,,,,x,x,x

data/examples/e2/e2.dot

@@ -0,0 +1,31 @@
+digraph {
+  rankdir=TB
+  node [style=filled, fillcolor=skyblue]
+  0 [label="(Unknown)"]
+  1 [label="Know ∼◇p\n(Contradiction)"]
+  2 [label=""]
+  3 [label="Know ∼p\n(Falsehood)"]
+  4 [label="(Counterfactual)"]
+  5 [label="Know ◇∼p\n(Negative possibility)"]
+  6 [label="(Uncertainty)"]
+  7 [label="(Fact)"]
+  8 [label="Know ◇p\n(Possibility)"]
+  9 [label="Know p\n(Truth)"]
+  10 [label="Know ◽p\n(Tautology)"]
+  0 -> 5 [dir=none]
+  0 -> 8 [dir=none]
+  1 -> 2 [dir=none]
+  3 -> 1 [dir=none]
+  3 -> 4 [dir=none]
+  4 -> 2 [dir=none]
+  5 -> 3 [dir=none]
+  5 -> 6 [dir=none]
+  6 -> 4 [dir=none]
+  6 -> 7 [dir=none]
+  7 -> 2 [dir=none]
+  8 -> 6 [dir=none]
+  8 -> 9 [dir=none]
+  9 -> 7 [dir=none]
+  9 -> 10 [dir=none]
+  10 -> 2 [dir=none]
+}

data/examples/e3/e3.csv

@@ -0,0 +1,3 @@
+,Attribute 1,Attribute 2
+Thing 1,mumble,foo
+Thing 2,not whitespace,“”

data/examples/e3/e3.dot

@@ -0,0 +1,5 @@
+digraph {
+  rankdir=TB
+  node [style=filled, fillcolor=skyblue]
+  0 [label="Attribute 1,Attribute 2\n(Thing 1,Thing 2)"]
+}

data/examples/e4/README.txt

@@ -0,0 +1,5 @@
+2015-02-18 17:11
+
+This example originally from Rudolf Wille as reproduced at
+www.upriss.org.uk/fca/examples.html.  A different version appears in the book
+Formal Concept Analysis:  Mathematical Foundations.

data/examples/e4/e4.csv

@@ -0,0 +1,9 @@
+,needs water to live,lives in water,lives on land,needs chlorophyll,dicotyledon,monocotyledon,can move,has limbs,breast feeds
+fish leech,x,x,,,,,x,,
+bream,x,x,,,,,x,x,
+frog,x,x,x,,,,x,x,
+dog,x,,x,,,,x,x,x
+water weeds,x,x,,x,,x,,,
+reed,x,x,x,x,,x,,,
+bean,x,,x,x,x,,,,
+corn,x,,x,x,,x,,,

data/examples/e4/e4.dot

@@ -0,0 +1,55 @@
+digraph {
+  rankdir=TB
+  node [style=filled, fillcolor=skyblue]
+  0 [label="needs water to live"]
+  1 [label="lives in water"]
+  2 [label=""]
+  3 [label="(reed)"]
+  4 [label=""]
+  5 [label="(frog)"]
+  6 [label="(water weeds)"]
+  7 [label="(fish leech)"]
+  8 [label="(bream)"]
+  9 [label="lives on land"]
+  10 [label=""]
+  11 [label="dicotyledon\n(bean)"]
+  12 [label="(corn)"]
+  13 [label=""]
+  14 [label="breast feeds\n(dog)"]
+  15 [label="needs chlorophyll"]
+  16 [label="monocotyledon"]
+  17 [label="can move"]
+  18 [label="has limbs"]
+  0 -> 1 [dir=none]
+  0 -> 9 [dir=none]
+  0 -> 15 [dir=none]
+  0 -> 17 [dir=none]
+  1 -> 2 [dir=none]
+  1 -> 6 [dir=none]
+  1 -> 7 [dir=none]
+  2 -> 3 [dir=none]
+  2 -> 5 [dir=none]
+  3 -> 4 [dir=none]
+  5 -> 4 [dir=none]
+  6 -> 3 [dir=none]
+  7 -> 8 [dir=none]
+  8 -> 5 [dir=none]
+  9 -> 2 [dir=none]
+  9 -> 10 [dir=none]
+  9 -> 13 [dir=none]
+  10 -> 11 [dir=none]
+  10 -> 12 [dir=none]
+  11 -> 4 [dir=none]
+  12 -> 3 [dir=none]
+  13 -> 5 [dir=none]
+  13 -> 14 [dir=none]
+  14 -> 4 [dir=none]
+  15 -> 10 [dir=none]
+  15 -> 16 [dir=none]
+  16 -> 6 [dir=none]
+  16 -> 12 [dir=none]
+  17 -> 7 [dir=none]
+  17 -> 18 [dir=none]
+  18 -> 8 [dir=none]
+  18 -> 13 [dir=none]
+}

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: qdfca
+version: !ruby/object:Gem::Version
+  version: '1'
+  prerelease: 
+platform: ruby
+authors:
+- David Flater
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-20 00:00:00.000000000 Z
+dependencies: []
+description: qdfca (Quick-Deploy Formal Concept Analysis) is a command-line filter
+  that implements Formal Concept Analysis (FCA).  It is small, scriptable, and easy
+  to install, with no external requirements other than the standard Ruby library.  The
+  input is a formal context in CSV table format.  The output is a dot format digraph
+  rendering of the concept lattice with reduced labelling.
+email: dflater@nist.gov
+executables:
+- qdfca
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- bin/qdfca
+- README.rdoc
+- examples/Makefile
+- examples/e1/e1.dot
+- examples/e1/e1.csv
+- examples/e1/e1.ods
+- examples/e2/e2.csv
+- examples/e2/e2.ods
+- examples/e2/e2.dot
+- examples/e3/e3.ods
+- examples/e3/e3.dot
+- examples/e3/e3.csv
+- examples/e4/README.txt
+- examples/e4/e4.csv
+- examples/e4/e4.ods
+- examples/e4/e4.dot
+homepage: http://www.nist.gov/itl/ssd/cs/software-performance.cfm
+licenses:
+- Unlicense
+post_install_message: 
+rdoc_options:
+- --main
+- README.rdoc
+- --title
+- Quick-Deploy Formal Concept Analysis (FCA)
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Quick-Deploy Formal Concept Analysis (FCA)
+test_files: []