Try to run Example1

[VishalPatel43]

[mtf90]

I assume this is VSCode? Unfortunately, I am not too experienced with this IDE, so I cannot really comment on how to properly setup a project. But since LearnLib isn't any different from a regular Maven project, you should be able to find plenty of documentation.

Given that GenerateRefinement is an annotation from our annotation processor, maybe VSCode has problems with dependencies that are declared as <scope>provided</scope>. At least this one of the more plausible explanations that I can come up with. Maybe this gives you a direction you could look into.

[VishalPatel43]

No, this is intelliJ idea

The first time I was able to run this but after some time it led to the above error

Which version of Java should be preferred? currently, I am using Java 17

Till now I have tried Automatalib and Learnlib whose versions are currently in development

Now I am trying the stable version of Automatalib (0.10.0) and Learnlib (0.16.0)

[mtf90]

We aim at supporting the recents LTS releases of Java, which currently are 8, 11, 17, and 21.

If you are using the stable versions of AutomataLib/LearnLib, why do you have the code imported in Intellij? Typically, you would only import your own project and declare AutomataLib/LearnLib as a dependency. Then you also wouldn't need to compile the (already compiled) code of AutomataLib/LearnLib.

[VishalPatel43]

actually I imported that and just wants to run the given example code and understand the flow

I am not able to install automatalib 0.10.0 version library on my device

[mtf90]

How about you just create a new project from scratch that only uses AutomataLib/LearnLib as dependencies without importing the libraries themselves? You can use one of the existing archetypes for this. Simply run

mvn archetype:generate -DarchetypeGroupId=de.learnlib.archetypes -DarchetypeArtifactId=complete -DarchetypeVersion=0.16.0

and provide the project data as you like (e.g. com.github.vishalpatel43 as groupId, etc.). This should give you a basic maven project that includes a simple example. You should be able to mvn install it, import it in IntelliJ and run it from IntelliJ. If this all works, you can start to expand the example to your liking.

[VishalPatel43]

I used this pom.xml file and successfully run the code which given examples in automatalib(0.10.0) and learnlib (0.16.0)

Thank you sir for your help, please tell me there will be changes in the POM.xml file

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>net.automatalib.distribution</groupId>
            <artifactId>automata-distribution</artifactId>
            <version>0.10.0</version>
            <type>pom</type>
        </dependency>

        <dependency>
            <groupId>de.learnlib.distribution</groupId>
            <artifactId>learnlib-distribution</artifactId>
            <version>0.16.0</version>
            <type>pom</type>
        </dependency>
    </dependencies>

</project>

[VishalPatel43]

Okay, Sir I generated the random 1000 DFA which are in dot format for my experiment, but can you provide that how to give SUL (oracle) to automata which is (.dot) file to the L* algortihm
please if possible, because learnlib and automatalib is very complex library and also I am trying to understand and explore these two libraries and how to use properly

[mtf90]

Did you generate the automata with AutomataLib and then exported them to .dot? If so, you can simply use the in-memory automaton object and wrap it in a SimulatorOracle to pass it to a learning algorithm. If the .dot files are created externally, you may have a look at the DOTParsers factory to import automata from .dot files. You may have to tinker around a little bit with the different node parsers and edge parsers depending on the structure of your .dot files (the parser-less methods typically only work with files that have been created by AutomataLib) but I think the semantics are quite straight-forward.

[VishalPatel43]

Sir I generate the DFA (.dot format) using the AALpy library.

.dot file of DFA

digraph random_dfa_1 {
s1 [label="s1"];
s2 [label="s2", shape=doublecircle];
s3 [label="s3", shape=doublecircle];
s4 [label="s4"];
s5 [label="s5", shape=doublecircle];
s6 [label="s6"];
s7 [label="s7"];
s1 -> s7 [label="a"];
s1 -> s6 [label="b"];
s2 -> s5 [label="a"];
s2 -> s4 [label="b"];
s3 -> s6 [label="a"];
s3 -> s6 [label="b"];
s4 -> s7 [label="a"];
s4 -> s2 [label="b"];
s5 -> s1 [label="a"];
s5 -> s4 [label="b"];
s6 -> s3 [label="a"];
s6 -> s2 [label="b"];
s7 -> s3 [label="a"];
s7 -> s5 [label="b"];
__start0 [label="", shape=none];
__start0 -> s1 [label=""];
}

Actually If there is any example of L* which take the dot file of DFA and learn it and it will give the result of the membership queries, equivalence queries, number state etc, then it will be helpful

Otherwise which format of DFA should I used how to generate the Random DFA using the Automatalib and then give to the SUL?

Learnlib and Automatalib libraries are large and little bit complex, I am also trying to learn this, but with your help it will be boost my progress and submission of my project is 8th Nov.

I learned the algortihms in my research (L*, NL*, KV, TTT) but its hard to use these libraries

It would be helpful if you provide the example with L* algorithms

[mtf90]

Unfortunately, there is no example for directly importing and learning a DFA from a .dot file. However, the example from #98 covers the basic workflow of evaluating the learner performance. The only thing that has changed is how to construct the DFA/SUL that you pass to the simulator oracle.

For that purpose you can use the previously mentioned DOTParsers class. For the syntax of the AALpy export you are probably good to go with the default #dfa method. If you need to customize the node parsing, edge parsing, or initial nodes of the .dot file, you may use the more general #fsa method whose arguments describe how the properties of nodes and edges should be parsed. For your file, the nodeParser argument would receive (for example) the map [("label", "s2"), ("shape", "doublecircle")] and should return the respective state property (true/false for the acceptance of the state).

[mtf90]

Do you still need guidance, or can we mark this thread as resolved?