[main]
; configuration parameters and descriptions taken from the Aleph tutorial
; https://www.cs.ox.ac.uk/activities/machlearn/Aleph/aleph.html and
; from the project GitHub page https://github.com/friguzzi/aleph

;threads

; If set to true then abduction and subsequent generalisation of abduced
; atoms is performed within the induce loop. Only predicates declared to be
; abducible by abducible/1 are candidates for abduction. See section
; [Abductive learning](https://www.cs.ox.ac.uk/activities/machlearn/Aleph/aleph.html#SEC34)
; for more details. 
; (default false)
;abduce=false

; Should be a 'clause label' obtained from an earlier run. This is a list
; containing at least the number of positives covered, the number of
; negatives covered, and the length of a clause found on a previous search.
; Useful when performing searches iteratively. 
;best=[1,2,3]

; Sets an upper bound on the length of clauses whose coverages are cached
; for future use. 
; (default 3)
;cache_clauselength=3

; If true then clauses and coverage are cached for future use. Only clauses
; upto length set by cache_clauselength are stored in the cache. 
; (default false)
;caching=false

; Specifies whether a call to redundant/2 (see section
; [Other commands](https://www.cs.ox.ac.uk/activities/machlearn/Aleph/aleph.html#SEC36))
; should be made for checking redundant literals in a clause. 
; (default false)
;check_redundant=false

; Check good clauses for duplicates
; (default false)
;check_good=false

; If set to true, removes literals in the bottom clause that do not
; contribute to establishing variable chains to output variables in the
; positive literal, or produce output variables that are not used by any
; other literal in the bottom clause. 
; (default false)
;check_useless=false

; Sets upper bound on number of literals in an acceptable clause. 
; (default 4)
;clauselength=4

; A list of the form [p1-1,p2-2,...] where "pi" represents the probability
; of drawing a clause with "i" literals. Used by randomised search methods
; See section
; [Randomised search methods](https://www.cs.ox.ac.uk/activities/machlearn/Aleph/aleph.html#SEC28). 
;clauselength_distribution=[-0.2,-0.3,-0.4]

; Maximum Clauses per Theory
;clauses

; If true then randomly generated examples are obtained after conditioning
; the stochastic generator with the positive examples. 
; (default false)
;condition=false

; Confidence for Rule Pruning
;confidence=0.95

; Is one of: saturation, reduction or false. Specifies the stage at which the
; bottom clause is constructed. If reduction then it is constructed lazily
; during the search. This is useful if the bottom clause is too large to be
; constructed prior to search. This also sets the flag lazy_bottom to true.
; The user has to provide a refinement operator definition (using refine/2).
; If not, the refine parameter is set to auto. If false then no bottom clause
; is constructed. The user would normally provide a refinement operator
; definition in this case. 
; (default saturation)
;construct_bottom=saturation

; Sets an upper bound on the proof depth to which theorem-proving proceeds. 
; (default 10)
;depth=10

; If true then forces search to continue until the point that all remaining
; elements in the search space are definitely worse than the current best
; element (normally, search would stop when it is certain that all remaining
; elements are no better than the current best. This is a weaker criterion.)
; All internal pruning is turned off (see section
; [Built-in and user-defined pruning](https://www.cs.ox.ac.uk/activities/machlearn/Aleph/aleph.html#SEC23)). 
; (default false)
;explore=false

; One of: coverage, compression, posonly, pbayes, accuracy, laplace, auto_m,
; mestimate, entropy, gini, sd, wracc, or user. Sets the evaluation function
; for a search. See section
; [Altering the search](https://www.cs.ox.ac.uk/activities/machlearn/Aleph/aleph.html#SEC20). 
; (default coverage)
;evalfn=coverage

; If true then stores a Prolog encoding of "good" clauses found in the
; search. A good clause is any clause with utility above that specified by
; the setting for minscore. If goodfile is set to some filename then this
; encoding is stored externally in that file. 
; (default false)
;good=false

; A Prolog atom. Sets the filename for storing a Prolog encoding of good
; clauses found in searches conducted to date. Any existing file with this
; name will get appended. 
;goodfile=deleteme

; The size of the randomly generated example set produced for learning from
; positive examples only. See section
; [Altering the search](https://www.cs.ox.ac.uk/activities/machlearn/Aleph/aleph.html#SEC20).
; (default 100)
;gsamplesize=100

; Set upper bound on layers of new variables. 
; (default 2)
;i=2

; Specifies the number of occurences of a predicate symbol in any clause. 
; (default inf)
;language=inf

; Specifies if theorem-proving should proceed if a constraint is violated. 
; (default false)
;lazy_on_contradiction=false

; Specifies if user-defined cost-statements require clause coverages to be
; evaluated. This is normally not user-set, and decided internally. 
; (default false)
;lazy_on_cost=false

; If true then theorem-proving on negative examples stops once bounds set by
; noise or minacc are violated. 
; (default false)
;lazy_negs=false

; A positive integer. Sets a lookahead value for the automatic refinement
; operator (obtained by setting refine to auto). 
;lookahead=5

; A floating point number. Sets a value for "m-estimate" calculations. See
; section
; [Evaluation functions](https://www.cs.ox.ac.uk/activities/machlearn/Aleph/aleph.html#SEC22). 
;m=0.5

; Sets an upper bound on the maximum number of ground atoms within any
; abductive explanation for an observation. See section Abductive learning. 
; (default 2)
;max_abducibles=2

; Maximum number of features to be constructed
; (default +inf)
;max_features=+inf

; A floating point number between 0 and 1. Set a lower bound on the minimum
; accuracy of an acceptable clause. The accuracy of a clause has the same
; meaning as precision: that is, it is p/(p+n) where p is the number of
; positive examples covered by the clause (the true positives) and n is the
; number of negative examples covered by the clause (the false positives). 
; (default 0.0)
;minacc=0.0

; Minimum expected gain
; (default 0.05)
;mingain=0.05

; Set a lower bound on the number of positive examples to be covered by an
; acceptable clause. If the best clause covers positive examples below this
; number, then it is not added to the current theory. This can be used to
; prevent Aleph from adding ground unit clauses to the theory (by setting the
; value to 2). Beware: you can get counter-intuitive results in conjunction
; with the minscore setting. 
; (default 1)
;minpos=1

; A is a floating point number in the interval [0.0,1.0]. Set a lower bound
; on the positive examples covered by an acceptable clause as a fraction of
; the positive examples covered by the head of that clause. If the best clause
; has a ratio below this number, then it is not added to the current theory.
; Beware: you can get counter-intuitive results in conjunction with the minpos
; setting. 
; (default 0.0)
;minposfrac=0.0

; A floating point number. Set a lower bound on the utility of of an
; acceptable clause. When constructing clauses, if the best clause has
; utility below this number, then it is not added to the current theory.
; Beware: you can get counter-intuitive results in conjunction with the
; minpos setting. 
; (default -inf)
;minscore=-inf

; An integer >= 0. Set an upper bound on the number of moves allowed when
; performing a randomised local search. This only makes sense if search is
; set to rls and rls_type is set to an appropriate value. 
; (default 5)
;moves=5

; A positive integer or inf. Set upper bound on the number of existential
; variables that can be introduced in the body of a clause. 
; (default inf)
;newvars=inf

; Set upper bound on the nodes to be explored when searching for an
; acceptable clause.
; (default 5000)
;nodes=20000

; An integer >= 0. Set an upper bound on the number of negative examples
; allowed to be covered by an acceptable clause. 
; (default 0)
;noise=3

; If true then removes literals in the body of the bottom clause using the
; negative examples. The procedure is as described by S. Muggleton and
; C. Feng in Efficient induction of logic programs, Inductive Logic
; Programming, S. Muggleton (ed.), AFP Press. 
; (default false)
;nreduce_bottom=false

; An integer >= 0 or inf. Set an upper bound on the beam-width to be used in
; a greedy search. 
; (default inf)
;openlist=inf

; If true performs query optimisations described by V.S. Costa,
; A. Srinivasan, and R.C. Camacho in A note on two simple transformations for
; improving the efficiency of an ILP system. 
; (default false)
;optimise_clauses=false

; If true randomly permutes literals in the body of the bottom clause, within
; the constraints imposed by the mode declarations. The utility of is
; described by P. Tschorn in Random Local Bottom Clause Permutations for
; Better Search Space Exploration in Progol-like ILP Systems. (short papers,
; ILP 2006). 
; (default false)
;permute_bottom=false

; If true executes goal aleph_portray(Term) where Term is one of train_pos,
; train_neg, test_pos, or test_neg when executing the command show(Term). 
; (default false)
;portray_examples=false

; Sets an upper bound on the maximum number of literals displayed on any one
; line of the trace. 
; (default 4)
;print=4

; One of: restricted_sld, sld, or user. If restricted_sld, then examples
; covered are determined by forcing current hypothesised clause to be the
; first parent clause in a SLD resolution proof. If sld then this restriction
; is not enforced. The former strategy is efficient, but not refutation
; complete. It is sufficient if all that is needed is to determine how many
; examples are covered by the current clause, which is what is needed when
; Aleph is used to construct a set of non-recursive clauses greedily (for
; example using the induce/0 command: see section Construct a theory). If set
; to user then Aleph expects a user-defined predicate prove/2, the first
; argument of which is a clause C, and the second is an example E. prove(C,E)
; succeeds if example E is provable using clause C and the background knowledge. 
; (default restricted_sld)
;proof_strategy=restricted_sld

; A positive integer or inf. Sets an upper bound on the time (in seconds) for
; testing whether an example is covered. Overrides any value set for searchtime. 
; (default inf)
;prooftime=inf

; If true then trace of Aleph execution is written to a file. The filename is
; given by recordfile. 
; (default false)
;record=true

; A Prolog atom. Sets the filename to write a trace of execution. Only makes
; sense if record is set to true. 
;recordfile=log

; An integer >= 1 or inf. Sets the number of times an example is resampled
; when selected by induce/0 or induce_cover/0. That is, is set to some
; integer N, then the example is repeatedly selected N times by induce/0 or
; induce_cover/0. 
; (default 1)
;resample=1

; One of: gsat, wsat, rrr, or anneal. Sets the randomised search method to be
; one of GSAT, WSAT, RRR or simulated annealing. Requires search to be set to
; rls, and integer values for tries and moves. See section
; [Randomised search methods](http://www.cs.ox.ac.uk/activities/machinelearning/Aleph/aleph.html#SEC19). 
;rls_type=gsat

; An integer >= 0. Sets number of examples selected randomly by the induce or
; induce_cover commands. The best clause from the sample is added to the
; theory. A value of 0 turns off random sampling, and the next uncovered
; example in order of appearance in the file of training examples is selected. 
; (default 0)
;samplesize=0

; A number in the range (0,100] (usually an integer). This denotes that any
; clause in the top n-percentile of clauses are considered "good" when
; performing stochastic clause selection. Only meaningful if search is set to
; scs. 
;scs_percentile=5

; A number in the range [0,1.0). This denotes the minimum probability of
; obtaining a "good" clause when performing stochastic clause selection. Only
; meaningful if search is set to scs. 
;scs_prob=0.7

; A positive integer that determines the number of clauses randomly selected
; from the hypothesis space in a clause-level search. Only meaningful if
; search is set to scs. his overrules any samplesizes calculated from
; settings for scs_percentile and scs_prob. 
;scs_sample=5

; One of: bf, df, heuristic, ibs, ils, rls, scs id, ic, ar, or false. Sets
; the search strategy. If false then no search is performed. See section
; [Altering the search](http://www.cs.ox.ac.uk/activities/machinelearning/Aleph/aleph.html#SEC20).
; (default bf)
;search=bf

; Search Strategy; one of bf, df, heuristic, ibs, ils, rls, scs, id, ic, ar, false
; (default bf)
;searchstrat=bf

; An integer >= 0 or inf. Sets an upper bound on the time (in seconds) for a
; search. 
; (default inf)
;searchtime=inf

; Sets the counter for variables in non-ground positive examples. Each
; variable will be replaced by a skolem variable that has a unique number
; which is no smaller than the value set here. This number has to be larger
; than the number of variables that would otherwise appear in a bottom
; clause. 
; (default 10000)
;skolemvars=10000

; If set to true before constructing a bottom clause, then variable
; co-references in the bottom clause are split apart by new variables. The
; new variables can occur at input or output positions of the head literal,
; and only at output positions in body literals. Equality literals between
; new and old variables are inserted into the bottom clause to maintain
; equivalence. It may also result in variable renamed versions of other
; literals being inserted into the bottom clause. All of this increases the
; search space considerably and can make the search explore redundant
; clauses. The current version also elects to perform variable splitting
; whilst constructing the bottom clause (in contrast to doing it dynamically
; whilst searching). This was to avoid unnecessary checks that could slow
; down the search when variable splitting was not required. This means the
; bottom clause can be extremely large, and the whole process is probably not
; very practical for large numbers of co-references. The procedure has not
; been rigourously tested to quantify this. 
; (default false)
;splitvars=false

; Stores bottom clause constructed for an example for future re-use. 
; (default false)
;store_bottom=false

; If true then uses a sample of the examples (set by value assigned to
; subsamplesize) to evaluate the utility of a clause. 
; (default false)
;subsample=false

; An integer >= 1 or inf. Sets an upper bound on the number of examples
; sampled to evaluate the utility of a clause. 
; (default inf)
;subsamplesize=inf

; A non-zero floating point number. Sets the temperature for randomised
; search using annealing. Requires search to be set to rls and rls_type to
; be set to anneal. 
;temperature=0.5

; A positive integer. Sets the maximum number of restarts allowed for
; randomised search methods. This only makes sense if search is set to rls
; and rls_type is set to an appropriate value. 
;tries=5

; Used when drawing clauses randomly from the clause-space. If set set to
; true then clauses are drawn by uniform random selection from the space of
; legal clauses. Since there are usually many more longer clauses than
; shorter ones, this will mean that clauses drawn randomly are more likely to
; be long ones. If set to false then assumes a uniform distribution over
; clause lengths (up to the maximum length allowed by clauselength). This is
; not necessarily uniform over legal clauses. If random clause selection is
; done without a bottom clause for guidance then this parameter is set to
; false. 
; (default false)
;uniform_sample=false

; A value between 0 and 1. It represents the random walk probability for the
; Walksat algorithm. 
;walk=0.5

