Feature element 1D const (#213)

* first very basic implementation of element1Dconst
* nice syntax for element constraint + sorting test case
* test case and first part of move_element_constraint
* activate element constraint and minor fixes of activation
* have _ functions for single_reverse and reverse to check is deactivated
* v0.8.2

Author: Wikunia

CHANGELOG.md

@@ -1,10 +1,17 @@
 # ConstrainSolver.jl - Changelog
+ 
+## v0.8.2 (6th of February 2022)
+- Support for element constraints with a constant array like `T[y] == z`
+  - **This is experimental** Quite some stuff that might go wrong when combining it inside an indicator, reified or boolean constraint.
+    - If you find any problems please open an issue. I release it to get more feedback get this more tested. I plan on refactoring this quite a bit later.
 
 ## v0.8.1 (5th of February 2022)
 - bugfix when using `CS.Integers` together with an alldifferent constraint. [PR #283](https://github.com/Wikunia/ConstraintSolver.jl/pull/283)
+
 ## v0.8.0 (8th of January 2022)
 - Using [TableLogger.jl](https://github.com/Wikunia/TableLogger.jl)
 - Only support Julia v1.6 and above
+
 ## v0.7.1 (1st of November 2021)
 - Using priority queue also for `BFS` problems [PR #274](https://github.com/Wikunia/ConstraintSolver.jl/pull/274)
 

Project.toml

@@ -1,7 +1,7 @@
 name = "ConstraintSolver"
 uuid = "e0e52ebd-5523-408d-9ca3-7641f1cd1405"
 authors = ["Ole Kröger <[email protected]>"]
-version = "0.8.1"
+version = "0.8.2"
 
 [deps]
 ConstraintProgrammingExtensions = "b65d079e-ed98-51d9-b0db-edee61a5c5f8"

benchmark/benchmarks.jl

@@ -1,6 +1,7 @@
 using BenchmarkTools
 using ConstraintSolver, JuMP, MathOptInterface
 using GLPK, JSON, Cbc
+using Random
 
 const CS = ConstraintSolver
 const MOI = MathOptInterface
@@ -150,4 +151,14 @@ SUITE["steiner"] = BenchmarkGroup(["reified", "and"])
 steiner(3)
 SUITE["steiner"]["steiner_7"] =
     @benchmarkable steiner(7) seconds = 5
-    
+    
+
+include(joinpath(dir, "benchmark/sort/benchmark.jl"))
+
+SUITE["sorting"] = BenchmarkGroup(["element1Dconst", "alldifferent", "equal", "less_than"])
+# compiling run
+sort_element_constr(10)
+SUITE["sorting"]["50_elements"] =
+    @benchmarkable sort_element_constr(50) seconds = 5
+SUITE["sorting"]["100_elements"] =
+    @benchmarkable sort_element_constr(100) seconds = 10

benchmark/sort/benchmark.jl

@@ -0,0 +1,20 @@
+function sort_element_constr(n)
+    m = Model(optimizer_with_attributes(CS.Optimizer,  
+        "logging" => [],
+        "seed" => 4,
+        "traverse_strategy" => :BFS,
+    ))
+    seed = 1337
+    Random.seed!(seed)
+    c = rand(1:1000, n)
+    @variable(m, 1 <= idx[1:length(c)] <= length(c), Int)
+    @variable(m, minimum(c) <= val[1:length(c)] <= maximum(c), Int)
+    for i in 1:length(c)-1
+        @constraint(m, val[i] <= val[i+1])
+    end
+    for i in 1:length(c)
+        @constraint(m, c[idx[i]] == val[i])
+    end
+    @constraint(m, idx in CS.AllDifferent())
+    optimize!(m)
+end

docs/src/supported.md

@@ -104,7 +104,7 @@ The following list shows constraints that are implemented and those which are pl
     - one can write something like `a || !b` 
     - **Attention:** Does not check whether `a` and `b` are actually binary variables
 - Element constraints
-  - [ ] 1D array with constant values 
+  - [X] 1D array with constant values 
     - i.e `T = [12,87,42,1337]` `T[y] == z` with `y` and `z` being variables [#213](https://github.com/Wikunia/ConstraintSolver.jl/pull/213)
   - [ ] 2D array with constant values 
     - where T is an array

src/ConstraintSolver.jl

@@ -84,6 +84,7 @@ include("constraints/activator_constraints.jl")
 include("constraints/indicator.jl")
 include("constraints/reified.jl")
 include("constraints/geqset.jl")
+include("constraints/element1Dconst.jl")
 
 include("pruning.jl")
 include("simplify.jl")

src/MOI_wrapper/MOI_wrapper.jl

@@ -166,6 +166,8 @@ function MOI.optimize!(model::Optimizer)
     # check if every variable has bounds and is an Integer
     check_var_bounds(model)
 
+    move_element_constraint(model)
+
     set_pvals!(model)
     set_var_in_all_different!(model)
 

src/MOI_wrapper/constraints.jl

@@ -5,6 +5,7 @@ sense_to_set(::Function, ::Val{:!=}) = CPE.DifferentFrom(0.0)
 sense_to_set(::Function, ::Val{:<}) = CPE.Strictly(MOI.LessThan(0.0))
 sense_to_set(::Function, ::Val{:>}) = CPE.Strictly(MOI.GreaterThan(0.0))
 
+include("element.jl")
 include("indicator.jl")
 include("reified.jl")
 include("bool.jl")
@@ -34,6 +35,7 @@ MOI.supports_constraint(
     ::Type{MOI.VectorOfVariables},
     ::Type{CPE.AllEqual},
 ) = true
+
 MOI.supports_constraint(
     ::Optimizer,
     ::Type{MOI.VectorOfVariables},
@@ -46,6 +48,12 @@ MOI.supports_constraint(
     ::Type{CPE.AllDifferent},
 ) where {T <: Real} = true
 
+MOI.supports_constraint(
+    ::Optimizer,
+    ::Type{MOI.VectorOfVariables},
+    ::Type{Element1DConstInner},
+) = true
+
 MOI.supports_constraint(
     ::Optimizer,
     ::Type{MOI.VectorOfVariables},
@@ -299,6 +307,8 @@ function MOI.add_constraint(
         com.info.n_constraint_types.table += 1
     elseif set isa CPE.AllEqual
         com.info.n_constraint_types.equality += 1
+    elseif set isa Element1DConstInner
+        com.info.n_constraint_types.element += 1
     end
 
     return MOI.ConstraintIndex{MOI.VectorOfVariables,typeof(set)}(length(com.constraints))
@@ -578,7 +588,7 @@ function MOI.add_constraint(
     set::IS,
 ) where {T,A,F,S<:MOI.AbstractVectorSet,IS<:CS.IndicatorSet{A,F,S}}
     com = model.inner
-    com.info.n_constraint_types.reified += 1
+    com.info.n_constraint_types.indicator += 1
 
     internals = create_internals(com, func, set)
 

src/MOI_wrapper/element.jl

@@ -0,0 +1,15 @@
+"""
+    Support for nice element 1D const constraint
+"""
+function Base.getindex(v::AbstractVector{<:Integer}, i::VariableRef)
+    m = JuMP.owner_model(i)
+    # check if the AbstractVector has standard indexing
+    if !checkbounds(Bool, v, 1:length(v))
+        throw(ArgumentError("Currently the specified vector needs to be using standard indexing 1:... so OffsetArrays are not possible."))
+    end
+    v = collect(v)
+    min_val, max_val = extrema(v)
+    x = @variable(m, integer=true, lower_bound = min_val, upper_bound = max_val)
+    @constraint(m, [x, i] in CS.Element1DConst(v))
+    return x
+end

src/MOI_wrapper/util.jl

@@ -96,6 +96,114 @@ function get_inner_constraint(com, vars::MOI.VectorOfVariables, set::Union{Reifi
     return init_constraint_struct(com, set.set, inner_internals)
 end
 
+"""
+    get_bool_constraint_fct_set(T, constraint::BoolConstraint, lhs_fct, lhs_set, rhs_fct, rhs_set)
+
+Create the fct and set of a [`BoolConstraint`](@ref) which combines the left hand side with the right hand side.
+"""
+function get_bool_constraint_fct_set(T, constraint::BoolConstraint, lhs_fct, lhs_set, rhs_fct, rhs_set)
+    BS = typeof_without_params(constraint.set)
+    fct = MOIU.operate(vcat, T, lhs_fct, rhs_fct)
+    set = BS{typeof(lhs_fct), typeof(rhs_fct)}(lhs_set, rhs_set)
+    return fct, set
+end
+
+function find_element_var_and_combine(T, constraint::BoolConstraint, element_constraint, element_var)
+    lhs = constraint.lhs
+    rhs = constraint.rhs
+    if element_var in lhs.indices
+        if lhs isa BoolConstraint
+            fct, set = find_element_var_and_combine(T, lhs, element_constraint, element_var)
+        else
+            fct = MOIU.operate(vcat, T, lhs.fct, element_constraint.fct)
+            set = XNorSet{typeof(lhs.fct), typeof(element_constraint.fct)}(lhs.set, element_constraint.set)
+        end
+        fct, set = get_bool_constraint_fct_set(T, constraint, fct, set, rhs.fct, rhs.set)
+    else
+        if rhs isa BoolConstraint
+            fct, set = find_element_var_and_combine(T, rhs, element_constraint, element_var)
+        else
+            fct = MOIU.operate(vcat, T, element_constraint.fct, rhs.fct)
+            set = XNorSet{typeof(element_constraint.fct), typeof(rhs.fct)}(element_constraint.set, rhs.set)
+        end
+        fct, set = get_bool_constraint_fct_set(T, constraint, lhs.fct, lhs.set, fct, set)
+    end
+    return fct, set
+end
+
+function create_new_activator_constraint(model, activation_constraint::ActivatorConstraint, fct, set)
+    com = model.inner
+    T = parametric_type(com)
+    ACS = typeof_without_params(activation_constraint.set)
+    A = get_activation_condition(activation_constraint.set)
+    if ACS == MOI.IndicatorSet
+        ACS = IndicatorSet
+    end
+    f = MOIU.eachscalar(activation_constraint.fct)
+
+    activator_fct = f[1]
+    fct = MOIU.operate(vcat, T, activator_fct, fct)
+    MOI.add_constraint(model, fct, ACS{A,typeof(fct)}(set))
+end
+
+"""
+    move_element_constraint(model)
+
+If there are element constraints which are only used inside of an indicator or reified constraint
+=> combine them with xnor and deactivate the previously added element constraint
+    this is to avoid filtering based on this element constraint when the inner constraint isn't active
+For more see: https://github.com/Wikunia/ConstraintSolver.jl/pull/213#issuecomment-860954185
+"""
+function move_element_constraint(model)
+    com = model.inner
+    T = parametric_type(com)
+    constraints = com.constraints
+    subscriptions = com.subscription
+    for element_cons in constraints
+        element_cons isa Element1DConstConstraint || continue
+        element_var = element_cons.indices[1]
+
+        # check if the element var only appears in indicator or reified constraints
+        only_inside = true
+        for constraint in constraints[subscriptions[element_var]]
+            # if not inside indicator, reified or OrConstraint and not the current constraint that we check
+            if !(constraint isa ActivatorConstraint) && !(constraint isa OrConstraint) && constraint.idx != element_cons.idx
+                only_inside = false
+            end
+        end
+        !only_inside && continue
+        # check if at least once inside
+        only_inside = false
+        for constraint in constraints[subscriptions[element_var]]
+            if constraint isa ActivatorConstraint || constraint isa OrConstraint
+                only_inside = true
+                break
+            end
+        end
+        !only_inside && continue
+
+        element_cons.is_deactivated = true
+        for constraint in constraints[subscriptions[element_var]]
+            constraint isa Element1DConstConstraint && continue
+            constraint.is_deactivated && continue
+            fct, set = nothing, nothing
+            if constraint isa ActivatorConstraint
+                if constraint.inner_constraint isa OrConstraint
+                    inner_constraint = constraint.inner_constraint
+                    fct, set = find_element_var_and_combine(T, inner_constraint, element_cons, element_var)
+                else
+                    fct = MOIU.operate(vcat, T, constraint.inner_constraint.fct, element_cons.fct)
+                    set = XNorSet{typeof(constraint.inner_constraint.fct), typeof(element_cons.fct)}(constraint.inner_constraint.set, element_cons.set)
+                end
+                create_new_activator_constraint(model, constraint, fct, set)
+            else # OrConstraint
+                fct, set = find_element_var_and_combine(T, constraint, element_cons, element_var)
+                MOI.add_constraint(model, fct, set)
+            end
+        end
+    end
+end
+
 function get_activator_internals(A, indices)
     ActivatorConstraintInternals(A, indices[1] in indices[2:end], false, 0)
 end