Update README.md

Author: bachish

README.md

@@ -1,139 +1,45 @@
-
 # UCFS
 
 > Note: project under heavy development!
 
-## About
-**UCFS** is an **U**niversal **C**ontext-**F**ree **S**olver: a tool to solve problems related to context-free and regular language intersection. Examples of such problems:
+## What is UCFS?
+
+UCFS is an **U**niversal **C**ontext-**F**ree **S**olver: a GLL‑based tool for problems at the intersection of context‑free languages 
+over edge‑labeled directed graphs. Examples of such problems:
+
 - Parsing
 - Context-free path querying (CFPQ)
 - Context-free language reachability (CFL-R)
+- static code analysis 
 
-<!-- Online -- offline modes.    
-    
-All-pairs, multiple-source. All-paths, reachability.     
-    
-Incrementality. Both the graph and RSM    
-    
-Error recovery.    
-    
- GLL-based    
- RSM    
--->    
-
-## Project structure 
-```
-├── solver                  -- base ucfs logic
-├── benchmarks              -- comparison with antlr4
-├── generator               -- parser and ast node classes generator
-├── examples                -- examples of grammars
-└── test-shared             -- test cases 
-    └── src
-        └── test
-            └── resources   -- grammars' description and inputs
-```
-
-## Core Algorithm
-UCFS is based on Generalized LL (GLL) parsing algorithm modified to handle language specification in form of Recursive State Machines (RSM-s) and input in form of arbitratry directed edge-labelled graph. Basic ideas described [here](https://arxiv.org/pdf/2312.11925.pdf). 
-
-## Grammar Combinator
-
-Kotlin DSL for describing context-free grammars.
-
-
-
-### Declaration
-
-Example for A* grammar
-
-*EBNF*
-``` 
-A = "a"    
-S = A*     
-``` 
-*DSL*  
-```kotlin 
-class AStar : Grammar() {    
-        var A = Term("a")    
-        val S by Nt().asStart(many(A))    
-    }    
-``` 
-### Non-terminals
-
-`val S by Nt()`
-
-Non-terminals must be fields of the grammar class. Make sure to declare using delegation `by Nt()`!
-
-Start non-terminal set with method `setStart(nt)`. Or in initialization with Nt method `asStart`.
+**Highlights**
 
- Can be set only once for grammar.
+* Kotlin implementation with a concise Grammar DSL (EBNF‑friendly).
+* Input: arbitrary edge‑labeled directed graphs.
+* Output: SPPF -- finite structure for all‑paths queries.
 
-### Terminals
 
-`val A = Term("a")`
 
-`val B = Term(42)`
-
-Terminal is a generic class. Can store terminals of any type. Terminals are compared based on their content.
-
-They can be declared as fields of a grammar class or directly in productions.
-
-### Operations
-Example for Dyck language
-
-*EBNF*
-``` 
-S = S1 | S2 | S3 | ε    
-S1 = '(' S ')' S     
-S2 = '[' S ']' S     
-S3 = '{' S '}' S     
-``` 
-*DSL*
-```kotlin 
-class DyckGrammar : Grammar() {
-    val S       by Nt().asStart()
-    val Round   by Nt("(" * S * ")")
-    val Quadrat by Nt("[" * S * "]")
-    val Curly   by Nt("{" * S * "}")
-
-    init {
-        //recursive nonterminals initialize in `init` block
-        S /= S * (Round or Quadrat or Curly) or Epsilon
-    }
-}
-``` 
-### Production
-$A \Longrightarrow B \hspace{4pt} \overset{def}{=} \hspace{4pt} A$  \\= $B$
-
-$A \Longrightarrow B \hspace{4pt} \overset{def}{=} \hspace{4pt} A~by~Nt(B)$
-
-### Concatenation
-$( \hspace{4pt} \cdot \hspace{4pt} ) : \sum_∗ \times \sum_∗ → \sum_∗$
-
-$a \cdot b \hspace{4pt} \overset{def}{=} \hspace{4pt} a * b$
-
-### Alternative
-$( \hspace{4pt} | \hspace{4pt} ) : \sum_∗ \times \sum_∗ → \sum_∗$
-
-$a \hspace{4pt} | \hspace{4pt} b \hspace{4pt} \overset{def}{=} \hspace{4pt} a \hspace{4pt} or \hspace{4pt} b$
-
-### Kleene Star
-
-$( \hspace{4pt} * \hspace{4pt} ) : \sum \to \sum_∗$
-
-$a^* \hspace{4pt} \overset{def}{=} \hspace{4pt} \displaystyle\bigcup_{i = 0}^{\infty}a^i$
-
-$a^* \hspace{4pt} \overset{def}{=} \hspace{4pt} many(a)$
-
-$a^+ \hspace{4pt} \overset{def}{=} \hspace{4pt} some(a)$
+### Repository layout (high‑level)
+```
+benchmarks/   # ANTLR4 comparison & perf harness (examples, scripts)
+examples/     # Grammar examples (A*, Dyck, etc.)
+generator/    # Parser & AST node‑class generator
+solver/       # Core UCFS logic (GLL + RSM)
+src/          # CLI and library entry points
+test-shared/  # Testcases, grammars, inputs
+```
 
-### Optional
-$a? \hspace{4pt} \overset{def}{=} \hspace{4pt} a \hspace{4pt} or \hspace{4pt} Epsilon$
+### Requirements
+- JDK 11+ (toolchain targets 11).  
+- Gradle Wrapper included (`./gradlew`).
 
-Epsilon -- constant terminal with behavior corresponding to the $\varepsilon$ -- terminal (empty string).
+### Typical workflow
+1) **Describe grammar** in Kotlin DSL.  
+2) **Load graph** (for now `dot` format is supported).  
+3) **Run query**.  
+4) **Inspect results**.
 
-$a? \hspace{4pt} \overset{def}{=} \hspace{4pt} opt(a)$
 
-### RSM
-DSL provides access to the RSM corresponding to the grammar using the `getRsm` method.    
-The algorithm for RSM construction is based on Brzozowski derivations.
+## Core Algorithm
+UCFS is based on Generalized LL (GLL) parsing algorithm modified to handle language specification in form of Recursive State Machines (RSM-s) and input in form of arbitratry directed edge-labelled graph. Basic ideas described [here](https://arxiv.org/pdf/2312.11925.pdf).