The ODIN (Open Dynamic Interaction Network system) was developed as
open-source software under National Science Foundation Social and
Behavioral Sciences grant #1338485. This system consists of an
Android cellphone application (“ODIN app”) and a central server (“ODIN
server”). Together, the ODIN System allows for secure anonymized
collection of disaggregated interaction sequences, based on GPS
location, spatial proximity, phone contact, SMS messaging, and other
spatio-temporal signatures. These interaction data streams are
essential to building better models towards understanding the
stochastic relationship between interactions and behavior--i.e. models
of influence. As of January 2015, the SNAPT platform is implemented as
roughly 50,000 lines of Java (on Android) and Ruby/Rails.
More information can be found here.
Tablet-based data-collection software, and related analytic
methodologies, aimed at the discovery of whole network topologies,
while providing participant confidentiality, and despite participants'
possibly incomplete knowledge of other network members'
identities. This method, called Social Network Analysis via Perceptual
Tomography (SNAPT) builds on matching techniques of "propitious
aggregation" in network data collection, and "multiple perspective"
techniques from semantic link analysis. The SNAPT platform allows for
the collection of network link data by using "selfie" pictures of
respondents who enroll in the project that are shown on a large
touch-screen tablet to other SNAPT participants who use "drag and
drop" techniques to sort other respondents into "associates/friends",
"recognized" and "unrecognized" bins. To do this, respondents need not
know the full identity of those whose images they sort. SNAPT_appThose
in the "associates/friends" bin are then reshown after the initial
sorting, and the respondent is asked to assign relational qualities to
them (e.g. "I would lend him/her money", "He/she would lend me money",
etc.) Network member sorts by salient roles arranged by the
participant are used to generate network topology data directly from
the screen. As of January 2015, the SNAPT platform is implemented as
roughly 50,000 lines of Java and Ruby/Rails.
More information can
be found here.
MABUSE is a general-purpose stochastic, agent-based, discrete event
simulator for actors in a network environment, and was originally
developed to model early HIV infection dynamics among Injecting Drug
User (IDU) co-use networks in New York City funded by a grant from the
National Institute of Health (NIH/NIDA 1RC1DA028476-01/02). The
MABUSE simulator runs on specialized high-performance hardware and is
capable of running simulations of dynamic networks having 1,000,000+
nodes, and handling approximately 800 million discrete events per
second. As of January 2015, the MABUSE platform is implemented as
roughly 100,000 lines of C# over Mono4.
In 1977, G. S. Makanin described an algorithm to decide whether a
system of equations has a solution in a free group. Extending
Makanin's work, in 1983 Alexander Razborov presented a procedure
which, given a system of equations over a free group, outputs a finite
description of the entire solution set.
Makanin noted that finding a solution to a system of equations in the
free group reduces to finding a solution to one of a set of
corresponding systems over a free semigroup. We followed his step by
enumerating all of the finitely many cancellation diagrams for a group
equation. Each of these cancellation diagrams then yields a
combinatorial object that Makanin referred to as a generalized
equation (GE). A set of rewriting rules specifies legal elementary
transformations that may be applied to a GE. Here we follow the
refined in the presentations of Miasnikov and Kharlamovich, as it is
important for us to use transformations which were easy to track in
terms of their actions on coordinate groups, so that we may be able to
compute periodic structures.
Regrettably, because of its complexity, no implementation of the
Makanin-Razborov algorithm is available. This project provided a first
implementation. The software described here was funded by the
National Security Agency, and able analyze solutions of systems of
equations over a free group. The MAKANIN-RAZBOROV SOLVER is
implemented as roughly 30,000 lines of Java.
- The Interactive Distributed Object Library (IDOL) is an
object framework, providing scalable distributed services required for
large geospatial data sets within the Mother of All Databases (MoaDB). Specifically,
IDOL provides an open system for managing dynamic annotations which reflect
the actual state of physical objects (e.g. a network hardware element or
a military vehicle), as well as simulated entities. Using this system,
independent external parties can add information to a dynamic distributed
database. Users are able to interact with annotations, modify them,
and request services of them. When a user exits the MoaDB, all annotations
continue to persist, and evolve over time by updating themselves autonomously,
and independently of whether they are being observed. IDOL supports
mechanisms which facilitate "layering and fusion of annotation" by permitting
annotations to influence each other. To provide this feature scalably,
each annotation is assigned a spatial range of influence, and is made aware
of other annotations of which it can "perceive". This contact between
annotations may result in changes ranging from physical (e.g. the alteration
of physical geometry) to logical (e.g. the alteration of behavior).
IDOL/MoADB is implemented as roughly 100,000 lines of C++ and Java; it is not releasable to the public.
- provides a scalable distributed network management system
for all-optical networks such as MONET. Optiprism provides a
scalable, secure, and fault-tolerant network management solution for
optical networks. Optiprism effectively distributes the
computational burden of information aggregation and request processing
over a large number of machines; these tasks would choke typical
centralized network management systems. Furthermore, Optiprism's
distributed architecture permits computations to take place closer to
the information sources, thereby reducing control traffic and system
latency. Optiprism enhances system availability and fault
tolerance by localizing the side-effects of node failures, and
permitting upgrades/patches to be installed into the "live" network
management system on a node-by-node basis.
OPTIPRISM is implemented as roughly 50,000 of Java; it is not releasable to the public.
-  The Toolkit for Routing in Optical Networks (TRON) is a
freely available library developed to facilitate research experiments
on OSPF-based routing protocols for optical networks.
Currently, TRON supports the LightWave-OSPF routing protocol,
which is our adaptation of the optical extensions to OSPF proposed in
the internet drafts of Kompella et al. and Wang et al. TRON is
implemented in C++ using the Component Architecture for Simulating
Network Objects (CASiNO). TRON software can be used in either
simulation or emulation mode. TRON has been used both to
simulate LightWave-OSPF routing in large optical networks, as
well as to emulate routing on a live optical switch.
OPTIPRISM is implemented as roughly 50,000 of C++.
-  PRouST is a freely distributed, extensible environment for
research and development in ATM switch signalling and routing. PRouST
includes a complete source-level release of the ATM switch PNNI
protocol stack, conformant to version 1.0 of the ATM Forum
specification. PRouST is implemented as roughly 150,000 of C++.
-  The Signalling Entity for ATM Networks (SEAN) is a free,
extensible environment for research and development in ATM host
signalling. It includes an object-oriented C++ API for writing
native ATM applications and a host ATM protocol stack that is
conformant with the ITU Q.2931 specification for point to point calls,
ITU Q.2971 for point to multipoint calls and version 4.0 of the ATM
Forum User Network Interface Extensions for leaf initiated join calls.
SEAN is implemented as roughly 100,000 of C++.
-  The Component Architecture for Simulating Network Objects
(CASiNO) is a C++ user-space framework library for rapid design and
implementation of network communication protocols. CASiNO provides
programmers with powerful patterns and access to a modular
coarse-grained dataflow architecture, as well as I/O notification,
timer, and interrupt services. The CASiNO library has been used
with great success to implement the User Network Interface (UNI) for
ATM host signaling, as well as the Private Network Network Interface
(PNNI) for ATM switch signaling and routing.
CASiNO is implemented as roughly 5,000 of C++.