Bottom up iterator

.github/workflows/TagBot.yml

@@ -28,4 +28,3 @@ jobs:
       - uses: JuliaRegistries/TagBot@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          ssh: ${{ secrets.DOCUMENTER_KEY }}

Project.toml

@@ -1,7 +1,7 @@
 name = "HerbSearch"
 uuid = "3008d8e8-f9aa-438a-92ed-26e9c7b4829f"
 authors = ["Sebastijan Dumancic <[email protected]>", "Jaap de Jong <[email protected]>", "Nicolae Filat <[email protected]>", "Piotr Cichoń <[email protected]>", "Tilman Hinnerichs <[email protected]>"]
-version = "0.3.1"
+version = "0.4.1"
 
 [deps]
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
@@ -10,25 +10,18 @@ HerbCore = "2b23ba43-8213-43cb-b5ea-38c12b45bd45"
 HerbGrammar = "4ef9e186-2fe5-4b24-8de7-9f7291f24af7"
 HerbInterpret = "5bbddadd-02c5-4713-84b8-97364418cca7"
 HerbSpecification = "6d54aada-062f-46d8-85cf-a1ceaf058a06"
-Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
 MLStyle = "d8e11817-5142-5d16-987a-aa16d5891078"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
 
 [compat]
 DataStructures = "0.17,0.18"
-HerbConstraints = "^0.2.0"
-HerbCore = "^0.3.0"
-HerbGrammar = "^0.4.0"
-HerbInterpret = "^0.1.3"
-HerbSpecification = "^0.1.0"
-MLStyle = "^0.4.17"
-StatsBase = "^0.34"
-julia = "^1.8"
-
-[extras]
-LegibleLambdas = "f1f30506-32fe-5131-bd72-7c197988f9e5"
-Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
-
-[targets]
-test = ["Test", "LegibleLambdas"]
+HerbConstraints = "0.2.0"
+HerbCore = "0.3.0"
+HerbGrammar = "0.5"
+HerbInterpret = "0.1.3"
+HerbSpecification = "0.2"
+MLStyle = "0.4.17"
+Random = "1.8.0"
+StatsBase = "0.34"
+julia = "1.8"

src/HerbSearch.jl

@@ -16,7 +16,12 @@ include("uniform_iterator.jl")
 
 include("heuristics.jl")
 
-include("fixed_shaped_iterator.jl")
+include("bottom_up_iterators/nested_rulenode_iterator.jl")
+include("bottom_up_iterators/nested_uniform_iterator.jl")
+include("bottom_up_iterators/bottom_up_iterator.jl")
+include("bottom_up_iterators/bottom_up_depth_iterator.jl")
+include("bottom_up_iterators/bottom_up_uniform_iterator.jl")
+
 include("top_down_iterator.jl")
 
 include("evaluate.jl")
@@ -42,8 +47,6 @@ export
   ProgramIterator,
   @programiterator,
 
-  ContextSensitivePriorityEnumerator,
-
   heuristic_leftmost,
   heuristic_rightmost,
   heuristic_random,
@@ -56,7 +59,6 @@ export
   optimal_program,
   suboptimal_program,
 
-  FixedShapedIterator,
   UniformIterator,
   next_solution!,
 
@@ -66,6 +68,10 @@ export
   DFSIterator,
   MLFSIterator,
 
+  BottomUpIterator,
+  BUDepthIterator,
+  BUUniformIterator,
+
   MHSearchIterator,
   VLSNSearchIterator,
   SASearchIterator,

src/bottom_up_iterators/bottom_up_depth_iterator.jl

@@ -0,0 +1,200 @@
+Base.@doc """
+    @programiterator BUDepthIterator(problem::Union{Nothing, Problem{Vector{IOExample}}}=nothing, obs_equivalence::Bool=false) <: BottomUpIterator
+
+Implementation of the `BottomUpIterator`. Iterates through complete programs in increasing order of their depth.
+""" BUDepthIterator
+@programiterator BUDepthIterator(
+    problem::Any=nothing, # TODO: Look into this usage of `Any`.
+    obs_equivalence::Bool=false
+) <: BottomUpIterator
+
+"""
+    struct BUDepthBank <: BottomUpBank
+
+Specialization of `BottomUpState`'s `BottomUpBank` type. Holds a `Dict` mapping `Symbols` to `Vectors` of `RuleNodes` of that `Symbol`.
+"""
+struct BUDepthBank <: BottomUpBank
+    rulenodes_by_symbol::Dict{Symbol, Vector{RuleNode}}
+end
+
+"""
+    struct BUDepthData <: BottomUpData
+
+Specialization of `BottomUpState`'s `BottomUpData` type. Contains the following:
+* `nested_rulenode_iterator::NestedRulenodeIterator`: Iterator generating `RuleNodes` using a grammar rule to combine existing `RuleNodes` from the `bank`.
+* `new_programs::Vector{RuleNode}`: Programs generated at the current depth level. Will be appended to the `bank` when starting a new depth level.
+* `rules::Queue{Int}`: Grammar rules left to be used at the current depth level. 
+* `depth::Int`: Current depth.
+"""
+mutable struct BUDepthData <: BottomUpData
+    nested_rulenode_iterator::NestedRulenodeIterator
+    new_programs::Vector{RuleNode}
+    rules::Queue{Int}
+    depth::Int
+end
+
+"""
+	order(iter::BUDepthIterator)::Queue{Int}
+
+Returns the non-terminal rules in the order in which they appear in the grammar.
+"""
+function order(
+    iter::BUDepthIterator
+)::Queue{Int}
+    grammar::ContextSensitiveGrammar = get_grammar(iter.solver)
+    rules::Queue{Int} = Queue{Int}()
+
+    for (rule_index, is_terminal) ∈ enumerate(grammar.isterminal)
+        if !is_terminal
+            enqueue!(rules, rule_index)
+        end
+    end
+
+    return rules
+end
+
+"""
+	init_bank(iter::BUDepthIterator)::BUDepthBank
+
+Returns an initialized object of type `BUDepthBank`. For each symbol in the grammar (i.e. key in the dictionary), an empty `Vector{RuleNode}` (i.e. value in the dictionary) is allocated.
+"""
+function init_bank(
+    iter::BUDepthIterator
+)::BUDepthBank
+    grammar::ContextSensitiveGrammar = get_grammar(iter.solver)
+    rulenodes_by_symbol::Dict{Symbol, Vector{RuleNode}} = Dict{Symbol, Vector{RuleNode}}()
+
+    for symbol ∈ grammar.types
+        rulenodes_by_symbol[symbol] = Vector{RuleNode}()
+    end
+
+    return BUDepthBank(rulenodes_by_symbol)
+end
+
+"""
+    init_data(iter::BUDepthIterator)::BUDepthData
+
+Returns an initialized object of type `BUDepthData`. The initialization consists of the following:
+* `nested_rulenode_iterator` is set to an empty `NestedRulenodeIterator`.
+* `rules` contains the indeces of terminal rules in the grammar.
+* `new_programs` is an empty `Vector{RuleNode}`.
+* `depth` is set to 1.
+"""
+function init_data(
+    iter::BUDepthIterator
+)::BUDepthData
+    grammar::ContextSensitiveGrammar = get_grammar(iter.solver)
+
+    empty_nested_iterator::NestedRulenodeIterator = NestedRulenodeIterator()
+    depth::Int = 1
+
+    rules::Queue{Int} = Queue{Int}()
+    for (rule_index, is_terminal) ∈ enumerate(grammar.isterminal)
+        if is_terminal
+            enqueue!(rules, rule_index)
+        end
+    end
+
+    return BUDepthData(empty_nested_iterator, Vector{RuleNode}(), rules, depth)
+end
+
+"""
+    create_program!(iter::BUDepthIterator, bank::BUDepthBank, data::BUDepthData)::Union{Nothing, RuleNode}
+
+Returns the next program in `BUDepthIterator`'s iteration. Performs the following steps:
+1. Check whether `data.nested_rulenode_iterator` contains any program.
+2. Otherwise, pick the next rule from `data.rules` and generate all combinations of `RuleNodes` from the bank that could be combined using this rule.
+3. If `data.rules` is empty, call `_increase_depth!` and go to step 2.
+"""
+function create_program!(
+    iter::BUDepthIterator,
+    bank::BUDepthBank,
+    data::BUDepthData
+)::Union{Nothing, RuleNode}
+    program::Union{RuleNode, Nothing} = get_next_rulenode!(data.nested_rulenode_iterator)
+
+    while isnothing(program)
+        grammar::ContextSensitiveGrammar = get_grammar(iter.solver)
+
+        if isempty(data.rules)
+            _increase_depth!(iter, bank, data, grammar)
+
+            if data.depth > get_max_depth(iter.solver)
+                return nothing
+            end
+        end
+
+        data.nested_rulenode_iterator = _create_nested_rulenode_iterator(iter, bank, data, grammar)
+        program = get_next_rulenode!(data.nested_rulenode_iterator)
+    end
+
+    return program
+end
+
+"""
+update_state!(::BUDepthIterator, ::BUDepthBank, data::BUDepthData, program::RuleNode)::Nothing
+
+Appends the `program` to `data.new_programs`.
+"""
+function update_state!(
+    ::BUDepthIterator,
+    ::BUDepthBank,
+    data::BUDepthData,
+    program::RuleNode
+)::Nothing
+    push!(data.new_programs, program)
+    return nothing
+end
+
+"""
+    _create_nested_rulenode_iterator(::BUDepthIterator, bank::BUDepthBank, data::BUDepthData, grammar::ContextSensitiveGrammar)::NestedRulenodeIterator
+
+Creates a new `NestedRulenodeIterator` iterating through `RuleNodes` having the root the current rule in `data.rules`.
+The childrens of the root will be all combinations of `RuleNodes` of matching `Symbol` types from the `bank`. 
+"""
+function _create_nested_rulenode_iterator(
+    ::BUDepthIterator,
+    bank::BUDepthBank,
+    data::BUDepthData,
+    grammar::ContextSensitiveGrammar,
+)::NestedRulenodeIterator
+    rule::Int = dequeue!(data.rules)
+
+    if grammar.isterminal[rule]
+        return NestedRulenodeIterator([Tuple{}()], rule)
+    end
+
+    childtypes::Vector{Symbol} = grammar.childtypes[rule]
+    children_combinations::Vector{Vector{RuleNode}} = map(symbol -> bank.rulenodes_by_symbol[symbol], childtypes)
+
+    return NestedRulenodeIterator(Iterators.product(children_combinations...), rule)
+end
+
+"""
+    _increase_depth!(iter::BUDepthIterator, bank::BUDepthBank, data::BUDepthData, grammar::ContextSensitiveGrammar)::Nothing
+
+Performs the following steps required when the depth is increased:
+* Increase `data.depth`.
+* Create a new `data.rules` queue consisting of the indices of non-terminal rules in the grammar.
+* Copy all programs from `data.new_programs` to the `bank`.
+* Go to Step 2.
+"""
+function _increase_depth!(
+    iter::BUDepthIterator,
+    bank::BUDepthBank,
+    data::BUDepthData,
+    grammar::ContextSensitiveGrammar
+)::Nothing
+    data.rules = order(iter)
+    data.depth += 1
+
+    rulenodes_by_symbol::Dict{Symbol, Vector{RuleNode}} = bank.rulenodes_by_symbol
+
+    for program ∈ data.new_programs
+        symbol::Symbol = grammar.types[program.ind]
+        push!(rulenodes_by_symbol[symbol], program)
+    end
+
+    empty!(data.new_programs)
+    return nothing
+end