JSON Export and Import

The hardware and bandwidth for this mirror is donated by dogado GmbH, the Webhosting and Full Service-Cloud Provider. Check out our Wordpress Tutorial.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]dogado.de.

In version 1.4.1, fcaR introduces comprehensive support for JSON (JavaScript Object Notation) export and import. This facilitates interoperability with other systems, web applications, and non-R based tools.

This vignette demonstrates how to export and import the main data structures in fcaR: FormalContext, ConceptLattice, ImplicationSet, and RuleSet.

Setup

First, ensure you have the jsonlite package installed, as it is required for these features.

library(fcaR)
# install.packages("jsonlite")

FormalContext

We can export a FormalContext to JSON, which preserves the objects, attributes, and the incidence matrix. Importantly, the incidence matrix is exported in a sparse format (indices and values) to handle large datasets efficiently.

Creating and Exporting

Let’s load a sample dataset and create a FormalContext.

data("planets")
fc <- FormalContext$new(planets)
print(fc)
#> FormalContext with 9 objects and 7 attributes.
#>          small  medium  large  near  far  moon  no_moon  
#>  Mercury   X                     X                 X     
#>    Venus   X                     X                 X     
#>    Earth   X                     X          X            
#>     Mars   X                     X          X            
#>  Jupiter                  X           X     X            
#>   Saturn                  X           X     X            
#>   Uranus           X                  X     X            
#>  Neptune           X                  X     X            
#>    Pluto   X                          X     X

To export the context to a JSON string:

json_str <- fc$to_json()
cat(substr(json_str, 1, 200), "...") # Print first 200 chars
#> {"type":"FormalContext","objects":["Mercury","Venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune","Pluto"],"attributes":["small","medium","large","near","far","moon","no_moon"],"I":{"indices": ...

You can also save it directly to a file:

fc$to_json(file = "context.json")

Importing

To verify the export, we can import the JSON string back into a new FormalContext object using context_from_json():

fc2 <- context_from_json(json_str)
print(fc2)
#> FormalContext with 9 objects and 7 attributes.
#>          small  medium  large  near  far  moon  no_moon  
#>  Mercury   X                     X                 X     
#>    Venus   X                     X                 X     
#>    Earth   X                     X          X            
#>     Mars   X                     X          X            
#>  Jupiter                  X           X     X            
#>   Saturn                  X           X     X            
#>   Uranus           X                  X     X            
#>  Neptune           X                  X     X            
#>    Pluto   X                          X     X

We can check that the original and reconstructed contexts are identical:

all(fc$objects == fc2$objects)
#> [1] TRUE
all(fc$attributes == fc2$attributes)
#> [1] TRUE
all(as.matrix(fc$I) == as.matrix(fc2$I))
#> [1] TRUE

Recursive Export

The to_json() method for FormalContext is recursive. If you have computed concepts or implications, they will be nested within the exported JSON.

fc$find_concepts()
fc$find_implications()

# Export with nested concepts and implications
json_full <- fc$to_json()
#> 'as(<ngCMatrix>, "dgCMatrix")' is deprecated.
#> Use 'as(., "dMatrix")' instead.
#> See help("Deprecated") and help("Matrix-deprecated").

# Import back
fc_full <- context_from_json(json_full)

# Check if concepts are present
fc_full$concepts$size()
#> [1] 12

ConceptLattice

You can also export a ConceptLattice independently.

cl <- fc$concepts
json_lattice <- cl$to_json()

And import it using lattice_from_json():

cl2 <- lattice_from_json(json_lattice)
print(cl2)
#> A set of 12 concepts:
#> 1: ({Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto}, {})
#> 2: ({Earth, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto}, {moon})
#> 3: ({Jupiter, Saturn, Uranus, Neptune, Pluto}, {far, moon})
#> 4: ({Jupiter, Saturn}, {large, far, moon})
#> 5: ({Uranus, Neptune}, {medium, far, moon})
#> 6: ({Mercury, Venus, Earth, Mars, Pluto}, {small})
#> 7: ({Earth, Mars, Pluto}, {small, moon})
#> 8: ({Pluto}, {small, far, moon})
#> 9: ({Mercury, Venus, Earth, Mars}, {small, near})
#> 10: ({Mercury, Venus}, {small, near, no_moon})
#> 11: ({Earth, Mars}, {small, near, moon})
#> 12: ({}, {small, medium, large, near, far, moon, no_moon})

The exported JSON includes the lattice hierarchy (superconcept/subconcept relations), allowing for full reconstruction of the lattice structure.

ImplicationSet

Similarly, sets of implications can be exported and imported.

imps <- fc$implications
json_imps <- imps$to_json()

Import using implications_from_json():

imps2 <- implications_from_json(json_imps)
print(imps2)
#> Implication set with 10 implications.
#> Rule 1: {no_moon} -> {small, near}
#> Rule 2: {far} -> {moon}
#> Rule 3: {near} -> {small}
#> Rule 4: {large} -> {far, moon}
#> Rule 5: {medium} -> {far, moon}
#> Rule 6: {medium, large, far, moon} -> {small, near, no_moon}
#> Rule 7: {small, near, moon, no_moon} -> {medium, large, far}
#> Rule 8: {small, near, far, moon} -> {medium, large, no_moon}
#> Rule 9: {small, large, far, moon} -> {medium, near, no_moon}
#> Rule 10: {small, medium, far, moon} -> {large, near, no_moon}

RuleSet

Association rules (including causal rules) are also supported.

# Assuming we have a RuleSet, e.g. from arules or created manually
# Here we'll just demonstrate the syntax
rs <- RuleSet$new(attributes = fc$attributes)
# ... populate rules ...
# json_rules <- rs$to_json()
# rs2 <- rules_from_json(json_rules)

Summary

The new JSON functionality ensures that you can easily move your FCA models out of R for visualization, storage, or integration with web services.

Class	Export Method	Import Function
`FormalContext`	`$to_json()`	`context_from_json()`
`ConceptLattice`	`$to_json()`	`lattice_from_json()`
`ImplicationSet`	`$to_json()`	`implications_from_json()`
`RuleSet`	`$to_json()`	`rules_from_json()`

These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.
Health stats visible at Monitor.