{"id":19914274,"url":"https://github.com/cinrc/irdc-ccsk","last_synced_at":"2025-05-03T05:31:09.312Z","repository":{"id":37457992,"uuid":"460170939","full_name":"CinRC/IRDC-CCSK","owner":"CinRC","description":"Java implementation of distributed reversible computation verification","archived":false,"fork":false,"pushed_at":"2023-09-10T02:02:12.000Z","size":563,"stargazers_count":4,"open_issues_count":11,"forks_count":2,"subscribers_count":4,"default_branch":"master","last_synced_at":"2023-09-16T09:45:09.568Z","etag":null,"topics":["calculus-of-communicating-systems","ccsk","java","process-algebra","reversible-computation"],"latest_commit_sha":null,"homepage":"https://spots.augusta.edu/caubert/cinrc/","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"gpl-3.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/CinRC.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE.txt","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":"CITATION.cff","codeowners":".github/CODEOWNERS","security":null,"support":null}},"created_at":"2022-02-16T20:42:53.000Z","updated_at":"2023-05-02T13:54:15.000Z","dependencies_parsed_at":"2023-02-19T10:31:19.205Z","dependency_job_id":null,"html_url":"https://github.com/CinRC/IRDC-CCSK","commit_stats":null,"previous_names":[],"tags_count":12,"template":null,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/CinRC%2FIRDC-CCSK","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/CinRC%2FIRDC-CCSK/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/CinRC%2FIRDC-CCSK/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/CinRC%2FIRDC-CCSK/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/CinRC","download_url":"https://codeload.github.com/CinRC/IRDC-CCSK/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":224353863,"owners_count":17297345,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["calculus-of-communicating-systems","ccsk","java","process-algebra","reversible-computation"],"created_at":"2024-11-12T21:35:42.390Z","updated_at":"2024-11-12T21:35:43.025Z","avatar_url":"https://github.com/CinRC.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Implementation of Reversible Distributed Calculus (CCSK)\n\n## What is RCCS/CCSK?\n\nThe Reversible Calculus of Communicating Systems (RCCS) and the Calculus of Communicating Systems with Keys (CCSK) are\ntwo formal languages that describes the interaction of concurrent systems in a reversible paradigm.\nThey are both described in **Static versus dynamic reversibility in\nCCS** ([doi:10.1007/s00236-019-00346-6](https://doi.org/10.1007/s00236-019-00346-6)), and shown to be equivalent (in\nterms of labelled transition system isomorphism) in the same paper.\n\n## What is this project?\n\nThis project is the first to publicly available implementation a functional formal language (in this case, inspired by\nCCSK) that models concurrent reversible systems.\nAt its core, this is a parser and evaluation tool.\nThe program takes user input in the form of CCS processes (using the syntax [specified below](#syntax)) and parses,\ntokenizes, and traverses it at the user's will (using CSSK's labelled transition system, described and exemplified\nin [this documentation](docs/lts.md)).\n\nEverything in this program is original, including string traversal libraries and GUI.\nIt is currently developed in the [School of Computer and Cyber Sciences](https://www.augusta.edu/ccs/), primarily\nby [Peter Browning](https://petech.me/) and Dr.[Clément Aubert](https://spots.augusta.edu/caubert/).\nPlease, refer to [our list of contributors](https://github.com/CinRC/IRDC-CCSK/graphs/contributors) for an up-to-date\nlist of contributors.\n\n## Getting Started\n\n### Use-Only\n\nYou will need the Java Runtime Environment (JRE) (≥8) to execute this program.\nDownload the .jar file in our [latest release](https://github.com/CinRC/IRDC-CCSK/releases/latest), potentially using\nthis simple one-liner[^1]:\n[^1]: Inspired by \u003chttps://gist.github.com/steinwaywhw/a4cd19cda655b8249d908261a62687f8\u003e.\n\n```\ncurl -s https://api.github.com/repos/CinRC/IRDC-CCSK/releases/latest \\\n| grep browser_download_url \\\n| cut -d : -f 2,3 \\\n| tr -d \\\" \\\n| wget -qi -\n```\n\nThen execute e.g., the process $((a+b) | \\overline{b}) | \\overline{a}) \\backslash a$ using\n\n```\njava -jar IRDC-*.jar \"(((a+b) |'b)|'a)\\{a}\"\n```\n\nTo run with a GUI, use the `--gui` flag. Else, a command-line-interface will open instead, you can use it with:\n\n```\njava -jar IRDC-*.jar \u003cFLAGS\u003e \"[Process]\"\n```\n\nSome examples of processes are indicated in [`docs/example_processes.md`](docs/example_processes.md) if you need inspiration.\n\n\nThe flags are [documented below](#command-arguments-flags).\n\n### Building\n\nYou will need [Maven](https://maven.apache.org/) (≥3.0) and the Java Development Kit (≥17) to compile this program.\nSome of the possible phases are:\n\n- `mvn package` to build from source (the executable will be in the `target/` folder),\n- `mvn validate` to test for checkstyle violations (we use [google_checks.xml](google_checks.xml)),\n- `mvn test` to run our pre-written unit tests (gathered in the [`src/test/java`](src/test/java) folder) that are\n designed to represent difficult a diverse range of different scenarios.\n\nTo run e.g., all the test methods whose name starts with `simulationIsStructural` in the `tests.SimulationTest` class,\nuse\n\n```\nmvn -Dtest=\"tests.SimulationTest#simulationIsStructural*\" test\n```\n\n### Contributing\n\nWe are thrilled that you consider contributing to our project.\nPlease refer to our [contributing](CONTRIBUTING.md) guidelines.\n\n## Additional Information\n\n### Developer slang\n\nSome parts of this program are named different from the convention. Some of the notable ones are are listed below:\n\n1. Channel names are referred to as 'Labels'\n2. Parallel operators (`|`) are referred to as 'Concurrent Processes'\n3. Deterministic operators (`+`) are referred to as 'Summation Processes'\n4. CCSK keys (`a[k0].P`) are referred to as 'Label Keys'\n\n### Syntax and Precedence of Operators\n\nThis program follows a slightly modified semantic structure based off of CCSK. Some notes are included below.\n\n- By default, all labels are given implicit null processes (`a` is implied to represent `a.0`). This is toggleable using [the `--require-explicit-null` flag](#command-arguments-flags).\n- Channel labels are limited to lowercase english letters `[a-z]`.\n- Complement channels are represented by an apostrophe before the label, `'a`, `'b`, etc.\n- Process names are limited to uppercase english letters `[A-Z]`.\n- We assume that all channels sharing the same label are complements. This means that `'a` is the complement to `a`, `'b` to `b`, and so forth.\n\n- Restrictions are applied under the following format: `a.P\\{a,b,c}`.\n- We assume that the operators have decreasing binding power, in the following order: `\\a`, `a.`, `|`, `+`.\n - This means that `a|b\\{a}` will be interpreted as `(a)|(b\\{a})`.\n - More specifically, `a.a + b | c \\{a}` is to be read as `(a.a) + (b | (c\\a))` (infix notation)\n or `+ . a a | b \\a c` (postfix notation).\n - Of course, parenthesis take precedence over all operators.\n - Redundant parenthesis are permitted, e.g., `(((a)|(b)))` will be accepted but interpreted as `(a|b)`.\n\n### Command arguments (flags)\n\nThis program can be configured by using command-line arguments, or flags. The flags are as follows:\n\n| **Flag** \t | **Description** \t |\n|-------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| --debug \t | Enables debug mode. Will print info to stdout \t |\n| --help \t | Prints help message documenting flags \t |\n| --dL \t | Labels are visibly differentiated by integers \t |\n| --hide-keys \t | CCSK keys are hidden \t |\n| --sA \t | Alternative display mode for summation processes. Reversible summations are not annotated \t |\n| --process-names-equivalent \t | Processes names will be treated as being equivalent (P == Q) \t |\n| --sC \t | Alternative display mode for summation processes. Reversible summations are hidden after execution \t |\n| --require-explicit-null \t | Labels explicitly require a trailing process. Labels will no longer have an implicit null process attached \t |\n| --hP \t | Parenthesis surrounding complex processes will be omitted \t |\n| --dN \t | Null processes will be displayed explicitly \t |\n| --iU \t | Parser will ignore unrecognized characters in the process formula \t |\n| --kL \t | (Deprecated) Keys will be visibly similar to the label they represent \t |\n| --gui \t | Program will start with a GUI instead of CLI \t |\n| --forward-only \t | Program will run in a non-reversible paradigm \t |\n| --interactive \t | Run the program in interactive mode. In interactive mode, the given process will be displayed and the user will be prompted to give a label or key to act on. \t |\n| --enumerate \t | Run the program in enumeration mode (Default). In enumeration mode, the given process will be enumerated to completion, and the transition tree will be printed to stdout \t |\n| --validate \t | Run the program in validation mode. In validation mode, a user inputted file will be scanned for processes to parse. Processes in the file must be separated by newlines, with one process per line. Each process will be validated for syntax and formatting. \t |\n| --equivalence \t | Run the program in equivalence mode. In equivalence mode, your input will be in the form of a *list* of processes separated by commas (,). All equivalence relationships between the given processes will be printed. \t |\n| --regenerate \t | Run the program in regeneration mode. In regeneration mode, you may input a process that has already begun execution. It will then regenerate to its ancestor process and enumerate. \t |\n\n## Contributing\n\nIf you'd like to contribute to this project, please refer to the CONTRIBUTING.md file\n\n### Versioning\n\nWhen contributing, the project version must be appropriately incremented inside the `pom.xml` file. We use a semantic\nMaj.Min.Patch.Rev system, where:\n\n* Maj = Major feature or system overhaul\n* Min = Feature addition\n* Patch = Bug fix\n* Rev = Revision (code cleanup, minor edits)\n\nWhen making changes, increment the version number according to changes made.\n## Alternatives\n\nThis project, in particular, is a working implementation of the Calculus of Communicating Systems with Keys (CCSk).\nSome of the other implementations of [process algebras](https://en.wikipedia.org/wiki/Process_calculus) that are\npublicly available are:\n\n- This [student project](https://github.com/ComputerScience-Projects/Calculus-of-Communicating-Systems),\n- The [Concurrency Workbench, Aalborg Edition](http://caal.cs.aau.dk/),\n- This [implementation of HOcore](https://people.rennes.inria.fr/Alan.Schmitt/research/hocore/), an intermediate\n languages between CSS and the π-calculus.\n- [muccs](https://github.com/andreasimonetto/muccs), an implementation of CCS in Prolog with some nice examples.\n- [CCS_Prolog](https://github.com/CoffeeStraw/CCS_Prolog), an interpreter for CCS language written in SWI-Prolog.\n\nThe implementation of CCSk\ndescribed [in this master thesis](https://leicester.figshare.com/articles/thesis/SimCCSK_simulation_of_the_reversible_process_calculi_CCSK/10091681)\nis to our knowledge not publicly available.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcinrc%2Firdc-ccsk","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fcinrc%2Firdc-ccsk","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcinrc%2Firdc-ccsk/lists"}