ommx/instance/

setter.rs

use super::*;

fn validate_one_hot_non_empty(constraint: &crate::OneHotConstraint) -> crate::Result<()> {
    crate::ensure!(
        !constraint.variables.is_empty(),
        crate::OneHotConstraintError::EmptyVariables
    );
    Ok(())
}

fn validate_sos1_non_empty(constraint: &crate::Sos1Constraint) -> crate::Result<()> {
    crate::ensure!(
        !constraint.variables.is_empty(),
        crate::Sos1ConstraintError::EmptyVariables
    );
    Ok(())
}

impl Instance {
    /// Internal helper to validate required IDs against precomputed sets.
    ///
    /// Mirrors the `used / fixed / dependent` disjointness invariant the
    /// builder enforces (`builder.rs`): a constraint or objective cannot
    /// reference a variable whose value has been pinned via
    /// a table-owned fixed value (`fixed`), nor a variable
    /// used as a substitution-dependency key (`dependent`).
    fn validate_required_ids_with_sets(
        required_ids: &VariableIDSet,
        variable_ids: &VariableIDSet,
        dependency_keys: &VariableIDSet,
        fixed_ids: &VariableIDSet,
    ) -> crate::Result<()> {
        // Check if all required IDs are defined
        if !required_ids.is_subset(variable_ids) {
            let id = *required_ids.difference(variable_ids).next().unwrap();
            crate::bail!({ ?id }, "Undefined variable ID is used: {id:?}");
        }

        // Check if any required ID is a dependent variable (used as a key in decision_variable_dependency)
        if let Some(&id) = required_ids.intersection(dependency_keys).next() {
            crate::bail!(
                { ?id },
                "Dependent variable cannot be used in objectives or constraints: {id:?}",
            );
        }

        // Check if any required ID is a fixed variable.
        if let Some(&id) = required_ids.intersection(fixed_ids).next() {
            crate::bail!(
                { ?id },
                "Fixed variable {id:?} cannot be used in objectives or constraints",
            );
        }

        Ok(())
    }

    /// Validate that all required variable IDs are defined in the instance
    /// and are not dependent variables (i.e., not used as keys in
    /// decision_variable_dependency) and are not fixed variables
    /// (table-owned fixed value set).
    fn validate_required_ids(&self, required_ids: VariableIDSet) -> crate::Result<()> {
        let variable_ids: VariableIDSet = self.decision_variables.keys().cloned().collect();
        let dependency_keys: VariableIDSet = self.decision_variable_dependency.keys().collect();
        let fixed_ids: VariableIDSet = self
            .fixed_decision_variable_values()
            .keys()
            .copied()
            .collect();
        Self::validate_required_ids_with_sets(
            &required_ids,
            &variable_ids,
            &dependency_keys,
            &fixed_ids,
        )
    }

    /// Set the objective function and rebase output semantics.
    ///
    /// # Postconditions
    ///
    /// Setting the objective makes it the new active and output semantics.
    ///
    /// ```
    /// use ommx::{
    ///     coeff, linear, v1::State, ATol, DecisionVariable, Evaluate, Function,
    ///     Instance, Sense, VariableID,
    /// };
    /// use std::collections::{BTreeMap, HashMap};
    ///
    /// let variable = VariableID::from(1);
    /// let mut instance = Instance::builder()
    ///     .sense(Sense::Maximize)
    ///     .objective(Function::from(linear!(1)))
    ///     .decision_variables(BTreeMap::from([(variable, DecisionVariable::binary())]))
    ///     .constraints(BTreeMap::new())
    ///     .build()
    ///     .unwrap();
    /// assert!(instance.convert_active_objective(Sense::Minimize));
    ///
    /// instance
    ///     .set_objective(Function::from((coeff!(2.0) * linear!(1)).unwrap()))
    ///     .unwrap();
    /// assert_eq!(instance.sense(), Sense::Minimize);
    /// assert!(instance.output_objective().is_none());
    /// let state = State::from(HashMap::from([(1, 1.0)]));
    /// let solution = instance.evaluate(&state, ATol::default()).unwrap();
    /// assert_eq!(*solution.sense(), Some(Sense::Minimize));
    /// assert_eq!(*solution.objective(), 2.0);
    /// ```
    pub fn set_objective(&mut self, objective: Function) -> crate::Result<()> {
        // Validate that all variables in the objective are defined
        self.validate_required_ids(objective.required_ids())?;
        self.objective = objective;
        self.output_objective = None;
        Ok(())
    }

    /// Insert a new constraint with its context, picking an unused id.
    ///
    /// Returns the newly assigned [`ConstraintID`]. The context is
    /// drained into the per-constraint [`ConstraintContextStore`]; pass
    /// `ConstraintContext::default()` for an unannotated constraint.
    ///
    /// All variable IDs referenced by the constraint must already be
    /// present in `decision_variables` and must not be substitution-
    /// dependency keys, matching the validation enforced by
    /// [`Self::insert_constraint`].
    pub fn add_constraint(
        &mut self,
        constraint: Constraint,
        context: crate::ConstraintContext,
    ) -> crate::Result<ConstraintID> {
        self.validate_required_ids(constraint.required_ids())?;
        let id = self.constraint_collection.unused_id();
        self.constraint_collection
            .insert_active_with_context(id, constraint, context)?;
        Ok(id)
    }

    /// Verify that the given id is a binary decision variable.
    ///
    /// Used at the structural positions of indicator and one-hot constraints,
    /// where the [`Instance`] builder enforces `Kind::Binary` and the same
    /// invariant must hold for the post-construction `add_*` setters.
    fn require_binary_variable(&self, id: VariableID) -> crate::Result<()> {
        let dv = self
            .decision_variables
            .get(&id)
            .ok_or_else(|| crate::error!("Variable {id:?} is not defined in decision_variables"))?;
        if dv.kind() != crate::decision_variable::Kind::Binary {
            crate::bail!({ ?id }, "Variable {id:?} must be binary");
        }
        Ok(())
    }

    /// Insert a new indicator constraint with its context, picking an unused id.
    ///
    /// Returns the newly assigned [`crate::IndicatorConstraintID`].
    /// Enforces the same invariants as the [`Instance`] builder:
    /// - All variable IDs referenced by the constraint (function plus the
    ///   indicator variable) must be present in `decision_variables` and must
    ///   not be substitution-dependency keys.
    /// - The indicator variable must have [`Kind::Binary`](crate::decision_variable::Kind).
    pub fn add_indicator_constraint(
        &mut self,
        constraint: crate::IndicatorConstraint,
        context: crate::ConstraintContext,
    ) -> crate::Result<crate::IndicatorConstraintID> {
        self.validate_required_ids(constraint.required_ids())?;
        self.require_binary_variable(constraint.indicator_variable)?;
        let id = self.indicator_constraint_collection.unused_id();
        self.indicator_constraint_collection
            .insert_active_with_context(id, constraint, context)?;
        Ok(id)
    }

    /// Insert a new one-hot constraint with its context, picking an unused id.
    ///
    /// Returns the newly assigned [`crate::OneHotConstraintID`]. Enforces
    /// the [`Instance`] builder's invariants: the one-hot set must be
    /// non-empty and every variable in it must be defined and have
    /// [`Kind::Binary`](crate::decision_variable::Kind).
    pub fn add_one_hot_constraint(
        &mut self,
        constraint: crate::OneHotConstraint,
        context: crate::ConstraintContext,
    ) -> crate::Result<crate::OneHotConstraintID> {
        validate_one_hot_non_empty(&constraint)?;
        self.validate_required_ids(constraint.required_ids())?;
        for var_id in &constraint.variables {
            self.require_binary_variable(*var_id)?;
        }
        let id = self.one_hot_constraint_collection.unused_id();
        self.one_hot_constraint_collection
            .insert_active_with_context(id, constraint, context)?;
        Ok(id)
    }

    /// Insert a new SOS1 constraint with its context, picking an unused id.
    ///
    /// Returns the newly assigned [`crate::Sos1ConstraintID`]. Enforces the
    /// [`Instance`] builder's invariants: the variable set must be non-empty
    /// and every variable must be defined in `decision_variables`.
    pub fn add_sos1_constraint(
        &mut self,
        constraint: crate::Sos1Constraint,
        context: crate::ConstraintContext,
    ) -> crate::Result<crate::Sos1ConstraintID> {
        validate_sos1_non_empty(&constraint)?;
        self.validate_required_ids(constraint.required_ids())?;
        let id = self.sos1_constraint_collection.unused_id();
        self.sos1_constraint_collection
            .insert_active_with_context(id, constraint, context)?;
        Ok(id)
    }

    /// Insert a decision variable with its modeling label.
    ///
    /// The table key must not collide with any existing variable and must not
    /// be a substitution-dependency key. Returns the inserted variable's id for
    /// symmetry with `add_constraint`.
    ///
    /// # Errors
    ///
    /// Returns an error whose chain contains
    /// [`crate::DecisionVariableError::DuplicateID`] when `id` is already
    /// owned by a decision variable.
    pub fn add_decision_variable(
        &mut self,
        id: crate::VariableID,
        variable: crate::DecisionVariable,
        label: crate::DecisionVariableLabel,
    ) -> crate::Result<crate::VariableID> {
        if !self.decision_variables.contains_key(&id)
            && self.decision_variable_dependency.keys().any(|k| k == id)
        {
            crate::bail!(
                { ?id },
                "Variable id {id:?} is currently used as a substitution-dependency key",
            );
        }
        self.decision_variables
            .insert(id, variable, label, None, crate::ATol::default())?;
        Ok(id)
    }

    fn apply_validated_constraint_insert(
        &mut self,
        id: ConstraintID,
        constraint: Constraint,
    ) -> crate::Result<Option<Constraint>> {
        if self.constraint_collection.active().contains_key(&id)
            || self.constraint_collection.removed().contains_key(&id)
        {
            let old = self
                .constraint_collection
                .replace_row_preserving_lifecycle(id, constraint)
                .expect("read-only membership check found this constraint");
            Ok(Some(old))
        } else {
            self.constraint_collection.insert_active_with_context(
                id,
                constraint,
                crate::ConstraintContext::default(),
            )?;
            Ok(None)
        }
    }

    /// Insert a constraint into the instance under the given [`ConstraintID`].
    ///
    /// - If the constraint already exists, it will be replaced.
    /// - If the ID is in the removed constraints, it replaces it.
    /// - Otherwise, it adds the constraint to the instance.
    ///
    pub fn insert_constraint(
        &mut self,
        id: ConstraintID,
        constraint: Constraint,
    ) -> crate::Result<Option<Constraint>> {
        // Validate that all variables in the constraints are defined
        self.validate_required_ids(constraint.required_ids())?;
        self.apply_validated_constraint_insert(id, constraint)
    }

    /// Insert multiple `(id, constraint)` pairs into the instance with a single validation pass.
    ///
    /// This is more efficient than calling [`Self::insert_constraint`] multiple times
    /// because it validates all required variable IDs once, rather than
    /// rebuilding the validation sets for each constraint.
    ///
    /// The behavior for each constraint follows the same rules as [`Self::insert_constraint`]:
    /// - If the constraint already exists, it will be replaced.
    /// - If the ID is in the removed constraints, it replaces it.
    /// - Otherwise, it adds the constraint to the instance.
    ///
    /// # Atomicity
    ///
    /// This method is atomic: all constraints are validated before any insertion occurs.
    /// If any constraint fails validation, no constraints are inserted and an error is returned.
    ///
    pub fn insert_constraints(
        &mut self,
        constraints: Vec<(ConstraintID, Constraint)>,
    ) -> crate::Result<BTreeMap<ConstraintID, Constraint>> {
        // Build validation sets once
        let variable_ids: VariableIDSet = self.decision_variables.keys().cloned().collect();
        let dependency_keys: VariableIDSet = self.decision_variable_dependency.keys().collect();
        let fixed_ids: VariableIDSet = self
            .fixed_decision_variable_values()
            .keys()
            .copied()
            .collect();

        // Validate all constraints first (atomic: fail before any insertion)
        for (_, constraint) in &constraints {
            let required_ids = constraint.required_ids();
            Self::validate_required_ids_with_sets(
                &required_ids,
                &variable_ids,
                &dependency_keys,
                &fixed_ids,
            )?;
        }

        // Insert all constraints (validation already done)
        let mut replaced = BTreeMap::new();
        for (id, constraint) in constraints {
            if let Some(old_constraint) = self.apply_validated_constraint_insert(id, constraint)? {
                replaced.insert(id, old_constraint);
            }
        }

        Ok(replaced)
    }

    /// Returns the next available ConstraintID.
    ///
    /// Finds the maximum ID from both active constraints and removed constraints,
    /// then adds 1. If there are no constraints, returns ConstraintID(0).
    ///
    /// Note: This method does not track which IDs have been allocated.
    /// Consecutive calls will return the same ID until a constraint is actually added.
    pub fn next_constraint_id(&self) -> ConstraintID {
        let max_in_constraints = self
            .constraints()
            .last_key_value()
            .map(|(id, _)| id.into_inner());
        let max_in_removed = self
            .removed_constraints()
            .last_key_value()
            .map(|(id, _)| id.into_inner());

        max_in_constraints
            .max(max_in_removed)
            .map(|max| ConstraintID::from(max + 1))
            .unwrap_or(ConstraintID::from(0))
    }
}

impl ParametricInstance {
    /// Validate that all required IDs are defined either as decision variables
    /// or as parameters, and are not currently used as substitution-dependency
    /// keys.
    ///
    /// `ParametricInstance` validation differs from
    /// [`Instance::validate_required_ids`](Instance) by also accepting
    /// parameter IDs — constraints in a parametric instance may reference
    /// parameters that will be substituted later via
    /// [`ParametricInstance::with_parameters`].
    fn validate_required_ids(&self, required_ids: VariableIDSet) -> crate::Result<()> {
        let variable_ids: VariableIDSet = self.decision_variables().keys().cloned().collect();
        let parameter_ids: VariableIDSet = self.parameters().keys().cloned().collect();
        let known_ids: VariableIDSet = variable_ids.union(&parameter_ids).cloned().collect();
        let dependency_keys: VariableIDSet = self.decision_variable_dependency().keys().collect();
        let fixed_ids: VariableIDSet = self
            .fixed_decision_variable_values()
            .keys()
            .copied()
            .collect();

        if !required_ids.is_subset(&known_ids) {
            let id = *required_ids.difference(&known_ids).next().unwrap();
            crate::bail!({ ?id }, "Undefined variable ID is used: {id:?}");
        }
        if let Some(&id) = required_ids.intersection(&dependency_keys).next() {
            crate::bail!(
                { ?id },
                "Dependent variable cannot be used in objectives or constraints: {id:?}",
            );
        }
        if let Some(&id) = required_ids.intersection(&fixed_ids).next() {
            crate::bail!(
                { ?id },
                "Fixed variable {id:?} cannot be used in objectives or constraints",
            );
        }
        Ok(())
    }

    /// Insert a new constraint with its context, picking an unused id.
    ///
    /// Mirrors [`Instance::add_constraint`] for parametric instances.
    /// Returns the newly assigned [`ConstraintID`]. The context is drained
    /// into the per-constraint [`ConstraintContextStore`]; pass
    /// [`ConstraintContext::default`](crate::ConstraintContext) for an
    /// unannotated constraint.
    ///
    /// All IDs referenced by the constraint must already be present in either
    /// `decision_variables` or `parameters`, and must not be substitution-
    /// dependency keys.
    pub fn add_constraint(
        &mut self,
        constraint: Constraint,
        context: crate::ConstraintContext,
    ) -> crate::Result<ConstraintID> {
        self.validate_required_ids(constraint.required_ids())?;
        let id = self.constraint_collection.unused_id();
        self.constraint_collection
            .insert_active_with_context(id, constraint, context)?;
        Ok(id)
    }

    /// Validate that the given ids are real decision variables (not parameters).
    ///
    /// Used for *structural* positions in special constraints — the indicator
    /// variable and the variable sets of one-hot / SOS1 — where parameter ids
    /// would not be substitutable in a way that preserves the constraint's
    /// semantics. Function-body ids continue to be validated through
    /// [`Self::validate_required_ids`], which permits parameters.
    fn require_decision_variables(&self, ids: VariableIDSet) -> crate::Result<()> {
        let variable_ids: VariableIDSet = self.decision_variables().keys().cloned().collect();
        if !ids.is_subset(&variable_ids) {
            let id = *ids.difference(&variable_ids).next().unwrap();
            if self.parameters().contains_key(&id) {
                crate::bail!(
                    { ?id },
                    "Parameter id {id:?} cannot occupy a structural variable position; \
                     structural variables in indicator / one-hot / SOS1 constraints \
                     must be decision variables",
                );
            }
            crate::bail!({ ?id }, "Undefined variable ID is used: {id:?}");
        }
        Ok(())
    }

    /// Verify that the given id is a binary decision variable. Mirrors
    /// [`Instance::require_binary_variable`](Instance) for the parametric
    /// host. Parameter ids are rejected because they are not decision
    /// variables in the first place — the matching error message points
    /// at the structural-position rule from
    /// [`Self::require_decision_variables`].
    fn require_binary_variable(&self, id: VariableID) -> crate::Result<()> {
        let dv = self.decision_variables().get(&id).ok_or_else(|| {
            if self.parameters().contains_key(&id) {
                crate::error!(
                    "Parameter id {id:?} cannot occupy a structural variable position; \
                     it must be a binary decision variable",
                )
            } else {
                crate::error!("Variable {id:?} is not defined in decision_variables")
            }
        })?;
        if dv.kind() != crate::decision_variable::Kind::Binary {
            crate::bail!({ ?id }, "Variable {id:?} must be binary");
        }
        Ok(())
    }

    /// Insert a new indicator constraint with its context, picking an unused id.
    ///
    /// Mirrors [`Instance::add_indicator_constraint`] for parametric
    /// instances. The function body may reference either decision variables
    /// or parameters, but the indicator variable itself must be a binary
    /// decision variable — substitution cannot replace a structural variable
    /// position, and the indicator semantics require `Kind::Binary`.
    pub fn add_indicator_constraint(
        &mut self,
        constraint: crate::IndicatorConstraint,
        context: crate::ConstraintContext,
    ) -> crate::Result<crate::IndicatorConstraintID> {
        // Structural position: the indicator variable must be a binary
        // decision variable, not a parameter or a non-binary variable.
        self.require_binary_variable(constraint.indicator_variable)?;
        // `validate_required_ids` (variables ∪ parameters minus dependency
        // keys) is allowed to see the indicator variable here too: the
        // variable-vs-parameter axis is already enforced above, so this
        // call's only added contribution for the indicator variable is the
        // dependency-key check.
        self.validate_required_ids(constraint.required_ids())?;
        let id = self.indicator_constraint_collection.unused_id();
        self.indicator_constraint_collection
            .insert_active_with_context(id, constraint, context)?;
        Ok(id)
    }

    /// Insert a new one-hot constraint with its context, picking an unused id.
    ///
    /// The one-hot set must be non-empty. All variables in the set are
    /// structural and must be binary decision variables (parameter ids and
    /// non-binary kinds are rejected). Dependency keys are also rejected.
    pub fn add_one_hot_constraint(
        &mut self,
        constraint: crate::OneHotConstraint,
        context: crate::ConstraintContext,
    ) -> crate::Result<crate::OneHotConstraintID> {
        validate_one_hot_non_empty(&constraint)?;
        for var_id in &constraint.variables {
            self.require_binary_variable(*var_id)?;
        }
        self.validate_required_ids(constraint.required_ids())?;
        let id = self.one_hot_constraint_collection.unused_id();
        self.one_hot_constraint_collection
            .insert_active_with_context(id, constraint, context)?;
        Ok(id)
    }

    /// Insert a new SOS1 constraint with its context, picking an unused id.
    ///
    /// All variables in the SOS1 set are structural and must be decision
    /// variables (parameter ids are rejected). The set must be non-empty.
    /// Dependency keys are also rejected. Unlike one-hot, SOS1 does not
    /// require `Kind::Binary`.
    pub fn add_sos1_constraint(
        &mut self,
        constraint: crate::Sos1Constraint,
        context: crate::ConstraintContext,
    ) -> crate::Result<crate::Sos1ConstraintID> {
        validate_sos1_non_empty(&constraint)?;
        let required_ids = constraint.required_ids();
        self.require_decision_variables(required_ids.clone())?;
        self.validate_required_ids(required_ids)?;
        let id = self.sos1_constraint_collection.unused_id();
        self.sos1_constraint_collection
            .insert_active_with_context(id, constraint, context)?;
        Ok(id)
    }

    /// Insert a decision variable with its modeling label.
    ///
    /// The table key must not collide with any existing decision
    /// variable, parameter, or substitution-dependency key.
    ///
    /// # Errors
    ///
    /// Returns an error whose chain contains
    /// [`crate::DecisionVariableError::DuplicateID`] when `id` is already
    /// owned by a decision variable, or
    /// [`crate::ParameterIDCollision`] when it is already owned by a
    /// parameter.
    pub fn add_decision_variable(
        &mut self,
        id: crate::VariableID,
        variable: crate::DecisionVariable,
        label: crate::DecisionVariableLabel,
    ) -> crate::Result<crate::VariableID> {
        let has_decision_variable = self.decision_variables().contains_key(&id);
        if !has_decision_variable && self.parameters().contains_key(&id) {
            return Err(crate::ParameterIDCollision { id }.into());
        }
        if !has_decision_variable && self.decision_variable_dependency().keys().any(|k| k == id) {
            crate::bail!(
                { ?id },
                "Variable id {id:?} is currently used as a substitution-dependency key",
            );
        }
        self.decision_variables
            .insert(id, variable, label, None, crate::ATol::default())?;
        Ok(id)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        assign, coeff,
        constraint::{Constraint, ConstraintID},
        linear,
        polynomial_base::{Linear, LinearMonomial},
        DecisionVariable, Function, ParameterIDCollision, ParameterTable, Substitute, VariableID,
    };

    use maplit::btreemap;
    use std::collections::BTreeSet;

    fn empty_one_hot_constraint() -> crate::OneHotConstraint {
        crate::OneHotConstraint {
            variables: BTreeSet::new(),
            stage: crate::OneHotCreatedData,
        }
    }

    fn empty_sos1_constraint() -> crate::Sos1Constraint {
        crate::Sos1Constraint {
            variables: BTreeSet::new(),
            stage: crate::Sos1CreatedData,
        }
    }

    #[test]
    fn add_decision_variable_preserves_duplicate_id_signal() {
        let id = VariableID::from(7);
        let mut instance = Instance::new(
            Sense::Minimize,
            Function::Zero,
            btreemap! { id => DecisionVariable::binary() },
            BTreeMap::new(),
        )
        .unwrap();

        let error = instance
            .add_decision_variable(
                id,
                DecisionVariable::binary(),
                crate::DecisionVariableLabel::default(),
            )
            .unwrap_err();

        assert!(matches!(
            error.downcast_ref::<crate::DecisionVariableError>(),
            Some(crate::DecisionVariableError::DuplicateID { id: duplicate }) if *duplicate == id
        ));
        assert_eq!(instance.decision_variables().len(), 1);
    }

    #[test]
    fn parametric_add_decision_variable_preserves_substituted_duplicate_signal() {
        let independent = VariableID::from(0);
        let dependent = VariableID::from(7);
        let instance = ParametricInstance::new(
            Sense::Minimize,
            Function::from(linear!(dependent.into_inner())),
            btreemap! {
                independent => DecisionVariable::binary(),
                dependent => DecisionVariable::binary(),
            },
            ParameterTable::default(),
            BTreeMap::new(),
        )
        .unwrap();
        let mut instance = instance
            .substitute_one(
                dependent,
                &Function::from(linear!(independent.into_inner())),
            )
            .unwrap();

        let error = instance
            .add_decision_variable(
                dependent,
                DecisionVariable::binary(),
                crate::DecisionVariableLabel::default(),
            )
            .unwrap_err();

        assert!(matches!(
            error.downcast_ref::<crate::DecisionVariableError>(),
            Some(crate::DecisionVariableError::DuplicateID { id }) if id == &dependent
        ));
        assert_eq!(instance.decision_variables().len(), 2);
    }

    #[test]
    fn add_decision_variable_preserves_parameter_id_collision_signal() {
        let parameter = VariableID::from(100);
        let mut instance = ParametricInstance::new(
            Sense::Minimize,
            Function::Zero,
            BTreeMap::new(),
            ParameterTable::from_ids(BTreeSet::from([parameter])),
            BTreeMap::new(),
        )
        .unwrap();

        let error = instance
            .add_decision_variable(
                parameter,
                DecisionVariable::binary(),
                crate::DecisionVariableLabel::default(),
            )
            .unwrap_err();

        assert!(matches!(
            error.downcast_ref::<ParameterIDCollision>(),
            Some(ParameterIDCollision { id }) if *id == parameter
        ));
        assert!(instance.decision_variables().is_empty());
    }

    #[test]
    fn test_insert_constraint_success() {
        // Create a simple instance with two decision variables
        let decision_variables = btreemap! {
            VariableID::from(1) => DecisionVariable::binary(),
            VariableID::from(2) => DecisionVariable::binary(),
        };

        let objective = linear!(1) + coeff!(1.0);

        let mut instance = Instance::new(
            Sense::Minimize,
            objective.into(),
            decision_variables,
            BTreeMap::new(),
        )
        .unwrap();

        // Insert a new constraint using variable 1
        let constraint = Constraint::equal_to_zero((linear!(1) + coeff!(2.0)).into());
        let result = instance
            .insert_constraint(ConstraintID::from(10), constraint.clone())
            .unwrap();

        // Should return None since no constraint with ID 10 existed before
        assert!(result.is_none());
        assert_eq!(instance.constraints().len(), 1);
        assert_eq!(
            instance.constraints().get(&ConstraintID::from(10)),
            Some(&constraint)
        );
    }

    #[test]
    fn test_insert_constraint_replace_existing() {
        // Create instance with one constraint
        let mut decision_variables = BTreeMap::new();
        decision_variables.insert(VariableID::from(1), DecisionVariable::binary());
        decision_variables.insert(VariableID::from(2), DecisionVariable::binary());

        let objective = Function::Linear(Linear::single_term(
            LinearMonomial::Variable(VariableID::from(1)),
            coeff!(1.0),
        ));

        let mut constraints = BTreeMap::new();
        let original_constraint = Constraint::equal_to_zero((linear!(1) + coeff!(1.0)).into());
        constraints.insert(ConstraintID::from(5), original_constraint.clone());

        let mut instance =
            Instance::new(Sense::Minimize, objective, decision_variables, constraints).unwrap();

        // Insert a new constraint with the same ID but using variable 2
        let new_constraint = Constraint::equal_to_zero((linear!(2) + coeff!(1.0)).into());
        let result = instance
            .insert_constraint(ConstraintID::from(5), new_constraint.clone())
            .unwrap();

        // Should return the old constraint that was replaced
        assert_eq!(result, Some(original_constraint));
        assert_eq!(instance.constraints().len(), 1);
        assert_eq!(
            instance.constraints().get(&ConstraintID::from(5)),
            Some(&new_constraint)
        );
    }

    #[test]
    fn test_insert_constraint_undefined_variable() {
        // Create instance with only variable 1 and 2
        let mut decision_variables = BTreeMap::new();
        decision_variables.insert(VariableID::from(1), DecisionVariable::binary());
        decision_variables.insert(VariableID::from(2), DecisionVariable::binary());

        let objective = Function::Linear(Linear::single_term(
            LinearMonomial::Variable(VariableID::from(1)),
            coeff!(1.0),
        ));

        let mut instance = Instance::new(
            Sense::Minimize,
            objective,
            decision_variables,
            BTreeMap::new(),
        )
        .unwrap();

        // Try to insert constraint using undefined variable 999
        let constraint = Constraint::equal_to_zero((linear!(999) + coeff!(1.0)).into());
        let result = instance.insert_constraint(ConstraintID::from(1), constraint);

        // Should fail with undefined variable error
        assert!(result.is_err());
        let err = result.unwrap_err();
        assert_eq!(
            err.to_string(),
            "Undefined variable ID is used: VariableID(999)"
        );
        // Ensure no constraint was added
        assert_eq!(instance.constraints().len(), 0);
    }

    #[test]
    fn test_insert_constraint_multiple_operations() {
        // Test multiple insertions and replacements
        let mut decision_variables = BTreeMap::new();
        decision_variables.insert(VariableID::from(1), DecisionVariable::binary());
        decision_variables.insert(VariableID::from(2), DecisionVariable::binary());
        decision_variables.insert(VariableID::from(3), DecisionVariable::binary());

        let objective = Function::Linear(Linear::single_term(
            LinearMonomial::Variable(VariableID::from(1)),
            coeff!(1.0),
        ));

        let mut instance = Instance::new(
            Sense::Minimize,
            objective,
            decision_variables,
            BTreeMap::new(),
        )
        .unwrap();

        // Insert multiple constraints
        let constraint1 = Constraint::equal_to_zero((linear!(1) + coeff!(1.0)).into());
        let constraint2 = Constraint::equal_to_zero((linear!(2) + coeff!(1.0)).into());
        let constraint3 = Constraint::equal_to_zero((linear!(3) + coeff!(1.0)).into());

        assert!(instance
            .insert_constraint(ConstraintID::from(1), constraint1.clone())
            .unwrap()
            .is_none());
        assert!(instance
            .insert_constraint(ConstraintID::from(2), constraint2.clone())
            .unwrap()
            .is_none());
        assert!(instance
            .insert_constraint(ConstraintID::from(3), constraint3.clone())
            .unwrap()
            .is_none());
        assert_eq!(instance.constraints().len(), 3);

        // Replace constraint 2 with new one
        let new_constraint2 = Constraint::equal_to_zero((linear!(1) + coeff!(1.0)).into());
        let replaced = instance
            .insert_constraint(ConstraintID::from(2), new_constraint2.clone())
            .unwrap();
        assert_eq!(replaced, Some(constraint2));
        assert_eq!(instance.constraints().len(), 3);
        assert_eq!(
            instance.constraints().get(&ConstraintID::from(2)),
            Some(&new_constraint2)
        );
    }

    #[test]
    fn test_insert_constraint_with_dependency_key() {
        // Create instance with decision variables and dependency
        let decision_variables = btreemap! {
            VariableID::from(1) => DecisionVariable::binary(),
            VariableID::from(2) => DecisionVariable::binary(),
            VariableID::from(3) => DecisionVariable::binary(),
        };
        let objective = linear!(1) + coeff!(1.0);
        let mut instance = Instance::new(
            Sense::Minimize,
            objective.into(),
            decision_variables,
            BTreeMap::new(),
        )
        .unwrap();

        // Add a dependency: x2 = x1 + 1
        instance.decision_variable_dependency = assign! {
            2 <- linear!(1) + coeff!(1.0)
        };

        // Try to insert constraint using variable 2 (which is in dependency keys)
        let constraint = Constraint::equal_to_zero((linear!(2) + coeff!(1.0)).into());
        let result = instance.insert_constraint(ConstraintID::from(1), constraint);
        assert_eq!(
            result.unwrap_err().to_string(),
            "Dependent variable cannot be used in objectives or constraints: VariableID(2)"
        );
        // Ensure no constraint was added
        assert_eq!(instance.constraints().len(), 0);
    }

    #[test]
    fn test_add_constraint_rejects_fixed_variable() {
        // Pin variable 2's value, then try to add a constraint that references it.
        // The setter must reject — same rule the builder enforces (used ∩ fixed = ∅).
        let decision_variables = btreemap! {
            VariableID::from(1) => DecisionVariable::binary(),
            VariableID::from(2) => DecisionVariable::binary(),
        };

        let objective = linear!(1) + coeff!(1.0);
        let mut instance = Instance::builder()
            .sense(Sense::Minimize)
            .objective(objective.into())
            .decision_variables(decision_variables)
            .fixed_decision_variable_values(btreemap! {
                VariableID::from(2) => 0.0,
            })
            .constraints(BTreeMap::new())
            .build()
            .unwrap();

        let bad = crate::Constraint::equal_to_zero((linear!(2) + coeff!(1.0)).into());
        let err = instance
            .add_constraint(bad, crate::ConstraintContext::default())
            .unwrap_err();
        assert!(
            err.to_string().contains("Fixed variable") && err.to_string().contains("VariableID(2)"),
            "unexpected error: {err}"
        );
        assert!(instance.constraints().is_empty());
    }

    #[test]
    fn test_add_one_hot_constraint_rejects_empty_variable_set() {
        let mut instance = Instance::new(
            Sense::Minimize,
            Function::Zero,
            BTreeMap::new(),
            BTreeMap::new(),
        )
        .unwrap();

        let err = instance
            .add_one_hot_constraint(
                empty_one_hot_constraint(),
                crate::ConstraintContext::default(),
            )
            .unwrap_err();

        assert!(matches!(
            err.downcast_ref::<crate::OneHotConstraintError>(),
            Some(crate::OneHotConstraintError::EmptyVariables)
        ));
        assert!(
            err.to_string().contains("at least one variable"),
            "unexpected error: {err}"
        );
        assert!(instance.one_hot_constraints().is_empty());
    }

    #[test]
    fn test_parametric_add_one_hot_constraint_rejects_empty_variable_set() {
        let mut instance = ParametricInstance::new(
            Sense::Minimize,
            Function::Zero,
            BTreeMap::new(),
            crate::ParameterTable::default(),
            BTreeMap::new(),
        )
        .unwrap();

        let err = instance
            .add_one_hot_constraint(
                empty_one_hot_constraint(),
                crate::ConstraintContext::default(),
            )
            .unwrap_err();

        assert!(matches!(
            err.downcast_ref::<crate::OneHotConstraintError>(),
            Some(crate::OneHotConstraintError::EmptyVariables)
        ));
        assert!(
            err.to_string().contains("at least one variable"),
            "unexpected error: {err}"
        );
        assert!(instance.one_hot_constraints().is_empty());
    }

    #[test]
    fn test_add_sos1_constraint_rejects_empty_variable_set() {
        let mut instance = Instance::new(
            Sense::Minimize,
            Function::Zero,
            BTreeMap::new(),
            BTreeMap::new(),
        )
        .unwrap();

        let err = instance
            .add_sos1_constraint(empty_sos1_constraint(), crate::ConstraintContext::default())
            .unwrap_err();

        assert!(matches!(
            err.downcast_ref::<crate::Sos1ConstraintError>(),
            Some(crate::Sos1ConstraintError::EmptyVariables)
        ));
        assert!(instance.sos1_constraints().is_empty());
    }

    #[test]
    fn test_parametric_add_sos1_constraint_rejects_empty_variable_set() {
        let mut instance = ParametricInstance::new(
            Sense::Minimize,
            Function::Zero,
            BTreeMap::new(),
            crate::ParameterTable::default(),
            BTreeMap::new(),
        )
        .unwrap();

        let err = instance
            .add_sos1_constraint(empty_sos1_constraint(), crate::ConstraintContext::default())
            .unwrap_err();

        assert!(matches!(
            err.downcast_ref::<crate::Sos1ConstraintError>(),
            Some(crate::Sos1ConstraintError::EmptyVariables)
        ));
        assert!(instance.sos1_constraints().is_empty());
    }

    #[test]
    fn test_set_objective_with_dependency_key() {
        // Create instance with decision variables and dependency
        let decision_variables = btreemap! {
            VariableID::from(1) => DecisionVariable::binary(),
            VariableID::from(2) => DecisionVariable::binary(),
        };
        let objective = linear!(1) + coeff!(1.0);
        let mut instance = Instance::new(
            Sense::Minimize,
            objective.into(),
            decision_variables,
            BTreeMap::new(),
        )
        .unwrap();

        // Add a dependency: x2 = x1 + 1
        instance.decision_variable_dependency = assign! {
            2 <- linear!(1) + coeff!(1.0)
        };

        // Try to set objective using variable 2 (which is in dependency keys)
        let new_objective = linear!(2) + coeff!(1.0);
        let result = instance.set_objective(new_objective.into());

        // Should fail with DependentVariableUsed error
        assert_eq!(
            result.unwrap_err().to_string(),
            "Dependent variable cannot be used in objectives or constraints: VariableID(2)"
        );
        // Ensure objective was not changed
        assert_eq!(instance.objective, Function::from(linear!(1) + coeff!(1.0)));
    }

    #[test]
    fn test_insert_constraint_replace_removed_constraint() {
        // Create instance with one active constraint and one removed constraint
        let decision_variables = btreemap! {
            VariableID::from(1) => DecisionVariable::binary(),
            VariableID::from(2) => DecisionVariable::binary(),
        };

        let objective = (linear!(1) + coeff!(1.0)).into();
        let constraints = btreemap! {
            ConstraintID::from(1) => Constraint::equal_to_zero((linear!(1) + coeff!(1.0)).into(),
            ),
            ConstraintID::from(2) => Constraint::equal_to_zero((linear!(2) + coeff!(2.0)).into(),
            ),
        };

        let mut instance =
            Instance::new(Sense::Minimize, objective, decision_variables, constraints).unwrap();
        instance
            .relax_constraint(ConstraintID::from(2), "test".to_string(), [])
            .unwrap();

        // Verify initial state
        assert_eq!(instance.constraints().len(), 1);
        assert_eq!(instance.removed_constraints().len(), 1);

        // Insert a new constraint with the same ID as the removed constraint
        let new_constraint = Constraint::equal_to_zero(
            ((linear!(1) + linear!(2)).unwrap() + coeff!(3.0))
                .unwrap()
                .into(),
        );
        let result = instance
            .insert_constraint(ConstraintID::from(2), new_constraint.clone())
            .unwrap();

        // Should return the old removed constraint
        assert_eq!(
            result,
            Some(Constraint::equal_to_zero((linear!(2) + coeff!(2.0)).into(),))
        );

        assert_eq!(instance.constraints().len(), 1);
        assert_eq!(instance.removed_constraints().len(), 1);
        let (removed, _reason) = instance
            .removed_constraints()
            .get(&ConstraintID::from(2))
            .unwrap();
        assert_eq!(removed.equality, new_constraint.equality);
        assert_eq!(removed.stage.function, new_constraint.stage.function);
    }

    #[test]
    fn test_insert_constraints_bulk() {
        // Create instance with decision variables
        let decision_variables = btreemap! {
            VariableID::from(1) => DecisionVariable::binary(),
            VariableID::from(2) => DecisionVariable::binary(),
            VariableID::from(3) => DecisionVariable::binary(),
        };
        let objective = linear!(1) + coeff!(1.0);
        let mut instance = Instance::new(
            Sense::Minimize,
            objective.into(),
            decision_variables,
            BTreeMap::new(),
        )
        .unwrap();

        // Insert multiple constraints at once
        let constraints = vec![
            (
                ConstraintID::from(1),
                Constraint::equal_to_zero((linear!(1) + coeff!(1.0)).into()),
            ),
            (
                ConstraintID::from(2),
                Constraint::equal_to_zero((linear!(2) + coeff!(2.0)).into()),
            ),
            (
                ConstraintID::from(3),
                Constraint::equal_to_zero((linear!(3) + coeff!(3.0)).into()),
            ),
        ];

        let replaced = instance.insert_constraints(constraints.clone()).unwrap();

        // No constraints were replaced since none existed before
        assert!(replaced.is_empty());
        assert_eq!(instance.constraints().len(), 3);

        // Verify constraints were inserted correctly
        for (id, constraint) in &constraints {
            assert_eq!(instance.constraints().get(id), Some(constraint));
        }
    }

    #[test]
    fn test_insert_constraints_bulk_with_undefined_variable() {
        // Create instance with only variables 1 and 2
        let decision_variables = btreemap! {
            VariableID::from(1) => DecisionVariable::binary(),
            VariableID::from(2) => DecisionVariable::binary(),
        };
        let objective = linear!(1) + coeff!(1.0);
        let mut instance = Instance::new(
            Sense::Minimize,
            objective.into(),
            decision_variables,
            BTreeMap::new(),
        )
        .unwrap();

        // Try to insert constraints where one uses undefined variable 999
        let constraints = vec![
            (
                ConstraintID::from(1),
                Constraint::equal_to_zero((linear!(1) + coeff!(1.0)).into()),
            ),
            (
                ConstraintID::from(2),
                Constraint::equal_to_zero((linear!(999) + coeff!(2.0)).into()),
            ),
            (
                ConstraintID::from(3),
                Constraint::equal_to_zero((linear!(2) + coeff!(3.0)).into()),
            ),
        ];

        let result = instance.insert_constraints(constraints);

        // Should fail with undefined variable error
        assert!(result.is_err());
        assert_eq!(
            result.unwrap_err().to_string(),
            "Undefined variable ID is used: VariableID(999)"
        );
        // Ensure no constraints were added (atomic operation)
        assert_eq!(instance.constraints().len(), 0);
    }

    #[test]
    fn test_insert_constraints_bulk_replace_existing() {
        // Create instance with existing constraints
        let decision_variables = btreemap! {
            VariableID::from(1) => DecisionVariable::binary(),
            VariableID::from(2) => DecisionVariable::binary(),
        };
        let objective = linear!(1) + coeff!(1.0);
        let constraints = btreemap! {
            ConstraintID::from(1) => Constraint::equal_to_zero((linear!(1) + coeff!(1.0)).into(),
            ),
            ConstraintID::from(2) => Constraint::equal_to_zero((linear!(2) + coeff!(2.0)).into(),
            ),
        };
        let mut instance = Instance::new(
            Sense::Minimize,
            objective.into(),
            decision_variables,
            constraints,
        )
        .unwrap();

        // Replace constraint 1, add constraint 3
        let new_constraints = vec![
            (
                ConstraintID::from(1),
                Constraint::equal_to_zero((linear!(2) + coeff!(10.0)).into()),
            ),
            (
                ConstraintID::from(3),
                Constraint::equal_to_zero((linear!(1) + coeff!(3.0)).into()),
            ),
        ];

        let replaced = instance
            .insert_constraints(new_constraints.clone())
            .unwrap();

        // Should have replaced constraint 1
        assert_eq!(replaced.len(), 1);
        assert!(replaced.contains_key(&ConstraintID::from(1)));
        assert_eq!(instance.constraints().len(), 3);
    }

    #[test]
    fn test_insert_constraints_bulk_replace_removed() {
        // Create instance with a removed constraint
        let decision_variables = btreemap! {
            VariableID::from(1) => DecisionVariable::binary(),
            VariableID::from(2) => DecisionVariable::binary(),
        };
        let objective = linear!(1) + coeff!(1.0);
        let constraints = btreemap! {
            ConstraintID::from(1) => Constraint::equal_to_zero((linear!(1) + coeff!(1.0)).into(),
            ),
        };
        let mut instance = Instance::new(
            Sense::Minimize,
            objective.into(),
            decision_variables,
            constraints,
        )
        .unwrap();

        // Remove constraint 1
        instance
            .relax_constraint(ConstraintID::from(1), "test".to_string(), [])
            .unwrap();
        assert_eq!(instance.constraints().len(), 0);
        assert_eq!(instance.removed_constraints().len(), 1);

        // Replace the removed constraint
        let new_constraints = vec![(
            ConstraintID::from(1),
            Constraint::equal_to_zero((linear!(2) + coeff!(10.0)).into()),
        )];

        let replaced = instance.insert_constraints(new_constraints).unwrap();

        // Should have replaced the removed constraint
        assert_eq!(replaced.len(), 1);
        assert!(replaced.contains_key(&ConstraintID::from(1)));
        // Constraint is still in removed_constraints (with updated content)
        assert_eq!(instance.removed_constraints().len(), 1);
    }

    #[test]
    fn test_insert_constraints_bulk_with_dependent_variable() {
        // Create instance with decision variables and dependency
        let decision_variables = btreemap! {
            VariableID::from(1) => DecisionVariable::binary(),
            VariableID::from(2) => DecisionVariable::binary(),
            VariableID::from(3) => DecisionVariable::binary(),
        };
        let objective = linear!(1) + coeff!(1.0);
        let mut instance = Instance::new(
            Sense::Minimize,
            objective.into(),
            decision_variables,
            BTreeMap::new(),
        )
        .unwrap();

        // Add a dependency: x2 = x1 + 1
        instance.decision_variable_dependency = assign! {
            2 <- linear!(1) + coeff!(1.0)
        };

        // Try to insert constraints using variable 2 (which is in dependency keys)
        let constraints = vec![
            (
                ConstraintID::from(1),
                Constraint::equal_to_zero((linear!(1) + coeff!(1.0)).into()),
            ),
            (
                ConstraintID::from(2),
                Constraint::equal_to_zero((linear!(2) + coeff!(2.0)).into()),
            ),
        ];

        let result = instance.insert_constraints(constraints);

        // Should fail with DependentVariableUsed error
        assert!(result.is_err());
        assert_eq!(
            result.unwrap_err().to_string(),
            "Dependent variable cannot be used in objectives or constraints: VariableID(2)"
        );
        // Ensure no constraints were added (atomic operation)
        assert_eq!(instance.constraints().len(), 0);
    }

    #[test]
    fn test_next_constraint_id() {
        // Test basic case: empty instance
        let decision_variables = btreemap! {
            VariableID::from(1) => DecisionVariable::binary(),
        };
        let objective = (linear!(1) + coeff!(1.0)).into();
        let instance = Instance::new(
            Sense::Minimize,
            objective,
            decision_variables,
            BTreeMap::new(),
        )
        .unwrap();
        assert_eq!(instance.next_constraint_id(), ConstraintID::from(0));

        // Test considering both active and removed constraints
        let decision_variables = btreemap! {
            VariableID::from(1) => DecisionVariable::binary(),
        };
        let objective = (linear!(1) + coeff!(1.0)).into();
        let constraints = btreemap! {
            ConstraintID::from(3) => Constraint::equal_to_zero((linear!(1) + coeff!(1.0)).into(),
            ),
            ConstraintID::from(15) => Constraint::equal_to_zero((linear!(1) + coeff!(2.0)).into(),
            ),
        };
        let mut instance =
            Instance::new(Sense::Minimize, objective, decision_variables, constraints).unwrap();
        instance
            .relax_constraint(ConstraintID::from(15), "test".to_string(), [])
            .unwrap();

        // Should return 16 (max(3, 15) + 1)
        assert_eq!(instance.next_constraint_id(), ConstraintID::from(16));
    }
}