#include <internal.hpp>

Collaboration diagram for CaDiCaL::Internal:

[legend]

Public Types
enum	Mode { BLOCK = (1 << 0) , CONDITION = (1 << 1) , CONGRUENCE = (1 << 2) , COVER = (1 << 3) , DECOMP = (1 << 4) , DEDUP = (1 << 5) , ELIM = (1 << 6) , FACTOR = (1 << 7) , LUCKY = (1 << 8) , PROBE = (1 << 9) , SEARCH = (1 << 10) , SIMPLIFY = (1 << 11) , SUBSUME = (1 << 12) , SWEEP = (1 << 13) , TERNARY = (1 << 14) , TRANSRED = (1 << 15) , VIVIFY = (1 << 16) , WALK = (1 << 17) }

Public Member Functions
bool	in_mode (Mode m) const

void	set_mode (Mode m)

void	reset_mode (Mode m)

void	require_mode (Mode m) const

	Internal ()

	~Internal ()

void	init_vars (int new_max_var)

void	init_enqueue (int idx)

void	init_queue (int old_max_var, int new_max_var)

void	init_scores (int old_max_var, int new_max_var)

void	add_original_lit (int lit)

void	finish_added_clause_with_id (int64_t id, bool restore=false)

void	reserve_ids (int number)

void	enlarge_vals (size_t new_vsize)

void	enlarge (int new_max_var)

bool	active (int lit)

int	active () const

void	reactivate (int lit)

int64_t	redundant () const

int64_t	irredundant () const

double	clause_variable_ratio () const

double	scale (double v) const

int	vidx (int lit) const

unsigned	vlit (int lit) const

int	u2i (unsigned u)

int	citten2lit (unsigned ulit)

unsigned	lit2citten (int lit)

int64_t	unit_id (int lit) const

int64_t &	unit_clauses (int uidx)

Var &	var (int lit)

Link &	link (int lit)

Flags &	flags (int lit)

int64_t &	bumped (int lit)

int &	propfixed (int lit)

double &	score (int lit)

const Flags &	flags (int lit) const

bool	occurring () const

bool	watching () const

Bins &	bins (int lit)

Occs &	occs (int lit)

int64_t &	noccs (int lit)

Watches &	watches (int lit)

bool	use_scores () const

void	bump_variable_score (int lit)

void	bump_variable_score_inc ()

void	rescale_variable_scores ()

signed char	marked (int lit) const

void	mark (int lit)

void	unmark (int lit)

signed char	marked67 (int lit) const

void	mark67 (int lit)

void	unmark67 (int lit)

void	unmark (vector< int > &lits)

bool	getbit (int lit, int bit) const

void	setbit (int lit, int bit)

void	unsetbit (int lit, int bit)

bool	marked2 (int lit) const

void	mark2 (int lit)

bool	getfact (int lit, int fact) const

void	markfact (int lit, int fact)

void	unmarkfact (int lit, int fact)

void	mark_clause ()

void	mark (Clause *)

void	mark2 (Clause *)

void	unmark_clause ()

void	unmark (Clause *)

void	watch_literal (int lit, int blit, Clause *c)

void	watch_clause (Clause *c)

void	unwatch_clause (Clause *c)

void	update_queue_unassigned (int idx)

void	bump_queue (int idx)

void	mark_eliminated (int)

void	mark_substituted (int)

void	mark_active (int)

void	mark_fixed (int)

void	mark_pure (int)

Clause *	new_clause (bool red, int glue=0)

void	promote_clause (Clause *, int new_glue)

void	promote_clause_glue_only (Clause *, int new_glue)

size_t	shrink_clause (Clause *, int new_size)

void	minimize_sort_clause ()

void	shrink_and_minimize_clause ()

void	reset_shrinkable ()

void	mark_shrinkable_as_removable (int, std::vector< int >::size_type)

int	shrink_literal (int, int, unsigned)

unsigned	shrunken_block_uip (int, int, std::vector< int >::reverse_iterator &, std::vector< int >::reverse_iterator &, std::vector< int >::size_type, const int)

void	shrunken_block_no_uip (const std::vector< int >::reverse_iterator &, const std::vector< int >::reverse_iterator &, unsigned &, const int)

void	push_literals_of_block (const std::vector< int >::reverse_iterator &, const std::vector< int >::reverse_iterator &, int, unsigned)

unsigned	shrink_next (int, unsigned &, unsigned &)

std::vector< int >::reverse_iterator	minimize_and_shrink_block (std::vector< int >::reverse_iterator &, unsigned int &, unsigned int &, const int)

unsigned	shrink_block (std::vector< int >::reverse_iterator &, std::vector< int >::reverse_iterator &, int, unsigned &, unsigned &, const int, unsigned)

unsigned	shrink_along_reason (int, int, bool, bool &, unsigned)

void	deallocate_clause (Clause *)

void	delete_clause (Clause *)

void	mark_garbage (Clause *)

void	assign_original_unit (int64_t, int)

void	add_new_original_clause (int64_t)

Clause *	new_learned_redundant_clause (int glue)

Clause *	new_hyper_binary_resolved_clause (bool red, int glue)

Clause *	new_clause_as (const Clause *orig)

Clause *	new_resolved_irredundant_clause ()

int	assignment_level (int lit, Clause *)

void	build_chain_for_units (int lit, Clause *reason, bool forced)

void	build_chain_for_empty ()

void	search_assign (int lit, Clause *)

void	search_assign_driving (int lit, Clause *reason)

void	search_assign_external (int lit)

void	search_assume_decision (int decision)

void	assign_unit (int lit)

int64_t	cache_lines (size_t bytes)

int64_t	cache_lines (size_t n, size_t bytes)

bool	propagate ()

void	propergate ()

void	unassign (int lit)

void	update_target_and_best ()

void	backtrack (int target_level=0)

void	backtrack_without_updating_phases (int target_level=0)

bool	minimize_literal (int lit, int depth=0)

void	minimize_clause ()

void	calculate_minimize_chain (int lit, std::vector< int > &stack)

void	learn_empty_clause ()

void	learn_unit_clause (int lit)

void	bump_variable (int lit)

void	bump_variables ()

int	recompute_glue (Clause *)

void	bump_clause (Clause *)

void	bump_clause2 (Clause *)

void	clear_unit_analyzed_literals ()

void	clear_analyzed_literals ()

void	clear_analyzed_levels ()

void	clear_minimized_literals ()

bool	bump_also_reason_literal (int lit)

void	bump_also_reason_literals (int lit, int depth_limit, size_t size_limit)

void	bump_also_all_reason_literals ()

void	analyze_literal (int lit, int &open, int &resolvent_size, int &antecedent_size)

void	analyze_reason (int lit, Clause *, int &open, int &resolvent_size, int &antecedent_size)

Clause *	new_driving_clause (const int glue, int &jump)

int	find_conflict_level (int &forced)

int	determine_actual_backtrack_level (int jump)

void	otfs_strengthen_clause (Clause *, int, int, const std::vector< int > &)

void	otfs_subsume_clause (Clause subsuming, Clause subsumed)

int	otfs_find_backtrack_level (int &forced)

Clause *	on_the_fly_strengthen (Clause *conflict, int lit)

void	update_decision_rate_average ()

void	analyze ()

void	iterate ()

bool	external_propagate ()

bool	external_check_solution ()

void	add_external_clause (int propagated_lit=0, bool no_backtrack=false)

Clause *	learn_external_reason_clause (int lit, int falsified_elit=0, bool no_backtrack=false)

Clause *	wrapped_learn_external_reason_clause (int lit)

void	explain_external_propagations ()

void	explain_reason (int lit, Clause *, int &open)

void	move_literals_to_watch ()

void	handle_external_clause (Clause *)

void	notify_assignments ()

void	notify_decision ()

void	notify_backtrack (size_t new_level)

void	force_backtrack (size_t new_level)

int	ask_decision ()

bool	ask_external_clause ()

void	add_observed_var (int ilit)

void	remove_observed_var (int ilit)

bool	observed (int ilit) const

bool	is_decision (int ilit)

void	check_watched_literal_invariants ()

void	set_tainted_literal ()

void	renotify_trail_after_ilb ()

void	renotify_trail_after_local_search ()

void	renotify_full_trail ()

void	connect_propagator ()

void	mark_garbage_external_forgettable (int64_t id)

bool	is_external_forgettable (int64_t id)

void	recompute_tier ()

void	eagerly_subsume_recently_learned_clauses (Clause *)

bool	stabilizing ()

bool	restarting ()

int	reuse_trail ()

void	restart ()

void	clear_phases (vector< signed char > &)

void	copy_phases (vector< signed char > &)

bool	rephasing ()

char	rephase_best ()

char	rephase_flipping ()

char	rephase_inverted ()

char	rephase_original ()

char	rephase_random ()

char	rephase_walk ()

void	shuffle_scores ()

void	shuffle_queue ()

void	rephase ()

int	unlucky (int res)

bool	lucky_propagate_discrepency (int)

int	trivially_false_satisfiable ()

int	trivially_true_satisfiable ()

int	forward_false_satisfiable ()

int	forward_true_satisfiable ()

int	backward_false_satisfiable ()

int	backward_true_satisfiable ()

int	positive_horn_satisfiable ()

int	negative_horn_satisfiable ()

bool	terminated_asynchronously (int factor=1)

bool	search_limits_hit ()

void	terminate ()

bool	flushing ()

bool	reducing ()

void	protect_reasons ()

void	mark_clauses_to_be_flushed ()

void	mark_useless_redundant_clauses_as_garbage ()

bool	propagate_out_of_order_units ()

void	unprotect_reasons ()

void	reduce ()

int	clause_contains_fixed_literal (Clause *)

void	remove_falsified_literals (Clause *)

void	mark_satisfied_clauses_as_garbage ()

void	copy_clause (Clause *)

void	flush_watches (int lit, Watches &)

size_t	flush_occs (int lit)

void	flush_all_occs_and_watches ()

void	update_reason_references ()

void	copy_non_garbage_clauses ()

void	delete_garbage_clauses ()

void	check_clause_stats ()

void	check_var_stats ()

bool	arenaing ()

void	garbage_collection ()

void	remove_garbage_binaries ()

void	init_occs ()

void	init_bins ()

void	init_noccs ()

void	clear_noccs ()

void	clear_occs ()

void	reset_occs ()

void	reset_bins ()

void	reset_noccs ()

void	init_watches ()

void	connect_watches (bool irredundant_only=false)

void	connect_binary_watches ()

void	sort_watches ()

void	clear_watches ()

void	reset_watches ()

void	strengthen_clause (Clause *, int)

void	subsume_clause (Clause subsuming, Clause subsumed)

int	subsume_check (Clause subsuming, Clause subsumed)

int	try_to_subsume_clause (Clause , vector< Clause > &shrunken)

void	reset_subsume_bits ()

bool	subsume_round ()

void	subsume ()

void	covered_literal_addition (int lit, Coveror &)

void	asymmetric_literal_addition (int lit, Coveror &)

void	cover_push_extension (int lit, Coveror &)

bool	cover_propagate_asymmetric (int lit, Clause *ignore, Coveror &)

bool	cover_propagate_covered (int lit, Coveror &)

bool	cover_clause (Clause *c, Coveror &)

int64_t	cover_round ()

bool	cover ()

void	demote_clause (Clause *)

void	flush_vivification_schedule (std::vector< Clause * > &, int64_t &)

void	vivify_increment_stats (const Vivifier &vivifier)

void	vivify_subsume_clause (Clause subsuming, Clause subsumed)

void	compute_tier_limits (Vivifier &)

void	vivify_initialize (Vivifier &vivifier, int64_t &ticks)

void	vivify_prioritize_leftovers (char, size_t prioritized, std::vector< Clause * > &schedule)

bool	consider_to_vivify_clause (Clause *candidate)

void	vivify_sort_watched (Clause *c)

bool	vivify_instantiate (const std::vector< int > &, Clause , std::vector< std::tuple< int, Clause , bool > > &lrat_stack, int64_t &ticks)

void	vivify_analyze_redundant (Vivifier &, Clause *start, bool &)

void	vivify_build_lrat (int, Clause , std::vector< std::tuple< int, Clause , bool > > &)

void	vivify_chain_for_units (int lit, Clause *reason)

void	vivify_strengthen (Clause *candidate)

void	vivify_assign (int lit, Clause *)

void	vivify_assume (int lit)

bool	vivify_propagate (int64_t &)

void	vivify_deduce (Clause candidate, Clause conflct, int implied, Clause **, bool &)

bool	vivify_clause (Vivifier &, Clause *candidate)

void	vivify_analyze (Clause start, bool &, Clause , const Clause const, int implied, bool &)

bool	vivify_shrinkable (const std::vector< int > &sorted, Clause *c)

void	vivify_round (Vivifier &, int64_t delta)

bool	vivify ()

bool	compacting ()

void	compact ()

void	transred ()

bool	likely_to_be_kept_clause (Clause *c)

void	mark_subsume (int lit)

void	mark_ternary (int lit)

void	mark_factor (int lit)

void	mark_added (int lit, int size, bool redundant)

void	mark_added (Clause *)

bool	marked_subsume (int lit) const

void	mark_elim (int lit)

void	mark_block (int lit)

void	mark_removed (int lit)

void	mark_removed (Clause *, int except=0)

bool	marked_block (int lit) const

void	unmark_block (int lit)

void	mark_skip (int lit)

bool	marked_skip (int lit)

void	mark_decomposed (int lit)

void	unmark_decomposed (int lit)

bool	marked_decomposed (int lit)

void	clear_sign_marked_literals ()

bool	is_blocked_clause (Clause *c, int pivot)

void	block_schedule (Blocker &)

size_t	block_candidates (Blocker &, int lit)

Clause *	block_impossible (Blocker &, int lit)

void	block_literal_with_at_least_two_negative_occs (Blocker &, int lit)

void	block_literal_with_one_negative_occ (Blocker &, int lit)

void	block_pure_literal (Blocker &, int lit)

void	block_reschedule_clause (Blocker &, int lit, Clause *)

void	block_reschedule (Blocker &, int lit)

void	block_literal (Blocker &, int lit)

bool	block ()

int	second_literal_in_binary_clause_lrat (Clause *, int first)

int	second_literal_in_binary_clause (Eliminator &, Clause *, int first)

void	mark_binary_literals (Eliminator &, int pivot)

void	find_and_gate (Eliminator &, int pivot)

void	find_equivalence (Eliminator &, int pivot)

bool	get_ternary_clause (Clause *, int &, int &, int &)

bool	match_ternary_clause (Clause *, int, int, int)

Clause *	find_ternary_clause (int, int, int)

bool	get_clause (Clause *, vector< int > &)

bool	is_clause (Clause *, const vector< int > &)

Clause *	find_clause (const vector< int > &)

void	find_xor_gate (Eliminator &, int pivot)

void	find_if_then_else (Eliminator &, int pivot)

Clause *	find_binary_clause (int, int)

void	find_gate_clauses (Eliminator &, int pivot)

void	unmark_gate_clauses (Eliminator &)

void	find_definition (Eliminator &, int)

void	init_citten ()

void	reset_citten ()

void	citten_clear_track_log_terminate ()

bool	ineliminating ()

double	compute_elim_score (unsigned lit)

void	mark_redundant_clauses_with_eliminated_variables_as_garbage ()

void	unmark_binary_literals (Eliminator &)

bool	resolve_clauses (Eliminator &, Clause , int pivot, Clause , bool)

void	mark_eliminated_clauses_as_garbage (Eliminator &, int pivot, bool &)

bool	elim_resolvents_are_bounded (Eliminator &, int pivot)

void	elim_update_removed_lit (Eliminator &, int lit)

void	elim_update_removed_clause (Eliminator &, Clause *, int except=0)

void	elim_update_added_clause (Eliminator &, Clause *)

void	elim_add_resolvents (Eliminator &, int pivot)

void	elim_backward_clause (Eliminator &, Clause *)

void	elim_backward_clauses (Eliminator &)

void	elim_propagate (Eliminator &, int unit)

void	elim_on_the_fly_self_subsumption (Eliminator &, Clause *, int)

void	try_to_eliminate_variable (Eliminator &, int pivot, bool &)

void	increase_elimination_bound ()

int	elim_round (bool &completed, bool &)

void	elim (bool update_limits=true)

int64_t	flush_elimfast_occs (int lit)

void	elimfast_add_resolvents (Eliminator &, int pivot)

bool	elimfast_resolvents_are_bounded (Eliminator &, int pivot)

void	try_to_fasteliminate_variable (Eliminator &, int pivot, bool &)

int	elimfast_round (bool &completed, bool &)

void	elimfast ()

int	sweep_solve ()

void	sweep_set_cadical_kitten_ticks_limit (Sweeper &sweeper)

bool	cadical_kitten_ticks_limit_hit (Sweeper &sweeper, const char *when)

void	init_sweeper (Sweeper &sweeper)

void	release_sweeper (Sweeper &sweeper)

void	clear_sweeper (Sweeper &sweeper)

int	sweep_repr (Sweeper &sweeper, int lit)

void	add_literal_to_environment (Sweeper &sweeper, unsigned depth, int)

void	sweep_clause (Sweeper &sweeper, unsigned depth, Clause *)

void	sweep_add_clause (Sweeper &sweeper, unsigned depth)

void	add_core (Sweeper &sweeper, unsigned core_idx)

void	save_core (Sweeper &sweeper, unsigned core)

void	clear_core (Sweeper &sweeper, unsigned core_idx)

void	save_add_clear_core (Sweeper &sweeper)

void	init_backbone_and_partition (Sweeper &sweeper)

void	sweep_empty_clause (Sweeper &sweeper)

void	sweep_refine_partition (Sweeper &sweeper)

void	sweep_refine_backbone (Sweeper &sweeper)

void	sweep_refine (Sweeper &sweeper)

void	flip_backbone_literals (struct Sweeper &sweeper)

bool	sweep_backbone_candidate (Sweeper &sweeper, int lit)

int64_t	add_sweep_binary (sweep_proof_clause, int lit, int other)

bool	scheduled_variable (Sweeper &sweeper, int idx)

void	schedule_inner (Sweeper &sweeper, int idx)

void	schedule_outer (Sweeper &sweeper, int idx)

int	next_scheduled (Sweeper &sweeper)

void	substitute_connected_clauses (Sweeper &sweeper, int lit, int other, int64_t id)

void	sweep_remove (Sweeper &sweeper, int lit)

void	flip_partition_literals (struct Sweeper &sweeper)

const char *	sweep_variable (Sweeper &sweeper, int idx)

bool	scheduable_variable (Sweeper &sweeper, int idx, size_t *occ_ptr)

unsigned	schedule_all_other_not_scheduled_yet (Sweeper &sweeper)

bool	sweep_equivalence_candidates (Sweeper &sweeper, int lit, int other)

unsigned	reschedule_previously_remaining (Sweeper &sweeper)

unsigned	incomplete_variables ()

void	mark_incomplete (Sweeper &sweeper)

unsigned	schedule_sweeping (Sweeper &sweeper)

void	unschedule_sweeping (Sweeper &sweeper, unsigned swept, unsigned scheduled)

bool	sweep ()

void	sweep_dense_propagate (Sweeper &sweeper)

void	sweep_sparse_mode ()

void	sweep_dense_mode_and_watch_irredundant ()

void	sweep_substitute_lrat (Clause *c, int64_t id)

void	sweep_substitute_new_equivalences (Sweeper &sweeper)

void	sweep_update_noccs (Clause *c)

void	delete_sweep_binary (const sweep_binary &sb)

bool	can_sweep_clause (Clause *c)

bool	sweep_flip (int)

int	sweep_flip_and_implicant (int)

bool	sweep_extract_fixed (Sweeper &sweeper, int lit)

void	factor_mode ()

void	reset_factor_mode ()

double	tied_next_factor_score (int)

Quotient *	new_quotient (Factoring &, int)

void	release_quotients (Factoring &)

size_t	first_factor (Factoring &, int)

void	clear_nounted (vector< int > &)

void	clear_flauses (vector< Clause * > &)

Quotient *	best_quotient (Factoring &, size_t *)

int	next_factor (Factoring &, unsigned *)

void	factorize_next (Factoring &, int, unsigned)

void	resize_factoring (Factoring &factoring, int lit)

void	flush_unmatched_clauses (Quotient *)

void	add_self_subsuming_factor (Quotient , Quotient )

bool	self_subsuming_factor (Quotient *)

void	add_factored_divider (Quotient *, int)

void	blocked_clause (Quotient *q, int)

void	add_factored_quotient (Quotient *, int not_fresh)

void	eagerly_remove_from_occurences (Clause *c)

void	delete_unfactored (Quotient *q)

void	update_factored (Factoring &factoring, Quotient *q)

bool	apply_factoring (Factoring &factoring, Quotient *q)

void	update_factor_candidate (Factoring &, int)

void	schedule_factorization (Factoring &)

bool	run_factorization (int64_t limit)

bool	factor ()

int	get_new_extension_variable ()

Clause *	new_factor_clause ()

void	inst_assign (int lit)

bool	inst_propagate ()

void	collect_instantiation_candidates (Instantiator &)

bool	instantiate_candidate (int lit, Clause *)

void	instantiate (Instantiator &)

void	new_trail_level (int lit)

bool	ternary_find_binary_clause (int, int)

bool	ternary_find_ternary_clause (int, int, int)

Clause *	new_hyper_ternary_resolved_clause (bool red)

Clause *	new_hyper_ternary_resolved_clause_and_watch (bool red, bool)

bool	hyper_ternary_resolve (Clause , int, Clause )

void	ternary_lit (int pivot, int64_t &steps, int64_t &htrs)

void	ternary_idx (int idx, int64_t &steps, int64_t &htrs)

bool	ternary_round (int64_t &steps, int64_t &htrs)

bool	ternary ()

bool	inprobing ()

void	failed_literal (int lit)

void	probe_lrat_for_units (int lit)

void	probe_assign_unit (int lit)

void	probe_assign_decision (int lit)

void	probe_assign (int lit, int parent)

void	mark_duplicated_binary_clauses_as_garbage ()

int	get_parent_reason_literal (int lit)

void	set_parent_reason_literal (int lit, int reason)

void	clean_probehbr_lrat ()

void	init_probehbr_lrat ()

void	get_probehbr_lrat (int lit, int uip)

void	set_probehbr_lrat (int lit, int uip)

void	probe_post_dominator_lrat (vector< Clause * > &, int, int)

void	probe_dominator_lrat (int dom, Clause *reason)

int	probe_dominator (int a, int b)

int	hyper_binary_resolve (Clause *)

void	probe_propagate2 ()

bool	probe_propagate ()

bool	is_binary_clause (Clause *c, int &, int &)

void	generate_probes ()

void	flush_probes ()

int	next_probe ()

bool	probe ()

void	inprobe (bool update_limits=true)

void	walk_save_minimum (Walker &)

Clause *	walk_pick_clause (Walker &)

unsigned	walk_break_value (int lit)

int	walk_pick_lit (Walker &, Clause *)

void	walk_flip_lit (Walker &, int lit)

int	walk_round (int64_t limit, bool prev)

void	walk ()

void	decompose_conflicting_scc_lrat (DFS *dfs, vector< int > &)

void	build_lrat_for_clause (const vector< vector< Clause * > > &dfs_chains, bool invert=false)

vector< Clause * >	decompose_analyze_binary_clauses (DFS *dfs, int from)

void	decompose_analyze_binary_chain (DFS *dfs, int)

bool	decompose_round ()

void	decompose ()

void	reset_limits ()

bool	flip (int lit)

bool	flippable (int lit)

void	assume_analyze_literal (int lit)

void	assume_analyze_reason (int lit, Clause *reason)

void	assume (int)

bool	failed (int lit)

void	reset_assumptions ()

void	sort_and_reuse_assumptions ()

void	failing ()

bool	assumed (int lit)

void	constrain (int)

bool	failed_constraint ()

void	reset_constraint ()

int	propagate_assumptions ()

void	implied (std::vector< int > &entrailed)

void	phase (int lit)

void	unphase (int lit)

bool	is_autarky_literal (int lit) const

bool	is_conditional_literal (int lit) const

void	mark_as_conditional_literal (int lit)

void	unmark_as_conditional_literal (int lit)

bool	is_in_candidate_clause (int lit) const

void	mark_in_candidate_clause (int lit)

void	unmark_in_candidate_clause (int lit)

void	condition_assign (int lit)

void	condition_unassign (int lit)

bool	conditioning ()

long	condition_round (long unassigned_literal_propagation_limit)

void	condition (bool update_limits=true)

bool	satisfied ()

int	next_decision_variable_on_queue ()

int	next_decision_variable_with_best_score ()

int	next_decision_variable ()

int	decide_phase (int idx, bool target)

int	likely_phase (int idx)

bool	better_decision (int lit, int other)

int	decide ()

void	limit_terminate (int)

void	limit_decisions (int)

void	limit_conflicts (int)

void	limit_preprocessing (int)

void	limit_local_search (int)

bool	limit (const char *name, int)

void	init_report_limits ()

void	init_preprocessing_limits ()

void	init_search_limits ()

void	init_averages ()

void	swap_averages ()

int	try_to_satisfy_formula_by_saved_phases ()

void	produce_failed_assumptions ()

int	already_solved ()

int	restore_clauses ()

bool	preprocess_round (int round)

void	preprocess_quickly ()

int	preprocess ()

int	local_search_round (int round)

int	local_search ()

int	lucky_phases ()

int	cdcl_loop_with_inprocessing ()

void	reset_solving ()

int	solve (bool preprocess_only=false)

void	finalize (int)

int	lookahead ()

CubesWithStatus	generate_cubes (int, int)

int	most_occurring_literal ()

int	lookahead_probing ()

int	lookahead_next_probe ()

void	lookahead_flush_probes ()

void	lookahead_generate_probes ()

std::vector< int >	lookahead_populate_locc ()

int	lookahead_locc (const std::vector< int > &)

bool	terminating_asked ()

signed char	val (int lit) const

void	set_val (int lit, signed char val)

int	fixed (int lit)

int	externalize (int lit)

void	freeze (int lit)

void	melt (int lit)

bool	frozen (int lit)

bool	extract_gates ()

const char *	parse_dimacs (FILE *)

const char *	parse_dimacs (const char *)

const char *	parse_solution (const char *)

void	new_proof_on_demand ()

void	force_lrat ()

void	resize_unit_clauses_idx ()

void	close_trace (bool stats=false)

void	flush_trace (bool stats=false)

void	trace (File *)

void	check ()

void	connect_proof_tracer (Tracer *tracer, bool antecedents, bool finalize_clauses=false)

void	connect_proof_tracer (InternalTracer *tracer, bool antecedents, bool finalize_clauses=false)

void	connect_proof_tracer (StatTracer *tracer, bool antecedents, bool finalize_clauses=false)

void	connect_proof_tracer (FileTracer *tracer, bool antecedents, bool finalize_clauses=false)

bool	disconnect_proof_tracer (Tracer *tracer)

bool	disconnect_proof_tracer (StatTracer *tracer)

bool	disconnect_proof_tracer (FileTracer *tracer)

void	conclude_unsat ()

void	reset_concluded ()

void	dump (Clause *)

void	dump ()

bool	traverse_clauses (ClauseIterator &)

bool	traverse_constraint (ClauseIterator &)

double	solve_time ()

double	process_time () const

double	real_time () const

double	time ()

void	report (char type, int verbose_level=0)

void	report_solving (int)

void	print_statistics ()

void	print_resource_usage ()

void	error_message_end ()

void	verror (const char *, va_list &)

void	error (const char *,...) CADICAL_ATTRIBUTE_FORMAT(2

void void	error_message_start ()

void	warning (const char *,...) CADICAL_ATTRIBUTE_FORMAT(2

Static Public Member Functions
static bool	is_valid_limit (const char *name)

Public Attributes
int	mode

int	tier1 [2]

int	tier2 [2]

bool	unsat

bool	iterating

bool	localsearching

bool	lookingahead

bool	preprocessing

bool	protected_reasons

bool	force_saved_phase

bool	searching_lucky_phases

bool	stable

bool	reported

bool	external_prop

bool	did_external_prop

bool	external_prop_is_lazy

bool	forced_backt_allowed

bool	private_steps

char	rephased

Reluctant	reluctant

size_t	vsize

int	max_var

int64_t	clause_id

int64_t	original_id

int64_t	reserved_ids

int64_t	conflict_id

int64_t	saved_decisions

bool	concluded

vector< int64_t >	conclusion

vector< int64_t >	unit_clauses_idx

vector< int64_t >	lrat_chain

vector< int64_t >	mini_chain

vector< int64_t >	minimize_chain

vector< int64_t >	unit_chain

vector< Clause * >	inst_chain

vector< vector< vector< int64_t > > >	probehbr_chains

bool	lrat

bool	frat

int	level

Phases	phases

signed char *	vals

vector< signed char >	marks

vector< unsigned >	frozentab

vector< int >	i2e

vector< unsigned >	relevanttab

Queue	queue

Links	links

double	score_inc

ScoreSchedule	scores

vector< double >	stab

vector< Var >	vtab

vector< int >	parents

vector< Flags >	ftab

vector< int64_t >	btab

vector< int64_t >	gtab

vector< Occs >	otab

vector< Occs >	rtab

vector< int >	ptab

vector< int64_t >	ntab

vector< Bins >	big

vector< Watches >	wtab

Clause *	conflict

Clause *	ignore

Clause *	dummy_binary

Clause *	external_reason

Clause *	newest_clause

bool	force_no_backtrack

bool	from_propagator

bool	ext_clause_forgettable

int	tainted_literal

size_t	notified

Clause *	probe_reason

size_t	propagated

size_t	propagated2

size_t	propergated

size_t	best_assigned

size_t	target_assigned

size_t	no_conflict_until

vector< int >	trail

vector< int >	clause

vector< int >	assumptions

vector< int >	constraint

bool	unsat_constraint

bool	marked_failed

vector< int >	original

vector< int >	levels

vector< int >	analyzed

vector< int >	unit_analyzed

vector< int >	sign_marked

vector< int >	minimized

vector< int >	shrinkable

Reap	reap

vector< int >	sweep_schedule

bool	sweep_incomplete

cadical_kitten *	citten

size_t	num_assigned

vector< int >	probes

vector< Level >	control

vector< Clause * >	clauses

Averages	averages

Delay	delay [2]

Delay	congruence_delay

Limit	lim

Last	last

Inc	inc

Delay	delaying_vivify_irredundant

Delay	delaying_sweep

Proof *	proof

vector< Tracer * >	tracers

vector< FileTracer * >	file_tracers

vector< StatTracer * >	stat_tracers

Options	opts

Stats	stats

Arena	arena

Format	error_message

string	prefix

Internal *	internal

External *	external

const unsigned	max_used = 255

volatile bool	termination_forced

const Range	vars

const Sange	lits

Detailed Description

Definition at line 136 of file internal.hpp.

Member Enumeration Documentation

◆ Mode

enum CaDiCaL::Internal::Mode

Enumerator
BLOCK
CONDITION
CONGRUENCE
COVER
DECOMP
DEDUP
ELIM
FACTOR
LUCKY
PROBE
SEARCH
SIMPLIFY
SUBSUME
SWEEP
TERNARY
TRANSRED
VIVIFY
WALK

Definition at line 143 of file internal.hpp.

            {
    BLOCK = (1 << 0),
    CONDITION = (1 << 1),
    CONGRUENCE = (1 << 2),
    COVER = (1 << 3),
    DECOMP = (1 << 4),
    DEDUP = (1 << 5),
    ELIM = (1 << 6),
    FACTOR = (1 << 7),
    LUCKY = (1 << 8),
    PROBE = (1 << 9),
    SEARCH = (1 << 10),
    SIMPLIFY = (1 << 11),
    SUBSUME = (1 << 12),
    SWEEP = (1 << 13),
    TERNARY = (1 << 14),
    TRANSRED = (1 << 15),
    VIVIFY = (1 << 16),
    WALK = (1 << 17),
  };

Constructor & Destructor Documentation

◆ Internal()

CaDiCaL::Internal::Internal ( )

Definition at line 12 of file cadical_internal.cpp.

    : mode (SEARCH), unsat (false), iterating (false),
      localsearching (false), lookingahead (false), preprocessing (false),
      protected_reasons (false), force_saved_phase (false),
      searching_lucky_phases (false), stable (false), reported (false),
      external_prop (false), did_external_prop (false),
      external_prop_is_lazy (true), forced_backt_allowed (false),
 
      private_steps (false), rephased (0), vsize (0), max_var (0),
      clause_id (0), original_id (0), reserved_ids (0), conflict_id (0),
      saved_decisions (0), concluded (false), lrat (false), frat (false),
      level (0), vals (0), score_inc (1.0), scores (this), conflict (0),
      ignore (0), external_reason (&external_reason_clause),
      newest_clause (0), force_no_backtrack (false),
      from_propagator (false), ext_clause_forgettable (false),
      tainted_literal (0), notified (0), probe_reason (0), propagated (0),
      propagated2 (0), propergated (0), best_assigned (0),
      target_assigned (0), no_conflict_until (0), unsat_constraint (false),
      marked_failed (true), sweep_incomplete (false), citten (0),
      num_assigned (0), proof (0), opts (this),
#ifndef CADICAL_QUIET
      profiles (this), force_phase_messages (false),
#endif
      arena (this), prefix ("c "), internal (this), external (0),
      termination_forced (false), vars (this->max_var),
      lits (this->max_var) {
  control.push_back (Level (0, 0));
 
  // The 'dummy_binary' is used in 'try_to_subsume_clause' to fake a real
  // clause, which then can be used to subsume or strengthen the given
  // clause in one routine for both binary and non binary clauses.  This
  // fake binary clause is always kept non-redundant (and not-moved etc.)
  // due to the following 'memset'.  Only literals will be changed.
 
  // In a previous version we used local automatic allocated 'Clause' on the
  // stack, which became incompatible with several compilers (see the
  // discussion on flexible array member in 'Clause.cpp').
 
  size_t bytes = Clause::bytes (2);
  dummy_binary = (Clause *) new char[bytes];
  memset (dummy_binary, 0, bytes);
  dummy_binary->size = 2;
}

Here is the call graph for this function:

◆ ~Internal()

CaDiCaL::Internal::~Internal ( )

Definition at line 56 of file cadical_internal.cpp.

                     {
  // If a memory exception ocurred a profile might still be active.
#ifndef CADICAL_QUIET
#define PROFILE(NAME, LEVEL) \
  if (PROFILE_ACTIVE (NAME)) \
    STOP (NAME);
  PROFILES
#undef PROFILE
#endif
  delete[] (char *) dummy_binary;
  for (const auto &c : clauses)
    delete_clause (c);
  if (proof)
    delete proof;
  for (auto &tracer : tracers)
    delete tracer;
  for (auto &filetracer : file_tracers)
    delete filetracer;
  for (auto &stattracer : stat_tracers)
    delete stattracer;
  if (vals) {
    vals -= vsize;
    delete[] vals;
  }
}

Here is the call graph for this function:

Member Function Documentation

◆ active() [1/2]

int CaDiCaL::Internal::active ( ) const

inline

Definition at line 362 of file internal.hpp.

                      {
    int res = stats.active;
#ifndef CADICAL_NDEBUG
    int tmp = max_var;
    tmp -= stats.unused;
    tmp -= stats.now.fixed;
    tmp -= stats.now.eliminated;
    tmp -= stats.now.substituted;
    tmp -= stats.now.pure;
    CADICAL_assert (tmp >= 0);
    CADICAL_assert (tmp == res);
#endif
    return res;
  }

Here is the caller graph for this function:

◆ active() [2/2]

bool CaDiCaL::Internal::active ( int lit )

inline

Definition at line 360 of file internal.hpp.

360{ return flags (lit).active (); }

CaDiCaL::flags

const char * flags()

Definition cadical_version.cpp:109

lit

int lit

Definition satVec.h:130

Here is the call graph for this function:

◆ add_core()

void CaDiCaL::Internal::add_core	(	Sweeper &	sweeper,
		unsigned	core_idx )

Definition at line 494 of file cadical_sweep.cpp.

                                                            {
  if (unsat)
    return;
  LOG ("check and add extracted core[%u] lemmas to proof", core_idx);
  CADICAL_assert (core_idx == 0 || core_idx == 1);
  vector<sweep_proof_clause> &core = sweeper.core[core_idx];
 
  CADICAL_assert (!lrat || proof);
 
  unsigned unsat_size = 0;
  for (auto &pc : core) {
    unsat_size++;
 
    if (!pc.learned) {
      LOG (pc.literals,
           "not adding already present core[%u] cadical_kitten[%u] clause",
           core_idx, pc.kit_id);
      continue;
    }
 
    LOG (pc.literals, "adding extracted core[%u] cadical_kitten[%u] lemma",
         core_idx, pc.kit_id);
 
    const unsigned new_size = pc.literals.size ();
 
    if (lrat) {
      CADICAL_assert (pc.cad_id == INVALID64);
      for (auto &cid : pc.chain) {
        int64_t id = 0;
        for (const auto &cpc : core) {
          if (cpc.kit_id == cid) {
            if (cpc.learned)
              id = cpc.cad_id;
            else {
              id = cpc.cad_id;
              CADICAL_assert (cpc.cad_id == sweeper.clauses[cpc.sweep_id]->id);
              CADICAL_assert (!sweeper.clauses[cpc.sweep_id]->garbage);
              // avoid duplicate ids of units with seen flags
              for (const auto &lit : cpc.literals) {
                if (val (lit) >= 0)
                  continue;
                if (flags (lit).seen)
                  continue;
                const int idx = abs (lit);
                if (sweeper.prev_units[idx]) {
                  int64_t uid = unit_id (-lit);
                  lrat_chain.push_back (uid);
                  analyzed.push_back (lit);
                  flags (lit).seen = true;
                }
              }
            }
            break;
          }
        }
        CADICAL_assert (id);
        if (id != INVALID64)
          lrat_chain.push_back (id);
      }
      clear_analyzed_literals ();
    }
 
    if (!new_size) {
      LOG ("sweeping produced empty clause");
      learn_empty_clause ();
      core.resize (unsat_size);
      return;
    }
 
    if (new_size == 1) {
      int unit = pc.literals[0];
      if (val (unit) > 0) {
        LOG ("already assigned sweeping unit %d", unit);
        lrat_chain.clear ();
      } else if (val (unit) < 0) {
        LOG ("falsified sweeping unit %d leads to empty clause", unit);
        if (lrat) {
          int64_t id = unit_id (-unit);
          lrat_chain.push_back (id);
        }
        learn_empty_clause ();
        core.resize (unsat_size);
        return;
      } else {
        LOG ("sweeping produced unit %d", unit);
        assign_unit (unit);
        stats.sweep_units++;
        sweeper.propagate.push_back (unit);
      }
      if (proof && lrat)
        pc.cad_id = unit_id (unit);
      continue;
    }
 
    CADICAL_assert (new_size > 1);
    CADICAL_assert (pc.learned);
 
    if (proof) {
      pc.cad_id = ++clause_id;
      proof->add_derived_clause (pc.cad_id, true, pc.literals, lrat_chain);
      lrat_chain.clear ();
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_external_clause()

void CaDiCaL::Internal::add_external_clause	(	int	propagated_lit = 0,
		bool	no_backtrack = false )

Definition at line 478 of file cadical_external_propagate.cpp.

                                                       {
  CADICAL_assert (original.empty ());
  int elit = 0;
 
  if (propagated_elit) {
    // Propagation reason clauses are by default assumed to be forgettable
    // irredundant. In case they would be unforgettably important, the
    // propagator can add them as an explicit unforgettable external clause
    // or set 'are_reasons_forgettable' to false.
    ext_clause_forgettable = external->propagator->are_reasons_forgettable;
#ifndef CADICAL_NDEBUG
    LOG ("add external reason of propagated lit: %d", propagated_elit);
#endif
    elit = external->propagator->cb_add_reason_clause_lit (propagated_elit);
  } else
    elit = external->propagator->cb_add_external_clause_lit ();
 
  // we need to be build a new LRAT chain if we are already in the middle of
  // the analysis (like during failed assumptions)
  LOG (lrat_chain, "lrat chain before");
  std::vector<int64_t> lrat_chain_ext = std::move (lrat_chain);
  lrat_chain.clear ();
  clause.clear ();
 
  // Read out the external lemma into original and simplify it into clause
  CADICAL_assert (clause.empty ());
  CADICAL_assert (original.empty ());
 
  CADICAL_assert (!force_no_backtrack);
  CADICAL_assert (!from_propagator);
  force_no_backtrack = no_backtrack;
  from_propagator = true;
  while (elit) {
    CADICAL_assert (external->is_observed[abs (elit)]);
    external->add (elit);
    if (propagated_elit)
      elit =
          external->propagator->cb_add_reason_clause_lit (propagated_elit);
    else
      elit = external->propagator->cb_add_external_clause_lit ();
  }
  external->add (elit);
  CADICAL_assert (original.empty ());
  CADICAL_assert (clause.empty ());
  force_no_backtrack = false;
  from_propagator = false;
  lrat_chain = std::move (lrat_chain_ext);
  LOG (lrat_chain, "lrat chain after");
}

Here is the caller graph for this function:

◆ add_factored_divider()

void CaDiCaL::Internal::add_factored_divider	(	Quotient *	q,
		int	fresh )

Definition at line 599 of file cadical_factor.cpp.

                                                           {
  const int factor = q->factor;
  LOG ("factored %d divider %d", factor, fresh);
  clause.push_back (factor);
  clause.push_back (fresh);
  new_factor_clause ();
  clause.clear ();
  if (lrat)
    mini_chain.push_back (-clause_id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_factored_quotient()

void CaDiCaL::Internal::add_factored_quotient	(	Quotient *	q,
		int	not_fresh )

Definition at line 631 of file cadical_factor.cpp.

                                                                {
  LOG ("adding factored quotient[%zu] clauses", q->id);
  const int factor = q->factor;
  CADICAL_assert (lrat_chain.empty ());
  auto qlauses = q->qlauses;
  for (unsigned idx = 0; idx < qlauses.size (); idx++) {
    const auto c = qlauses[idx];
    CADICAL_assert (clause.empty ());
    for (const auto &other : *c) {
      if (other == factor) {
        continue;
      }
      clause.push_back (other);
    }
    if (lrat) {
      CADICAL_assert (proof);
      CADICAL_assert (q->bid);
      unsigned idxtoo = idx;
      for (Quotient *p = q; p; p = p->prev) {
        lrat_chain.push_back (p->qlauses[idxtoo]->id);
        if (p->prev)
          idxtoo = p->matches[idx];
      }
      lrat_chain.push_back (q->bid);
    }
    clause.push_back (not_fresh);
    new_factor_clause ();
    clause.clear ();
    lrat_chain.clear ();
  }
  if (proof) {
    for (Quotient *p = q; p; p = p->prev) {
      clause.push_back (-p->factor);
    }
    clause.push_back (not_fresh);
    proof->delete_clause (q->bid, true, clause);
    clause.clear ();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_literal_to_environment()

void CaDiCaL::Internal::add_literal_to_environment	(	Sweeper &	sweeper,
		unsigned	depth,
		int	lit )

Definition at line 343 of file cadical_sweep.cpp.

                                                    {
  const int repr = sweep_repr (sweeper, lit);
  if (repr != lit)
    return;
  const int idx = abs (lit);
  if (sweeper.depths[idx])
    return;
  CADICAL_assert (depth < UINT_MAX);
  sweeper.depths[idx] = depth + 1;
  CADICAL_assert (idx);
  sweeper.vars.push_back (idx);
  LOG ("sweeping[%u] adding literal %d", depth, lit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_new_original_clause()

void CaDiCaL::Internal::add_new_original_clause ( int64_t id )

Definition at line 385 of file cadical_clause.cpp.

                                                  {
 
  if (!from_propagator && level && !opts.ilb) {
    backtrack ();
  } else if (tainted_literal) {
    CADICAL_assert (val (tainted_literal));
    int new_level = var (tainted_literal).level - 1;
    CADICAL_assert (new_level >= 0);
    backtrack (new_level);
  }
  CADICAL_assert (!tainted_literal);
  LOG (original, "original clause");
  CADICAL_assert (clause.empty ());
  bool skip = false;
  unordered_set<int> learned_levels;
  size_t unassigned = 0;
  newest_clause = 0;
  if (unsat) {
    LOG ("skipping clause since formula is already inconsistent");
    skip = true;
  } else {
    CADICAL_assert (clause.empty ());
    for (const auto &lit : original) {
      int tmp = marked (lit);
      if (tmp > 0) {
        LOG ("removing duplicated literal %d", lit);
      } else if (tmp < 0) {
        LOG ("tautological since both %d and %d occur", -lit, lit);
        skip = true;
      } else {
        mark (lit);
        tmp = fixed (lit);
        if (tmp < 0) {
          LOG ("removing falsified literal %d", lit);
          if (lrat) {
            int elit = externalize (lit);
            unsigned eidx = (elit > 0) + 2u * (unsigned) abs (elit);
            if (!external->ext_units[eidx]) {
              int64_t uid = unit_id (-lit);
              lrat_chain.push_back (uid);
            }
          }
        } else if (tmp > 0) {
          LOG ("satisfied since literal %d true", lit);
          skip = true;
        } else {
          clause.push_back (lit);
          CADICAL_assert (flags (lit).status != Flags::UNUSED);
          tmp = val (lit);
          if (tmp)
            learned_levels.insert (var (lit).level);
          else
            unassigned++;
        }
      }
    }
    for (const auto &lit : original)
      unmark (lit);
  }
  if (skip) {
    if (from_propagator) {
      stats.ext_prop.elearn_conf++;
 
      // In case it was a skipped external forgettable, we need to mark it
      // immediately as removed
 
      if (opts.check && is_external_forgettable (id))
        mark_garbage_external_forgettable (id);
    }
    if (proof) {
      proof->delete_external_original_clause (id, false, external->eclause);
    }
  } else {
    int64_t new_id = id;
    const size_t size = clause.size ();
    if (original.size () > size) {
      new_id = ++clause_id;
      if (proof) {
        if (lrat)
          lrat_chain.push_back (id);
        proof->add_derived_clause (new_id, false, clause, lrat_chain);
        proof->delete_external_original_clause (id, false,
                                                external->eclause);
      }
      external->check_learned_clause ();
 
      if (from_propagator) {
        // The original form of the added clause is immediately forgotten
        // TODO: shall we save and check the simplified form? (one with
        // new_id)
        if (opts.check && is_external_forgettable (id))
          mark_garbage_external_forgettable (id);
      }
    }
    external->eclause.clear ();
    lrat_chain.clear ();
    if (!size) {
      if (from_propagator)
        stats.ext_prop.elearn_conf++;
      CADICAL_assert (!unsat);
      if (!original.size ())
        VERBOSE (1, "found empty original clause");
      else
        VERBOSE (1, "found falsified original clause");
      unsat = true;
      conflict_id = new_id;
      marked_failed = true;
      conclusion.push_back (new_id);
    } else if (size == 1) {
      if (force_no_backtrack) {
        CADICAL_assert (level);
        const int idx = vidx (clause[0]);
        CADICAL_assert (val (clause[0]) >= 0);
        CADICAL_assert (!flags (idx).eliminated ());
        Var &v = var (idx);
        CADICAL_assert (val (clause[0]));
        v.level = 0;
        v.reason = 0;
        const unsigned uidx = vlit (clause[0]);
        if (lrat || frat)
          unit_clauses (uidx) = new_id;
        mark_fixed (clause[0]);
      } else {
        const int lit = clause[0];
        CADICAL_assert (!val (lit) || var (lit).level);
        if (val (lit) < 0)
          backtrack (var (lit).level - 1);
        CADICAL_assert (val (lit) >= 0);
        handle_external_clause (0);
        assign_original_unit (new_id, lit);
      }
    } else {
      move_literals_to_watch ();
#ifndef CADICAL_NDEBUG
      check_watched_literal_invariants ();
#endif
      int glue = (int) (learned_levels.size () + unassigned);
      CADICAL_assert (glue <= (int) clause.size ());
      bool clause_redundancy = from_propagator && ext_clause_forgettable;
      Clause *c = new_clause (clause_redundancy, glue);
      c->id = new_id;
      clause_id--;
      watch_clause (c);
      clause.clear ();
      original.clear ();
      handle_external_clause (c);
      newest_clause = c;
    }
  }
  clause.clear ();
  lrat_chain.clear ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_observed_var()

void CaDiCaL::Internal::add_observed_var ( int ilit )

Definition at line 14 of file cadical_external_propagate.cpp.

                                         {
  int idx = vidx (ilit);
  if (idx >= (int64_t) relevanttab.size ())
    relevanttab.resize (1 + (size_t) idx, 0);
  unsigned &ref = relevanttab[idx];
  if (ref < UINT_MAX) {
    ref++;
    LOG ("variable %d is observed %u times", idx, ref);
  } else
    LOG ("variable %d remains observed forever", idx);
  // TODO: instead of actually backtracking, it would be enough to notify
  // backtrack and re-play again every levels' notification to the
  // propagator
  if (val (ilit) && level && !fixed (ilit)) {
    // The variable is already assigned, but we can not send a notification
    // about it because it happened on an earlier decision level.
    // To not break the stack-like view of the trail, we simply backtrack to
    // undo this unnotifiable assignment.
    const int assignment_level = var (ilit).level;
    backtrack (assignment_level - 1);
  } else if (level && fixed (ilit)) {
    backtrack (0);
  }
}

Here is the call graph for this function:

◆ add_original_lit()

void CaDiCaL::Internal::add_original_lit ( int lit )

Definition at line 184 of file cadical_internal.cpp.

                                        {
  CADICAL_assert (abs (lit) <= max_var);
  if (lit) {
    original.push_back (lit);
  } else {
    const int64_t id =
        original_id < reserved_ids ? ++original_id : ++clause_id;
    if (proof) {
      // Use the external form of the clause for printing in proof
      // Externalize(internalized literal) != external literal
      CADICAL_assert (!original.size () || !external->eclause.empty ());
      proof->add_external_original_clause (id, false, external->eclause);
    }
    if (internal->opts.check &&
        (internal->opts.checkwitness || internal->opts.checkfailed)) {
      bool forgettable = from_propagator && ext_clause_forgettable;
      if (forgettable && opts.check) {
        CADICAL_assert (!original.size () || !external->eclause.empty ());
 
        // First integer is the presence-flag (even if the clause is empty)
        external->forgettable_original[id] = {1};
 
        for (auto const &elit : external->eclause)
          external->forgettable_original[id].push_back (elit);
 
        LOG (external->eclause,
             "clause added to external forgettable map:");
      }
    }
 
    add_new_original_clause (id);
    original.clear ();
  }
}

Here is the call graph for this function:

◆ add_self_subsuming_factor()

void CaDiCaL::Internal::add_self_subsuming_factor	(	Quotient *	q,
		Quotient *	p )

Definition at line 510 of file cadical_factor.cpp.

                                                                  {
  const int factor = q->factor;
  const int not_factor = p->factor;
  CADICAL_assert (-factor == not_factor);
  LOG (
      "adding self subsuming factor because blocked clause is a tautology");
  for (auto c : q->qlauses) {
    for (const auto &lit : *c) {
      if (lit == factor)
        continue;
      clause.push_back (lit);
    }
    if (lrat) {
      for (auto d : p->qlauses) {
        bool match = true;
        for (const auto &lit : *d) {
          if (lit == not_factor)
            continue;
          if (std::find (clause.begin (), clause.end (), lit) ==
              clause.end ()) {
            match = false;
            break;
          }
        }
        if (match) {
          lrat_chain.push_back (d->id);
          break;
        }
      }
      lrat_chain.push_back (c->id);
      CADICAL_assert (lrat_chain.size () == 2);
    }
    if (clause.size () > 1) {
      new_factor_clause ();
    } else {
      const int unit = clause[0];
      const signed char tmp = val (unit);
      if (!tmp)
        assign_unit (unit);
      else if (tmp < 0) {
        if (lrat) {
          int64_t id = unit_id (-unit);
          lrat_chain.push_back (id);
          std::reverse (lrat_chain.begin (), lrat_chain.end ());
        }
        learn_empty_clause ();
        clause.clear ();
        lrat_chain.clear ();
        break;
      }
    }
    clause.clear ();
    lrat_chain.clear ();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_sweep_binary()

int64_t CaDiCaL::Internal::add_sweep_binary	(	sweep_proof_clause	pc,
		int	lit,
		int	other )

Definition at line 899 of file cadical_sweep.cpp.

                                               {
  CADICAL_assert (!unsat);
  if (unsat)
    return 0; // sanity check, should be fuzzed
 
  CADICAL_assert (!val (lit) && !val (other));
  if (val (lit) || val (other))
    return 0;
 
  if (lrat) {
    for (const auto &plit : pc.literals) {
      if (val (plit)) {
        int64_t id = unit_id (-plit);
        lrat_chain.push_back (id);
      }
    }
    lrat_chain.push_back (pc.cad_id);
  }
  clause.push_back (lit);
  clause.push_back (other);
  const int64_t id = ++clause_id;
  if (proof) {
    proof->add_derived_clause (id, false, clause, lrat_chain);
    proof->weaken_minus (id, clause);
  }
  external->push_binary_clause_on_extension_stack (id, lit, other);
  clause.clear ();
  lrat_chain.clear ();
  return id;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ already_solved()

int CaDiCaL::Internal::already_solved ( )

Definition at line 941 of file cadical_internal.cpp.

                              {
  int res = 0;
  if (unsat || unsat_constraint) {
    LOG ("already inconsistent");
    res = 20;
  } else {
    if (level && !opts.ilb)
      backtrack ();
    if (!level && !propagate ()) {
      LOG ("root level propagation produces conflict");
      learn_empty_clause ();
      res = 20;
    }
    if (max_var == 0 && res == 0)
      res = 10;
  }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ analyze()

void CaDiCaL::Internal::analyze ( )

Definition at line 943 of file cadical_analyze.cpp.

                        {
 
  START (analyze);
 
  CADICAL_assert (conflict);
  CADICAL_assert (lrat_chain.empty ());
  CADICAL_assert (unit_chain.empty ());
  CADICAL_assert (unit_analyzed.empty ());
  CADICAL_assert (clause.empty ());
 
  // First update moving averages of trail height at conflict.
  //
  UPDATE_AVERAGE (averages.current.trail.fast, num_assigned);
  UPDATE_AVERAGE (averages.current.trail.slow, num_assigned);
  update_decision_rate_average ();
 
  /*----------------------------------------------------------------------*/
 
  if (external_prop && !external_prop_is_lazy && opts.exteagerreasons) {
    explain_external_propagations ();
  }
 
  if (opts.chrono || external_prop) {
 
    int forced;
 
    const int conflict_level = find_conflict_level (forced);
 
    // In principle we can perform conflict analysis as in non-chronological
    // backtracking except if there is only one literal with the maximum
    // assignment level in the clause.  Then standard conflict analysis is
    // unnecessary and we can use the conflict as a driving clause.  In the
    // pseudo code of the SAT'18 paper on chronological backtracking this
    // corresponds to the situation handled in line 4-6 in Alg. 1, except
    // that the pseudo code in the paper only backtracks while we eagerly
    // assign the single literal on the highest decision level.
 
    if (forced) {
 
      CADICAL_assert (forced);
      CADICAL_assert (conflict_level > 0);
      LOG ("single highest level literal %d", forced);
 
      // The pseudo code in the SAT'18 paper actually backtracks to the
      // 'second highest decision' level, while their code backtracks
      // to 'conflict_level-1', which is more in the spirit of chronological
      // backtracking anyhow and thus we also do the latter.
      //
      backtrack (conflict_level - 1);
 
      // if we are on decision level 0 search assign will learn unit
      // so we need a valid chain here (of course if we are not on decision
      // level 0 this will not result in a valid chain).
      // we can just use build_chain_for_units in propagate
      //
      build_chain_for_units (forced, conflict, 0);
 
      LOG ("forcing %d", forced);
      search_assign_driving (forced, conflict);
 
      conflict = 0;
      STOP (analyze);
      return;
    }
 
    // Backtracking to the conflict level is in the pseudo code in the
    // SAT'18 chronological backtracking paper, but not in their actual
    // implementation.  In principle we do not need to backtrack here.
    // However, as a side effect of backtracking to the conflict level we
    // set 'level' to the conflict level which then allows us to reuse the
    // old 'analyze' code as is.  The alternative (which we also tried but
    // then abandoned) is to use 'conflict_level' instead of 'level' in the
    // analysis, which however requires to pass it to the 'analyze_reason'
    // and 'analyze_literal' functions.
    //
    backtrack (conflict_level);
  }
 
  // Actual conflict on root level, thus formula unsatisfiable.
  //
  if (!level) {
    learn_empty_clause ();
    if (external->learner)
      external->export_learned_empty_clause ();
    STOP (analyze);
    return;
  }
 
  /*----------------------------------------------------------------------*/
 
  // First derive the 1st UIP clause by going over literals assigned on the
  // current decision level.  Literals in the conflict are marked as 'seen'
  // as well as all literals in reason clauses of already 'seen' literals on
  // the current decision level.  Thus the outer loop starts with the
  // conflict clause as 'reason' and then uses the 'reason' of the next
  // seen literal on the trail assigned on the current decision level.
  // During this process maintain the number 'open' of seen literals on the
  // current decision level with not yet processed 'reason'.  As soon 'open'
  // drops to one, we have found the first unique implication point.  This
  // is sound because the topological order in which literals are processed
  // follows the assignment order and a more complex algorithm to find
  // articulation points is not necessary.
  //
  Clause *reason = conflict;
  LOG (reason, "analyzing conflict");
 
  CADICAL_assert (clause.empty ());
  CADICAL_assert (lrat_chain.empty ());
 
  const auto &t = &trail;
  int i = t->size ();      // Start at end-of-trail.
  int open = 0;            // Seen but not processed on this level.
  int uip = 0;             // The first UIP literal.
  int resolvent_size = 0;  // without the uip
  int antecedent_size = 1; // with the uip and without unit literals
  int conflict_size = 0;   // without the uip and without unit literals
  int resolved = 0;        // number of resolution (0 = clause in CNF)
  const bool otfs = opts.otfs;
 
  for (;;) {
    antecedent_size = 1; // for uip
    analyze_reason (uip, reason, open, resolvent_size, antecedent_size);
    if (resolved == 0)
      conflict_size = antecedent_size - 1;
    CADICAL_assert (resolvent_size == open + (int) clause.size ());
 
    if (otfs && resolved > 0 && antecedent_size > 2 &&
        resolvent_size < antecedent_size) {
      CADICAL_assert (reason != conflict);
      LOG (analyzed, "found candidate for OTFS conflict");
      LOG (clause, "found candidate for OTFS conflict");
      LOG (reason, "found candidate (size %d) for OTFS resolvent",
           antecedent_size);
      const int other = reason->literals[0] ^ reason->literals[1] ^ uip;
      CADICAL_assert (other != uip);
      reason = on_the_fly_strengthen (reason, uip);
      if (opts.bump)
        bump_variables ();
 
      CADICAL_assert (conflict_size);
      if (!reason) {
        uip = -other;
        CADICAL_assert (open == 1);
        LOG ("clause is actually unit %d, stopping", -uip);
        reverse (begin (mini_chain), end (mini_chain));
        for (auto id : mini_chain)
          lrat_chain.push_back (id);
        mini_chain.clear ();
        clear_analyzed_levels ();
        CADICAL_assert (!opts.exteagerreasons);
        clause.clear ();
        break;
      }
      CADICAL_assert (conflict_size >= 2);
 
      if (resolved == 1 && resolvent_size < conflict_size) {
        // here both clauses are part of the CNF, so one subsumes the other
        otfs_subsume_clause (reason, conflict);
        LOG (reason, "changing conflict to");
        --conflict_size;
        CADICAL_assert (conflict_size == reason->size);
        ++stats.otfs.subsumed;
        ++stats.subsumed;
      }
 
      LOG (reason, "changing conflict to");
      conflict = reason;
      if (open == 1) {
        int forced = 0;
        const int conflict_level = otfs_find_backtrack_level (forced);
        int new_level = determine_actual_backtrack_level (conflict_level);
        UPDATE_AVERAGE (averages.current.level, new_level);
        backtrack (new_level);
 
        LOG ("forcing %d", forced);
        search_assign_driving (forced, conflict);
 
        // Clean up.
        //
        conflict = 0;
        clear_analyzed_literals ();
        clear_analyzed_levels ();
        clause.clear ();
        STOP (analyze);
        return;
      }
 
      stats.conflicts++;
 
      clear_analyzed_literals ();
      clear_analyzed_levels ();
      clause.clear ();
      resolvent_size = 0;
      antecedent_size = 1;
      resolved = 0;
      open = 0;
      analyze_reason (0, reason, open, resolvent_size, antecedent_size);
      conflict_size = antecedent_size - 1;
      CADICAL_assert (open > 1);
    }
 
    ++resolved;
 
    uip = 0;
    while (!uip) {
      CADICAL_assert (i > 0);
      const int lit = (*t)[--i];
      if (!flags (lit).seen)
        continue;
      if (var (lit).level == level)
        uip = lit;
    }
    if (!--open)
      break;
    reason = var (uip).reason;
    if (reason == external_reason) {
      CADICAL_assert (!opts.exteagerreasons);
      reason = learn_external_reason_clause (-uip, 0, true);
      var (uip).reason = reason;
    }
    CADICAL_assert (reason != external_reason);
    LOG (reason, "analyzing %d reason", uip);
    CADICAL_assert (resolvent_size);
    --resolvent_size;
  }
  LOG ("first UIP %d", uip);
  clause.push_back (-uip);
 
  // Update glue and learned (1st UIP literals) statistics.
  //
  int size = (int) clause.size ();
  const int glue = (int) levels.size () - 1;
  LOG (clause, "1st UIP size %d and glue %d clause", size, glue);
  UPDATE_AVERAGE (averages.current.glue.fast, glue);
  UPDATE_AVERAGE (averages.current.glue.slow, glue);
  stats.learned.literals += size;
  stats.learned.clauses++;
  CADICAL_assert (glue < size);
 
  // up to this point lrat_chain contains the proof for current clause in
  // reversed order. in minimize and shrink the clause is changed and
  // therefore lrat_chain has to be extended. Unfortunately we cannot create
  // the chain directly during minimization (or shrinking) but afterwards we
  // can calculate it pretty easily and even better the same algorithm works
  // for both shrinking and minimization.
 
  // Minimize the 1st UIP clause as pioneered by Niklas Soerensson in
  // MiniSAT and described in our joint SAT'09 paper.
  //
  if (size > 1) {
    if (opts.shrink)
      shrink_and_minimize_clause ();
    else if (opts.minimize)
      minimize_clause ();
 
    size = (int) clause.size ();
 
    // Update decision heuristics.
    //
    if (opts.bump) {
      bump_also_all_reason_literals ();
      bump_variables ();
    }
 
    if (external->learner)
      external->export_learned_large_clause (clause);
  } else if (external->learner)
    external->export_learned_unit_clause (-uip);
 
  // Update actual size statistics.
  //
  stats.units += (size == 1);
  stats.binaries += (size == 2);
  UPDATE_AVERAGE (averages.current.size, size);
 
  // reverse lrat_chain. We could probably work with reversed iterators
  // (views) to be more efficient but we would have to distinguish in proof
  //
  if (lrat) {
    LOG (unit_chain, "unit chain: ");
    for (auto id : unit_chain)
      lrat_chain.push_back (id);
    unit_chain.clear ();
    reverse (lrat_chain.begin (), lrat_chain.end ());
  }
 
  // Determine back-jump level, learn driving clause, backtrack and assign
  // flipped 1st UIP literal.
  //
  int jump;
  Clause *driving_clause = new_driving_clause (glue, jump);
  UPDATE_AVERAGE (averages.current.jump, jump);
 
  int new_level = determine_actual_backtrack_level (jump);
  UPDATE_AVERAGE (averages.current.level, new_level);
  backtrack (new_level);
 
  // It should hold that (!level <=> size == 1)
  //                 and (!uip   <=> size == 0)
  // this means either we have already learned a clause => size >= 2
  // in this case we will not learn empty clause or unit here
  // or we haven't actually learned a clause in new_driving_clause
  // then lrat_chain is still valid and we will learn a unit or empty clause
  //
  if (uip) {
    search_assign_driving (-uip, driving_clause);
  } else
    learn_empty_clause ();
 
  if (stable)
    reluctant.tick (); // Reluctant has its own 'conflict' counter.
 
  // Clean up.
  //
  clear_analyzed_literals ();
  clear_unit_analyzed_literals ();
  clear_analyzed_levels ();
  clause.clear ();
  conflict = 0;
 
  lrat_chain.clear ();
  STOP (analyze);
 
  if (driving_clause && opts.eagersubsume)
    eagerly_subsume_recently_learned_clauses (driving_clause);
 
  if (lim.recompute_tier <= stats.conflicts)
    recompute_tier ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ analyze_literal()

void CaDiCaL::Internal::analyze_literal	(	int	lit,
		int &	open,
		int &	resolvent_size,
		int &	antecedent_size )

inline

Definition at line 256 of file cadical_analyze.cpp.

                                                             {
  CADICAL_assert (lit);
  Var &v = var (lit);
  Flags &f = flags (lit);
 
  if (!v.level) {
    if (f.seen || !lrat)
      return;
    f.seen = true;
    unit_analyzed.push_back (lit);
    CADICAL_assert (val (lit) < 0);
    int64_t id = unit_id (-lit);
    unit_chain.push_back (id);
    return;
  }
  ++antecedent_size;
  if (f.seen)
    return;
 
  // before marking as seen, get reason and check for missed unit
 
  CADICAL_assert (val (lit) < 0);
  CADICAL_assert (v.level <= level);
  if (v.reason == external_reason) {
    CADICAL_assert (!opts.exteagerreasons);
    v.reason = learn_external_reason_clause (-lit, 0, true);
    if (!v.reason) { // actually a unit
      --antecedent_size;
      LOG ("%d unit after explanation", -lit);
      if (f.seen || !lrat)
        return;
      f.seen = true;
      unit_analyzed.push_back (lit);
      CADICAL_assert (val (lit) < 0);
      const unsigned uidx = vlit (-lit);
      int64_t id = unit_clauses (uidx);
      CADICAL_assert (id);
      unit_chain.push_back (id);
      return;
    }
  }
 
  f.seen = true;
  analyzed.push_back (lit);
 
  CADICAL_assert (v.reason != external_reason);
  if (v.level < level)
    clause.push_back (lit);
  Level &l = control[v.level];
  if (!l.seen.count++) {
    LOG ("found new level %d contributing to conflict", v.level);
    levels.push_back (v.level);
  }
  if (v.trail < l.seen.trail)
    l.seen.trail = v.trail;
  ++resolvent_size;
  LOG ("analyzed literal %d assigned at level %d", lit, v.level);
  if (v.level == level)
    open++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ analyze_reason()

void CaDiCaL::Internal::analyze_reason	(	int	lit,
		Clause *	reason,
		int &	open,
		int &	resolvent_size,
		int &	antecedent_size )

inline

Definition at line 319 of file cadical_analyze.cpp.

                                                            {
  CADICAL_assert (reason);
  CADICAL_assert (reason != external_reason);
  bump_clause (reason);
  if (lrat)
    lrat_chain.push_back (reason->id);
  for (const auto &other : *reason)
    if (other != lit)
      analyze_literal (other, open, resolvent_size, antecedent_size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_factoring()

bool CaDiCaL::Internal::apply_factoring	(	Factoring &	factoring,
		Quotient *	q )

Definition at line 713 of file cadical_factor.cpp.

                                                                 {
  for (Quotient *p = q; p->prev; p = p->prev)
    flush_unmatched_clauses (p);
  if (self_subsuming_factor (q)) {
    for (Quotient *p = q; p; p = p->prev)
      delete_unfactored (p);
    for (Quotient *p = q; p; p = p->prev)
      update_factored (factoring, p);
    return true;
  }
  const int fresh = get_new_extension_variable ();
  if (!fresh)
    return false;
  stats.factored++;
  factoring.fresh.push_back (fresh);
  for (Quotient *p = q; p; p = p->prev)
    add_factored_divider (p, fresh);
  const int not_fresh = -fresh;
  blocked_clause (q, not_fresh);
  add_factored_quotient (q, not_fresh);
  for (Quotient *p = q; p; p = p->prev)
    delete_unfactored (p);
  for (Quotient *p = q; p; p = p->prev)
    update_factored (factoring, p);
  CADICAL_assert (fresh > 0);
  resize_factoring (factoring, fresh);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ arenaing()

bool CaDiCaL::Internal::arenaing ( )

Definition at line 527 of file cadical_collect.cpp.

527{ return opts.arena && (stats.collections > 1); }

Here is the caller graph for this function:

◆ ask_decision()

int CaDiCaL::Internal::ask_decision ( )

Definition at line 998 of file cadical_external_propagate.cpp.

                            {
  if (!external_prop || external_prop_is_lazy || private_steps)
    return 0;
 
  CADICAL_assert (!unsat);
  CADICAL_assert (!conflict);
  notify_assignments ();
  int level_before = level;
  forced_backt_allowed = true;
  int elit = external->propagator->cb_decide ();
  forced_backt_allowed = false;
  stats.ext_prop.ext_cb++;
 
  if (level_before != level) {
 
    propagate ();
    CADICAL_assert (!unsat);
    CADICAL_assert (!conflict);
    notify_assignments ();
 
    // In case the external propagator forced to backtrack below the
    // pseduo decision levels, we must go back to the CDCL loop instead of
    // making a decision.
    if ((size_t) level < assumptions.size () ||
        ((size_t) level == assumptions.size () && constraint.size ())) {
      return 0;
    }
  }
 
  if (!elit)
    return 0;
  LOG ("external propagator proposes decision: %d", elit);
  CADICAL_assert (external->is_observed[abs (elit)]);
  if (!external->is_observed[abs (elit)])
    return 0;
 
  int ilit = external->e2i[abs (elit)];
  if (elit < 0)
    ilit = -ilit;
 
  CADICAL_assert (fixed (ilit) || observed (ilit));
 
  LOG ("Asking external propagator for decision returned: %d (internal: "
       "%d, fixed: %d, val: %d)",
       elit, ilit, fixed (ilit), val (ilit));
 
  if (fixed (ilit) || val (ilit)) {
    LOG ("Proposed decision variable is already assigned, falling back to "
         "internal decision.");
    return 0;
  }
 
  return ilit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ask_external_clause()

bool CaDiCaL::Internal::ask_external_clause ( )

Definition at line 392 of file cadical_external_propagate.cpp.

                                    {
  ext_clause_forgettable = false;
  bool res =
      external->propagator->cb_has_external_clause (ext_clause_forgettable);
 
  return res;
}

Here is the caller graph for this function:

◆ assign_original_unit()

void CaDiCaL::Internal::assign_original_unit	(	int64_t	id,
		int	lit )

Definition at line 347 of file cadical_clause.cpp.

                                                        {
  CADICAL_assert (!level || opts.chrono);
  CADICAL_assert (!unsat);
  const int idx = vidx (lit);
  CADICAL_assert (!vals[idx]);
  CADICAL_assert (!flags (idx).eliminated ());
  Var &v = var (idx);
  v.level = 0;
  v.trail = (int) trail.size ();
  v.reason = 0;
  const signed char tmp = sign (lit);
  set_val (idx, tmp);
  trail.push_back (lit);
  num_assigned++;
  const unsigned uidx = vlit (lit);
  if (lrat || frat)
    unit_clauses (uidx) = id;
  LOG ("original unit assign %d", lit);
  CADICAL_assert (num_assigned == trail.size () || level);
  mark_fixed (lit);
  if (level)
    return;
  if (propagate ())
    return;
  CADICAL_assert (conflict);
  LOG ("propagation of original unit results in conflict");
  learn_empty_clause ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assign_unit()

void CaDiCaL::Internal::assign_unit ( int lit )

Definition at line 184 of file cadical_propagate.cpp.

                                   {
  CADICAL_assert (!level);
  search_assign (lit, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assignment_level()

int CaDiCaL::Internal::assignment_level	(	int	lit,
		Clause *	reason )

inline

Definition at line 42 of file cadical_propagate.cpp.

                                                              {
 
  CADICAL_assert (opts.chrono || external_prop);
  if (!reason || reason == external_reason)
    return level;
 
  int res = 0;
 
  for (const auto &other : *reason) {
    if (other == lit)
      continue;
    CADICAL_assert (val (other));
    int tmp = var (other).level;
    if (tmp > res)
      res = tmp;
  }
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assume()

void CaDiCaL::Internal::assume ( int lit )

Definition at line 13 of file cadical_assume.cpp.

                              {
  if (level && !opts.ilbassumptions)
    backtrack ();
  else if (val (lit) < 0)
    backtrack (max (0, var (lit).level - 1));
  Flags &f = flags (lit);
  const unsigned char bit = bign (lit);
  if (f.assumed & bit) {
    LOG ("ignoring already assumed %d", lit);
    return;
  }
  LOG ("assume %d", lit);
  f.assumed |= bit;
  assumptions.push_back (lit);
  freeze (lit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assume_analyze_literal()

void CaDiCaL::Internal::assume_analyze_literal ( int lit )

Definition at line 33 of file cadical_assume.cpp.

                                              {
  CADICAL_assert (lit);
  Flags &f = flags (lit);
  if (f.seen)
    return;
  f.seen = true;
  analyzed.push_back (lit);
  Var &v = var (lit);
  CADICAL_assert (val (lit) < 0);
  if (v.reason == external_reason) {
    v.reason = wrapped_learn_external_reason_clause (-lit);
    CADICAL_assert (v.reason || !v.level);
  }
  CADICAL_assert (v.reason != external_reason);
  if (!v.level) {
    int64_t id = unit_id (-lit);
    lrat_chain.push_back (id);
    return;
  }
  if (v.reason) {
    CADICAL_assert (v.level);
    LOG (v.reason, "analyze reason");
    for (const auto &other : *v.reason) {
      assume_analyze_literal (other);
    }
    lrat_chain.push_back (v.reason->id);
    return;
  }
  CADICAL_assert (assumed (-lit));
  LOG ("failed assumption %d", -lit);
  clause.push_back (lit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assume_analyze_reason()

void CaDiCaL::Internal::assume_analyze_reason	(	int	lit,
		Clause *	reason )

Definition at line 66 of file cadical_assume.cpp.

                                                             {
  CADICAL_assert (reason);
  CADICAL_assert (lrat_chain.empty ());
  CADICAL_assert (reason != external_reason);
  CADICAL_assert (lrat);
  for (const auto &other : *reason)
    if (other != lit)
      assume_analyze_literal (other);
  lrat_chain.push_back (reason->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assumed()

bool CaDiCaL::Internal::assumed ( int lit )

inline

Definition at line 1384 of file internal.hpp.

                         { // Marked as assumption.
    Flags &f = flags (lit);
    const unsigned bit = bign (lit);
    return (f.assumed & bit) != 0;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ asymmetric_literal_addition()

void CaDiCaL::Internal::asymmetric_literal_addition	(	int	lit,
		Coveror &	coveror )

inline

Definition at line 85 of file cadical_cover.cpp.

                                                                     {
  require_mode (COVER);
  CADICAL_assert (level == 1);
  LOG ("initial asymmetric literal addition %d", lit);
  CADICAL_assert (!vals[lit]), CADICAL_assert (!vals[-lit]);
  set_val (lit, -1);
  coveror.added.push_back (lit);
  coveror.alas++;
  coveror.next.covered = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ backtrack()

void CaDiCaL::Internal::backtrack ( int target_level = 0 )

Definition at line 80 of file cadical_backtrack.cpp.

                                       {
  CADICAL_assert (new_level <= level);
  if (new_level == level)
    return;
 
  update_target_and_best ();
  backtrack_without_updating_phases (new_level);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ backtrack_without_updating_phases()

void CaDiCaL::Internal::backtrack_without_updating_phases ( int target_level = 0 )

Definition at line 89 of file cadical_backtrack.cpp.

                                                               {
 
  CADICAL_assert (new_level <= level);
  if (new_level == level)
    return;
 
  stats.backtracks++;
 
  CADICAL_assert (num_assigned == trail.size ());
 
  const size_t assigned = control[new_level + 1].trail;
 
  LOG ("backtracking to decision level %d with decision %d and trail %zd",
       new_level, control[new_level].decision, assigned);
 
  const size_t end_of_trail = trail.size ();
  size_t i = assigned, j = i;
 
#ifdef LOGGING
  int unassigned = 0;
#endif
  int reassigned = 0;
 
  notify_backtrack (new_level);
  if (external_prop && !external_prop_is_lazy && !private_steps &&
      notified > assigned) {
    LOG ("external propagator is notified about some unassignments (trail: "
         "%zd, notified: %zd).",
         trail.size (), notified);
    notified = assigned;
  }
 
  while (i < end_of_trail) {
    int lit = trail[i++];
    Var &v = var (lit);
    if (v.level > new_level) {
      unassign (lit);
#ifdef LOGGING
      unassigned++;
#endif
    } else {
      // This is the essence of the SAT'18 paper on chronological
      // backtracking.  It is possible to just keep out-of-order assigned
      // literals on the trail without breaking the solver (after some
      // modifications to 'analyze' - see 'opts.chrono' guarded code there).
      CADICAL_assert (opts.chrono || external_prop || did_external_prop);
#ifdef LOGGING
      if (!v.level)
        LOG ("reassign %d @ 0 unit clause %d", lit, lit);
      else
        LOG (v.reason, "reassign %d @ %d", lit, v.level);
#endif
      trail[j] = lit;
      v.trail = j++;
      reassigned++;
    }
  }
  trail.resize (j);
  LOG ("unassigned %d literals %.0f%%", unassigned,
       percent (unassigned, unassigned + reassigned));
  LOG ("reassigned %d literals %.0f%%", reassigned,
       percent (reassigned, unassigned + reassigned));
 
  if (propagated > assigned)
    propagated = assigned;
  if (propagated2 > assigned)
    propagated2 = assigned;
  if (no_conflict_until > assigned)
    no_conflict_until = assigned;
 
  propergated = 0; // Always go back to root-level.
 
  CADICAL_assert (notified <= assigned + reassigned);
  if (reassigned) {
    notify_assignments ();
  }
 
  control.resize (new_level + 1);
  level = new_level;
  if (tainted_literal) {
    CADICAL_assert (opts.ilb);
    if (!val (tainted_literal)) {
      tainted_literal = 0;
    }
  }
  CADICAL_assert (num_assigned == trail.size ());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ backward_false_satisfiable()

int CaDiCaL::Internal::backward_false_satisfiable ( )

Definition at line 206 of file cadical_lucky.cpp.

                                          {
  LOG ("checking decreasing variable index false assignment");
  CADICAL_assert (!unsat);
  CADICAL_assert (!level);
  CADICAL_assert (assumptions.empty ());
  for (int idx = max_var; idx > 0; idx--) {
  START:
    if (terminated_asynchronously (10))
      return unlucky (-1);
    if (val (idx))
      continue;
    if (lucky_propagate_discrepency (-idx)) {
      if (unsat)
        return 20;
      else
        return unlucky (0);
    } else
      goto START;
  }
  VERBOSE (1, "backward assuming variables false satisfies formula");
  CADICAL_assert (satisfied ());
  stats.lucky.backward.zero++;
  return 10;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ backward_true_satisfiable()

int CaDiCaL::Internal::backward_true_satisfiable ( )

Definition at line 231 of file cadical_lucky.cpp.

                                         {
  LOG ("checking decreasing variable index true assignment");
  CADICAL_assert (!unsat);
  CADICAL_assert (!level);
  CADICAL_assert (assumptions.empty ());
  for (int idx = max_var; idx > 0; idx--) {
  START:
    if (terminated_asynchronously (10))
      return unlucky (-1);
    if (val (idx))
      continue;
    if (lucky_propagate_discrepency (idx)) {
      if (unsat)
        return 20;
      else
        return unlucky (0);
    } else
      goto START;
  }
  VERBOSE (1, "backward assuming variables true satisfies formula");
  CADICAL_assert (satisfied ());
  stats.lucky.backward.one++;
  return 10;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ best_quotient()

Quotient * CaDiCaL::Internal::best_quotient	(	Factoring &	factoring,
		size_t *	best_reduction_ptr )

Definition at line 217 of file cadical_factor.cpp.

                                                               {
  size_t factors = 1, best_reduction = 0;
  Quotient *best = 0;
  for (Quotient *q = factoring.quotients.first; q; q = q->next) {
    size_t quotients = q->qlauses.size ();
    size_t before_factorization = quotients * factors;
    size_t after_factorization = quotients + factors;
    if (before_factorization == after_factorization)
      LOG ("quotient[%zu] factors %zu clauses into %zu thus no change",
           factors - 1, before_factorization, after_factorization);
    else if (before_factorization < after_factorization)
      LOG ("quotient[%zu] factors %zu clauses into %zu thus %zu more",
           factors - 1, before_factorization, after_factorization,
           after_factorization - before_factorization);
    else {
      size_t delta = before_factorization - after_factorization;
      LOG ("quotient[%zu] factors %zu clauses into %zu thus %zu less",
           factors - 1, before_factorization, after_factorization, delta);
      if (!best || best_reduction < delta) {
        best_reduction = delta;
        best = q;
      }
    }
    factors++;
  }
  if (!best) {
    LOG ("no decreasing quotient found");
    return 0;
  }
  LOG ("best decreasing quotient[%zu] with reduction %zu", best->id,
       best_reduction);
  *best_reduction_ptr = best_reduction;
  return best;
}

Here is the caller graph for this function:

◆ better_decision()

bool CaDiCaL::Internal::better_decision	(	int	lit,
		int	other )

Definition at line 114 of file cadical_decide.cpp.

                                                  {
  int lit_idx = abs (lit);
  int other_idx = abs (other);
  if (stable)
    return stab[lit_idx] > stab[other_idx];
  else
    return btab[lit_idx] > btab[other_idx];
}

Here is the caller graph for this function:

◆ bins()

Bins & CaDiCaL::Internal::bins ( int lit )

inline

Definition at line 464 of file internal.hpp.

464{ return big[vlit (lit)]; }

CaDiCaL::Internal::big

vector< Bins > big

Definition internal.hpp:240

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block()

bool CaDiCaL::Internal::block ( )

Definition at line 741 of file cadical_block.cpp.

                      {
 
  if (!opts.block)
    return false;
  if (unsat)
    return false;
  if (!stats.current.irredundant)
    return false;
  if (terminated_asynchronously ())
    return false;
 
  if (propagated < trail.size ()) {
    LOG ("need to propagate %zd units first", trail.size () - propagated);
    init_watches ();
    connect_watches ();
    if (!propagate ()) {
      LOG ("propagating units results in empty clause");
      learn_empty_clause ();
      CADICAL_assert (unsat);
    }
    clear_watches ();
    reset_watches ();
    if (unsat)
      return false;
  }
 
  START_SIMPLIFIER (block, BLOCK);
 
  stats.blockings++;
 
  LOG ("block-%" PRId64 "", stats.blockings);
 
  CADICAL_assert (!level);
  CADICAL_assert (!watching ());
  CADICAL_assert (!occurring ());
 
  mark_satisfied_clauses_as_garbage ();
 
  init_occs ();  // Occurrence lists for all literals.
  init_noccs (); // Number of occurrences to avoid flushing garbage clauses.
 
  Blocker blocker (this);
  block_schedule (blocker);
 
  int64_t blocked = stats.blocked;
  int64_t resolutions = stats.blockres;
  int64_t purelits = stats.blockpurelits;
  int64_t pured = stats.blockpured;
 
  while (!terminated_asynchronously () && !blocker.schedule.empty ()) {
    int lit = u2i (blocker.schedule.front ());
    blocker.schedule.pop_front ();
    block_literal (blocker, lit);
    block_reschedule (blocker, lit);
  }
 
  blocker.erase ();
  reset_noccs ();
  reset_occs ();
 
  resolutions = stats.blockres - resolutions;
  blocked = stats.blocked - blocked;
 
  PHASE ("block", stats.blockings,
         "blocked %" PRId64 " clauses in %" PRId64 " resolutions", blocked,
         resolutions);
 
  pured = stats.blockpured - pured;
  purelits = stats.blockpurelits - purelits;
 
  if (pured)
    mark_redundant_clauses_with_eliminated_variables_as_garbage ();
 
  if (purelits)
    PHASE ("block", stats.blockings,
           "found %" PRId64 " pure literals in %" PRId64 " clauses",
           purelits, pured);
  else
    PHASE ("block", stats.blockings, "no pure literals found");
 
  report ('b', !opts.reportall && !blocked);
 
  STOP_SIMPLIFIER (block, BLOCK);
 
  return blocked;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_candidates()

size_t CaDiCaL::Internal::block_candidates	(	Blocker &	blocker,
		int	lit )

Definition at line 439 of file cadical_block.cpp.

                                                            {
 
  CADICAL_assert (blocker.candidates.empty ());
 
  Occs &pos = occs (lit); // Positive occurrences of 'lit'.
  Occs &nos = occs (-lit);
 
  CADICAL_assert ((size_t) noccs (lit) <= pos.size ());
  CADICAL_assert ((size_t) noccs (-lit) == nos.size ()); // Already flushed.
 
  // Mark all literals in clauses with '-lit'.  Note that 'mark2' uses
  // separate bits for 'lit' and '-lit'.
  //
  for (const auto &c : nos)
    mark2 (c);
 
  const auto eop = pos.end ();
  auto j = pos.begin (), i = j;
 
  for (; i != eop; i++) {
    Clause *c = *j++ = *i;
    if (c->garbage) {
      j--;
      continue;
    }
    CADICAL_assert (!c->redundant);
    if (c->size > opts.blockmaxclslim)
      continue;
    if (c->size < opts.blockminclslim)
      continue;
    const const_literal_iterator eoc = c->end ();
    const_literal_iterator l;
    for (l = c->begin (); l != eoc; l++) {
      const int other = *l;
      if (other == lit)
        continue;
      CADICAL_assert (other != -lit);
      CADICAL_assert (active (other));
      CADICAL_assert (!val (other));
      if (marked2 (-other))
        break;
    }
    if (l != eoc)
      blocker.candidates.push_back (c);
  }
  if (j == pos.begin ())
    erase_vector (pos);
  else
    pos.resize (j - pos.begin ());
 
  CADICAL_assert (pos.size () == (size_t) noccs (lit)); // Now also flushed.
 
  for (const auto &c : nos)
    unmark (c);
 
  return blocker.candidates.size ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_impossible()

Clause * CaDiCaL::Internal::block_impossible	(	Blocker &	blocker,
		int	lit )

Definition at line 504 of file cadical_block.cpp.

                                                             {
  CADICAL_assert (noccs (-lit) > 1);
  CADICAL_assert (blocker.candidates.size () > 1);
 
  for (const auto &c : blocker.candidates)
    mark2 (c);
 
  Occs &nos = occs (-lit);
  Clause *res = 0;
 
  for (const auto &c : nos) {
    CADICAL_assert (!c->garbage);
    CADICAL_assert (!c->redundant);
    CADICAL_assert (c->size <= opts.blockmaxclslim);
    const const_literal_iterator eoc = c->end ();
    const_literal_iterator l;
    for (l = c->begin (); l != eoc; l++) {
      const int other = *l;
      if (other == -lit)
        continue;
      CADICAL_assert (other != lit);
      CADICAL_assert (active (other));
      CADICAL_assert (!val (other));
      if (marked2 (-other))
        break;
    }
    if (l == eoc)
      res = c;
  }
 
  for (const auto &c : blocker.candidates)
    unmark (c);
 
  if (res) {
    LOG (res, "common non-tautological resolvent producing");
    blocker.candidates.clear ();
  }
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_literal()

void CaDiCaL::Internal::block_literal	(	Blocker &	blocker,
		int	lit )

Definition at line 694 of file cadical_block.cpp.

                                                       {
  CADICAL_assert (!marked_skip (lit));
 
  if (!active (lit))
    return; // Pure literal '-lit'.
  if (frozen (lit))
    return;
 
  CADICAL_assert (!val (lit));
 
  // If the maximum number of a negative clauses (with '-lit') exceeds the
  // occurrence limit ignore this candidate literal.
  //
  if (noccs (-lit) > opts.blockocclim)
    return;
 
  LOG ("blocking literal candidate %d "
       "with %" PRId64 " positive and %" PRId64 " negative occurrences",
       lit, noccs (lit), noccs (-lit));
 
  stats.blockcands++;
 
  CADICAL_assert (blocker.reschedule.empty ());
  CADICAL_assert (blocker.candidates.empty ());
 
  if (!noccs (-lit))
    block_pure_literal (blocker, lit);
  else if (!noccs (lit)) {
    // Rare situation, where the clause length limit was hit for 'lit' and
    // '-lit' is skipped and then it becomes pure.  Can be ignored.  We also
    // so it once happening for a 'elimboundmin=-1' and zero positive and
    // one negative occurrence.
  } else if (noccs (-lit) == 1)
    block_literal_with_one_negative_occ (blocker, lit);
  else
    block_literal_with_at_least_two_negative_occs (blocker, lit);
 
  // Done with blocked clause elimination on this literal and we do not
  // have to try blocked clause elimination on it again until irredundant
  // clauses with its negation are removed.
  //
  CADICAL_assert (!frozen (lit)); // just to be sure ...
  unmark_block (lit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_literal_with_at_least_two_negative_occs()

void CaDiCaL::Internal::block_literal_with_at_least_two_negative_occs	(	Blocker &	blocker,
		int	lit )

Definition at line 549 of file cadical_block.cpp.

                               {
  CADICAL_assert (active (lit));
  CADICAL_assert (!frozen (lit));
  CADICAL_assert (noccs (lit) > 0);
  CADICAL_assert (noccs (-lit) > 1);
 
  Occs &nos = occs (-lit);
  CADICAL_assert ((size_t) noccs (-lit) <= nos.size ());
 
  int max_size = 0;
 
  // Flush all garbage clauses in occurrence list 'nos' of '-lit' and
  // determine the maximum size of negative clauses (with '-lit').
  //
  const auto eon = nos.end ();
  auto j = nos.begin (), i = j;
  for (; i != eon; i++) {
    Clause *c = *j++ = *i;
    if (c->garbage)
      j--;
    else if (c->size > max_size)
      max_size = c->size;
  }
  if (j == nos.begin ())
    erase_vector (nos);
  else
    nos.resize (j - nos.begin ());
 
  CADICAL_assert (nos.size () == (size_t) noccs (-lit));
  CADICAL_assert (nos.size () > 1);
 
  // If the maximum size of a negative clause (with '-lit') exceeds the
  // maximum clause size limit ignore this candidate literal.
  //
  if (max_size > opts.blockmaxclslim) {
    LOG ("maximum size %d of clauses with %d exceeds clause size limit %d",
         max_size, -lit, opts.blockmaxclslim);
    return;
  }
 
  LOG ("maximum size %d of clauses with %d", max_size, -lit);
 
  // We filter candidate clauses with positive occurrence of 'lit' in
  // 'blocker.candidates' and return if no candidate clause remains.
  // Candidates should be small enough and should have at least one literal
  // which occurs negated in one of the clauses with '-lit'.
  //
  size_t candidates = block_candidates (blocker, lit);
  if (!candidates) {
    LOG ("no candidate clauses found");
    return;
  }
 
  LOG ("found %zd candidate clauses", candidates);
 
  // We further search for a clause with '-lit' that has no literal
  // negated in any of the candidate clauses (except 'lit').  If such a
  // clause exists, we know that none of the candidates is blocked.
  //
  if (candidates > 1 && block_impossible (blocker, lit)) {
    LOG ("impossible to block any candidate clause on %d", lit);
    CADICAL_assert (blocker.candidates.empty ());
    return;
  }
 
  LOG ("trying to block %zd clauses out of %" PRId64 " with literal %d",
       candidates, noccs (lit), lit);
 
  int64_t blocked = 0;
 
  // Go over all remaining candidates and try to block them on 'lit'.
  //
  for (const auto &c : blocker.candidates) {
    CADICAL_assert (!c->garbage);
    CADICAL_assert (!c->redundant);
    if (!is_blocked_clause (c, lit))
      continue;
    blocked++;
    LOG (c, "blocked");
    if (proof) {
      proof->weaken_minus (c);
    }
    external->push_clause_on_extension_stack (c, lit);
    blocker.reschedule.push_back (c);
    mark_garbage (c);
  }
 
  LOG ("blocked %" PRId64
       " clauses on %d out of %zd candidates in %zd occurrences",
       blocked, lit, blocker.candidates.size (), occs (lit).size ());
 
  blocker.candidates.clear ();
  stats.blocked += blocked;
  if (blocked)
    flush_occs (lit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_literal_with_one_negative_occ()

void CaDiCaL::Internal::block_literal_with_one_negative_occ	(	Blocker &	blocker,
		int	lit )

Definition at line 302 of file cadical_block.cpp.

                                                             {
  CADICAL_assert (active (lit));
  CADICAL_assert (!frozen (lit));
  CADICAL_assert (noccs (lit) > 0);
  CADICAL_assert (noccs (-lit) == 1);
 
  Occs &nos = occs (-lit);
  CADICAL_assert (nos.size () >= 1);
 
  Clause *d = 0;
  for (const auto &c : nos) {
    if (c->garbage)
      continue;
    CADICAL_assert (!d);
    d = c;
#ifndef CADICAL_NDEBUG
    break;
#endif
  }
  CADICAL_assert (d);
  nos.resize (1);
  nos[0] = d;
 
  if (d && d->size > opts.blockmaxclslim) {
    LOG (d, "skipped common antecedent");
    return;
  }
 
  CADICAL_assert (!d->garbage);
  CADICAL_assert (!d->redundant);
  CADICAL_assert (d->size <= opts.blockmaxclslim);
 
  LOG (d, "common %d antecedent", lit);
  mark (d);
  int64_t blocked = 0;
#ifdef LOGGING
  int64_t skipped = 0;
#endif
  Occs &pos = occs (lit);
 
  // Again no 'auto' since 'pos' is update during traversal.
  //
  const auto eop = pos.end ();
  auto j = pos.begin (), i = j;
 
  for (; i != eop; i++) {
    Clause *c = *j++ = *i;
 
    if (c->garbage) {
      j--;
      continue;
    }
    if (c->size > opts.blockmaxclslim) {
#ifdef LOGGING
      skipped++;
#endif
      continue;
    }
    if (c->size < opts.blockminclslim) {
#ifdef LOGGING
      skipped++;
#endif
      continue;
    }
 
    LOG (c, "trying to block on %d", lit);
 
    // We use the same literal move-to-front strategy as in
    // 'is_blocked_clause'.  See there for more explanations.
 
    int prev_other = 0; // Previous non-tautological literal.
 
    // No 'auto' since literals of 'c' are updated during traversal.
    //
    const const_literal_iterator end_of_c = c->end ();
    literal_iterator l;
 
    for (l = c->begin (); l != end_of_c; l++) {
      const int other = *l;
      *l = prev_other;
      prev_other = other;
      if (other == lit)
        continue;
      CADICAL_assert (other != -lit);
      CADICAL_assert (active (other));
      CADICAL_assert (!val (other));
      if (marked (other) < 0) {
        LOG ("found tautological literal %d", other);
        c->literals[0] = other; // Move to front of 'c'.
        break;
      }
    }
 
    if (l == end_of_c) {
      LOG ("no tautological literal found");
 
      // Restore old literal order in the clause because.
 
      const const_literal_iterator begin_of_c = c->begin ();
      while (l-- != begin_of_c) {
        const int other = *l;
        *l = prev_other;
        prev_other = other;
      }
 
      continue; // ... with next candidate 'c' in 'pos'.
    }
 
    blocked++;
    LOG (c, "blocked");
    if (proof) {
      proof->weaken_minus (c);
    }
    external->push_clause_on_extension_stack (c, lit);
    blocker.reschedule.push_back (c);
    mark_garbage (c);
    j--;
  }
  if (j == pos.begin ())
    erase_vector (pos);
  else
    pos.resize (j - pos.begin ());
 
  stats.blocked += blocked;
  LOG ("blocked %" PRId64 " clauses on %d (skipped %" PRId64 ")", blocked,
       lit, skipped);
 
  unmark (d);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_pure_literal()

void CaDiCaL::Internal::block_pure_literal	(	Blocker &	blocker,
		int	lit )

Definition at line 253 of file cadical_block.cpp.

                                                            {
  if (frozen (lit))
    return;
  CADICAL_assert (active (lit));
 
  Occs &pos = occs (lit);
  Occs &nos = occs (-lit);
 
  CADICAL_assert (!noccs (-lit));
#ifndef CADICAL_NDEBUG
  for (const auto &c : nos)
    CADICAL_assert (c->garbage);
#endif
  stats.blockpurelits++;
  LOG ("found pure literal %d", lit);
#ifdef LOGGING
  int64_t pured = 0;
#endif
  for (const auto &c : pos) {
    if (c->garbage)
      continue;
    CADICAL_assert (!c->redundant);
    LOG (c, "pure literal %d in", lit);
    blocker.reschedule.push_back (c);
    if (proof) {
      proof->weaken_minus (c);
    }
    external->push_clause_on_extension_stack (c, lit);
    stats.blockpured++;
    mark_garbage (c);
#ifdef LOGGING
    pured++;
#endif
  }
 
  erase_vector (pos);
  erase_vector (nos);
 
  mark_pure (lit);
  stats.blockpured++;
  LOG ("blocking %" PRId64 " clauses on pure literal %d", pured, lit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_reschedule()

void CaDiCaL::Internal::block_reschedule	(	Blocker &	blocker,
		int	lit )

Definition at line 684 of file cadical_block.cpp.

                                                          {
  while (!blocker.reschedule.empty ()) {
    Clause *c = blocker.reschedule.back ();
    blocker.reschedule.pop_back ();
    block_reschedule_clause (blocker, lit, c);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_reschedule_clause()

void CaDiCaL::Internal::block_reschedule_clause	(	Blocker &	blocker,
		int	lit,
		Clause *	c )

Definition at line 651 of file cadical_block.cpp.

                                                   {
#ifdef CADICAL_NDEBUG
  (void) lit;
#endif
  CADICAL_assert (c->garbage);
 
  for (const auto &other : *c) {
 
    int64_t &n = noccs (other);
    CADICAL_assert (n > 0);
    n--;
 
    LOG ("updating %d with %" PRId64 " positive and %" PRId64
         " negative occurrences",
         other, noccs (other), noccs (-other));
 
    if (blocker.schedule.contains (vlit (-other)))
      blocker.schedule.update (vlit (-other));
    else if (active (other) && !frozen (other) && !marked_skip (-other)) {
      LOG ("rescheduling to block clauses on %d", -other);
      blocker.schedule.push_back (vlit (-other));
    }
 
    if (blocker.schedule.contains (vlit (other))) {
      CADICAL_assert (other != lit);
      blocker.schedule.update (vlit (other));
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_schedule()

void CaDiCaL::Internal::block_schedule ( Blocker & blocker )

Definition at line 153 of file cadical_block.cpp.

                                               {
  // Set skip flags for all literals in too large clauses.
  //
  for (const auto &c : clauses) {
 
    if (c->garbage)
      continue;
    if (c->redundant)
      continue;
    if (c->size <= opts.blockmaxclslim)
      continue;
 
    for (const auto &lit : *c)
      mark_skip (-lit);
  }
 
  // Connect all literal occurrences in irredundant clauses.
  //
  for (const auto &c : clauses) {
 
    if (c->garbage)
      continue;
    if (c->redundant)
      continue;
 
    for (const auto &lit : *c) {
      CADICAL_assert (active (lit));
      CADICAL_assert (!val (lit));
      occs (lit).push_back (c);
    }
  }
 
  // We establish the invariant that 'noccs' gives the number of actual
  // occurrences of 'lit' in non-garbage clauses,  while 'occs' might still
  // refer to garbage clauses, thus 'noccs (lit) <= occs (lit).size ()'.  It
  // is expensive to remove references to garbage clauses from 'occs' during
  // blocked clause elimination, but decrementing 'noccs' is cheap.
 
  for (auto lit : lits) {
    if (!active (lit))
      continue;
    CADICAL_assert (!val (lit));
    Occs &os = occs (lit);
    noccs (lit) = os.size ();
  }
 
  // Now we fill the schedule (priority queue) of candidate literals to be
  // tried as blocking literals.  It is probably slightly faster to do this
  // in one go after all occurrences have been determined, instead of
  // filling the priority queue during pushing occurrences.  Filling the
  // schedule can not be fused with the previous loop (easily) since we
  // first have to initialize 'noccs' for both 'lit' and '-lit'.
 
#ifndef CADICAL_QUIET
  int skipped = 0;
#endif
 
  for (auto idx : vars) {
    if (!active (idx))
      continue;
    if (frozen (idx)) {
#ifndef CADICAL_QUIET
      skipped += 2;
#endif
      continue;
    }
    CADICAL_assert (!val (idx));
    for (int sign = -1; sign <= 1; sign += 2) {
      const int lit = sign * idx;
      if (marked_skip (lit)) {
#ifndef CADICAL_QUIET
        skipped++;
#endif
        continue;
      }
      if (!marked_block (lit))
        continue;
      unmark_block (lit);
      LOG ("scheduling %d with %" PRId64 " positive and %" PRId64
           " negative occurrences",
           lit, noccs (lit), noccs (-lit));
      blocker.schedule.push_back (vlit (lit));
    }
  }
 
  PHASE ("block", stats.blockings,
         "scheduled %zd candidate literals %.2f%% (%d skipped %.2f%%)",
         blocker.schedule.size (),
         percent (blocker.schedule.size (), 2.0 * active ()), skipped,
         percent (skipped, 2.0 * active ()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ blocked_clause()

void CaDiCaL::Internal::blocked_clause	(	Quotient *	q,
		int	not_fresh )

Definition at line 613 of file cadical_factor.cpp.

                                                         {
  if (!proof)
    return;
  int64_t new_id = ++clause_id;
  q->bid = new_id;
  CADICAL_assert (clause.empty ());
  for (Quotient *p = q; p; p = p->prev)
    clause.push_back (-p->factor);
  clause.push_back (not_fresh);
  CADICAL_assert (!lrat || mini_chain.size ());
  proof->add_derived_clause (new_id, true, clause, mini_chain);
  mini_chain.clear ();
  clause.clear ();
}

Here is the caller graph for this function:

◆ build_chain_for_empty()

void CaDiCaL::Internal::build_chain_for_empty ( )

Definition at line 89 of file cadical_propagate.cpp.

                                      {
  if (!lrat || !lrat_chain.empty ())
    return;
  CADICAL_assert (!level);
  CADICAL_assert (lrat_chain.empty ());
  CADICAL_assert (conflict);
  LOG (conflict, "lrat for global empty clause with conflict");
  for (auto &lit : *conflict) {
    CADICAL_assert (val (lit) < 0);
    int64_t id = unit_id (-lit);
    lrat_chain.push_back (id);
  }
  lrat_chain.push_back (conflict->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ build_chain_for_units()

void CaDiCaL::Internal::build_chain_for_units	(	int	lit,
		Clause *	reason,
		bool	forced )

Definition at line 64 of file cadical_propagate.cpp.

                                                   {
  if (!lrat)
    return;
  if (opts.chrono && assignment_level (lit, reason) && !forced)
    return;
  else if (!opts.chrono && level && !forced)
    return; // not decision level 0
  CADICAL_assert (lrat_chain.empty ());
  for (auto &reason_lit : *reason) {
    if (lit == reason_lit)
      continue;
    CADICAL_assert (val (reason_lit));
    if (!val (reason_lit))
      continue;
    const int signed_reason_lit = val (reason_lit) * reason_lit;
    int64_t id = unit_id (signed_reason_lit);
    lrat_chain.push_back (id);
  }
  lrat_chain.push_back (reason->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ build_lrat_for_clause()

void CaDiCaL::Internal::build_lrat_for_clause	(	const vector< vector< Clause * > > &	dfs_chains,
		bool	invert = false )

Definition at line 72 of file cadical_decompose.cpp.

                                                             {
  CADICAL_assert (lrat);
  LOG ("building chain for not subsumed clause");
  CADICAL_assert (lrat_chain.empty ());
  CADICAL_assert (sign_marked.empty ());
  // build chain for each replaced literal
  for (const auto lit : clause) {
    auto other = lit;
    if (val (other) > 0) {
      if (marked_decomposed (other))
        continue;
      mark_decomposed (other);
      int64_t id = unit_id (other);
      lrat_chain.push_back (id);
      continue;
    }
    CADICAL_assert (mini_chain.empty ());
    for (auto p : dfs_chains[vlit (other)]) {
      if (marked_decomposed (other))
        continue;
      mark_decomposed (other);
      int implied = p->literals[0];
      implied = implied == other ? -p->literals[1] : -implied;
      LOG ("ADDED %d -> %d (%" PRId64 ")", implied, other, p->id);
      other = implied;
      mini_chain.push_back (p->id);
      if (val (implied) <= 0)
        continue;
      if (marked_decomposed (implied))
        break;
      mark_decomposed (implied);
      int64_t id = unit_id (implied);
      mini_chain.push_back (id);
      break;
    }
    if (invert)
      for (auto p = mini_chain.rbegin (); p != mini_chain.rend (); p++)
        lrat_chain.push_back (*p);
    else
      for (auto p = mini_chain.begin (); p != mini_chain.end (); p++)
        lrat_chain.push_back (*p);
    mini_chain.clear ();
  }
  clear_sign_marked_literals ();
  LOG (lrat_chain, "lrat_chain:");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bump_also_all_reason_literals()

void CaDiCaL::Internal::bump_also_all_reason_literals ( )

inline

Definition at line 387 of file cadical_analyze.cpp.

                                                     {
  CADICAL_assert (opts.bump);
  if (!opts.bumpreason)
    return;
  if (averages.current.decisions > opts.bumpreasonrate) {
    LOG ("decisions per conflict rate %g > limit %d",
         (double) averages.current.decisions, opts.bumpreasonrate);
    return;
  }
  if (delay[stable].bumpreasons.limit) {
    LOG ("delaying reason bumping %" PRId64 " more times",
         delay[stable].bumpreasons.limit);
    delay[stable].bumpreasons.limit--;
    return;
  }
  CADICAL_assert (opts.bumpreasondepth > 0);
  const int depth_limit = opts.bumpreasondepth + stable;
  size_t saved_analyzed = analyzed.size ();
  size_t analyzed_limit = saved_analyzed * opts.bumpreasonlimit;
  for (const auto &lit : clause)
    if (analyzed.size () <= analyzed_limit)
      bump_also_reason_literals (-lit, depth_limit, analyzed_limit);
    else
      break;
  if (analyzed.size () > analyzed_limit) {
    LOG ("not bumping reason side literals as limit exhausted");
    for (size_t i = saved_analyzed; i != analyzed.size (); i++) {
      const int lit = analyzed[i];
      Flags &f = flags (lit);
      CADICAL_assert (f.seen);
      f.seen = false;
    }
    delay[stable].bumpreasons.interval++;
    analyzed.resize (saved_analyzed);
  } else {
    LOG ("bumping reasons up to depth %d", opts.bumpreasondepth);
    delay[stable].bumpreasons.interval /= 2;
  }
  LOG ("delay internal %" PRId64, delay[stable].bumpreasons.interval);
  delay[stable].bumpreasons.limit = delay[stable].bumpreasons.interval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bump_also_reason_literal()

bool CaDiCaL::Internal::bump_also_reason_literal ( int lit )

inline

Definition at line 345 of file cadical_analyze.cpp.

                                                       {
  CADICAL_assert (lit);
  CADICAL_assert (val (lit) < 0);
  Flags &f = flags (lit);
  if (f.seen)
    return false;
  const Var &v = var (lit);
  if (!v.level)
    return false;
  f.seen = true;
  analyzed.push_back (lit);
  LOG ("bumping also reason literal %d assigned at level %d", lit, v.level);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bump_also_reason_literals()

void CaDiCaL::Internal::bump_also_reason_literals	(	int	lit,
		int	depth_limit,
		size_t	size_limit )

inline

Definition at line 362 of file cadical_analyze.cpp.

                                                                        {
  CADICAL_assert (lit);
  CADICAL_assert (depth_limit > 0);
  const Var &v = var (lit);
  CADICAL_assert (val (lit));
  if (!v.level)
    return;
  Clause *reason = v.reason;
  if (!reason || reason == external_reason)
    return;
  stats.ticks.search[stable]++;
  for (const auto &other : *reason) {
    if (other == lit)
      continue;
    if (!bump_also_reason_literal (other))
      continue;
    if (depth_limit < 2)
      continue;
    bump_also_reason_literals (-other, depth_limit - 1, analyzed_limit);
    if (analyzed.size () > analyzed_limit)
      break;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bump_clause()

void CaDiCaL::Internal::bump_clause ( Clause * c )

inline

Definition at line 228 of file cadical_analyze.cpp.

                                            {
  LOG (c, "bumping");
  c->used = max_used;
  if (c->hyper)
    return;
  if (!c->redundant)
    return;
  int new_glue = recompute_glue (c);
  if (new_glue < c->glue)
    promote_clause (c, new_glue);
 
  const size_t glue =
      std::min ((size_t) c->glue, stats.used[stable].size () - 1);
  ++stats.used[stable][glue];
  ++stats.bump_used[stable];
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bump_clause2()

void CaDiCaL::Internal::bump_clause2 ( Clause * c )

Definition at line 245 of file cadical_analyze.cpp.

245{ bump_clause (c); }

Here is the call graph for this function:

◆ bump_queue()

void CaDiCaL::Internal::bump_queue ( int idx )

Definition at line 56 of file cadical_analyze.cpp.

                                  {
  CADICAL_assert (opts.bump);
  const int idx = vidx (lit);
  if (!links[idx].next)
    return;
  queue.dequeue (links, idx);
  queue.enqueue (links, idx);
  CADICAL_assert (stats.bumped != INT64_MAX);
  btab[idx] = ++stats.bumped;
  LOG ("moved to front variable %d and bumped to %" PRId64 "", idx,
       btab[idx]);
  if (!vals[idx])
    update_queue_unassigned (idx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bump_variable()

void CaDiCaL::Internal::bump_variable ( int lit )

Definition at line 131 of file cadical_analyze.cpp.

                                     {
  if (use_scores ())
    bump_variable_score (lit);
  else
    bump_queue (lit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bump_variable_score()

void CaDiCaL::Internal::bump_variable_score ( int lit )

Definition at line 109 of file cadical_analyze.cpp.

                                           {
  CADICAL_assert (opts.bump);
  int idx = vidx (lit);
  double old_score = score (idx);
  CADICAL_assert (!evsids_limit_hit (old_score));
  double new_score = old_score + score_inc;
  if (evsids_limit_hit (new_score)) {
    LOG ("bumping %g score of %d hits EVSIDS score limit", old_score, idx);
    rescale_variable_scores ();
    old_score = score (idx);
    CADICAL_assert (!evsids_limit_hit (old_score));
    new_score = old_score + score_inc;
  }
  CADICAL_assert (!evsids_limit_hit (new_score));
  LOG ("new %g score of %d", new_score, idx);
  score (idx) = new_score;
  if (scores.contains (idx))
    scores.update (idx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bump_variable_score_inc()

void CaDiCaL::Internal::bump_variable_score_inc ( )

Definition at line 141 of file cadical_analyze.cpp.

                                        {
  CADICAL_assert (use_scores ());
  CADICAL_assert (!evsids_limit_hit (score_inc));
  double f = 1e3 / opts.scorefactor;
  double new_score_inc = score_inc * f;
  if (evsids_limit_hit (new_score_inc)) {
    LOG ("bumping %g increment by %g hits EVSIDS score limit", score_inc,
         f);
    rescale_variable_scores ();
    new_score_inc = score_inc * f;
  }
  CADICAL_assert (!evsids_limit_hit (new_score_inc));
  LOG ("bumped score increment from %g to %g with factor %g", score_inc,
       new_score_inc, f);
  score_inc = new_score_inc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bump_variables()

void CaDiCaL::Internal::bump_variables ( )

Definition at line 179 of file cadical_analyze.cpp.

                               {
 
  CADICAL_assert (opts.bump);
 
  START (bump);
 
  if (!use_scores ()) {
 
    // Variables are bumped in the order they are in the current decision
    // queue.  This maintains relative order between bumped variables in
    // the queue and seems to work best.  We also experimented with
    // focusing on variables of the last decision level, but results were
    // mixed.
 
    MSORT (opts.radixsortlim, analyzed.begin (), analyzed.end (),
           analyze_bumped_rank (this), analyze_bumped_smaller (this));
  }
 
  for (const auto &lit : analyzed)
    bump_variable (lit);
 
  if (use_scores ())
    bump_variable_score_inc ();
 
  STOP (bump);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bumped()

int64_t & CaDiCaL::Internal::bumped ( int lit )

inline

Definition at line 455 of file internal.hpp.

455{ return btab[vidx (lit)]; }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cache_lines() [1/2]

int64_t CaDiCaL::Internal::cache_lines ( size_t bytes )

inline

Definition at line 722 of file internal.hpp.

722{ return (bytes + 127) / 128; }

Here is the caller graph for this function:

◆ cache_lines() [2/2]

int64_t CaDiCaL::Internal::cache_lines	(	size_t	n,
		size_t	bytes )

inline

Definition at line 723 of file internal.hpp.

                                               {
    return cache_lines (n * bytes);
  }

Here is the call graph for this function:

◆ cadical_kitten_ticks_limit_hit()

bool CaDiCaL::Internal::cadical_kitten_ticks_limit_hit	(	Sweeper &	sweeper,
		const char *	when )

Definition at line 201 of file cadical_sweep.cpp.

                                                                                 {
  const uint64_t current =
      cadical_kitten_current_ticks (citten) + sweeper.current_ticks;
  if (current >= sweeper.limit.ticks) {
    LOG ("'cadical_kitten_ticks' limit of %" PRIu64 " ticks hit after %" PRIu64
         " ticks during %s",
         sweeper.limit.ticks, current, when);
    return true;
  }
#ifndef LOGGING
  (void) when;
#endif
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculate_minimize_chain()

void CaDiCaL::Internal::calculate_minimize_chain	(	int	lit,
		std::vector< int > &	stack )

Definition at line 159 of file cadical_minimize.cpp.

                                                                       {
  CADICAL_assert (stack.empty ());
  stack.push_back (vidx (lit));
 
  while (!stack.empty ()) {
    const int idx = stack.back ();
    CADICAL_assert (idx);
    stack.pop_back ();
    if (idx < 0) {
      Var &v = var (idx);
      mini_chain.push_back (v.reason->id);
      continue;
    }
    CADICAL_assert (idx);
    Flags &f = flags (idx);
    Var &v = var (idx);
    if (f.keep || f.added || f.poison) {
      continue;
    }
    if (!v.level) {
      if (f.seen)
        continue;
      f.seen = true;
      unit_analyzed.push_back (idx);
      const int lit = val (idx) > 0 ? idx : -idx;
      int64_t id = unit_id (lit);
      unit_chain.push_back (id);
      continue;
    }
    f.added = true;
    CADICAL_assert (v.reason && f.removable);
    const const_literal_iterator end = v.reason->end ();
    const_literal_iterator i;
    LOG (v.reason, "LRAT chain for lit %d at depth %zd by going over", lit,
         stack.size ());
    stack.push_back (-idx);
    for (i = v.reason->begin (); i != end; i++) {
      const int other = *i;
      if (other == idx)
        continue;
      stack.push_back (vidx (other));
    }
  }
  CADICAL_assert (stack.empty ());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ can_sweep_clause()

bool CaDiCaL::Internal::can_sweep_clause ( Clause * c )

Definition at line 68 of file cadical_sweep.cpp.

                                          {
  if (c->garbage)
    return false;
  if (!c->redundant)
    return true;
  return c->size == 2; // && !c->hyper;  // could ignore hyper
}

Here is the caller graph for this function:

◆ cdcl_loop_with_inprocessing()

int CaDiCaL::Internal::cdcl_loop_with_inprocessing ( )

Definition at line 276 of file cadical_internal.cpp.

                                           {
 
  int res = 0;
 
  START (search);
 
  if (stable) {
    START (stable);
    report ('[');
  } else {
    START (unstable);
    report ('{');
  }
 
  while (!res) {
    if (unsat)
      res = 20;
    else if (unsat_constraint)
      res = 20;
    else if (!propagate_wrapper ())
      analyze_wrapper (); // propagate and analyze
    else if (iterating)
      iterate ();                               // report learned unit
    else if (!external_propagate () || unsat) { // external propagation
      if (unsat)
        continue;
      else
        analyze ();
    } else if (satisfied ()) { // found model
      if (!external_check_solution () || unsat) {
        if (unsat)
          continue;
        else
          analyze ();
      } else if (satisfied ())
        res = 10;
    } else if (search_limits_hit ())
      break;                               // decision or conflict limit
    else if (terminated_asynchronously ()) // externally terminated
      break;
    else if (restarting ())
      restart (); // restart by backtracking
    else if (rephasing ())
      rephase (); // reset variable phases
    else if (reducing ())
      reduce (); // collect useless clauses
    else if (inprobing ())
      inprobe (); // schedule of inprocessing
    else if (ineliminating ())
      elim (); // variable elimination
    else if (compacting ())
      compact (); // collect variables
    else if (conditioning ())
      condition (); // globally blocked clauses
    else
      res = decide (); // next decision
  }
 
  if (stable) {
    STOP (stable);
    report (']');
  } else {
    STOP (unstable);
    report ('}');
  }
 
  STOP (search);
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check()

void CaDiCaL::Internal::check ( )

Definition at line 162 of file cadical_proof.cpp.

                      {
  new_proof_on_demand ();
  if (opts.checkproof > 1) {
    StatTracer *lratchecker = new LratChecker (this);
    DeferDeletePtr<LratChecker> delete_lratchecker (
        (LratChecker *) lratchecker);
    LOG ("PROOF connecting LRAT proof checker");
    force_lrat ();
    frat = true;
    resize_unit_clauses_idx ();
    proof->connect (lratchecker);
    stat_tracers.push_back (lratchecker);
    delete_lratchecker.release ();
  }
  if (opts.checkproof == 1 || opts.checkproof == 3) {
    StatTracer *checker = new Checker (this);
    DeferDeletePtr<Checker> delete_checker ((Checker *) checker);
    LOG ("PROOF connecting proof checker");
    proof->connect (checker);
    stat_tracers.push_back (checker);
    delete_checker.release ();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_clause_stats()

void CaDiCaL::Internal::check_clause_stats ( )

Definition at line 452 of file cadical_collect.cpp.

                                   {
#ifndef CADICAL_NDEBUG
  int64_t irredundant = 0, redundant = 0, total = 0, irrlits = 0;
  for (const auto &c : clauses) {
    if (c->garbage)
      continue;
    if (c->redundant)
      redundant++;
    else
      irredundant++;
    if (!c->redundant)
      irrlits += c->size;
    total++;
  }
  CADICAL_assert (stats.current.irredundant == irredundant);
  CADICAL_assert (stats.current.redundant == redundant);
  CADICAL_assert (stats.current.total == total);
  CADICAL_assert (stats.irrlits == irrlits);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_var_stats()

void CaDiCaL::Internal::check_var_stats ( )

Definition at line 15 of file cadical_var.cpp.

                                {
#ifndef CADICAL_NDEBUG
  int64_t fixed = 0, eliminated = 0, substituted = 0, pure = 0, unused = 0;
  for (auto idx : vars) {
    Flags &f = flags (idx);
    if (f.active ())
      continue;
    if (f.fixed ())
      fixed++;
    if (f.eliminated ())
      eliminated++;
    if (f.substituted ())
      substituted++;
    if (f.unused ())
      unused++;
    if (f.pure ())
      pure++;
  }
  CADICAL_assert (stats.now.fixed == fixed);
  CADICAL_assert (stats.now.eliminated == eliminated);
  CADICAL_assert (stats.now.substituted == substituted);
  CADICAL_assert (stats.now.pure == pure);
  int64_t inactive = unused + fixed + eliminated + substituted + pure;
  CADICAL_assert (stats.inactive == inactive);
  CADICAL_assert (max_var == stats.active + stats.inactive);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_watched_literal_invariants()

void CaDiCaL::Internal::check_watched_literal_invariants ( )

Definition at line 1085 of file cadical_external_propagate.cpp.

                                                 {
#ifndef CADICAL_NDEBUG
  int v0 = 0;
  int v1 = 0;
 
  if (val (clause[0]) > 0)
    v0 = 1;
  else if (val (clause[0]) < 0)
    v0 = -1;
 
  if (val (clause[1]) > 0)
    v1 = 1;
  else if (val (clause[1]) < 0)
    v1 = -1;
  CADICAL_assert (v0 >= v1);
#endif
  if (val (clause[0]) > 0) {
    if (val (clause[1]) > 0) { // Case 1: Both literals are satisfied
      // They are ordered by lower to higher decision level
      CADICAL_assert (var (clause[0]).level <= var (clause[1]).level);
 
      // Every other literal of the clause is either
      //    - satisfied at higher level
      //    - unassigned
      //    - falsified
      for (size_t i = 2; i < clause.size (); i++)
        CADICAL_assert (val (clause[i]) <= 0 ||
                (var (clause[1]).level <= var (clause[i]).level));
 
    } else if (val (clause[1]) ==
               0) { // Case 2: First satisfied, next unassigned
 
      // Every other literal of the clause is either
      //    - unassigned
      //    - falsified
      for (size_t i = 2; i < clause.size (); i++)
        CADICAL_assert (val (clause[i]) <= 0);
 
    } else { // Case 3: First satisfied, next falsified -> could have been a
             // reason of a previous propagation
      // Every other literal of the clause is falsified but at a lower
      // decision level
      for (size_t i = 2; i < clause.size (); i++)
        CADICAL_assert (val (clause[i]) < 0 &&
                (var (clause[1]).level >= var (clause[i]).level));
    }
  } else if (val (clause[0]) == 0) {
    if (val (clause[1]) == 0) { // Case 4: Both literals are unassigned
 
      // Every other literal of the clause is either
      //    - unassigned
      //    - falsified
      for (size_t i = 2; i < clause.size (); i++)
        CADICAL_assert (val (clause[i]) <= 0);
 
    } else { // Case 5: First unassigned, next falsified -> PROPAGATE
      // Every other literal of the clause is falsified but at a lower
      // decision level
      for (size_t i = 2; i < clause.size (); i++)
        CADICAL_assert (val (clause[i]) < 0 &&
                (var (clause[1]).level >= var (clause[i]).level));
    }
  } else {
    CADICAL_assert (val (clause[0]) < 0 &&
            val (clause[1]) < 0); // Case 6: Both literals are falsified
 
    // They are ordered by higher to lower decision level
    CADICAL_assert (var (clause[0]).level >= var (clause[1]).level);
 
    // Every other literal of the clause is falsified, but at a lower level
    for (size_t i = 2; i < clause.size (); i++)
      CADICAL_assert (val (clause[i]) < 0 &&
              (var (clause[1]).level >= var (clause[i]).level));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ citten2lit()

int CaDiCaL::Internal::citten2lit ( unsigned ulit )

inline

Definition at line 421 of file internal.hpp.

                                 {
    int res = (ulit / 2) + 1;
    CADICAL_assert (res <= max_var);
    if (ulit & 1)
      res = -res;
    return res;
  }

◆ citten_clear_track_log_terminate()

void CaDiCaL::Internal::citten_clear_track_log_terminate ( )

Definition at line 482 of file cadical_sweep.cpp.

                                                 {
  CADICAL_assert (citten);
  cadical_kitten_clear (citten);
  cadical_kitten_track_antecedents (citten);
  if (external->terminator)
    cadical_kitten_set_terminator (citten, internal, citten_terminate);
#ifdef LOGGING
  if (opts.log)
    cadical_kitten_set_logging (citten);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clause_contains_fixed_literal()

int CaDiCaL::Internal::clause_contains_fixed_literal ( Clause * c )

Definition at line 16 of file cadical_collect.cpp.

                                                      {
  int satisfied = 0, falsified = 0;
  for (const auto &lit : *c) {
    const int tmp = fixed (lit);
    if (tmp > 0) {
      LOG (c, "root level satisfied literal %d in", lit);
      satisfied++;
    }
    if (tmp < 0) {
      LOG (c, "root level falsified literal %d in", lit);
      falsified++;
    }
  }
  if (satisfied)
    return 1;
  else if (falsified)
    return -1;
  else
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clause_variable_ratio()

double CaDiCaL::Internal::clause_variable_ratio ( ) const

inline

Definition at line 385 of file internal.hpp.

                                        {
    return relative (irredundant (), active ());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clean_probehbr_lrat()

void CaDiCaL::Internal::clean_probehbr_lrat ( )

Definition at line 58 of file cadical_probe.cpp.

                                    {
  if (!lrat || opts.probehbr)
    return;
  for (auto &field : probehbr_chains) {
    for (auto &chain : field) {
      chain.clear ();
    }
  }
}

Here is the caller graph for this function:

◆ clear_analyzed_levels()

void CaDiCaL::Internal::clear_analyzed_levels ( )

Definition at line 466 of file cadical_analyze.cpp.

                                      {
  LOG ("clearing %zd analyzed levels", levels.size ());
  for (const auto &l : levels)
    if (l < (int) control.size ())
      control[l].reset ();
  levels.clear ();
}

Here is the caller graph for this function:

◆ clear_analyzed_literals()

void CaDiCaL::Internal::clear_analyzed_literals ( )

Definition at line 445 of file cadical_analyze.cpp.

                                        {
  LOG ("clearing %zd analyzed literals", analyzed.size ());
  for (const auto &lit : analyzed) {
    Flags &f = flags (lit);
    CADICAL_assert (f.seen);
    f.seen = false;
    CADICAL_assert (!f.keep);
    CADICAL_assert (!f.poison);
    CADICAL_assert (!f.removable);
  }
  analyzed.clear ();
#if 0 // to expensive, even for debugging mode
  if (unit_analyzed.size ())
    return;
  for (auto idx : vars) {
    Flags &f = flags (idx);
    CADICAL_assert (!f.seen);
  }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_core()

void CaDiCaL::Internal::clear_core	(	Sweeper &	sweeper,
		unsigned	core_idx )

Definition at line 612 of file cadical_sweep.cpp.

                                                              {
  CADICAL_assert (core_idx == 0 || core_idx == 1);
  LOG ("clearing core[%u] lemmas", core_idx);
  vector<sweep_proof_clause> &core = sweeper.core[core_idx];
  if (proof) {
    LOG ("deleting sub-solver core clauses");
    for (auto &pc : core) {
      if (pc.learned && pc.literals.size () > 1)
        proof->delete_clause (pc.cad_id, true, pc.literals);
    }
  }
  core.clear ();
}

Here is the caller graph for this function:

◆ clear_flauses()

void CaDiCaL::Internal::clear_flauses ( vector< Clause * > & flauses )

Definition at line 209 of file cadical_factor.cpp.

                                                       {
  for (auto c : flauses) {
    CADICAL_assert (c->swept);
    c->swept = false;
  }
  flauses.clear ();
}

Here is the caller graph for this function:

◆ clear_minimized_literals()

void CaDiCaL::Internal::clear_minimized_literals ( )

Definition at line 215 of file cadical_minimize.cpp.

                                         {
  LOG ("clearing %zd minimized literals", minimized.size ());
  for (const auto &lit : minimized) {
    Flags &f = flags (lit);
    f.poison = f.removable = f.shrinkable = f.added = false;
  }
  for (const auto &lit : clause)
    CADICAL_assert (!flags (lit).shrinkable), flags (lit).keep =
                                          flags (lit).shrinkable =
                                              flags (lit).added = false;
  minimized.clear ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_noccs()

void CaDiCaL::Internal::clear_noccs ( )

Definition at line 43 of file cadical_occs.cpp.

                            {
  CADICAL_assert (!ntab.empty ());
  for (auto &nt : ntab)
    nt = 0;
  LOG ("clear two-sided occurrence counters");
}

◆ clear_nounted()

void CaDiCaL::Internal::clear_nounted ( vector< int > & nounted )

Definition at line 201 of file cadical_factor.cpp.

                                                  {
  for (const auto &lit : nounted) {
    CADICAL_assert (getfact (lit, NOUNTED));
    unmarkfact (lit, NOUNTED);
  }
  nounted.clear ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_occs()

void CaDiCaL::Internal::clear_occs ( )

Definition at line 25 of file cadical_occs.cpp.

                           {
  CADICAL_assert (occurring ());
  for (auto &occ : otab)
    occ.clear ();
  LOG ("clear occurrence lists");
}

Here is the call graph for this function:

◆ clear_phases()

void CaDiCaL::Internal::clear_phases ( vector< signed char > & dst )

Definition at line 16 of file cadical_phases.cpp.

                                                     {
  START (copy);
  for (auto i : vars)
    dst[i] = 0;
  STOP (copy);
}

Here is the caller graph for this function:

◆ clear_sign_marked_literals()

void CaDiCaL::Internal::clear_sign_marked_literals ( )

Definition at line 120 of file cadical_decompose.cpp.

                                           {
  LOG ("clearing %zd marked literals", sign_marked.size ());
  for (const auto &lit : sign_marked) {
    // CADICAL_assert (marked_signed (lit));  violated on purpose in factor
    unmark_decomposed (lit);
  }
  sign_marked.clear ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_sweeper()

void CaDiCaL::Internal::clear_sweeper ( Sweeper & sweeper )

Definition at line 298 of file cadical_sweep.cpp.

                                              {
  LOG ("clearing sweeping environment");
  sweeper.current_ticks += cadical_kitten_current_ticks (citten);
 
  citten_clear_track_log_terminate ();
  for (auto &idx : sweeper.vars) {
    CADICAL_assert (sweeper.depths[idx]);
    sweeper.depths[idx] = 0;
  }
  sweeper.vars.clear ();
  for (auto c : sweeper.clauses) {
    CADICAL_assert (c->swept);
    c->swept = false;
  }
  sweeper.clauses.clear ();
  sweeper.backbone.clear ();
  sweeper.partition.clear ();
  sweeper.encoded = 0;
  sweep_set_cadical_kitten_ticks_limit (sweeper);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_unit_analyzed_literals()

void CaDiCaL::Internal::clear_unit_analyzed_literals ( )

Definition at line 431 of file cadical_analyze.cpp.

                                             {
  LOG ("clearing %zd unit analyzed literals", unit_analyzed.size ());
  for (const auto &lit : unit_analyzed) {
    Flags &f = flags (lit);
    CADICAL_assert (f.seen);
    CADICAL_assert (!var (lit).level);
    f.seen = false;
    CADICAL_assert (!f.keep);
    CADICAL_assert (!f.poison);
    CADICAL_assert (!f.removable);
  }
  unit_analyzed.clear ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_watches()

void CaDiCaL::Internal::clear_watches ( )

Definition at line 16 of file cadical_watch.cpp.

                              {
  for (auto lit : lits)
    watches (lit).clear ();
}

Here is the caller graph for this function:

◆ close_trace()

void CaDiCaL::Internal::close_trace ( bool stats = false )

Definition at line 188 of file cadical_proof.cpp.

                                      {
  for (auto &tracer : file_tracers)
    tracer->close (print);
}

◆ collect_instantiation_candidates()

void CaDiCaL::Internal::collect_instantiation_candidates ( Instantiator & instantiator )

Definition at line 18 of file cadical_instantiate.cpp.

                                {
  CADICAL_assert (occurring ());
  for (auto idx : vars) {
    if (frozen (idx))
      continue;
    if (!active (idx))
      continue;
    if (flags (idx).elim)
      continue; // BVE attempt pending
    for (int sign = -1; sign <= 1; sign += 2) {
      const int lit = sign * idx;
      if (noccs (lit) > opts.instantiateocclim)
        continue;
      Occs &os = occs (lit);
      for (const auto &c : os) {
        if (c->garbage)
          continue;
        if (opts.instantiateonce && c->instantiated)
          continue;
        if (c->size < opts.instantiateclslim)
          continue;
        bool satisfied = false;
        int unassigned = 0;
        for (const auto &other : *c) {
          const signed char tmp = val (other);
          if (tmp > 0)
            satisfied = true;
          if (!tmp)
            unassigned++;
        }
        if (satisfied)
          continue;
        if (unassigned < 3)
          continue; // avoid learning units
        size_t negoccs = occs (-lit).size ();
        LOG (c,
             "instantiation candidate literal %d "
             "with %zu negative occurrences in",
             lit, negoccs);
        instantiator.candidate (lit, c, c->size, negoccs);
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compact()

void CaDiCaL::Internal::compact ( )

Definition at line 166 of file cadical_compact.cpp.

                        {
 
  START (compact);
 
  CADICAL_assert (active () < max_var);
 
  stats.compacts++;
 
  CADICAL_assert (!level);
  CADICAL_assert (!unsat);
  CADICAL_assert (!conflict);
  CADICAL_assert (clause.empty ());
  CADICAL_assert (levels.empty ());
  CADICAL_assert (analyzed.empty ());
  CADICAL_assert (minimized.empty ());
  CADICAL_assert (control.size () == 1);
  CADICAL_assert (propagated == trail.size ());
 
  garbage_collection ();
 
  Mapper mapper (this);
 
  if (mapper.first_fixed)
    LOG ("found first fixed %d",
         sign (mapper.first_fixed_val) * mapper.first_fixed);
  else
    LOG ("no variable fixed");
 
  if (!assumptions.empty ()) {
    CADICAL_assert (!external->assumptions.empty ());
    LOG ("temporarily reset internal assumptions");
    reset_assumptions ();
  }
 
  const bool is_constraint = !constraint.empty ();
  if (is_constraint) {
    CADICAL_assert (!external->constraint.empty ());
    LOG ("temporarily reset internal constraint");
    reset_constraint ();
  }
 
  /*======================================================================*/
  // In this first part we only map stuff without reallocation / shrinking.
  /*======================================================================*/
 
  // Flush the external indices.  This has to occur before we map 'vals'.
  // Also fixes external units.
  //
  for (auto eidx : external->vars) {
    int src = external->e2i[eidx];
    if (!src) {
      continue;
    }
    if (lrat || frat) {
      CADICAL_assert (eidx > 0);
      CADICAL_assert (external->ext_units.size () >= (size_t) 2 * eidx + 1);
      int64_t id1 = external->ext_units[2 * eidx];
      int64_t id2 = external->ext_units[2 * eidx + 1];
      CADICAL_assert (!id1 || !id2);
      if (!id1 && !id2) {
        int64_t new_id1 = unit_clauses (2 * src);
        int64_t new_id2 = unit_clauses (2 * src + 1);
        external->ext_units[2 * eidx] = new_id1;
        external->ext_units[2 * eidx + 1] = new_id2;
      }
    }
    int dst = mapper.map_lit (src);
    LOG ("compact %" PRId64
         " maps external %d to internal %d from internal %d",
         stats.compacts, eidx, dst, src);
    external->e2i[eidx] = dst;
  }
 
  // Delete garbage units. Needs to occur before resizing unit_clauses
  //
  if (lrat || frat) {
    for (auto src : internal->vars) {
      const int dst = mapper.map_idx (src);
      CADICAL_assert (dst <= src);
      const signed char tmp = internal->val (src);
      if (!dst && !tmp) {
        unit_clauses (2 * src) = 0;
        unit_clauses (2 * src + 1) = 0;
        continue;
      }
      if (!tmp || src == mapper.first_fixed) {
        CADICAL_assert (0 < dst);
        if (dst == src)
          continue;
        CADICAL_assert (!unit_clauses (2 * dst) && !unit_clauses (2 * dst + 1));
        unit_clauses (2 * dst) = unit_clauses (2 * src);
        unit_clauses (2 * dst + 1) = unit_clauses (2 * src + 1);
        unit_clauses (2 * src) = 0;
        unit_clauses (2 * src + 1) = 0;
        continue;
      }
      int64_t id = unit_clauses (2 * src);
      int lit = src;
      if (!id) {
        id = unit_clauses (2 * src + 1);
        lit = -lit;
      }
      unit_clauses (2 * src) = 0;
      unit_clauses (2 * src + 1) = 0;
      CADICAL_assert (id);
    }
    unit_clauses_idx.resize (2 * mapper.new_vsize);
    shrink_vector (unit_clauses_idx);
  }
  // Map the literals in all clauses.
  //
  for (const auto &c : clauses) {
    CADICAL_assert (!c->garbage);
    for (auto &src : *c) {
      CADICAL_assert (!val (src));
      int dst;
      dst = mapper.map_lit (src);
      CADICAL_assert (dst || c->garbage);
      src = dst;
    }
  }
 
  // Map the blocking literals in all watches.
  //
  if (!wtab.empty ())
    for (auto lit : lits)
      for (auto &w : watches (lit))
        w.blit = mapper.map_lit (w.blit);
 
  // We first flush inactive variables and map the links in the queue.  This
  // has to be done before we map the actual links data structure 'links'.
  {
    int prev = 0, mapped_prev = 0, next;
    for (int idx = queue.first; idx; idx = next) {
      next = links[idx].next;
      if (idx == mapper.first_fixed)
        continue;
      const int dst = mapper.map_idx (idx);
      if (!dst)
        continue;
      CADICAL_assert (active (idx));
      if (prev)
        links[prev].next = dst;
      else
        queue.first = dst;
      links[idx].prev = mapped_prev;
      mapped_prev = dst;
      prev = idx;
    }
    if (prev)
      links[prev].next = 0;
    else
      queue.first = 0;
    queue.unassigned = queue.last = mapped_prev;
  }
 
  /*======================================================================*/
  // In the second part we map, flush and shrink arrays.
  /*======================================================================*/
 
  CADICAL_assert (trail.size () == num_assigned);
  mapper.map_flush_and_shrink_lits (trail);
  propagated = trail.size ();
  num_assigned = trail.size ();
  if (mapper.first_fixed) {
    CADICAL_assert (trail.size () == 1);
    var (mapper.first_fixed).trail = 0; // before mapping 'vtab'
  } else
    CADICAL_assert (trail.empty ());
 
  if (!probes.empty ())
    mapper.map_flush_and_shrink_lits (probes);
 
  if (!sweep_schedule.empty ())
    mapper.map_flush_and_shrink_lits (sweep_schedule);
 
  /*======================================================================*/
  // In the third part we map stuff and also reallocate memory.
  /*======================================================================*/
 
  // Now we continue in reverse order of allocated bytes, e.g., see
  // 'Internal::enlarge' which reallocates in order of allocated bytes.
 
  mapper.map_vector (ftab);
  mapper.map_vector (parents);
  mapper.map_vector (marks);
  mapper.map_vector (phases.saved);
  mapper.map_vector (phases.forced);
  mapper.map_vector (phases.target);
  mapper.map_vector (phases.best);
  mapper.map_vector (phases.prev);
  mapper.map_vector (phases.min);
 
  // Special code for 'frozentab'.
  //
  for (auto src : vars) {
    const int dst = abs (mapper.map_lit (src));
    if (!dst)
      continue;
    if (src == dst)
      continue;
    CADICAL_assert (dst < src);
    if ((size_t) src >= frozentab.size ())
      break;
    if ((size_t) dst >= frozentab.size ())
      break;
    frozentab[dst] += frozentab[src];
    frozentab[src] = 0;
  }
  frozentab.resize (min (frozentab.size (), mapper.new_vsize));
  shrink_vector (frozentab);
 
  // Special code for 'relevanttab'.
  //
  if (external) {
    for (auto src : vars) {
      const int dst = abs (mapper.map_lit (src));
      if (!dst)
        continue;
      if (src == dst)
        continue;
      CADICAL_assert (dst < src);
 
      relevanttab[dst] += relevanttab[src];
      relevanttab[src] = 0;
    }
    relevanttab.resize (mapper.new_vsize);
    shrink_vector (relevanttab);
  }
 
  /*----------------------------------------------------------------------*/
 
  if (!external->assumptions.empty ()) {
 
    for (const auto &elit : external->assumptions) {
      CADICAL_assert (elit);
      CADICAL_assert (elit != INT_MIN);
      int eidx = abs (elit);
      CADICAL_assert (eidx <= external->max_var);
      int ilit = external->e2i[eidx];
      CADICAL_assert (ilit); // Because we froze all!!!
      if (elit < 0)
        ilit = -ilit;
      assume (ilit);
    }
 
    PHASE ("compact", stats.compacts, "reassumed %zd external assumptions",
           external->assumptions.size ());
  }
 
  // Special case for 'val' as for 'val' we trade branch less code for
  // memory and always allocated an [-maxvar,...,maxvar] array.
  {
    signed char *new_vals = new signed char[2 * mapper.new_vsize];
    ignore_clang_analyze_memory_leak_warning = new_vals;
    new_vals += mapper.new_vsize;
    for (auto src : vars)
      new_vals[-mapper.map_idx (src)] = vals[-src];
    for (auto src : vars)
      new_vals[mapper.map_idx (src)] = vals[src];
    new_vals[0] = 0;
    vals -= vsize;
    delete[] vals;
    vals = new_vals;
    vsize = mapper.new_vsize;
  }
 
  // 'constrain' uses 'val', so this code has to be after remapping that
  if (is_constraint) {
    CADICAL_assert (!level);
    CADICAL_assert (!external->constraint.back ());
    for (auto elit : external->constraint) {
      CADICAL_assert (elit != INT_MIN);
      int eidx = abs (elit);
      CADICAL_assert (eidx <= external->max_var);
      int ilit = external->e2i[eidx];
      CADICAL_assert (!ilit == !elit);
      if (elit < 0)
        ilit = -ilit;
      LOG ("re adding lit external %d internal %d to constraint", elit,
           ilit);
      constrain (ilit);
    }
    PHASE ("compact", stats.compacts,
           "added %zd external literals to constraint",
           external->constraint.size () - 1);
  }
 
  mapper.map_vector (i2e);
  mapper.map2_vector (ptab);
  mapper.map_vector (btab);
  mapper.map_vector (gtab);
  mapper.map_vector (links);
  mapper.map_vector (vtab);
  if (!ntab.empty ())
    mapper.map2_vector (ntab);
  if (!wtab.empty ())
    mapper.map2_vector (wtab);
  if (!otab.empty ())
    mapper.map2_vector (otab);
  if (!rtab.empty ())
    mapper.map2_vector (rtab);
  if (!big.empty ())
    mapper.map2_vector (big);
 
  /*======================================================================*/
  // In the fourth part we map the binary heap for scores.
  /*======================================================================*/
 
  // The simplest way to map a binary heap is to get all elements from the
  // heap and reinsert them.  This could be slightly improved in terms of
  // speed if we add a 'flush (int * map)' function to 'Heap', but that is
  // pretty complicated and would require that the 'Heap' knows that mapped
  // elements with 'zero' destination should be flushed.
 
  vector<int> saved;
  CADICAL_assert (saved.empty ());
  if (!scores.empty ()) {
    while (!scores.empty ()) {
      const int src = scores.front ();
      scores.pop_front ();
      const int dst = mapper.map_idx (src);
      if (!dst)
        continue;
      if (src == mapper.first_fixed)
        continue;
      saved.push_back (dst);
    }
    scores.erase ();
  }
  mapper.map_vector (stab);
  if (!saved.empty ()) {
    for (const auto idx : saved)
      scores.push_back (idx);
    scores.shrink ();
  }
 
  /*----------------------------------------------------------------------*/
 
  PHASE ("compact", stats.compacts,
         "reducing internal variables from %d to %d", max_var,
         mapper.new_max_var);
 
  /*----------------------------------------------------------------------*/
 
  // Need to adjust the target and best assigned counters too.
 
  size_t new_target_assigned = 0, new_best_assigned = 0;
 
  for (auto idx : Range (mapper.new_max_var)) {
    if (phases.target[idx])
      new_target_assigned++;
    if (phases.best[idx])
      new_best_assigned++;
  }
 
  LOG ("reset target assigned from %zd to %zd", target_assigned,
       new_target_assigned);
  LOG ("reset best assigned from %zd to %zd", best_assigned,
       new_best_assigned);
 
  target_assigned = new_target_assigned;
  best_assigned = new_best_assigned;
  no_conflict_until = 0;
  notified = 0;
 
  INIT_EMA (averages.current.trail.fast, opts.ematrailfast);
  INIT_EMA (averages.current.trail.slow, opts.ematrailslow);
 
  /*----------------------------------------------------------------------*/
 
  max_var = mapper.new_max_var;
 
  stats.unused = 0;
  stats.inactive = stats.now.fixed = mapper.first_fixed ? 1 : 0;
  stats.now.substituted = stats.now.eliminated = stats.now.pure = 0;
 
  check_var_stats ();
 
  int64_t delta = opts.compactint * (stats.compacts + 1);
  lim.compact = stats.conflicts + delta;
 
  PHASE ("compact", stats.compacts,
         "new compact limit %" PRId64 " after %" PRId64 " conflicts",
         lim.compact, delta);
 
  STOP (compact);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compacting()

bool CaDiCaL::Internal::compacting ( )

Definition at line 17 of file cadical_compact.cpp.

                           {
  if (level)
    return false;
  if (!opts.compact)
    return false;
  if (stats.conflicts < lim.compact)
    return false;
  int inactive = max_var - active ();
  CADICAL_assert (inactive >= 0);
  if (!inactive)
    return false;
  if (inactive < opts.compactmin)
    return false;
  return inactive >= (1e-3 * opts.compactlim) * max_var;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compute_elim_score()

double CaDiCaL::Internal::compute_elim_score ( unsigned lit )

inline

Definition at line 25 of file cadical_elim.cpp.

                                                        {
  CADICAL_assert (1 <= lit), CADICAL_assert (lit <= (unsigned) max_var);
  const unsigned uidx = 2 * lit;
  const double pos = internal->ntab[uidx];
  const double neg = internal->ntab[uidx + 1];
  if (!pos)
    return -neg;
  if (!neg)
    return -pos;
  double sum = 0, prod = 0;
  if (opts.elimsum)
    sum = opts.elimsum * (pos + neg);
  if (opts.elimprod)
    prod = opts.elimprod * (pos * neg);
  return prod + sum;
}

◆ compute_tier_limits()

void CaDiCaL::Internal::compute_tier_limits ( Vivifier & vivifier )

Definition at line 1792 of file cadical_vivify.cpp.

                                                      {
  if (!opts.vivifycalctier) {
    vivifier.tier1_limit = 2;
    vivifier.tier2_limit = 6;
    return;
  }
  vivifier.tier1_limit = tier1[false];
  vivifier.tier2_limit = tier2[false];
}

Here is the caller graph for this function:

◆ conclude_unsat()

void CaDiCaL::Internal::conclude_unsat ( )

Definition at line 465 of file cadical_assume.cpp.

                               {
  if (!proof || concluded)
    return;
  concluded = true;
  if (!marked_failed) {
    CADICAL_assert (conclusion.empty ());
    if (!conflict_id)
      failing ();
    marked_failed = true;
  }
  ConclusionType con;
  if (conflict_id)
    con = CONFLICT;
  else if (unsat_constraint)
    con = CONSTRAINT;
  else
    con = ASSUMPTIONS;
  proof->conclude_unsat (con, conclusion);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ condition()

void CaDiCaL::Internal::condition ( bool update_limits = true )

Definition at line 899 of file cadical_condition.cpp.

                                            {
 
  if (unsat)
    return;
  if (!stats.current.irredundant)
    return;
 
  START_SIMPLIFIER (condition, CONDITION);
  stats.conditionings++;
 
  // Propagation limit to avoid too much work in 'condition'.  We mark
  // tried candidate clauses after giving up, such that next time we run
  // 'condition' we can try them.
  //
  long limit = stats.propagations.search;
  limit *= opts.conditioneffort;
  limit /= 1000;
  if (limit < opts.conditionmineff)
    limit = opts.conditionmineff;
  if (limit > opts.conditionmaxeff)
    limit = opts.conditionmaxeff;
  CADICAL_assert (stats.current.irredundant);
  limit *= 2.0 * active () / (double) stats.current.irredundant;
  limit = max (limit, 2l * active ());
 
  PHASE ("condition", stats.conditionings,
         "started after %" PRIu64 " conflicts limited by %ld propagations",
         stats.conflicts, limit);
 
  long blocked = condition_round (limit);
 
  STOP_SIMPLIFIER (condition, CONDITION);
  report ('g', !blocked);
 
  if (!update_limits)
    return;
 
  long delta = opts.conditionint * (stats.conditionings + 1);
  lim.condition = stats.conflicts + delta;
 
  PHASE ("condition", stats.conditionings,
         "next limit at %" PRIu64 " after %ld conflicts", lim.condition,
         delta);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ condition_assign()

void CaDiCaL::Internal::condition_assign ( int lit )

Definition at line 90 of file cadical_condition.cpp.

                                        {
  LOG ("condition assign %d", lit);
  CADICAL_assert (!val (lit));
  set_val (lit, 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ condition_round()

long CaDiCaL::Internal::condition_round ( long unassigned_literal_propagation_limit )

Definition at line 159 of file cadical_condition.cpp.

                                          {
 
  long limit;
#ifndef CADICAL_QUIET
  long props = 0;
#endif
  if (LONG_MAX - delta < stats.condprops)
    limit = LONG_MAX;
  else
    limit = stats.condprops + delta;
 
  size_t initial_trail_level = trail.size ();
  int initial_level = level;
 
  LOG ("initial trail level %zd", initial_trail_level);
 
  protect_reasons ();
 
#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
  int additionally_assigned = 0;
#endif
 
  for (auto idx : vars) {
    const signed char tmp = val (idx);
    Var &v = var (idx);
    if (tmp) {
      if (v.level) {
        const int lit = tmp < 0 ? -idx : idx;
        if (!active (idx)) {
          LOG ("temporarily unassigning inactive literal %d", lit);
          condition_unassign (lit);
        }
        if (frozen (idx)) {
          LOG ("temporarily unassigning frozen literal %d", lit);
          condition_unassign (lit);
        }
      }
    } else if (frozen (idx)) {
      LOG ("keeping frozen literal %d unassigned", idx);
    } else if (!active (idx)) {
      LOG ("keeping inactive literal %d unassigned", idx);
    } else { // if (preprocessing) {
      if (initial_level == level) {
        level++;
        LOG ("new condition decision level");
      }
      const int lit = decide_phase (idx, true);
      condition_assign (lit);
      v.level = level;
      trail.push_back (lit);
#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
      additionally_assigned++;
#endif
    }
  }
  LOG ("assigned %d additional literals", additionally_assigned);
 
  // We compute statistics about the size of the assignments.
  //
  // The initial assignment consists of the non-root-level assigned literals
  // split into a conditional and an autarky part.  The conditional part
  // consists of literals assigned true and occurring negated in a clause
  // (touch the clause), which does not contain another literal assigned to
  // true.  This initial partition is the same for all refinements used in
  // checking whether a candidate clause is globally blocked.
  //
  // For each candidate clause some of the conditional literals have to be
  // unassigned, and the autarky is shrunken by turning some of the autarky
  // literals into conditional literals (which might get unassigned in a
  // later refinement though).
  //
  // The fix-point of this procedure produces a final assignment, which
  // consists of the remaining assigned literals, again split into a
  // conditional and an autarky part.
  //
  struct {
    size_t assigned, conditional, autarky;
  } initial, remain;
 
  initial.assigned = 0;
  for (auto idx : vars) {
    const signed char tmp = val (idx);
    if (!tmp)
      continue;
    if (!var (idx).level)
      continue;
    LOG ("initial assignment %ds", tmp < 0 ? -idx : idx);
    initial.assigned++;
  }
 
  PHASE ("condition", stats.conditionings, "initial assignment of size %zd",
         initial.assigned);
 
  // For each candidate clause we refine the assignment (monotonically),
  // by unassigning some conditional literals and turning some autarky
  // literals into conditionals.
  //
  // As the conditional part is usually smaller than the autarky part our
  // implementation only explicitly maintains the initial conditional part,
  // with conditional bit set to true through 'mark_as_conditional_literal'.
  // The autarky part consists of all literals assigned true which do not
  // have their conditional bit set to true.  Since in both cases the
  // literal has to be assigned true, we only need a single bit for both the
  // literal as well as its negation (it does not have to be 'signed').
  //
  vector<int> conditional;
 
  vector<Clause *> candidates; // Gather candidate clauses.
#ifndef CADICAL_QUIET
  size_t watched = 0; // Number of watched clauses.
#endif
 
  initial.autarky = initial.assigned; // Initially all are in autarky
  initial.conditional = 0;            // and none in conditional part.
 
  // Upper bound on the number of watched clauses. In principle one could
  // use 'SIZE_MAX' but this is not available by default (yet).
  //
  const size_t size_max = clauses.size () + 1;
 
  // Initialize additional occurrence lists.
  //
  init_occs ();
 
  // Number of previously conditioned and unconditioned candidates.
  //
  size_t conditioned = 0, unconditioned = 0;
 
  // Now go over all (non-garbage) irredundant clauses and check whether
  // they are candidates, have to be watched, or whether they force the
  // negation of some of their literals to be conditional initially.
  //
  for (const auto &c : clauses) {
    if (c->garbage)
      continue; // Can already be ignored.
    if (c->redundant)
      continue; // Ignore redundant clauses too.
 
    // First determine the following numbers for the candidate clause
    // (restricted to non-root-level assignments).
    //
    int positive = 0; // Number true literals.
    int negative = 0; // Number false literals.
    int watch = 0;    // True Literal to watch.
    //
    size_t minsize = size_max; // Number of occurrences of 'watch'.
    //
    // But also ignore root-level satisfied but not yet garbage clauses.
    //
    bool satisfied = false; // Root level satisfied.
    //
    for (const_literal_iterator l = c->begin ();
         !satisfied && l != c->end (); l++) {
      const int lit = *l;
      const signed char tmp = val (lit);
      if (tmp && !var (lit).level)
        satisfied = (tmp > 0);
      else if (tmp < 0)
        negative++;
      else if (tmp > 0) {
        const size_t size = occs (lit).size ();
        if (size < minsize)
          watch = lit, minsize = size;
        positive++;
      }
    }
    if (satisfied) {    // Ignore root-level satisfied clauses.
      mark_garbage (c); // But mark them as garbage already now.
      continue;         // ... with next clause 'c'.
    }
 
    // Candidates are clauses with at least a positive literal in it.
    //
    if (positive > 0) {
      LOG (c, "found %d positive literals in candidate", positive);
      candidates.push_back (c);
      if (c->conditioned)
        conditioned++;
      else
        unconditioned++;
    }
 
    // Only one positive literal in each clauses with also at least one
    // negative literal has to be watched in occurrence lists.  These
    // watched clauses will be checked to contain only negative literals as
    // soon such a positive literal is unassigned.  If this is the case
    // these false literals have to be unassigned and potentially new
    // conditional literals have to be determined.
    //
    // Note that only conditional literals are unassigned. However it does
    // not matter that we might also watch autarky literals, because either
    // such an autarky literal remains a witness that the clause is
    // satisfied as long it remains an autarky literal. Otherwise at one
    // point it becomes conditional and is unassigned, but then a
    // replacement watch will be searched.
    //
    if (negative > 0 && positive > 0) {
      LOG (c, "found %d negative literals in candidate", negative);
      CADICAL_assert (watch);
      CADICAL_assert (val (watch) > 0);
      Occs &os = occs (watch);
      CADICAL_assert (os.size () == minsize);
      os.push_back (c);
#ifndef CADICAL_QUIET
      watched++;
#endif
      LOG (c, "watching %d with %zd occurrences in", watch, minsize);
    }
 
    // The initial global conditional part for the current assignment is
    // extracted from clauses with only negative literals.  It is the same
    // for all considered candidate clauses. These negative literals make up
    // the global conditional part, are marked here.
    //
    if (negative > 0 && !positive) {
 
      size_t new_conditionals = 0;
 
      for (const_literal_iterator l = c->begin (); l != c->end (); l++) {
        const int lit = *l;
        signed char tmp = val (lit);
        if (!tmp)
          continue;
        CADICAL_assert (tmp < 0);
        if (!var (lit).level)
          continue; // Not unassigned yet!
        if (is_conditional_literal (-lit))
          continue;
        mark_as_conditional_literal (-lit);
        conditional.push_back (-lit);
        new_conditionals++;
      }
      if (new_conditionals > 0)
        LOG (c, "marked %zu negations of literals as conditional in",
             new_conditionals);
 
      initial.conditional += new_conditionals;
      CADICAL_assert (initial.autarky >= new_conditionals);
      initial.autarky -= new_conditionals;
    }
 
  } // End of loop over all clauses to collect candidates etc.
 
  PHASE ("condition", stats.conditionings, "found %zd candidate clauses",
         candidates.size ());
  PHASE ("condition", stats.conditionings,
         "watching %zu literals and clauses", watched);
  PHASE ("condition", stats.conditionings,
         "initially %zd conditional literals %.0f%%", initial.conditional,
         percent (initial.conditional, initial.assigned));
  PHASE ("condition", stats.conditionings,
         "initially %zd autarky literals %.0f%%", initial.autarky,
         percent (initial.autarky, initial.assigned));
#ifdef LOGGING
  for (size_t i = 0; i < conditional.size (); i++) {
    LOG ("initial conditional %d", conditional[i]);
    CADICAL_assert (is_conditional_literal (conditional[i]));
  }
  for (size_t i = 0; i < trail.size (); i++)
    if (is_autarky_literal (trail[i]))
      LOG ("initial autarky %d", trail[i]);
#endif
  CADICAL_assert (initial.conditional == conditional.size ());
  CADICAL_assert (initial.assigned == initial.conditional + initial.autarky);
 
  stats.condassinit += initial.assigned;
  stats.condcondinit += initial.conditional;
  stats.condautinit += initial.autarky;
  stats.condassvars += active ();
 
  // To speed-up and particularly simplify the code we unassign all
  // root-level variables temporarily, actually all inactive assigned
  // variables.  This allows us to avoid tests on whether an assigned
  // literal is actually root-level assigned and thus should be ignored (not
  // considered to be assigned).  For this to work we have to ignore root
  // level satisfied clauses as done above.  These are neither candidates
  // nor have to be watched.  Remaining originally root-level assigned
  // literals in clauses are only set to false.
  //
  for (const auto &lit : trail)
    if (fixed (lit))
      condition_unassign (lit);
 
  // Stack to save temporarily unassigned (conditional) literals.
  //
  vector<int> unassigned;
 
  // Make sure to focus on clauses not tried before by marking clauses which
  // have been checked before using the 'conditioned' bit of clauses. If all
  // candidates have their bit set, we have to reset it.  Since the
  // assignment might be completely different then last time and thus also
  // the set of candidates this method does not really exactly lead to a
  // round robin scheme of scheduling clauses.
  //
  // TODO consider computing conditioned and unconditioned over all clauses.
  //
  CADICAL_assert (conditioned + unconditioned == candidates.size ());
  if (conditioned && unconditioned) {
    stable_sort (candidates.begin (), candidates.end (),
                 less_conditioned ());
    PHASE ("condition", stats.conditionings,
           "focusing on %zd candidates %.0f%% not tried last time",
           unconditioned, percent (unconditioned, candidates.size ()));
  } else if (conditioned && !unconditioned) {
    for (auto const &c : candidates) {
      CADICAL_assert (c->conditioned);
      c->conditioned = false; // Reset 'conditioned' bit.
    }
    PHASE ("condition", stats.conditionings,
           "all %zd candidates tried before", conditioned);
  } else {
    CADICAL_assert (!conditioned);
    PHASE ("condition", stats.conditionings, "all %zd candidates are fresh",
           unconditioned);
  }
 
  // TODO prune assignments further!
  // And thus might result in less watched clauses.
  // So watching should be done here and not earlier.
  // Also, see below, we might need to consider the negation of unassigned
  // literals in candidate clauses as being watched.
 
  // Now try to block all candidate clauses.
  //
  long blocked = 0; // Number of Successfully blocked clauses.
  //
#ifndef CADICAL_QUIET
  size_t untried = candidates.size ();
#endif
  for (const auto &c : candidates) {
 
    if (initial.autarky <= 0)
      break;
 
    if (c->reason)
      continue;
 
    bool terminated_or_limit_hit = true;
    if (terminated_asynchronously ())
      LOG ("asynchronous termination detected");
    else if (stats.condprops >= limit)
      LOG ("condition propagation limit %ld hit", limit);
    else
      terminated_or_limit_hit = false;
 
    if (terminated_or_limit_hit) {
      PHASE ("condition", stats.conditionings,
             "%zd candidates %.0f%% not tried after %ld propagations",
             untried, percent (untried, candidates.size ()), props);
      break;
    }
#ifndef CADICAL_QUIET
    untried--;
#endif
    CADICAL_assert (!c->garbage);
    CADICAL_assert (!c->redundant);
 
    LOG (c, "candidate");
    c->conditioned = 1; // Next time later.
 
    // We watch an autarky literal in the clause, and can stop trying to
    // globally block the clause as soon it turns into a conditional
    // literal and we can not find another one.  If the fix-point assignment
    // is reached and we still have an autarky literal left the watched one
    // is reported as witness for this clause being globally blocked.
    //
    int watched_autarky_literal = 0;
 
    // First mark all true literals in the candidate clause and find an
    // autarky literal which witnesses that this clause has still a chance
    // to be globally blocked.
    //
    for (const_literal_iterator l = c->begin (); l != c->end (); l++) {
      const int lit = *l;
      mark_in_candidate_clause (lit);
      if (watched_autarky_literal)
        continue;
      if (!is_autarky_literal (lit))
        continue;
      watched_autarky_literal = lit;
 
      // TODO assign non-assigned literals to false?
      // Which might need to trigger watching additional clauses.
    }
 
    if (!watched_autarky_literal) {
      LOG ("no initial autarky literal found");
      for (const_literal_iterator l = c->begin (); l != c->end (); l++)
        unmark_in_candidate_clause (*l);
      continue;
    }
 
    stats.condcands++; // Only now ...
 
    LOG ("watching first autarky literal %d", watched_autarky_literal);
 
    // Save assignment sizes for statistics, logging and checking.
    //
    remain = initial;
 
    // Position of next conditional and unassigned literal to process in the
    // 'conditional' and the 'unassigned' stack.
    //
    struct {
      size_t conditional, unassigned;
    } next = {0, 0};
 
    CADICAL_assert (unassigned.empty ());
    CADICAL_assert (conditional.size () == initial.conditional);
 
    while (watched_autarky_literal && stats.condprops < limit &&
           next.conditional < conditional.size ()) {
 
      CADICAL_assert (next.unassigned == unassigned.size ());
 
      const int conditional_lit = conditional[next.conditional++];
      LOG ("processing next conditional %d", conditional_lit);
      CADICAL_assert (is_conditional_literal (conditional_lit));
 
      if (is_in_candidate_clause (-conditional_lit)) {
        LOG ("conditional %d negated in candidate clause", conditional_lit);
        continue;
      }
 
      LOG ("conditional %d does not occur negated in candidate clause",
           conditional_lit);
 
      condition_unassign (conditional_lit);
      CADICAL_assert (!is_conditional_literal (conditional_lit));
      unassigned.push_back (conditional_lit);
 
      CADICAL_assert (remain.assigned > 0);
      CADICAL_assert (remain.conditional > 0);
      remain.conditional--;
      remain.assigned--;
 
      while (watched_autarky_literal && stats.condprops < limit &&
             next.unassigned < unassigned.size ()) {
        const int unassigned_lit = unassigned[next.unassigned++];
        LOG ("processing next unassigned %d", unassigned_lit);
        CADICAL_assert (!val (unassigned_lit));
#ifndef CADICAL_QUIET
        props++;
#endif
        stats.condprops++;
 
        Occs &os = occs (unassigned_lit);
        if (os.empty ())
          continue;
 
        // Traverse all watched clauses of 'unassigned_lit' and find
        // replacement watches or if none is found turn the negation of all
        // false autarky literals in that clause into conditional literals.
        // If one of those autarky literals is the watched autarky literal
        // in the candidate clause, that one has to be updated too.
        //
        // We expect that this loop is a hot-spot for the procedure and thus
        // are more careful about accessing end points for iterating.
        //
        auto i = os.begin (), j = i;
        for (; watched_autarky_literal && j != os.end (); j++) {
          Clause *d = *i++ = *j;
 
          int replacement = 0; // New watched literal in 'd'.
          int negative = 0;    // Negative autarky literals in 'd'.
 
          for (const_literal_iterator l = d->begin (); l != d->end ();
               l++) {
            const int lit = *l;
            const signed char tmp = val (lit);
            if (tmp > 0)
              replacement = lit;
            if (tmp < 0 && is_autarky_literal (-lit))
              negative++;
          }
 
          if (replacement) {
            LOG ("found replacement %d for unassigned %d", replacement,
                 unassigned_lit);
            LOG (d, "unwatching %d in", unassigned_lit);
            i--; // Drop watch!
            LOG (d, "watching %d in", replacement);
 
            CADICAL_assert (replacement != unassigned_lit);
            occs (replacement).push_back (d);
 
            continue; // ... with next watched clause 'd'.
          }
 
          LOG ("no replacement found for unassigned %d", unassigned_lit);
 
          // Keep watching 'd' by 'unassigned_lit' if no replacement found.
 
          if (!negative) {
            LOG (d, "no negative autarky literals left in");
            continue; // ... with next watched clause 'd'.
          }
 
          LOG (d, "found %d negative autarky literals in", negative);
 
          for (const_literal_iterator l = d->begin ();
               watched_autarky_literal && l != d->end (); l++) {
            const int lit = *l;
            if (!is_autarky_literal (-lit))
              continue;
            mark_as_conditional_literal (-lit);
            conditional.push_back (-lit);
 
            remain.conditional++;
            CADICAL_assert (remain.autarky > 0);
            remain.autarky--;
 
            if (-lit != watched_autarky_literal)
              continue;
 
            LOG ("need to replace autarky literal %d in candidate", -lit);
            replacement = 0;
 
            // TODO save starting point because we only move it forward?
 
            for (const_literal_iterator k = c->begin ();
                 !replacement && k != c->end (); k++) {
              const int other = *k;
              if (is_autarky_literal (other))
                replacement = other;
            }
            watched_autarky_literal = replacement;
 
            if (replacement) {
              LOG (c, "watching autarky %d instead %d in candidate",
                   replacement, watched_autarky_literal);
              watched_autarky_literal = replacement;
            } else {
              LOG ("failed to find an autarky replacement");
              watched_autarky_literal = 0; // Breaks out of 4 loops!!!!!
            }
          } // End of loop of turning autarky literals into conditionals.
        } // End of loop of all watched clauses of an unassigned literal.
        //
        // We might abort the occurrence traversal early but already
        // removed some watches, thus have to just copy the rest.
        //
        if (i < j) {
          while (j != os.end ())
            *i++ = *j++;
          LOG ("flushed %zd occurrences of %d", os.end () - i,
               unassigned_lit);
          os.resize (i - os.begin ());
        }
      } // End of loop which goes over all unprocessed unassigned literals.
    } // End of loop which goes over all unprocessed conditional literals.
 
    // We are still processing the candidate 'c' and now have reached a
    // final fix-point assignment partitioned into a conditional and an
    // autarky part, or during unassigned literals figured that there is no
    // positive autarky literal left in 'c'.
 
    LOG ("remaining assignment of size %zd", remain.assigned);
    LOG ("remaining conditional part of size %zd", remain.conditional);
    LOG ("remaining autarky part of size %zd", remain.autarky);
    //
    CADICAL_assert (remain.assigned - remain.conditional == remain.autarky);
    //
#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
    //
    // This is a sanity check, that the size of our implicit representation
    // of the autarky part matches our 'remain' counts.  We need the same
    // code for determining autarky literals as in the loop below which adds
    // autarky literals to the extension stack.
    //
    struct {
      size_t assigned, conditional, autarky;
    } check;
    check.assigned = check.conditional = check.autarky = 0;
    for (size_t i = 0; i < trail.size (); i++) {
      const int lit = trail[i];
      if (val (lit)) {
        check.assigned++;
        if (is_conditional_literal (lit)) {
          LOG ("remaining conditional %d", lit);
          CADICAL_assert (!is_autarky_literal (lit));
          check.conditional++;
        } else {
          CADICAL_assert (is_autarky_literal (lit));
          LOG ("remaining autarky %d", lit);
          check.autarky++;
        }
      } else {
        CADICAL_assert (!is_autarky_literal (lit));
        CADICAL_assert (!is_conditional_literal (lit));
      }
    }
    CADICAL_assert (remain.assigned == check.assigned);
    CADICAL_assert (remain.conditional == check.conditional);
    CADICAL_assert (remain.autarky == check.autarky);
#endif
 
    // Success if an autarky literal is left in the clause and
    // we did not abort the loop too early because the propagation
    // limit was hit.
    //
    if (watched_autarky_literal && stats.condprops < limit) {
      CADICAL_assert (is_autarky_literal (watched_autarky_literal));
      CADICAL_assert (is_in_candidate_clause (watched_autarky_literal));
 
      blocked++;
      stats.conditioned++;
      LOG (c, "positive autarky literal %d globally blocks",
           watched_autarky_literal);
 
      LOG ("remaining %zd assigned literals %.0f%%", remain.assigned,
           percent (remain.assigned, initial.assigned));
      LOG ("remaining %zd conditional literals %.0f%%", remain.conditional,
           percent (remain.conditional, remain.assigned));
      LOG ("remaining %zd autarky literals %.0f%%", remain.autarky,
           percent (remain.autarky, remain.assigned));
 
      // A satisfying assignment of a formula after removing a globally
      // blocked clause might not satisfy that clause.  As for variable
      // elimination and classical blocked clauses, we thus maintain an
      // extension stack for reconstructing an assignment which both
      // satisfies the remaining formula as well as the clause.
      //
      // For globally blocked clauses we simply have to flip all literals in
      // the autarky part and thus save the autarky on the extension stack
      // in addition to the removed clause.  In the classical situation (in
      // bounded variable elimination etc.) we simply save one literal on
      // the extension stack.
      //
      // TODO find a way to shrink the autarky part or some other way to
      // avoid pushing too many literals on the extension stack.
      //
      external->push_zero_on_extension_stack ();
      for (const auto &lit : trail)
        if (is_autarky_literal (lit))
          external->push_witness_literal_on_extension_stack (lit);
      if (proof)
        proof->weaken_minus (c);
      external->push_clause_on_extension_stack (c);
 
      mark_garbage (c);
 
      stats.condassrem += remain.assigned;
      stats.condcondrem += remain.conditional;
      stats.condautrem += remain.autarky;
      stats.condassirem += initial.assigned;
    }
 
    // In this last part specific to one candidate clause, we have to get
    // back to the initial assignment and reset conditionals.  First we
    // assign all the unassigned literals (if necessary).
    //
    if (!unassigned.empty ()) {
      LOG ("reassigning %zd literals", unassigned.size ());
      while (!unassigned.empty ()) {
        const int lit = unassigned.back ();
        unassigned.pop_back ();
        condition_assign (lit);
      }
    }
 
    // Then we remove from the conditional stack autarky literals which
    // became conditional and also reset their 'conditional' bit.
    //
    if (initial.conditional < conditional.size ()) {
      LOG ("flushing %zd autarky literals from conditional stack",
           conditional.size () - initial.conditional);
      while (initial.conditional < conditional.size ()) {
        const int lit = conditional.back ();
        conditional.pop_back ();
        unmark_as_conditional_literal (lit);
      }
    }
 
    // Finally unmark all literals in the candidate clause.
    //
    for (const_literal_iterator l = c->begin (); l != c->end (); l++)
      unmark_in_candidate_clause (*l);
 
  } // End of loop over all candidate clauses.
 
  PHASE ("condition", stats.conditionings,
         "globally blocked %ld clauses %.0f%%", blocked,
         percent (blocked, candidates.size ()));
 
  // Unmark initial conditional variables.
  //
  for (const auto &lit : conditional)
    unmark_as_conditional_literal (lit);
 
  erase_vector (unassigned);
  erase_vector (conditional);
  erase_vector (candidates);
 
  // Unassign additionally assigned literals.
  //
#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
  int additionally_unassigned = 0;
#endif
  while (trail.size () > initial_trail_level) {
    int lit = trail.back ();
    trail.pop_back ();
    condition_unassign (lit);
#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
    additionally_unassigned++;
#endif
  }
  LOG ("unassigned %d additionally assigned literals",
       additionally_unassigned);
  CADICAL_assert (additionally_unassigned == additionally_assigned);
 
  if (level > initial_level) {
    LOG ("reset condition decision level");
    level = initial_level;
  }
 
  reset_occs ();
  delete_garbage_clauses ();
 
  // Reassign previously assigned variables again.
  //
  LOG ("reassigning previously assigned variables");
  for (size_t i = 0; i < initial_trail_level; i++) {
    const int lit = trail[i];
    const signed char tmp = val (lit);
    CADICAL_assert (tmp >= 0);
    if (!tmp)
      condition_assign (lit);
  }
 
#ifndef CADICAL_NDEBUG
  for (const auto &lit : trail)
    CADICAL_assert (!marked (lit));
#endif
 
  unprotect_reasons ();
 
  return blocked;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ condition_unassign()

void CaDiCaL::Internal::condition_unassign ( int lit )

Definition at line 84 of file cadical_condition.cpp.

                                          {
  LOG ("condition unassign %d", lit);
  CADICAL_assert (val (lit) > 0);
  set_val (lit, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ conditioning()

bool CaDiCaL::Internal::conditioning ( )

Definition at line 39 of file cadical_condition.cpp.

                             {
 
  if (!opts.condition)
    return false;
  if (!preprocessing && !opts.inprocessing)
    return false;
  if (preprocessing)
    CADICAL_assert (lim.preprocessing);
 
  // Triggered in regular 'opts.conditionint' conflict intervals.
  //
  if (lim.condition > stats.conflicts)
    return false;
 
  if (!level)
    return false; // One decision necessary.
 
  if (level <= averages.current.jump)
    return false; // Main heuristic.
 
  if (!stats.current.irredundant)
    return false;
  double remain = active ();
  if (!remain)
    return false;
  double ratio = stats.current.irredundant / remain;
  return ratio <= opts.conditionmaxrat;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ connect_binary_watches()

void CaDiCaL::Internal::connect_binary_watches ( )

Definition at line 86 of file cadical_watch.cpp.

                                       {
  START (connect);
  CADICAL_assert (watching ());
 
  LOG ("watching binary clauses");
 
  // First connect binary clauses.
  //
  for (const auto &c : clauses) {
    if (c->garbage || c->size > 2)
      continue;
    watch_clause (c);
  }
 
  STOP (connect);
}

Here is the call graph for this function:

◆ connect_proof_tracer() [1/4]

void CaDiCaL::Internal::connect_proof_tracer	(	FileTracer *	tracer,
		bool	antecedents,
		bool	finalize_clauses = false )

Definition at line 73 of file cadical_proof.cpp.

                                                            {
  new_proof_on_demand ();
  if (antecedents)
    force_lrat ();
  if (finalize_clauses)
    frat = true;
  resize_unit_clauses_idx ();
  tracer->connect_internal (this);
  proof->connect (tracer);
  file_tracers.push_back (tracer);
}

Here is the call graph for this function:

◆ connect_proof_tracer() [2/4]

void CaDiCaL::Internal::connect_proof_tracer	(	InternalTracer *	tracer,
		bool	antecedents,
		bool	finalize_clauses = false )

Definition at line 46 of file cadical_proof.cpp.

                                                            {
  new_proof_on_demand ();
  if (antecedents)
    force_lrat ();
  if (finalize_clauses)
    frat = true;
  resize_unit_clauses_idx ();
  tracer->connect_internal (this);
  proof->connect (tracer);
  tracers.push_back (tracer);
}

Here is the call graph for this function:

◆ connect_proof_tracer() [3/4]

void CaDiCaL::Internal::connect_proof_tracer	(	StatTracer *	tracer,
		bool	antecedents,
		bool	finalize_clauses = false )

Definition at line 60 of file cadical_proof.cpp.

                                                            {
  new_proof_on_demand ();
  if (antecedents)
    force_lrat ();
  if (finalize_clauses)
    frat = true;
  resize_unit_clauses_idx ();
  tracer->connect_internal (this);
  proof->connect (tracer);
  stat_tracers.push_back (tracer);
}

Here is the call graph for this function:

◆ connect_proof_tracer() [4/4]

void CaDiCaL::Internal::connect_proof_tracer	(	Tracer *	tracer,
		bool	antecedents,
		bool	finalize_clauses = false )

Definition at line 34 of file cadical_proof.cpp.

                                                            {
  new_proof_on_demand ();
  if (antecedents)
    force_lrat ();
  if (finalize_clauses)
    frat = true;
  resize_unit_clauses_idx ();
  proof->connect (tracer);
  tracers.push_back (tracer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ connect_propagator()

void CaDiCaL::Internal::connect_propagator ( )

Definition at line 968 of file cadical_external_propagate.cpp.

                                   {
  if (level)
    backtrack ();
}

Here is the call graph for this function:

◆ connect_watches()

void CaDiCaL::Internal::connect_watches ( bool irredundant_only = false )

Definition at line 30 of file cadical_watch.cpp.

                                                     {
  START (connect);
  CADICAL_assert (watching ());
 
  LOG ("watching all %sclauses", irredundant_only ? "irredundant " : "");
 
  // First connect binary clauses.
  //
  for (const auto &c : clauses) {
    if (irredundant_only && c->redundant)
      continue;
    if (c->garbage || c->size > 2)
      continue;
    watch_clause (c);
  }
 
  // Then connect non-binary clauses.
  //
  for (const auto &c : clauses) {
    if (irredundant_only && c->redundant)
      continue;
    if (c->garbage || c->size == 2)
      continue;
    watch_clause (c);
    if (!level) {
      const int lit0 = c->literals[0];
      const int lit1 = c->literals[1];
      const signed char tmp0 = val (lit0);
      const signed char tmp1 = val (lit1);
      if (tmp0 > 0)
        continue;
      if (tmp1 > 0)
        continue;
      if (tmp0 < 0) {
        const size_t pos0 = var (lit0).trail;
        if (pos0 < propagated) {
          propagated = pos0;
          LOG ("literal %d resets propagated to %zd", lit0, pos0);
        }
      }
      if (tmp1 < 0) {
        const size_t pos1 = var (lit1).trail;
        if (pos1 < propagated) {
          propagated = pos1;
          LOG ("literal %d resets propagated to %zd", lit1, pos1);
        }
      }
    }
  }
 
  STOP (connect);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ consider_to_vivify_clause()

bool CaDiCaL::Internal::consider_to_vivify_clause ( Clause * candidate )

Definition at line 511 of file cadical_vivify.cpp.

                                                   {
  if (c->garbage)
    return false;
  if (opts.vivifyonce >= 1 && c->redundant && c->vivified)
    return false;
  if (opts.vivifyonce >= 2 && !c->redundant && c->vivified)
    return false;
  if (!c->redundant)
    return true;
  CADICAL_assert (c->redundant);
 
  // likely_to_be_kept_clause is too aggressive at removing tier-3 clauses
  return true;
}

Here is the caller graph for this function:

◆ constrain()

void CaDiCaL::Internal::constrain ( int lit )

Definition at line 9 of file cadical_constrain.cpp.

                                 {
  if (lit)
    constraint.push_back (lit);
  else {
    if (level)
      backtrack ();
    LOG (constraint, "shrinking constraint");
    bool satisfied_constraint = false;
    const vector<int>::const_iterator end = constraint.end ();
    vector<int>::iterator i = constraint.begin ();
    for (vector<int>::const_iterator j = i; j != end; j++) {
      int tmp = marked (*j);
      if (tmp > 0) {
        LOG ("removing duplicated literal %d from constraint", *j);
      } else if (tmp < 0) {
        LOG ("tautological since both %d and %d occur in constraint", -*j,
             *j);
        satisfied_constraint = true;
        break;
      } else {
        tmp = val (*j);
        if (tmp < 0) {
          LOG ("removing falsified literal %d from constraint clause", *j);
        } else if (tmp > 0) {
          LOG ("satisfied constraint with literal %d", *j);
          satisfied_constraint = true;
          break;
        } else {
          *i++ = *j;
          mark (*j);
        }
      }
    }
    constraint.resize (i - constraint.begin ());
    for (const auto &lit : constraint)
      unmark (lit);
    if (satisfied_constraint)
      constraint.clear ();
    else if (constraint.empty ()) {
      unsat_constraint = true;
      if (!conflict_id)
        marked_failed = false; // allow to trigger failing ()
    } else
      for (const auto lit : constraint)
        freeze (lit);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copy_clause()

void CaDiCaL::Internal::copy_clause ( Clause * c )

Definition at line 315 of file cadical_collect.cpp.

                                     {
  LOG (c, "moving");
  CADICAL_assert (!c->moved);
  char *p = (char *) c;
  char *q = arena.copy (p, c->bytes ());
  c->copy = (Clause *) q;
  c->moved = true;
  LOG ("copied clause[%" PRId64 "] from %p to %p", c->id, (void *) c,
       (void *) c->copy);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copy_non_garbage_clauses()

void CaDiCaL::Internal::copy_non_garbage_clauses ( )

Definition at line 328 of file cadical_collect.cpp.

                                         {
 
  size_t collected_clauses = 0, collected_bytes = 0;
  size_t moved_clauses = 0, moved_bytes = 0;
 
  // First determine 'moved_bytes' and 'collected_bytes'.
  //
  for (const auto &c : clauses)
    if (!c->collect ())
      moved_bytes += c->bytes (), moved_clauses++;
    else
      collected_bytes += c->bytes (), collected_clauses++;
 
  PHASE ("collect", stats.collections,
         "moving %zd bytes %.0f%% of %zd non garbage clauses", moved_bytes,
         percent (moved_bytes, collected_bytes + moved_bytes),
         moved_clauses);
  (void) moved_clauses, (void) collected_clauses, (void) collected_bytes;
  // Prepare 'to' space of size 'moved_bytes'.
  //
  arena.prepare (moved_bytes);
 
  // Keep clauses in arena in the same order.
  //
  if (opts.arenacompact)
    for (const auto &c : clauses)
      if (!c->collect () && arena.contains (c))
        copy_clause (c);
 
  if (opts.arenatype == 1 || !watching ()) {
 
    // Localize according to current clause order.
 
    // If the option 'opts.arenatype == 1' is set, then this means the
    // solver uses the original order of clauses.  If there are no watches,
    // we can not use the watched based copying policies below.  This
    // happens if garbage collection is triggered during bounded variable
    // elimination.
 
    // Copy clauses according to the order of calling 'copy_clause', which
    // in essence just gives a compacting garbage collector, since their
    // relative order is kept, and actually already gives the largest
    // benefit due to better cache locality.
 
    for (const auto &c : clauses)
      if (!c->moved && !c->collect ())
        copy_clause (c);
 
  } else if (opts.arenatype == 2) {
 
    // Localize according to (original) variable order.
 
    // This is almost the version used by MiniSAT and descendants.
    // Our version uses saved phases too.
 
    for (int sign = -1; sign <= 1; sign += 2)
      for (auto idx : vars)
        for (const auto &w : watches (sign * likely_phase (idx)))
          if (!w.clause->moved && !w.clause->collect ())
            copy_clause (w.clause);
 
  } else {
 
    // Localize according to decision queue order.
 
    // This is the default for search. It allocates clauses in the order of
    // the decision queue and also uses saved phases.  It seems faster than
    // the MiniSAT version and thus we keep 'opts.arenatype == 3'.
 
    CADICAL_assert (opts.arenatype == 3);
 
    for (int sign = -1; sign <= 1; sign += 2)
      for (int idx = queue.last; idx; idx = link (idx).prev)
        for (const auto &w : watches (sign * likely_phase (idx)))
          if (!w.clause->moved && !w.clause->collect ())
            copy_clause (w.clause);
  }
 
  // Do not forget to move clauses which are not watched, which happened in
  // a rare situation, and now is only left as defensive code.
  //
  for (const auto &c : clauses)
    if (!c->collect () && !c->moved)
      copy_clause (c);
 
  flush_all_occs_and_watches ();
  update_reason_references ();
 
  // Replace and flush clause references in 'clauses'.
  //
  const auto end = clauses.end ();
  auto j = clauses.begin (), i = j;
  for (; i != end; i++) {
    Clause *c = *i;
    if (c->collect ())
      delete_clause (c);
    else
      CADICAL_assert (c->moved), *j++ = c->copy, deallocate_clause (c);
  }
  clauses.resize (j - clauses.begin ());
  if (clauses.size () < clauses.capacity () / 2)
    shrink_vector (clauses);
 
  if (opts.arenasort)
    rsort (clauses.begin (), clauses.end (), pointer_rank ());
 
  // Release 'from' space completely and then swap 'to' with 'from'.
  //
  arena.swap ();
 
  PHASE ("collect", stats.collections,
         "collected %zd bytes %.0f%% of %zd garbage clauses",
         collected_bytes,
         percent (collected_bytes, collected_bytes + moved_bytes),
         collected_clauses);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copy_phases()

void CaDiCaL::Internal::copy_phases ( vector< signed char > & dst )

Definition at line 9 of file cadical_phases.cpp.

                                                    {
  START (copy);
  for (auto i : vars)
    dst[i] = phases.saved[i];
  STOP (copy);
}

Here is the caller graph for this function:

◆ cover()

bool CaDiCaL::Internal::cover ( )

Definition at line 649 of file cadical_cover.cpp.

                      {
 
  if (!opts.cover)
    return false;
  if (unsat)
    return false;
  if (terminated_asynchronously ())
    return false;
  if (!stats.current.irredundant)
    return false;
 
  // TODO: Our current algorithm for producing the necessary clauses on the
  // reconstruction stack for extending the witness requires a covered
  // literal addition step which (empirically) conflicts with flushing
  // during restoring clauses (see 'regr00{48,51}.trace') even though
  // flushing during restore is disabled by default (as is covered clause
  // elimination).  The consequence of combining these two options
  // ('opts.cover' and 'opts.restoreflush') can thus produce incorrect
  // witness reconstruction and thus invalid witnesses.  This is quite
  // infrequent (one out of half billion mobical test cases) but as the two
  // regression traces show, does happen. Thus we disable the combination.
  //
  if (opts.restoreflush)
    return false;
 
  START_SIMPLIFIER (cover, COVER);
 
  stats.cover.count++;
 
  // During variable elimination unit clauses can be generated which need to
  // be propagated properly over redundant clauses too.  Since variable
  // elimination avoids to have occurrence lists and watches at the same
  // time this propagation is delayed until the end of variable elimination.
  // Since we want to interleave CCE with it, we have to propagate here.
  // Otherwise this triggers inconsistencies.
  //
  if (propagated < trail.size ()) {
    init_watches ();
    connect_watches (); // need to propagated over all clauses!
    LOG ("elimination produced %zd units",
         (size_t) (trail.size () - propagated));
    if (!propagate ()) {
      LOG ("propagating units before covered clause elimination "
           "results in empty clause");
      learn_empty_clause ();
      CADICAL_assert (unsat);
    }
    reset_watches ();
  }
  CADICAL_assert (unsat || propagated == trail.size ());
 
  int64_t covered = cover_round ();
 
  STOP_SIMPLIFIER (cover, COVER);
  report ('c', !opts.reportall && !covered);
 
  return covered;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cover_clause()

bool CaDiCaL::Internal::cover_clause	(	Clause *	c,
		Coveror &	coveror )

Definition at line 327 of file cadical_cover.cpp.

                                                        {
 
  require_mode (COVER);
  CADICAL_assert (!c->garbage);
 
  LOG (c, "trying covered clauses elimination on");
  bool satisfied = false;
  for (const auto &lit : *c)
    if (val (lit) > 0)
      satisfied = true;
 
  if (satisfied) {
    LOG (c, "clause already satisfied");
    mark_garbage (c);
    return false;
  }
 
  CADICAL_assert (coveror.added.empty ());
  CADICAL_assert (coveror.extend.empty ());
  CADICAL_assert (coveror.covered.empty ());
 
  CADICAL_assert (!level);
  level = 1;
  LOG ("assuming literals of candidate clause");
  for (const auto &lit : *c) {
    if (val (lit))
      continue;
    asymmetric_literal_addition (lit, coveror);
    coveror.covered.push_back (lit);
  }
 
  bool tautological = false;
 
  coveror.next.added = coveror.next.covered = 0;
 
  while (!tautological) {
    if (coveror.next.added < coveror.added.size ()) {
      const int lit = coveror.added[coveror.next.added++];
      tautological = cover_propagate_asymmetric (lit, c, coveror);
    } else if (coveror.next.covered < coveror.covered.size ()) {
      const int lit = coveror.covered[coveror.next.covered++];
      tautological = cover_propagate_covered (lit, coveror);
    } else
      break;
  }
 
  if (tautological) {
    if (coveror.extend.empty ()) {
      stats.cover.asymmetric++;
      stats.cover.total++;
      LOG (c, "asymmetric tautological");
    } else {
      stats.cover.blocked++;
      stats.cover.total++;
      // Only copy extension stack if successful.
      int prev = INT_MIN;
      bool already_pushed = false;
      int64_t last_id = 0;
      LOG (c, "covered tautological");
      CADICAL_assert (clause.empty ());
      LOG (coveror.extend, "extension = ");
      for (const auto &other : coveror.extend) {
        if (!prev) {
          // are we finishing a clause?
          if (already_pushed) {
            // add missing literals that are not needed for covering
            // but avoid RAT proofs
            for (auto i = 0, j = 0; i < c->size; ++i, ++j) {
              const int lit = c->literals[i];
              if (j >= (int) coveror.covered.size () ||
                  c->literals[i] != coveror.covered[j]) {
                --j;
                LOG ("adding lit %d not needed for ATA", lit);
                clause.push_back (lit);
                external->push_clause_literal_on_extension_stack (lit);
              }
            }
          }
          if (proof && already_pushed) {
            if (lrat)
              lrat_chain.push_back (c->id);
            LOG ("LEARNING clause with id %" PRId64, last_id);
            proof->add_derived_clause (last_id, false, clause, lrat_chain);
            proof->weaken_plus (last_id, clause);
            lrat_chain.clear ();
          }
          last_id = ++clause_id;
          external->push_zero_on_extension_stack ();
          external->push_witness_literal_on_extension_stack (other);
          external->push_zero_on_extension_stack ();
          external->push_id_on_extension_stack (last_id);
          external->push_zero_on_extension_stack ();
          clause.clear ();
          already_pushed = true;
        }
        if (other) {
          external->push_clause_literal_on_extension_stack (other);
          clause.push_back (other);
          LOG (clause, "current clause is");
        }
        prev = other;
      }
 
      if (proof) {
        // add missing literals that are not needed for covering
        // but avoid RAT proofs
        for (auto i = 0, j = 0; i < c->size; ++i, ++j) {
          const int lit = c->literals[i];
          if (j >= (int) coveror.covered.size () ||
              c->literals[i] != coveror.covered[j]) {
            --j;
            LOG ("adding lit %d not needed for ATA", lit);
            clause.push_back (lit);
            external->push_clause_literal_on_extension_stack (lit);
          }
        }
        if (lrat)
          lrat_chain.push_back (c->id);
        proof->add_derived_clause (last_id, false, clause, lrat_chain);
        proof->weaken_plus (last_id, clause);
        lrat_chain.clear ();
      }
      clause.clear ();
 
      mark_garbage (c);
    }
  }
 
  // Backtrack and 'unassign' all literals.
 
  CADICAL_assert (level == 1);
  for (const auto &lit : coveror.added)
    set_val (lit, 0);
  level = 0;
 
  coveror.covered.clear ();
  coveror.extend.clear ();
  coveror.added.clear ();
 
  return tautological;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cover_propagate_asymmetric()

bool CaDiCaL::Internal::cover_propagate_asymmetric	(	int	lit,
		Clause *	ignore,
		Coveror &	coveror )

Definition at line 104 of file cadical_cover.cpp.

                                                             {
  require_mode (COVER);
  stats.propagations.cover++;
  CADICAL_assert (val (lit) < 0);
  bool subsumed = false;
  LOG ("asymmetric literal propagation of %d", lit);
  Watches &ws = watches (lit);
  const const_watch_iterator eow = ws.end ();
  watch_iterator j = ws.begin ();
  const_watch_iterator i = j;
  while (!subsumed && i != eow) {
    const Watch w = *j++ = *i++;
    if (w.clause == ignore)
      continue; // costly but necessary here ...
    const signed char b = val (w.blit);
    if (b > 0)
      continue;
    if (w.clause->garbage)
      j--;
    else if (w.binary ()) {
      if (b < 0) {
        LOG (w.clause, "found subsuming");
        subsumed = true;
      } else
        asymmetric_literal_addition (-w.blit, coveror);
    } else {
      literal_iterator lits = w.clause->begin ();
      const int other = lits[0] ^ lits[1] ^ lit;
      lits[0] = other, lits[1] = lit;
      const signed char u = val (other);
      if (u > 0)
        j[-1].blit = other;
      else {
        const int size = w.clause->size;
        const const_literal_iterator end = lits + size;
        const literal_iterator middle = lits + w.clause->pos;
        literal_iterator k = middle;
        signed char v = -1;
        int r = 0;
        while (k != end && (v = val (r = *k)) < 0)
          k++;
        if (v < 0) {
          k = lits + 2;
          CADICAL_assert (w.clause->pos <= size);
          while (k != middle && (v = val (r = *k)) < 0)
            k++;
        }
        w.clause->pos = k - lits;
        CADICAL_assert (lits + 2 <= k), CADICAL_assert (k <= w.clause->end ());
        if (v > 0)
          j[-1].blit = r;
        else if (!v) {
          LOG (w.clause, "unwatch %d in", lit);
          lits[1] = r;
          *k = lit;
          watch_literal (r, lit, w.clause);
          j--;
        } else if (!u) {
          CADICAL_assert (v < 0);
          asymmetric_literal_addition (-other, coveror);
        } else {
          CADICAL_assert (u < 0), CADICAL_assert (v < 0);
          LOG (w.clause, "found subsuming");
          subsumed = true;
          break;
        }
      }
    }
  }
  if (j != i) {
    while (i != eow)
      *j++ = *i++;
    ws.resize (j - ws.begin ());
  }
  return subsumed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cover_propagate_covered()

bool CaDiCaL::Internal::cover_propagate_covered	(	int	lit,
		Coveror &	coveror )

Definition at line 185 of file cadical_cover.cpp.

                                                                 {
  require_mode (COVER);
 
  CADICAL_assert (val (lit) < 0);
  if (frozen (lit)) {
    LOG ("no covered propagation on frozen literal %d", lit);
    return false;
  }
 
  stats.propagations.cover++;
 
  LOG ("covered propagation of %d", lit);
  CADICAL_assert (coveror.intersection.empty ());
 
  Occs &os = occs (-lit);
  const auto end = os.end ();
  bool first = true;
 
  // Compute the intersection of the literals in all the clauses with
  // '-lit'.  If all these clauses are double satisfied then we know that
  // the extended clauses (in 'added') is blocked.  All literals in the
  // intersection can be added as covered literal. As soon the intersection
  // becomes empty (during traversal of clauses with '-lit') we abort.
 
  for (auto i = os.begin (); i != end; i++) {
 
    Clause *c = *i;
    if (c->garbage)
      continue;
 
    // First check whether clause is 'blocked', i.e., is double satisfied.
 
    bool blocked = false;
    for (const auto &other : *c) {
      if (other == -lit)
        continue;
      const signed char tmp = val (other);
      if (tmp < 0)
        continue;
      if (tmp > 0) {
        blocked = true;
        break;
      }
    }
    if (blocked) { // ... if 'c' is double satisfied.
      LOG (c, "blocked");
      continue; // with next clause with '-lit'.
    }
 
    if (first) {
 
      // Copy and mark literals of first clause.
 
      for (const auto &other : *c) {
        if (other == -lit)
          continue;
        const signed char tmp = val (other);
        if (tmp < 0)
          continue;
        CADICAL_assert (!tmp);
        coveror.intersection.push_back (other);
        mark (other);
      }
 
      first = false;
 
    } else {
 
      // Unmark all literals in current clause.
 
      for (const auto &other : *c) {
        if (other == -lit)
          continue;
        signed char tmp = val (other);
        if (tmp < 0)
          continue;
        CADICAL_assert (!tmp);
        tmp = marked (other);
        if (tmp > 0)
          unmark (other);
      }
 
      // Then remove from intersection all marked literals.
 
      const auto end = coveror.intersection.end ();
      auto j = coveror.intersection.begin ();
      for (auto k = j; k != end; k++) {
        const int other = *j++ = *k;
        const int tmp = marked (other);
        CADICAL_assert (tmp >= 0);
        if (tmp)
          j--, unmark (other); // remove marked and unmark it
        else
          mark (other); // keep unmarked and mark it
      }
      const size_t new_size = j - coveror.intersection.begin ();
      coveror.intersection.resize (new_size);
 
      if (!coveror.intersection.empty ())
        continue;
 
      // No covered literal addition candidates in the intersection left!
      // Move this clause triggering early abort to the beginning.
      // This is a common move to front strategy to minimize effort.
 
      auto begin = os.begin ();
      while (i != begin) {
        auto prev = i - 1;
        *i = *prev;
        i = prev;
      }
      *begin = c;
 
      break; // early abort ...
    }
  }
 
  bool res = false;
  if (first) {
    LOG ("all resolution candidates with %d blocked", -lit);
    CADICAL_assert (coveror.intersection.empty ());
    cover_push_extension (lit, coveror);
    res = true;
  } else if (coveror.intersection.empty ()) {
    LOG ("empty intersection of resolution candidate literals");
  } else {
    LOG (coveror.intersection,
         "non-empty intersection of resolution candidate literals");
    covered_literal_addition (lit, coveror);
    unmark (coveror.intersection);
    coveror.intersection.clear ();
    coveror.next.covered = 0; // Restart covering.
  }
 
  unmark (coveror.intersection);
  coveror.intersection.clear ();
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cover_push_extension()

void CaDiCaL::Internal::cover_push_extension	(	int	lit,
		Coveror &	coveror )

inline

Definition at line 53 of file cadical_cover.cpp.

                                                                     {
  coveror.extend.push_back (0);
  coveror.extend.push_back (lit); // blocking literal comes first
  bool found = false;
  for (const auto &other : coveror.covered)
    if (lit == other)
      CADICAL_assert (!found), found = true;
    else
      coveror.extend.push_back (other);
  CADICAL_assert (found);
  (void) found;
}

Here is the caller graph for this function:

◆ cover_round()

int64_t CaDiCaL::Internal::cover_round ( )

Definition at line 483 of file cadical_cover.cpp.

                               {
 
  if (unsat)
    return 0;
 
  init_watches ();
  connect_watches (true); // irredundant watches only is enough
 
  int64_t delta = stats.propagations.search;
  delta *= 1e-3 * opts.covereffort;
  if (delta < opts.covermineff)
    delta = opts.covermineff;
  if (delta > opts.covermaxeff)
    delta = opts.covermaxeff;
  delta = max (delta, ((int64_t) 2) * active ());
 
  PHASE ("cover", stats.cover.count,
         "covered clause elimination limit of %" PRId64 " propagations",
         delta);
 
  int64_t limit = stats.propagations.cover + delta;
 
  init_occs ();
 
  vector<Clause *> schedule;
  Coveror coveror;
 
  // First connect all clauses and find all not yet tried clauses.
  //
#ifndef CADICAL_QUIET
  int64_t untried = 0;
#endif
  //
  for (auto c : clauses) {
    CADICAL_assert (!c->frozen);
    if (c->garbage)
      continue;
    if (c->redundant)
      continue;
    bool satisfied = false, allfrozen = true;
    for (const auto &lit : *c)
      if (val (lit) > 0) {
        satisfied = true;
        break;
      } else if (allfrozen && !frozen (lit))
        allfrozen = false;
    if (satisfied) {
      mark_garbage (c);
      continue;
    }
    if (allfrozen) {
      c->frozen = true;
      continue;
    }
    for (const auto &lit : *c)
      occs (lit).push_back (c);
    if (c->size < opts.coverminclslim)
      continue;
    if (c->size > opts.covermaxclslim)
      continue;
    if (c->covered)
      continue;
    schedule.push_back (c);
#ifndef CADICAL_QUIET
    untried++;
#endif
  }
 
  if (schedule.empty ()) {
 
    PHASE ("cover", stats.cover.count, "no previously untried clause left");
 
    for (auto c : clauses) {
      if (c->garbage)
        continue;
      if (c->redundant)
        continue;
      if (c->frozen) {
        c->frozen = false;
        continue;
      }
      if (c->size < opts.coverminclslim)
        continue;
      if (c->size > opts.covermaxclslim)
        continue;
      CADICAL_assert (c->covered);
      c->covered = false;
      schedule.push_back (c);
    }
  } else { // Mix of tried and not tried clauses ....
 
    for (auto c : clauses) {
      if (c->garbage)
        continue;
      if (c->redundant)
        continue;
      if (c->frozen) {
        c->frozen = false;
        continue;
      }
      if (c->size < opts.coverminclslim)
        continue;
      if (c->size > opts.covermaxclslim)
        continue;
      if (!c->covered)
        continue;
      schedule.push_back (c);
    }
  }
 
  stable_sort (schedule.begin (), schedule.end (),
               clause_covered_or_smaller ());
 
#ifndef CADICAL_QUIET
  const size_t scheduled = schedule.size ();
  PHASE ("cover", stats.cover.count,
         "scheduled %zd clauses %.0f%% with %" PRId64 " untried %.0f%%",
         scheduled, percent (scheduled, stats.current.irredundant), untried,
         percent (untried, scheduled));
#endif
 
  // Heuristically it should be beneficial to intersect with smaller clauses
  // first, since then the chances are higher that the intersection of
  // resolution candidates becomes emptier earlier.
 
  for (auto lit : lits) {
    if (!active (lit))
      continue;
    Occs &os = occs (lit);
    stable_sort (os.begin (), os.end (), clause_smaller_size ());
  }
 
  // This is the main loop of trying to do CCE of candidate clauses.
  //
  int64_t covered = 0;
  //
  while (!terminated_asynchronously () && !schedule.empty () &&
         stats.propagations.cover < limit) {
    Clause *c = schedule.back ();
    schedule.pop_back ();
    c->covered = true;
    if (cover_clause (c, coveror))
      covered++;
  }
 
#ifndef CADICAL_QUIET
  const size_t remain = schedule.size ();
  const size_t tried = scheduled - remain;
  PHASE ("cover", stats.cover.count,
         "eliminated %" PRId64 " covered clauses out of %zd tried %.0f%%",
         covered, tried, percent (covered, tried));
  if (remain)
    PHASE ("cover", stats.cover.count,
           "remaining %zu clauses %.0f%% untried", remain,
           percent (remain, scheduled));
  else
    PHASE ("cover", stats.cover.count, "all scheduled clauses tried");
#endif
  reset_occs ();
  reset_watches ();
 
  return covered;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ covered_literal_addition()

void CaDiCaL::Internal::covered_literal_addition	(	int	lit,
		Coveror &	coveror )

inline

Definition at line 68 of file cadical_cover.cpp.

                                                                         {
  require_mode (COVER);
  CADICAL_assert (level == 1);
  cover_push_extension (lit, coveror);
  for (const auto &other : coveror.intersection) {
    LOG ("covered literal addition %d", other);
    CADICAL_assert (!vals[other]), CADICAL_assert (!vals[-other]);
    set_val (other, -1);
    coveror.covered.push_back (other);
    coveror.added.push_back (other);
    coveror.clas++;
  }
  coveror.next.covered = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deallocate_clause()

void CaDiCaL::Internal::deallocate_clause ( Clause * c )

Definition at line 250 of file cadical_clause.cpp.

                                           {
  char *p = (char *) c;
  if (arena.contains (p))
    return;
  LOG (c, "deallocate pointer %p", (void *) c);
  delete[] p;
}

Here is the caller graph for this function:

◆ decide()

int CaDiCaL::Internal::decide ( )

Definition at line 126 of file cadical_decide.cpp.

                      {
  CADICAL_assert (!satisfied ());
  START (decide);
  int res = 0;
  if ((size_t) level < assumptions.size ()) {
    const int lit = assumptions[level];
    CADICAL_assert (assumed (lit));
    const signed char tmp = val (lit);
    if (tmp < 0) {
      LOG ("assumption %d falsified", lit);
      res = 20;
    } else if (tmp > 0) {
      LOG ("assumption %d already satisfied", lit);
      new_trail_level (0);
      LOG ("added pseudo decision level");
      notify_decision ();
    } else {
      LOG ("deciding assumption %d", lit);
      search_assume_decision (lit);
    }
  } else if ((size_t) level == assumptions.size () && constraint.size ()) {
 
    int satisfied_lit = 0;  // The literal satisfying the constrain.
    int unassigned_lit = 0; // Highest score unassigned literal.
    int previous_lit = 0;   // Move satisfied literals to the front.
 
    const size_t size_constraint = constraint.size ();
 
#ifndef CADICAL_NDEBUG
    unsigned sum = 0;
    for (auto lit : constraint)
      sum += lit;
#endif
    for (size_t i = 0; i != size_constraint; i++) {
 
      // Get literal and move 'constraint[i] = constraint[i-1]'.
 
      int lit = constraint[i];
      constraint[i] = previous_lit;
      previous_lit = lit;
 
      const signed char tmp = val (lit);
      if (tmp < 0) {
        LOG ("constraint literal %d falsified", lit);
        continue;
      }
 
      if (tmp > 0) {
        LOG ("constraint literal %d satisfied", lit);
        satisfied_lit = lit;
        break;
      }
 
      CADICAL_assert (!tmp);
      LOG ("constraint literal %d unassigned", lit);
 
      if (!unassigned_lit || better_decision (lit, unassigned_lit))
        unassigned_lit = lit;
    }
 
    if (satisfied_lit) {
 
      constraint[0] = satisfied_lit; // Move satisfied to the front.
 
      LOG ("literal %d satisfies constraint and "
           "is implied by assumptions",
           satisfied_lit);
 
      new_trail_level (0);
      LOG ("added pseudo decision level for constraint");
      notify_decision ();
 
    } else {
 
      // Just move all the literals back.  If we found an unsatisfied
      // literal then it will be satisfied (most likely) at the next
      // decision and moved then to the first position.
 
      if (size_constraint) {
 
        for (size_t i = 0; i + 1 != size_constraint; i++)
          constraint[i] = constraint[i + 1];
 
        constraint[size_constraint - 1] = previous_lit;
      }
 
      if (unassigned_lit) {
 
        LOG ("deciding %d to satisfy constraint", unassigned_lit);
        search_assume_decision (unassigned_lit);
 
      } else {
 
        LOG ("failing constraint");
        unsat_constraint = true;
        res = 20;
      }
    }
 
#ifndef CADICAL_NDEBUG
    for (auto lit : constraint)
      sum -= lit;
    CADICAL_assert (!sum); // Checksum of literal should not change!
#endif
 
  } else {
 
    int decision = ask_decision ();
    if ((size_t) level < assumptions.size () ||
        ((size_t) level == assumptions.size () && constraint.size ())) {
      // Forced backtrack below pseudo decision levels.
      // So one of the two branches above will handle it.
      STOP (decide);
      res = decide (); // STARTS and STOPS profiling
      START (decide);
    } else {
      stats.decisions++;
      if (!decision) {
        int idx = next_decision_variable ();
        const bool target = (opts.target > 1 || (stable && opts.target));
        decision = decide_phase (idx, target);
      }
      search_assume_decision (decision);
    }
  }
  if (res)
    marked_failed = false;
  STOP (decide);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decide_phase()

int CaDiCaL::Internal::decide_phase	(	int	idx,
		bool	target )

Definition at line 57 of file cadical_decide.cpp.

                                                {
  const int initial_phase = opts.phase ? 1 : -1;
  int phase = 0;
  if (force_saved_phase)
    phase = phases.saved[idx];
  if (!phase)
    phase = phases.forced[idx]; // swapped with opts.forcephase case!
  if (!phase && opts.forcephase)
    phase = initial_phase;
  if (!phase && target)
    phase = phases.target[idx];
  if (!phase)
    phase = phases.saved[idx];
 
  // The following should not be necessary and in some version we had even
  // a hard 'COVER' CADICAL_assertion here to check for this.   Unfortunately it
  // triggered for some users and we could not get to the root cause of
  // 'phase' still not being set here.  The logic for phase and target
  // saving is pretty complex, particularly in combination with local
  // search, and to avoid running in such an issue in the future again, we
  // now use this 'defensive' code here, even though such defensive code is
  // considered bad programming practice.
  //
  if (!phase)
    phase = initial_phase;
 
  return phase * idx;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decompose()

void CaDiCaL::Internal::decompose ( )

Definition at line 731 of file cadical_decompose.cpp.

                          {
  for (int round = 1; round <= opts.decomposerounds; round++)
    if (!decompose_round ())
      break;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decompose_analyze_binary_chain()

void CaDiCaL::Internal::decompose_analyze_binary_chain	(	DFS *	dfs,
		int	from )

Definition at line 9 of file cadical_decompose.cpp.

                                                                 {
  if (!lrat)
    return;
  LOG ("binary chain starting at %d", from);
  DFS &from_dfs = dfs[vlit (from)];
  Clause *reason = from_dfs.parent;
  if (!reason)
    return;
  CADICAL_assert (reason->size == 2);
  mini_chain.push_back (reason->id);
  int other = reason->literals[0];
  other = other == from ? -reason->literals[1] : -other;
  Flags &f = flags (other);
  if (f.seen)
    return;
  f.seen = true;
  analyzed.push_back (other);
  decompose_analyze_binary_chain (dfs, other);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decompose_analyze_binary_clauses()

vector< Clause * > CaDiCaL::Internal::decompose_analyze_binary_clauses	(	DFS *	dfs,
		int	from )

Definition at line 29 of file cadical_decompose.cpp.

                                                                       {
  vector<Clause *> result;
  LOG ("binary chain starting at %d", from);
  DFS &from_dfs = dfs[vlit (from)];
  Clause *reason = from_dfs.parent;
  while (reason) {
    result.push_back (reason);
    CADICAL_assert (reason->size == 2);
    int other = reason->literals[0];
    other = other == from ? -reason->literals[1] : -other;
    Flags &f = flags (other);
    if (f.seen)
      break;
    f.seen = true;
    analyzed.push_back (other);
    from = other;
    DFS &from_dfs = dfs[vlit (from)];
    reason = from_dfs.parent;
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decompose_conflicting_scc_lrat()

void CaDiCaL::Internal::decompose_conflicting_scc_lrat	(	DFS *	dfs,
		vector< int > &	scc )

Definition at line 52 of file cadical_decompose.cpp.

                                                                         {
  if (!lrat)
    return;
  CADICAL_assert (lrat_chain.empty ());
  CADICAL_assert (mini_chain.empty ());
  for (auto &lit : scc) {
    Flags &f = flags (lit);
    if (f.seen)
      return;
    f.seen = true;
    analyzed.push_back (lit);
    decompose_analyze_binary_chain (dfs, lit);
    for (auto p = mini_chain.rbegin (); p != mini_chain.rend (); p++) {
      lrat_chain.push_back (*p);
    }
    mini_chain.clear ();
  }
  clear_analyzed_literals ();
}

Here is the call graph for this function:

◆ decompose_round()

bool CaDiCaL::Internal::decompose_round ( )

Definition at line 134 of file cadical_decompose.cpp.

                                {
 
  if (!opts.decompose)
    return false;
  if (unsat)
    return false;
  if (terminated_asynchronously ())
    return false;
 
  CADICAL_assert (!level);
 
  START_SIMPLIFIER (decompose, DECOMP);
 
  stats.decompositions++;
 
  const size_t size_dfs = 2 * (1 + (size_t) max_var);
  DFS *dfs = new DFS[size_dfs];
  DeferDeleteArray<DFS> dfs_delete (dfs);
  int *reprs = new int[size_dfs];
  DeferDeleteArray<int> reprs_delete (reprs);
  clear_n (reprs, size_dfs);
  vector<vector<Clause *>> dfs_chains;
  dfs_chains.resize (size_dfs);
  if (lrat) {
    for (size_t i = 0; i > size_dfs; i++) {
      vector<Clause *> empty;
      dfs_chains[i] = empty;
    }
  }
 
  int substituted = 0;
#ifndef CADICAL_QUIET
  int non_trivial_sccs = 0;
  int before = active ();
#endif
  unsigned dfs_idx = 0;
 
  vector<int> work; // depth first search working stack
  vector<int> scc;  // collects members of one SCC
 
  // The binary implication graph might have disconnected components and
  // thus we have in general to start several depth first searches.
 
  for (auto root_idx : vars) {
    if (unsat)
      break;
    if (!active (root_idx))
      continue;
    for (int root_sign = -1; !unsat && root_sign <= 1; root_sign += 2) {
      int root = root_sign * root_idx;
      if (dfs[vlit (root)].min == TRAVERSED)
        continue; // skip traversed
      LOG ("new dfs search starting at root %d", root);
      CADICAL_assert (work.empty ());
      CADICAL_assert (scc.empty ());
      work.push_back (root);
      while (!unsat && !work.empty ()) {
        int parent = work.back ();
        DFS &parent_dfs = dfs[vlit (parent)];
        if (parent_dfs.min == TRAVERSED) { // skip traversed
          CADICAL_assert (reprs[vlit (parent)]);
          work.pop_back ();
        } else {
          CADICAL_assert (!reprs[vlit (parent)]);
 
          // Go over all implied literals, thus need to iterate over all
          // binary watched clauses with the negation of 'parent'.
 
          Watches &ws = watches (-parent);
 
          // Two cases: Either the node has never been visited before, i.e.,
          // it's depth first search index is zero, then perform the
          // 'pre-fix' work before visiting it's children.  Otherwise all
          // it's children and nodes reachable from those children have been
          // visited and their minimum reachable depth first search index
          // has been computed.  This second case is the 'post-fix' work.
 
          if (parent_dfs.idx) { // post-fix
 
            work.pop_back (); // 'parent' done
 
            // Get the minimum reachable depth first search index reachable
            // from the children of 'parent'.
 
            unsigned new_min = parent_dfs.min;
 
            for (const auto &w : ws) {
              if (!w.binary ())
                continue;
              const int child = w.blit;
              if (!active (child))
                continue;
              DFS &child_dfs = dfs[vlit (child)];
              if (new_min > child_dfs.min)
                new_min = child_dfs.min;
            }
 
            LOG ("post-fix work dfs search %d index %u reaches minimum %u",
                 parent, parent_dfs.idx, new_min);
 
            if (parent_dfs.idx == new_min) { // entry to SCC
 
              // All nodes on the 'scc' stack after and including 'parent'
              // are in the same SCC.  Their representative is computed as
              // the smallest literal (index-wise) in the SCC.  If the SCC
              // contains both a literal and its negation, then the formula
              // becomes unsatisfiable.
 
              if (lrat) {
                CADICAL_assert (analyzed.empty ());
                int other, first = 0;
                bool conflicting = false;
                size_t j = scc.size ();
                do {
                  CADICAL_assert (j > 0);
                  other = scc[--j];
                  if (!first || vlit (other) < vlit (first))
                    first = other;
                  Flags &f = flags (other);
                  if (other == -parent) {
                    conflicting = true; // conflicting scc
                  }
                  if (f.seen) {
                    continue; // also conflicting scc
                  }
                  f.seen = true;
                  analyzed.push_back (other);
                } while (other != parent);
 
                CADICAL_assert (!conflicting || first > 0);
                vector<int> to_justify;
                if (conflicting) {
                  LOG ("conflicting scc simulating up at %d", parent);
                  to_justify.push_back (-parent);
                } else
                  to_justify.push_back (first);
                while (!to_justify.empty ()) {
                  const int next = to_justify.back ();
                  to_justify.pop_back ();
                  Watches &next_ws = watches (-next);
                  for (const auto &w : next_ws) {
                    if (!w.binary ())
                      continue;
                    const int child = w.blit;
                    if (!active (child))
                      continue;
                    if (!flags (child).seen)
                      continue;
                    DFS &child_dfs = dfs[vlit (child)];
                    if (child_dfs.parent)
                      continue;
                    child_dfs.parent = w.clause;
                    to_justify.push_back (child);
                  }
                }
 
                clear_analyzed_literals ();
              }
 
              int other, repr = parent;
#ifndef CADICAL_QUIET
              int size = 0;
#endif
              CADICAL_assert (!scc.empty ());
              size_t j = scc.size ();
              do {
                CADICAL_assert (j > 0);
                other = scc[--j];
                if (other == -parent) {
                  LOG ("both %d and %d in one SCC", parent, -parent);
                  if (lrat) {
                    Flags &f = flags (-parent);
                    f.seen = true;
                    analyzed.push_back (-parent);
                    decompose_analyze_binary_chain (dfs, parent);
                    for (auto p : mini_chain)
                      lrat_chain.push_back (p);
                    mini_chain.clear ();
                  }
                  assign_unit (parent);
#ifndef CADICAL_NDEBUG
                  bool ok =
#endif
                      propagate ();
                  CADICAL_assert (!ok);
                  learn_empty_clause ();
                  lrat_chain.clear ();
                } else {
                  if (abs (other) < abs (repr))
                    repr = other;
#ifndef CADICAL_QUIET
                  size++;
#endif
                }
              } while (!unsat && other != parent);
 
              if (unsat)
                break;
#ifndef CADICAL_QUIET
              LOG ("SCC of representative %d of size %d", repr, size);
#endif
              do {
                CADICAL_assert (!scc.empty ());
                other = scc.back ();
                scc.pop_back ();
                dfs[vlit (other)].min = TRAVERSED;
                if (frozen (other)) {
                  reprs[vlit (other)] = other;
                  continue;
                }
                reprs[vlit (other)] = repr;
                if (other == repr)
                  continue;
                substituted++;
                LOG ("literal %d in SCC of %d", other, repr);
                if (!lrat)
                  continue;
                CADICAL_assert (mini_chain.empty ());
                Flags &f = flags (repr);
                f.seen = true;
                analyzed.push_back (repr);
                // no need to reverse dfs_chain because this is handled by
                // build_lrat_for_clause.
                dfs_chains[vlit (other)] =
                    decompose_analyze_binary_clauses (dfs, other);
                clear_analyzed_literals ();
              } while (other != parent);
 
#ifndef CADICAL_QUIET
              if (size > 1)
                non_trivial_sccs++;
#endif
 
            } else {
 
              // Current node 'parent' is in a non-trivial SCC but is not
              // the entry point of the SCC in this depth first search, so
              // keep it on the SCC stack until the entry point is reached.
 
              parent_dfs.min = new_min;
            }
 
          } else { // pre-fix
 
            dfs_idx++;
            CADICAL_assert (dfs_idx < TRAVERSED);
            parent_dfs.idx = parent_dfs.min = dfs_idx;
            scc.push_back (parent);
 
            LOG ("pre-fix work dfs search %d index %u", parent, dfs_idx);
 
            // Now traverse all the children in the binary implication
            // graph but keep 'parent' on the stack for 'post-fix' work.
 
            for (const auto &w : ws) {
              if (!w.binary ())
                continue;
              const int child = w.blit;
              if (!active (child))
                continue;
              DFS &child_dfs = dfs[vlit (child)];
              if (child_dfs.idx)
                continue;
              work.push_back (child);
            }
          }
        }
      }
    }
  }
 
  erase_vector (work);
  erase_vector (scc);
  // delete [] dfs; need to postpone until after changing clauses...
 
  // Only keep the representatives 'repr' mapping.
 
  PHASE ("decompose", stats.decompositions,
         "%d non-trivial sccs, %d substituted %.2f%%", non_trivial_sccs,
         substituted, percent (substituted, before));
 
  bool new_unit = false, new_binary_clause = false;
 
  // Finally, mark substituted literals as such and push the equivalences of
  // the substituted literals to their representative on the extension
  // stack to fix an assignment during 'extend'.
  // It is also necessary to do so for proper IDRUP/LIDRUP/Resolution proofs
 
  vector<int64_t> decompose_ids;
  const size_t size = 2 * (1 + (size_t) max_var);
  decompose_ids.resize (size);
 
  for (auto idx : vars) {
    if (!substituted)
      break;
    if (unsat)
      break;
    if (!active (idx))
      continue;
    int other = reprs[vlit (idx)];
    if (other == idx)
      continue;
    CADICAL_assert (!flags (other).eliminated ());
    CADICAL_assert (!flags (other).substituted ());
 
    LOG ("marking equivalence of %d and %d", idx, other);
    CADICAL_assert (clause.empty ());
    CADICAL_assert (lrat_chain.empty ());
    clause.push_back (other);
    clause.push_back (-idx);
    if (lrat) {
      build_lrat_for_clause (dfs_chains);
      CADICAL_assert (!lrat_chain.empty ());
    }
 
    const int64_t id1 = ++clause_id;
    if (proof) {
      proof->add_derived_clause (id1, false, clause, lrat_chain);
      proof->weaken_minus (id1, clause);
    }
    external->push_binary_clause_on_extension_stack (id1, -idx, other);
 
    decompose_ids[vlit (-idx)] = id1;
 
    lrat_chain.clear ();
    clause.clear ();
 
    CADICAL_assert (clause.empty ());
    CADICAL_assert (lrat_chain.empty ());
    clause.push_back (idx);
    clause.push_back (-other);
    if (lrat) {
      build_lrat_for_clause (dfs_chains);
      CADICAL_assert (!lrat_chain.empty ());
    }
    const int64_t id2 = ++clause_id;
    if (proof) {
      proof->add_derived_clause (id2, false, clause, lrat_chain);
      proof->weaken_minus (id2, clause);
    }
    external->push_binary_clause_on_extension_stack (id2, idx, -other);
    decompose_ids[vlit (idx)] = id2;
 
    clause.clear ();
    lrat_chain.clear ();
  }
 
  vector<Clause *> postponed_garbage;
 
  // Now go over all clauses and find clause which contain literals that
  // should be substituted by their representative.
 
  size_t clauses_size = clauses.size ();
#ifndef CADICAL_QUIET
  size_t garbage = 0, replaced = 0;
#endif
  for (size_t i = 0; substituted && !unsat && i < clauses_size; i++) {
    Clause *c = clauses[i];
    if (c->garbage)
      continue;
    int j, size = c->size;
    for (j = 0; j < size; j++) {
      const int lit = c->literals[j];
      if (reprs[vlit (lit)] != lit)
        break;
    }
 
    if (j == size)
      continue;
 
#ifndef CADICAL_QUIET
    replaced++;
#endif
    LOG (c, "first substituted literal %d in", substituted);
 
    // Now copy the result to 'clause'.  Substitute literals if they have a
    // different representative.  Skip duplicates and false literals.  If a
    // literal occurs in both phases or is assigned to true the clause is
    // satisfied and can be marked as garbage.
 
    CADICAL_assert (clause.empty ());
    CADICAL_assert (lrat_chain.empty ());
    CADICAL_assert (analyzed.empty ());
    bool satisfied = false;
 
    for (int k = 0; !satisfied && k < size; k++) {
      const int lit = c->literals[k];
      signed char tmp = val (lit);
      if (tmp > 0)
        satisfied = true;
      else if (tmp < 0) {
        if (!lrat)
          continue;
        Flags &f = flags (lit);
        if (f.seen)
          continue;
        f.seen = true;
        analyzed.push_back (lit);
        int64_t id = unit_id (-lit);
        lrat_chain.push_back (id);
        continue;
      } else {
        const int other = reprs[vlit (lit)];
        tmp = val (other);
        if (tmp < 0) {
          if (!lrat)
            continue;
          Flags &f = flags (other);
          if (!f.seen) {
            f.seen = true;
            analyzed.push_back (other);
            int64_t id = unit_id (-other);
            lrat_chain.push_back (id);
          }
          if (other == lit)
            continue;
          int64_t id = decompose_ids[vlit (-lit)];
          CADICAL_assert (id);
          lrat_chain.push_back (id);
          continue;
        } else if (tmp > 0)
          satisfied = true;
        else {
          tmp = marked (other);
          if (tmp < 0)
            satisfied = true;
          else if (!tmp) {
            mark (other);
            clause.push_back (other);
          }
          if (other == lit)
            continue;
          if (!lrat)
            continue;
          int64_t id = decompose_ids[vlit (-lit)];
          CADICAL_assert (id);
          lrat_chain.push_back (id);
        }
      }
    }
    if (lrat)
      lrat_chain.push_back (c->id);
    clear_analyzed_literals ();
    LOG (lrat_chain, "lrat_chain:");
    if (satisfied) {
      LOG (c, "satisfied after substitution (postponed)");
      postponed_garbage.push_back (c);
#ifndef CADICAL_QUIET
      garbage++;
#endif
    } else if (!clause.size ()) {
      LOG ("learned empty clause during decompose");
      learn_empty_clause ();
    } else if (clause.size () == 1) {
      LOG (c, "unit %d after substitution", clause[0]);
      assign_unit (clause[0]);
      mark_garbage (c);
      new_unit = true;
#ifndef CADICAL_QUIET
      garbage++;
#endif
    } else if (c->literals[0] != clause[0] || c->literals[1] != clause[1]) {
      LOG ("need new clause since at least one watched literal changed");
      if (clause.size () == 2)
        new_binary_clause = true;
      size_t d_clause_idx = clauses.size ();
      Clause *d = new_clause_as (c);
      CADICAL_assert (clauses[d_clause_idx] == d);
      clauses[d_clause_idx] = c;
      clauses[i] = d;
      mark_garbage (c);
#ifndef CADICAL_QUIET
      garbage++;
#endif
    } else {
      LOG ("simply shrinking clause since watches did not change");
      CADICAL_assert (c->size > 2);
      if (!c->redundant)
        mark_removed (c);
      if (proof) {
        proof->add_derived_clause (++clause_id, c->redundant, clause,
                                   lrat_chain);
        proof->delete_clause (c);
        c->id = clause_id;
      }
      size_t l;
      int *literals = c->literals;
      for (l = 2; l < clause.size (); l++)
        literals[l] = clause[l];
      int flushed = c->size - (int) l;
      if (flushed) {
        if (l == 2)
          new_binary_clause = true;
        LOG ("flushed %d literals", flushed);
        (void) shrink_clause (c, l);
      } else if (likely_to_be_kept_clause (c))
        mark_added (c);
      // we have shrunken c->size to l so even though there is an CADICAL_assertion
      // for c->size > 2 at the beginning of this else block, the new size
      // can be 2 now.
      if (c->size == 2) { // cheaper to update only new binary clauses
        CADICAL_assert (new_binary_clause);
        update_watch_size (watches (c->literals[0]), c->literals[1], c);
        update_watch_size (watches (c->literals[1]), c->literals[0], c);
      }
      LOG (c, "substituted");
    }
    while (!clause.empty ()) {
      int lit = clause.back ();
      clause.pop_back ();
      CADICAL_assert (marked (lit) > 0);
      unmark (lit);
    }
    lrat_chain.clear ();
  }
 
  if (proof) {
    for (auto idx : vars) {
      if (!substituted)
        break;
      if (!active (idx))
        continue;
      const int64_t id1 = decompose_ids[vlit (-idx)];
      if (!id1)
        continue;
      int other = reprs[vlit (idx)];
      CADICAL_assert (other != idx);
      CADICAL_assert (!flags (other).eliminated ());
      CADICAL_assert (!flags (other).substituted ());
 
      clause.push_back (other);
      clause.push_back (-idx);
      proof->delete_clause (id1, false, clause);
      clause.clear ();
 
      clause.push_back (idx);
      clause.push_back (-other);
      const int64_t id2 = decompose_ids[vlit (idx)];
      proof->delete_clause (id2, false, clause);
      clause.clear ();
    }
  }
 
  if (!unsat && !postponed_garbage.empty ()) {
    LOG ("now marking %zd postponed garbage clauses",
         postponed_garbage.size ());
    for (const auto &c : postponed_garbage)
      mark_garbage (c);
  }
  erase_vector (postponed_garbage);
 
  PHASE ("decompose", stats.decompositions,
         "%zd clauses replaced %.2f%% producing %zd garbage clauses %.2f%%",
         replaced, percent (replaced, clauses_size), garbage,
         percent (garbage, replaced));
 
  erase_vector (scc);
 
  // Propagate found units.
 
  if (!unsat && propagated < trail.size () && !propagate ()) {
    LOG ("empty clause after propagating units from substitution");
    learn_empty_clause ();
  }
 
  for (auto idx : vars) {
    if (!substituted)
      break;
    if (unsat)
      break;
    if (!active (idx))
      continue;
    int other = reprs[vlit (idx)];
    if (other == idx)
      continue;
    CADICAL_assert (!flags (other).eliminated ());
    CADICAL_assert (!flags (other).substituted ());
    if (!flags (other).fixed ())
      mark_substituted (idx);
  }
 
  reprs_delete.free ();
  dfs_delete.free ();
  erase_vector (dfs_chains);
 
  if (substituted)
    flush_all_occs_and_watches (); // particularly the 'blit's
 
  bool success =
      unsat || (substituted > 0 && (new_unit || new_binary_clause));
  report ('d', !opts.reportall && !success);
 
  STOP_SIMPLIFIER (decompose, DECOMP);
 
  return success;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_clause()

void CaDiCaL::Internal::delete_clause ( Clause * c )

Definition at line 258 of file cadical_clause.cpp.

                                       {
  LOG (c, "delete pointer %p", (void *) c);
  size_t bytes = c->bytes ();
  stats.collected += bytes;
  if (c->garbage) {
    CADICAL_assert (stats.garbage.bytes >= (int64_t) bytes);
    stats.garbage.bytes -= bytes;
    CADICAL_assert (stats.garbage.clauses > 0);
    stats.garbage.clauses--;
    CADICAL_assert (stats.garbage.literals >= c->size);
    stats.garbage.literals -= c->size;
 
    // See the discussion in 'propagate' on avoiding to eagerly trace binary
    // clauses as deleted (produce 'd ...' lines) as soon they are marked
    // garbage.  We avoid this and only trace them as deleted when they are
    // actually deleted here.  This allows the solver to propagate binary
    // garbage clauses without producing incorrect 'd' lines.  The effect
    // from the proof perspective is that the deletion of these binary
    // clauses occurs later in the proof file.
    //
    if (proof && c->size == 2 && !c->flushed) {
      proof->delete_clause (c);
    }
  }
  deallocate_clause (c);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_garbage_clauses()

void CaDiCaL::Internal::delete_garbage_clauses ( )

Definition at line 279 of file cadical_collect.cpp.

                                       {
 
  flush_all_occs_and_watches ();
 
  LOG ("deleting garbage clauses");
#ifndef CADICAL_QUIET
  int64_t collected_bytes = 0, collected_clauses = 0;
#endif
  const auto end = clauses.end ();
  auto j = clauses.begin (), i = j;
  while (i != end) {
    Clause *c = *j++ = *i++;
    if (!c->collect ())
      continue;
#ifndef CADICAL_QUIET
    collected_bytes += c->bytes ();
    collected_clauses++;
#endif
    delete_clause (c);
    j--;
  }
  clauses.resize (j - clauses.begin ());
  shrink_vector (clauses);
 
  PHASE ("collect", stats.collections,
         "collected %" PRId64 " bytes of %" PRId64 " garbage clauses",
         collected_bytes, collected_clauses);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_sweep_binary()

void CaDiCaL::Internal::delete_sweep_binary ( const sweep_binary & sb )

Definition at line 931 of file cadical_sweep.cpp.

                                                          {
  if (unsat)
    return;
  if (!proof)
    return;
  vector<int> bin;
  bin.push_back (sb.lit);
  bin.push_back (sb.other);
  proof->delete_clause (sb.id, false, bin);
}

Here is the caller graph for this function:

◆ delete_unfactored()

void CaDiCaL::Internal::delete_unfactored ( Quotient * q )

Definition at line 690 of file cadical_factor.cpp.

                                             {
  LOG ("deleting unfactored quotient[%zu] clauses", q->id);
  for (auto c : q->qlauses) {
    eagerly_remove_from_occurences (c);
    mark_garbage (c);
    stats.literals_unfactored += c->size;
    stats.clauses_unfactored++;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ demote_clause()

void CaDiCaL::Internal::demote_clause ( Clause * c )

inline

Definition at line 120 of file cadical_vivify.cpp.

                                              {
  stats.subsumed++;
  stats.vivifydemote++;
  LOG (c, "demoting");
  CADICAL_assert (!c->redundant);
  mark_removed (c);
  c->redundant = true;
  CADICAL_assert (stats.current.irredundant > 0);
  stats.current.irredundant--;
  CADICAL_assert (stats.added.irredundant > 0);
  stats.added.irredundant--;
  stats.irrlits -= c->size;
  stats.current.redundant++;
  stats.added.redundant++;
  c->glue = c->size - 1;
  // ... and keep 'stats.added.total'.
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ determine_actual_backtrack_level()

int CaDiCaL::Internal::determine_actual_backtrack_level ( int jump )

inline

Definition at line 652 of file cadical_analyze.cpp.

                                                               {
 
  int res;
 
  CADICAL_assert (level > jump);
 
  if (!opts.chrono) {
    res = jump;
    LOG ("chronological backtracking disabled using jump level %d", res);
  } else if (opts.chronoalways) {
    stats.chrono++;
    res = level - 1;
    LOG ("forced chronological backtracking to level %d", res);
  } else if (jump >= level - 1) {
    res = jump;
    LOG ("jump level identical to chronological backtrack level %d", res);
  } else if ((size_t) jump < assumptions.size ()) {
    res = jump;
    LOG ("using jump level %d since it is lower than assumption level %zd",
         res, assumptions.size ());
  } else if (level - jump > opts.chronolevelim) {
    stats.chrono++;
    res = level - 1;
    LOG ("back-jumping over %d > %d levels prohibited"
         "thus backtracking chronologically to level %d",
         level - jump, opts.chronolevelim, res);
  } else if (opts.chronoreusetrail) {
    int best_idx = 0, best_pos = 0;
 
    if (use_scores ()) {
      for (size_t i = control[jump + 1].trail; i < trail.size (); i++) {
        const int idx = abs (trail[i]);
        if (best_idx && !score_smaller (this) (best_idx, idx))
          continue;
        best_idx = idx;
        best_pos = i;
      }
      LOG ("best variable score %g", score (best_idx));
    } else {
      for (size_t i = control[jump + 1].trail; i < trail.size (); i++) {
        const int idx = abs (trail[i]);
        if (best_idx && bumped (best_idx) >= bumped (idx))
          continue;
        best_idx = idx;
        best_pos = i;
      }
      LOG ("best variable bumped %" PRId64 "", bumped (best_idx));
    }
    CADICAL_assert (best_idx);
    LOG ("best variable %d at trail position %d", best_idx, best_pos);
 
    // Now find the frame and decision level in the control stack of that
    // best variable index.  Note that, as in 'reuse_trail', the frame
    // 'control[i]' for decision level 'i' contains the trail before that
    // decision level, i.e., the decision 'control[i].decision' sits at
    // 'control[i].trail' in the trail and we thus have to check the level
    // of the control frame one higher than at the result level.
    //
    res = jump;
    while (res < level - 1 && control[res + 1].trail <= best_pos)
      res++;
 
    if (res == jump)
      LOG ("default non-chronological back-jumping to level %d", res);
    else {
      stats.chrono++;
      LOG ("chronological backtracking to level %d to reuse trail", res);
    }
 
  } else {
    res = jump;
    LOG ("non-chronological back-jumping to level %d", res);
  }
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disconnect_proof_tracer() [1/3]

bool CaDiCaL::Internal::disconnect_proof_tracer ( FileTracer * tracer )

Definition at line 108 of file cadical_proof.cpp.

                                                          {
  auto it = std::find (file_tracers.begin (), file_tracers.end (), tracer);
  if (it != file_tracers.end ()) {
    file_tracers.erase (it);
    CADICAL_assert (proof);
    proof->disconnect (tracer);
    return true;
  }
  return false;
}

◆ disconnect_proof_tracer() [2/3]

bool CaDiCaL::Internal::disconnect_proof_tracer ( StatTracer * tracer )

Definition at line 97 of file cadical_proof.cpp.

                                                          {
  auto it = std::find (stat_tracers.begin (), stat_tracers.end (), tracer);
  if (it != stat_tracers.end ()) {
    stat_tracers.erase (it);
    CADICAL_assert (proof);
    proof->disconnect (tracer);
    return true;
  }
  return false;
}

◆ disconnect_proof_tracer() [3/3]

bool CaDiCaL::Internal::disconnect_proof_tracer ( Tracer * tracer )

Definition at line 86 of file cadical_proof.cpp.

                                                      {
  auto it = std::find (tracers.begin (), tracers.end (), tracer);
  if (it != tracers.end ()) {
    tracers.erase (it);
    CADICAL_assert (proof);
    proof->disconnect (tracer);
    return true;
  }
  return false;
}

◆ dump() [1/2]

void CaDiCaL::Internal::dump ( )

Definition at line 1114 of file cadical_internal.cpp.

                     {
  int64_t m = assumptions.size ();
  for (auto idx : vars)
    if (fixed (idx))
      m++;
  for (const auto &c : clauses)
    if (!c->garbage)
      m++;
  printf ("p cnf %d %" PRId64 "\n", max_var, m);
  for (auto idx : vars) {
    const int tmp = fixed (idx);
    if (tmp)
      printf ("%d 0\n", tmp < 0 ? -idx : idx);
  }
  for (const auto &c : clauses)
    if (!c->garbage)
      dump (c);
  for (const auto &lit : assumptions)
    printf ("%d 0\n", lit);
  fflush (stdout);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dump() [2/2]

void CaDiCaL::Internal::dump ( Clause * c )

Definition at line 1108 of file cadical_internal.cpp.

                              {
  for (const auto &lit : *c)
    printf ("%d ", lit);
  printf ("0\n");
}

◆ eagerly_remove_from_occurences()

void CaDiCaL::Internal::eagerly_remove_from_occurences ( Clause * c )

Definition at line 672 of file cadical_factor.cpp.

                                                        {
  for (const auto &lit : *c) {
    auto &occ = occs (lit);
    auto p = occ.begin ();
    auto q = occ.begin ();
    auto begin = occ.begin ();
    auto end = occ.end ();
    while (p != end) {
      *q = *p++;
      if (*q != c)
        q++;
    }
    CADICAL_assert (q + 1 == p);
    occ.resize (q - begin);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eagerly_subsume_recently_learned_clauses()

void CaDiCaL::Internal::eagerly_subsume_recently_learned_clauses ( Clause * c )

Definition at line 731 of file cadical_analyze.cpp.

                                                                  {
  CADICAL_assert (opts.eagersubsume);
  LOG (c, "trying eager subsumption with");
  mark (c);
  int64_t lim = stats.eagertried + opts.eagersubsumelim;
  const auto begin = clauses.begin ();
  auto it = clauses.end ();
#ifdef LOGGING
  int64_t before = stats.eagersub;
#endif
  while (it != begin && stats.eagertried++ <= lim) {
    Clause *d = *--it;
    if (c == d)
      continue;
    if (d->garbage)
      continue;
    if (!d->redundant)
      continue;
    int needed = c->size;
    for (auto &lit : *d) {
      if (marked (lit) <= 0)
        continue;
      if (!--needed)
        break;
    }
    if (needed)
      continue;
    LOG (d, "eager subsumed");
    stats.eagersub++;
    stats.subsumed++;
    mark_garbage (d);
  }
  unmark (c);
#ifdef LOGGING
  uint64_t subsumed = stats.eagersub - before;
  if (subsumed)
    LOG ("eagerly subsumed %" PRIu64 " clauses", subsumed);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elim()

void CaDiCaL::Internal::elim ( bool update_limits = true )

Definition at line 1020 of file cadical_elim.cpp.

                                       {
 
  if (unsat)
    return;
  if (level)
    backtrack ();
  if (!propagate ()) {
    learn_empty_clause ();
    return;
  }
 
  stats.elimphases++;
  PHASE ("elim-phase", stats.elimphases,
         "starting at most %d elimination rounds", opts.elimrounds);
 
  if (external_prop) {
    CADICAL_assert (!level);
    private_steps = true;
  }
 
#ifndef CADICAL_QUIET
  int old_active_variables = active ();
  int old_eliminated = stats.all.eliminated;
#endif
 
  // Make sure there was a complete subsumption phase since last
  // elimination including vivification etc.
  //
  if (last.elim.subsumephases == stats.subsumephases)
    subsume ();
 
  reset_watches (); // saves lots of memory
 
  init_citten ();
 
  // Alternate one round of bounded variable elimination ('elim_round') and
  // subsumption ('subsume_round'), blocked ('block') and covered clause
  // elimination ('cover') until nothing changes, or the round limit is hit.
  // The loop also aborts early if no variable could be eliminated, the
  // empty clause is resolved, it is asynchronously terminated or a
  // resolution limit is hit.
 
  // This variable determines whether the whole loop of this bounded
  // variable elimination phase ('elim') ran until completion.  This
  // potentially triggers an incremental increase of the elimination bound.
  //
  bool phase_complete = false, deleted_binary_clause = false;
 
  int round = 1;
#ifndef CADICAL_QUIET
  int eliminated = 0;
#endif
 
  bool round_complete = false;
  while (!unsat && !phase_complete && !terminated_asynchronously ()) {
#ifndef CADICAL_QUIET
    int eliminated =
#endif
        elim_round (round_complete, deleted_binary_clause);
 
    if (!round_complete) {
      PHASE ("elim-phase", stats.elimphases, "last round %d incomplete %s",
             round, eliminated ? "but successful" : "and unsuccessful");
      CADICAL_assert (!phase_complete);
      break;
    }
 
    if (round++ >= opts.elimrounds) {
      PHASE ("elim-phase", stats.elimphases, "round limit %d hit (%s)",
             round - 1,
             eliminated ? "though last round successful"
                        : "last round unsuccessful anyhow");
      CADICAL_assert (!phase_complete);
      break;
    }
 
    // Prioritize 'subsumption' over blocked and covered clause elimination.
 
    if (subsume_round ())
      continue;
    if (block ())
      continue;
    if (cover ())
      continue;
 
    // Was not able to generate new variable elimination candidates after
    // variable elimination round, neither through subsumption, nor blocked,
    // nor covered clause elimination.
    //
    PHASE ("elim-phase", stats.elimphases,
           "no new variable elimination candidates");
 
    CADICAL_assert (round_complete);
    phase_complete = true;
  }
 
  if (phase_complete) {
    stats.elimcompleted++;
    PHASE ("elim-phase", stats.elimphases,
           "fully completed elimination %" PRId64
           " at elimination bound %" PRId64 "",
           stats.elimcompleted, lim.elimbound);
  } else {
    PHASE ("elim-phase", stats.elimphases,
           "incomplete elimination %" PRId64
           " at elimination bound %" PRId64 "",
           stats.elimcompleted + 1, lim.elimbound);
  }
 
  reset_citten ();
  if (deleted_binary_clause)
    delete_garbage_clauses ();
  init_watches ();
  connect_watches ();
 
  if (unsat)
    LOG ("elimination derived empty clause");
  else if (propagated < trail.size ()) {
    LOG ("elimination produced %zd units",
         (size_t) (trail.size () - propagated));
    if (!propagate ()) {
      LOG ("propagating units after elimination results in empty clause");
      learn_empty_clause ();
    }
  }
 
  // If we ran variable elimination until completion we increase the
  // variable elimination bound and reschedule elimination of all variables.
  //
  if (phase_complete)
    increase_elimination_bound ();
 
#ifndef CADICAL_QUIET
  eliminated = stats.all.eliminated - old_eliminated;
  PHASE ("elim-phase", stats.elimphases, "eliminated %d variables %.2f%%",
         eliminated, percent (eliminated, old_active_variables));
#endif
 
  if (external_prop) {
    CADICAL_assert (!level);
    private_steps = false;
  }
 
  if (!update_limits)
    return;
 
  int64_t delta = scale (opts.elimint * (stats.elimphases + 1));
  lim.elim = stats.conflicts + delta;
 
  PHASE ("elim-phase", stats.elimphases,
         "new limit at %" PRId64 " conflicts after %" PRId64 " conflicts",
         lim.elim, delta);
 
  last.elim.fixed = stats.all.fixed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elim_add_resolvents()

void CaDiCaL::Internal::elim_add_resolvents	(	Eliminator &	eliminator,
		int	pivot )

inline

Definition at line 542 of file cadical_elim.cpp.

                                                      {
 
  const bool substitute = !eliminator.gates.empty ();
  const bool resolve_gates = eliminator.definition_unit;
  if (substitute) {
    LOG ("substituting pivot %d by resolving with %zd gate clauses", pivot,
         eliminator.gates.size ());
    stats.elimsubst++;
  }
  switch (eliminator.gatetype) {
  case EQUI:
    stats.eliminated_equi++;
    break;
  case AND:
    stats.eliminated_and++;
    break;
  case ITE:
    stats.eliminated_ite++;
    break;
  case XOR:
    stats.eliminated_xor++;
    break;
  case DEF:
    stats.eliminated_def++;
    break;
  default:
    CADICAL_assert (eliminator.gatetype == NO);
  }
 
  LOG ("adding all resolvents on %d", pivot);
 
  CADICAL_assert (!val (pivot));
  CADICAL_assert (!flags (pivot).eliminated ());
 
  const Occs &ps = occs (pivot);
  const Occs &ns = occs (-pivot);
#ifdef LOGGING
  int64_t resolvents = 0;
#endif
  for (auto &c : ps) {
    if (unsat)
      break;
    if (c->garbage)
      continue;
    for (auto &d : ns) {
      if (unsat)
        break;
      if (d->garbage)
        continue;
      if (!resolve_gates && substitute && c->gate == d->gate)
        continue;
      if (!resolve_clauses (eliminator, c, pivot, d, false))
        continue;
      CADICAL_assert (!lrat || !lrat_chain.empty ());
      Clause *r = new_resolved_irredundant_clause ();
      elim_update_added_clause (eliminator, r);
      eliminator.enqueue (r);
      lrat_chain.clear ();
      clause.clear ();
#ifdef LOGGING
      resolvents++;
#endif
    }
  }
 
  LOG ("added %" PRId64 " resolvents to eliminate %d", resolvents, pivot);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elim_backward_clause()

void CaDiCaL::Internal::elim_backward_clause	(	Eliminator &	eliminator,
		Clause *	c )

Definition at line 44 of file cadical_backward.cpp.

                                                                      {
  CADICAL_assert (opts.elimbackward);
  CADICAL_assert (!c->redundant);
  if (c->garbage)
    return;
  LOG (c, "attempting backward subsumption and strengthening with");
  size_t len = UINT_MAX;
  unsigned size = 0;
  int best = 0;
  bool satisfied = false;
  CADICAL_assert (mini_chain.empty ());
  for (const auto &lit : *c) {
    const signed char tmp = val (lit);
    if (tmp > 0) {
      satisfied = true;
      break;
    }
    if (tmp < 0)
      continue;
    size_t l = occs (lit).size ();
    LOG ("literal %d occurs %zd times", lit, l);
    if (l < len)
      best = lit, len = l;
    mark (lit);
    size++;
  }
  if (satisfied) {
    LOG ("clause actually already satisfied");
    elim_update_removed_clause (eliminator, c);
    mark_garbage (c);
  } else if (len > (size_t) opts.elimocclim) {
    LOG ("skipping backward subsumption due to too many occurrences");
  } else {
    CADICAL_assert (len);
    LOG ("literal %d has smallest number of occurrences %zd", best, len);
    LOG ("marked %d literals in clause of size %d", size, c->size);
    for (auto &d : occs (best)) {
      if (d == c)
        continue;
      if (d->garbage)
        continue;
      if ((unsigned) d->size < size)
        continue;
      int negated = 0;
      unsigned found = 0;
      satisfied = false;
      for (const auto &lit : *d) {
        signed char tmp = val (lit);
        if (tmp > 0) {
          satisfied = true;
          break;
        }
        if (tmp < 0)
          continue;
        tmp = marked (lit);
        if (!tmp)
          continue;
        if (tmp < 0) {
          if (negated) {
            size = UINT_MAX;
            break;
          } else
            negated = lit;
        }
        if (++found == size)
          break;
      }
      if (satisfied) {
        LOG (d, "found satisfied clause");
        elim_update_removed_clause (eliminator, d);
        mark_garbage (d);
      } else if (found == size) {
        if (!negated) {
          LOG (d, "found subsumed clause");
          elim_update_removed_clause (eliminator, d);
          mark_garbage (d);
          stats.subsumed++;
          stats.elimbwsub++;
        } else {
          int unit = 0;
          CADICAL_assert (minimize_chain.empty ());
          CADICAL_assert (analyzed.empty ());
          CADICAL_assert (lrat_chain.empty ());
          // figure out wether we strengthen c or get a new unit
          for (const auto &lit : *d) {
            const signed char tmp = val (lit);
            if (tmp < 0) {
              if (!lrat)
                continue;
              Flags &f = flags (lit);
              CADICAL_assert (!f.seen);
              if (f.seen)
                continue;
              f.seen = true;
              analyzed.push_back (lit);
              continue;
            }
            if (tmp > 0) {
              satisfied = true;
              break;
            }
            if (lit == negated)
              continue;
            if (unit) {
              unit = INT_MIN;
              continue; // needed to guarantee d is not satsified
            } else
              unit = lit;
          }
          if (lrat && !satisfied) {
            // if we found a unit we need to add all unit ids from
            // {c\d}U{d\c} otherwise just the unit ids from {c\d}
            for (const auto &lit : *c) {
              const signed char tmp = val (lit);
              CADICAL_assert (tmp <= 0);
              if (tmp >= 0)
                continue;
              Flags &f = flags (lit);
              if (f.seen && unit && unit == INT_MIN) {
                f.seen = false;
                continue;
              } else if (!f.seen) {
                f.seen = true;
                analyzed.push_back (lit);
              }
            }
            if (unit == INT_MIN) { // we do not need units from {d\c}
              for (const auto &lit : *d) {
                flags (lit).seen = false;
              }
            }
            for (const auto &lit : analyzed) {
              Flags &f = flags (lit);
              if (!f.seen) {
                f.seen = true;
                continue;
              }
              int64_t id = unit_id (-lit);
              lrat_chain.push_back (id);
            }
            clear_analyzed_literals ();
            lrat_chain.push_back (d->id);
            lrat_chain.push_back (c->id);
          } else if (lrat)
            clear_analyzed_literals ();
          if (satisfied) {
            CADICAL_assert (lrat_chain.empty ());
            mark_garbage (d);
            elim_update_removed_clause (eliminator, d);
          } else if (unit && unit != INT_MIN) {
            CADICAL_assert (unit);
            LOG (d, "unit %d through hyper unary resolution with", unit);
            assign_unit (unit);
            elim_propagate (eliminator, unit);
            lrat_chain.clear ();
            break;
          } else if (occs (negated).size () <= (size_t) opts.elimocclim) {
            strengthen_clause (d, negated);
            remove_occs (occs (negated), d);
            elim_update_removed_lit (eliminator, negated);
            stats.elimbwstr++;
            CADICAL_assert (negated != best);
            eliminator.enqueue (d);
          }
          lrat_chain.clear ();
        }
      }
    }
  }
  mini_chain.clear ();
  unmark (c);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elim_backward_clauses()

void CaDiCaL::Internal::elim_backward_clauses ( Eliminator & eliminator )

Definition at line 219 of file cadical_backward.cpp.

                                                            {
  if (!opts.elimbackward) {
    CADICAL_assert (eliminator.backward.empty ());
    return;
  }
  START (backward);
  LOG ("attempting backward subsumption and strengthening with %zd clauses",
       eliminator.backward.size ());
  Clause *c;
  while (!unsat && (c = eliminator.dequeue ()))
    elim_backward_clause (eliminator, c);
  STOP (backward);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elim_on_the_fly_self_subsumption()

void CaDiCaL::Internal::elim_on_the_fly_self_subsumption	(	Eliminator &	eliminator,
		Clause *	c,
		int	pivot )

Definition at line 214 of file cadical_elim.cpp.

                                                                       {
  LOG (c, "pivot %d on-the-fly self-subsuming resolution", pivot);
  stats.elimotfstr++;
  stats.strengthened++;
  CADICAL_assert (clause.empty ());
  for (const auto &lit : *c) {
    if (lit == pivot)
      continue;
    const signed char tmp = val (lit);
    CADICAL_assert (tmp <= 0);
    if (tmp < 0)
      continue;
    clause.push_back (lit);
  }
  Clause *r = new_resolved_irredundant_clause ();
  elim_update_added_clause (eliminator, r);
  clause.clear ();
  lrat_chain.clear ();
  elim_update_removed_clause (eliminator, c, pivot);
  mark_garbage (c);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elim_propagate()

void CaDiCaL::Internal::elim_propagate	(	Eliminator &	eliminator,
		int	unit )

Definition at line 147 of file cadical_elim.cpp.

                                                               {
  CADICAL_assert (val (root) > 0);
  vector<int> work;
  size_t i = 0;
  work.push_back (root);
  while (i < work.size ()) {
    int lit = work[i++];
    LOG ("elimination propagation of %d", lit);
    CADICAL_assert (val (lit) > 0);
    const Occs &ns = occs (-lit);
    for (const auto &c : ns) {
      if (c->garbage)
        continue;
      int unit = 0, satisfied = 0;
      for (const auto &other : *c) {
        const signed char tmp = val (other);
        if (tmp < 0)
          continue;
        if (tmp > 0) {
          satisfied = other;
          break;
        }
        if (unit)
          unit = INT_MIN;
        else
          unit = other;
      }
      if (satisfied) {
        LOG (c, "elimination propagation of %d finds %d satisfied", lit,
             satisfied);
        elim_update_removed_clause (eliminator, c, satisfied);
        mark_garbage (c);
      } else if (!unit) {
        LOG ("empty clause during elimination propagation of %d", lit);
        // need to set conflict = c for lrat
        conflict = c;
        learn_empty_clause ();
        conflict = 0;
        break;
      } else if (unit != INT_MIN) {
        LOG ("new unit %d during elimination propagation of %d", unit, lit);
        build_chain_for_units (unit, c, 0);
        assign_unit (unit);
        work.push_back (unit);
      }
    }
    if (unsat)
      break;
    const Occs &ps = occs (lit);
    for (const auto &c : ps) {
      if (c->garbage)
        continue;
      LOG (c, "elimination propagation of %d produces satisfied", lit);
      elim_update_removed_clause (eliminator, c, lit);
      mark_garbage (c);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elim_resolvents_are_bounded()

bool CaDiCaL::Internal::elim_resolvents_are_bounded	(	Eliminator &	eliminator,
		int	pivot )

Definition at line 467 of file cadical_elim.cpp.

                                                       {
  const bool substitute = !eliminator.gates.empty ();
  const bool resolve_gates = eliminator.definition_unit;
  if (substitute)
    LOG ("trying to substitute %d", pivot);
 
  stats.elimtried++;
 
  CADICAL_assert (!unsat);
  CADICAL_assert (active (pivot));
 
  const Occs &ps = occs (pivot);
  const Occs &ns = occs (-pivot);
  const int64_t pos = ps.size ();
  const int64_t neg = ns.size ();
  if (!pos || !neg)
    return lim.elimbound >= 0;
  const int64_t bound = pos + neg + lim.elimbound;
 
  LOG ("checking number resolvents on %d bounded by "
       "%" PRId64 " = %" PRId64 " + %" PRId64 " + %" PRId64,
       pivot, bound, pos, neg, lim.elimbound);
 
  // Try all resolutions between a positive occurrence (outer loop) of
  // 'pivot' and a negative occurrence of 'pivot' (inner loop) as long the
  // bound on non-tautological resolvents is not hit and the size of the
  // generated resolvents does not exceed the resolvent clause size limit.
 
  int64_t resolvents = 0; // Non-tautological resolvents.
 
  for (const auto &c : ps) {
    CADICAL_assert (!c->redundant);
    if (c->garbage)
      continue;
    for (const auto &d : ns) {
      CADICAL_assert (!d->redundant);
      if (d->garbage)
        continue;
      if (!resolve_gates && substitute && c->gate == d->gate)
        continue;
      stats.elimrestried++;
      if (resolve_clauses (eliminator, c, pivot, d, true)) {
        resolvents++;
        int size = clause.size ();
        clause.clear ();
        LOG ("now at least %" PRId64
             " non-tautological resolvents on pivot %d",
             resolvents, pivot);
        if (size > opts.elimclslim) {
          LOG ("resolvent size %d too big after %" PRId64
               " resolvents on %d",
               size, resolvents, pivot);
          return false;
        }
        if (resolvents > bound) {
          LOG ("too many non-tautological resolvents on %d", pivot);
          return false;
        }
      } else if (unsat)
        return false;
      else if (val (pivot))
        return false;
    }
  }
 
  LOG ("need %" PRId64 " <= %" PRId64 " non-tautological resolvents",
       resolvents, bound);
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elim_round()

int CaDiCaL::Internal::elim_round	(	bool &	completed,
		bool &	deleted_binary_clause )

Definition at line 771 of file cadical_elim.cpp.

                                                                      {
 
  CADICAL_assert (opts.elim);
  CADICAL_assert (!unsat);
 
  START_SIMPLIFIER (elim, ELIM);
  stats.elimrounds++;
 
  int64_t marked_before = last.elim.marked;
  last.elim.marked = stats.mark.elim;
  CADICAL_assert (!level);
 
  int64_t resolution_limit;
 
  if (opts.elimlimited) {
    int64_t delta = stats.propagations.search;
    delta *= 1e-3 * opts.elimeffort;
    if (delta < opts.elimmineff)
      delta = opts.elimmineff;
    if (delta > opts.elimmaxeff)
      delta = opts.elimmaxeff;
    delta = max (delta, (int64_t) 2l * active ());
 
    PHASE ("elim-round", stats.elimrounds,
           "limit of %" PRId64 " resolutions", delta);
 
    resolution_limit = stats.elimres + delta;
  } else {
    PHASE ("elim-round", stats.elimrounds, "resolutions unlimited");
    resolution_limit = LONG_MAX;
  }
 
  init_noccs ();
 
  // First compute the number of occurrences of each literal and at the same
  // time mark satisfied clauses and update 'elim' flags of variables in
  // clauses with root level assigned literals (both false and true).
  //
  for (const auto &c : clauses) {
    if (c->garbage || c->redundant)
      continue;
    bool satisfied = false, falsified = false;
    for (const auto &lit : *c) {
      const signed char tmp = val (lit);
      if (tmp > 0)
        satisfied = true;
      else if (tmp < 0)
        falsified = true;
      else
        CADICAL_assert (active (lit));
    }
    if (satisfied)
      mark_garbage (c); // forces more precise counts
    else {
      for (const auto &lit : *c) {
        if (!active (lit))
          continue;
        if (falsified)
          mark_elim (lit); // simulate unit propagation
        noccs (lit)++;
      }
    }
  }
 
  init_occs ();
 
  Eliminator eliminator (this);
  ElimSchedule &schedule = eliminator.schedule;
  CADICAL_assert (schedule.empty ());
 
  // Now find elimination candidates which occurred in clauses removed since
  // the last time we ran bounded variable elimination, which in turned
  // triggered their 'elim' bit to be set.
  //
  for (auto idx : vars) {
    if (!active (idx))
      continue;
    if (frozen (idx))
      continue;
    if (!flags (idx).elim)
      continue;
    LOG ("scheduling %d for elimination initially", idx);
    schedule.push_back (idx);
  }
 
  schedule.shrink ();
 
#ifndef CADICAL_QUIET
  int64_t scheduled = schedule.size ();
#endif
 
  PHASE ("elim-round", stats.elimrounds,
         "scheduled %" PRId64 " variables %.0f%% for elimination",
         scheduled, percent (scheduled, active ()));
 
  // Connect irredundant clauses.
  //
  for (const auto &c : clauses)
    if (!c->garbage && !c->redundant)
      for (const auto &lit : *c)
        if (active (lit))
          occs (lit).push_back (c);
 
#ifndef CADICAL_QUIET
  const int64_t old_resolutions = stats.elimres;
#endif
  const int old_eliminated = stats.all.eliminated;
  const int old_fixed = stats.all.fixed;
 
  // Limit on garbage literals during variable elimination. If the limit is
  // hit a garbage collection is performed.
  //
  const int64_t garbage_limit = (2 * stats.irrlits / 3) + (1 << 20);
 
  // Main loops tries to eliminate variables according to the schedule. The
  // schedule is updated dynamically and variables are potentially
  // rescheduled to be tried again if they occur in a removed clause.
  //
#ifndef CADICAL_QUIET
  int64_t tried = 0;
#endif
  while (!unsat && !terminated_asynchronously () &&
         stats.elimres <= resolution_limit && !schedule.empty ()) {
    int idx = schedule.front ();
    schedule.pop_front ();
    flags (idx).elim = false;
    try_to_eliminate_variable (eliminator, idx, deleted_binary_clause);
#ifndef CADICAL_QUIET
    tried++;
#endif
    if (stats.garbage.literals <= garbage_limit)
      continue;
    mark_redundant_clauses_with_eliminated_variables_as_garbage ();
    garbage_collection ();
  }
 
  // If the schedule is empty all variables have been tried (even
  // rescheduled ones).  Otherwise asynchronous termination happened or we
  // ran into the resolution limit (or derived unsatisfiability).
  //
  completed = !schedule.size ();
 
  if (!completed)
    last.elim.marked = marked_before;
 
  PHASE ("elim-round", stats.elimrounds,
         "tried to eliminate %" PRId64 " variables %.0f%% (%zd remain)",
         tried, percent (tried, scheduled), schedule.size ());
 
  schedule.erase ();
 
  // Collect potential literal clause instantiation pairs, which needs full
  // occurrence lists and thus we have it here before resetting them.
  //
  Instantiator instantiator;
  if (!unsat && !terminated_asynchronously () && opts.instantiate)
    collect_instantiation_candidates (instantiator);
 
  reset_occs ();
  reset_noccs ();
 
  // Mark all redundant clauses with eliminated variables as garbage.
  //
  if (!unsat)
    mark_redundant_clauses_with_eliminated_variables_as_garbage ();
 
  int eliminated = stats.all.eliminated - old_eliminated;
#ifndef CADICAL_QUIET
  int64_t resolutions = stats.elimres - old_resolutions;
  PHASE ("elim-round", stats.elimrounds,
         "eliminated %d variables %.0f%% in %" PRId64 " resolutions",
         eliminated, percent (eliminated, scheduled), resolutions);
#endif
 
  last.elim.subsumephases = stats.subsumephases;
  const int units = stats.all.fixed - old_fixed;
  report ('e', !opts.reportall && !(eliminated + units));
  STOP_SIMPLIFIER (elim, ELIM);
 
  if (!unsat && !terminated_asynchronously () &&
      instantiator) // Do we have candidate pairs?
    instantiate (instantiator);
 
  return eliminated; // non-zero if successful
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elim_update_added_clause()

void CaDiCaL::Internal::elim_update_added_clause	(	Eliminator &	eliminator,
		Clause *	c )

Definition at line 95 of file cadical_elim.cpp.

                                                    {
  CADICAL_assert (!c->redundant);
  ElimSchedule &schedule = eliminator.schedule;
  for (const auto &lit : *c) {
    if (!active (lit))
      continue;
    occs (lit).push_back (c);
    if (frozen (lit))
      continue;
    noccs (lit)++;
    const int idx = abs (lit);
    if (schedule.contains (idx))
      schedule.update (idx);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elim_update_removed_clause()

void CaDiCaL::Internal::elim_update_removed_clause	(	Eliminator &	eliminator,
		Clause *	c,
		int	except = 0 )

Definition at line 130 of file cadical_elim.cpp.

                                                                  {
  CADICAL_assert (!c->redundant);
  for (const auto &lit : *c) {
    if (lit == except)
      continue;
    CADICAL_assert (lit != -except);
    elim_update_removed_lit (eliminator, lit);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elim_update_removed_lit()

void CaDiCaL::Internal::elim_update_removed_lit	(	Eliminator &	eliminator,
		int	lit )

Definition at line 112 of file cadical_elim.cpp.

                                                                       {
  if (!active (lit))
    return;
  if (frozen (lit))
    return;
  int64_t &score = noccs (lit);
  CADICAL_assert (score > 0);
  score--;
  const int idx = abs (lit);
  ElimSchedule &schedule = eliminator.schedule;
  if (schedule.contains (idx))
    schedule.update (idx);
  else {
    LOG ("rescheduling %d for elimination after removing clause", idx);
    schedule.push_back (idx);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elimfast()

void CaDiCaL::Internal::elimfast ( )

Definition at line 442 of file cadical_elimfast.cpp.

                         {
 
  if (unsat)
    return;
  if (level)
    backtrack ();
  if (!propagate ()) {
    learn_empty_clause ();
    return;
  }
 
  stats.elimfastphases++;
  PHASE ("fastelim-phase", stats.elimfastphases,
         "starting at most %d elimination rounds", opts.fastelimrounds);
 
  if (external_prop) {
    CADICAL_assert (!level);
    private_steps = true;
  }
 
#ifndef CADICAL_QUIET
  int old_active_variables = active ();
  int old_eliminated = stats.all.eliminated;
#endif
 
  reset_watches (); // saves lots of memory
 
  // Alternate one round of bounded variable elimination ('elim_round') and
  // subsumption ('subsume_round'), blocked ('block') and covered clause
  // elimination ('cover') until nothing changes, or the round limit is hit.
  // The loop also aborts early if no variable could be eliminated, the
  // empty clause is resolved, it is asynchronously terminated or a
  // resolution limit is hit.
 
  // This variable determines whether the whole loop of this bounded
  // variable elimination phase ('elim') ran until completion.  This
  // potentially triggers an incremental increase of the elimination bound.
  //
  bool phase_complete = false, deleted_binary_clause = false;
 
  int round = 1;
#ifndef CADICAL_QUIET
  int eliminated = 0;
#endif
 
  bool round_complete = false;
  while (!unsat && !phase_complete && !terminated_asynchronously ()) {
#ifndef CADICAL_QUIET
    int eliminated =
#endif
        elimfast_round (round_complete, deleted_binary_clause);
 
    if (!round_complete) {
      PHASE ("fastelim-phase", stats.elimphases,
             "last round %d incomplete %s", round,
             eliminated ? "but successful" : "and unsuccessful");
      CADICAL_assert (!phase_complete);
      break;
    }
 
    if (round++ >= opts.fastelimrounds) {
      PHASE ("fastelim-phase", stats.elimphases, "round limit %d hit (%s)",
             round - 1,
             eliminated ? "though last round successful"
                        : "last round unsuccessful anyhow");
      CADICAL_assert (!phase_complete);
      break;
    }
 
    // Prioritize 'subsumption' over blocked and covered clause elimination.
 
    if (subsume_round ())
      continue;
 
    // Was not able to generate new variable elimination candidates after
    // variable elimination round, neither through subsumption, nor blocked,
    // nor covered clause elimination.
    //
    PHASE ("fastelim-phase", stats.elimphases,
           "no new variable elimination candidates");
 
    CADICAL_assert (round_complete);
    phase_complete = true;
  }
 
  for (auto idx : vars) {
    if (active (idx))
      flags (idx).elim = true;
  }
 
  if (phase_complete) {
    stats.elimcompleted++;
    PHASE ("fastelim-phase", stats.elimphases,
           "fully completed elimination %" PRId64
           " at elimination bound %" PRId64 "",
           stats.elimcompleted, lim.elimbound);
  } else {
    PHASE ("fastelim-phase", stats.elimphases,
           "incomplete elimination %" PRId64
           " at elimination bound %" PRId64 "",
           stats.elimcompleted + 1, lim.elimbound);
  }
 
  if (deleted_binary_clause)
    delete_garbage_clauses ();
  init_watches ();
  connect_watches ();
 
  if (unsat)
    LOG ("elimination derived empty clause");
  else if (propagated < trail.size ()) {
    LOG ("elimination produced %zd units",
         (size_t) (trail.size () - propagated));
    if (!propagate ()) {
      LOG ("propagating units after elimination results in empty clause");
      learn_empty_clause ();
    }
  }
 
#ifndef CADICAL_QUIET
  eliminated = stats.all.eliminated - old_eliminated;
  PHASE ("fastelim-phase", stats.elimphases,
         "eliminated %d variables %.2f%%", eliminated,
         percent (eliminated, old_active_variables));
#endif
 
  if (external_prop) {
    CADICAL_assert (!level);
    private_steps = false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elimfast_add_resolvents()

void CaDiCaL::Internal::elimfast_add_resolvents	(	Eliminator &	eliminator,
		int	pivot )

inline

Definition at line 143 of file cadical_elimfast.cpp.

                                                          {
 
  CADICAL_assert (eliminator.gates.empty ());
  CADICAL_assert (!eliminator.definition_unit);
 
  LOG ("adding all resolvents on %d", pivot);
 
  CADICAL_assert (!val (pivot));
  CADICAL_assert (!flags (pivot).eliminated ());
 
  const Occs &ps = occs (pivot);
  const Occs &ns = occs (-pivot);
#ifdef LOGGING
  int64_t resolvents = 0;
#endif
  for (auto &c : ps) {
    if (unsat)
      break;
    if (c->garbage)
      continue;
    for (auto &d : ns) {
      if (unsat)
        break;
      if (d->garbage)
        continue;
      if (!resolve_clauses (eliminator, c, pivot, d, false))
        continue;
      CADICAL_assert (!lrat || !lrat_chain.empty ());
      Clause *r = new_resolved_irredundant_clause ();
      elim_update_added_clause (eliminator, r);
      eliminator.enqueue (r);
      lrat_chain.clear ();
      clause.clear ();
#ifdef LOGGING
      resolvents++;
#endif
    }
  }
 
  LOG ("added %" PRId64 " resolvents to eliminate %d", resolvents, pivot);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elimfast_resolvents_are_bounded()

bool CaDiCaL::Internal::elimfast_resolvents_are_bounded	(	Eliminator &	eliminator,
		int	pivot )

Definition at line 59 of file cadical_elimfast.cpp.

                                                           {
  CADICAL_assert (eliminator.gates.empty ());
  CADICAL_assert (!eliminator.definition_unit);
 
  stats.elimtried++;
 
  CADICAL_assert (!unsat);
  CADICAL_assert (active (pivot));
 
  const Occs &ps = occs (pivot);
  const Occs &ns = occs (-pivot);
 
  int64_t pos = ps.size ();
  int64_t neg = ns.size ();
 
  int64_t bound = opts.fastelimbound;
 
  if (!pos || !neg)
    return bound >= 0;
 
  const int64_t sum = pos + neg;
  const int64_t product = pos * neg;
  if (bound > sum)
    bound = sum;
 
  LOG ("checking number resolvents on %d bounded by "
       "%" PRId64 " = %" PRId64 " + %" PRId64 " + %d",
       pivot, bound, pos, neg, opts.fastelimbound);
 
  if (product <= bound) {
    LOG ("fast elimination occurrence limits sufficiently small enough");
    return true;
  }
 
  // Try all resolutions between a positive occurrence (outer loop) of
  // 'pivot' and a negative occurrence of 'pivot' (inner loop) as long the
  // bound on non-tautological resolvents is not hit and the size of the
  // generated resolvents does not exceed the resolvent clause size limit.
 
  int64_t resolvents = 0; // Non-tautological resolvents.
 
  for (const auto &c : ps) {
    CADICAL_assert (!c->redundant);
    if (c->garbage)
      continue;
    for (const auto &d : ns) {
      CADICAL_assert (!d->redundant);
      if (d->garbage)
        continue;
      if (resolve_clauses (eliminator, c, pivot, d, true)) {
        resolvents++;
        int size = clause.size ();
        clause.clear ();
        LOG ("now at least %" PRId64
             " non-tautological resolvents on pivot %d",
             resolvents, pivot);
        if (size > opts.fastelimclslim) {
          LOG ("resolvent size %d too big after %" PRId64
               " resolvents on %d",
               size, resolvents, pivot);
          return false;
        }
        if (resolvents > bound) {
          LOG ("too many non-tautological resolvents on %d", pivot);
          return false;
        }
      } else if (unsat)
        return false;
      else if (val (pivot))
        return false;
    }
  }
 
  LOG ("need %" PRId64 " <= %" PRId64 " non-tautological resolvents",
       resolvents, bound);
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elimfast_round()

int CaDiCaL::Internal::elimfast_round	(	bool &	completed,
		bool &	deleted_binary_clause )

Definition at line 268 of file cadical_elimfast.cpp.

                                                           {
 
  CADICAL_assert (opts.fastelim);
  CADICAL_assert (!unsat);
 
  START_SIMPLIFIER (fastelim, ELIM);
 
  stats.elimfastrounds++;
 
  CADICAL_assert (!level);
 
  int64_t resolution_limit;
 
  if (opts.elimlimited) {
    int64_t delta = stats.propagations.search;
    delta *= 1e-3 * opts.elimeffort;
    if (delta < opts.elimmineff)
      delta = opts.elimmineff;
    if (delta > opts.elimmaxeff)
      delta = opts.elimmaxeff;
    delta = max (delta, (int64_t) 2l * active ());
 
    PHASE ("fastelim-round", stats.elimfastrounds,
           "limit of %" PRId64 " resolutions", delta);
 
    resolution_limit = stats.elimres + delta;
  } else {
    PHASE ("fastelim-round", stats.elimfastrounds, "resolutions unlimited");
    resolution_limit = LONG_MAX;
  }
 
  init_noccs ();
 
  // First compute the number of occurrences of each literal and at the same
  // time mark satisfied clauses and update 'elim' flags of variables in
  // clauses with root level assigned literals (both false and true).
  //
  for (const auto &c : clauses) {
    if (c->garbage || c->redundant)
      continue;
    bool satisfied = false, falsified = false;
    for (const auto &lit : *c) {
      const signed char tmp = val (lit);
      if (tmp > 0)
        satisfied = true;
      else if (tmp < 0)
        falsified = true;
      else
        CADICAL_assert (active (lit));
    }
    if (satisfied)
      mark_garbage (c); // forces more precise counts
    else {
      for (const auto &lit : *c) {
        if (!active (lit))
          continue;
        if (falsified)
          mark_elim (lit); // simulate unit propagation
        noccs (lit)++;
      }
    }
  }
 
  init_occs ();
 
  Eliminator eliminator (this);
  ElimSchedule &schedule = eliminator.schedule;
  CADICAL_assert (schedule.empty ());
 
  // Now find elimination candidates which occurred in clauses removed since
  // the last time we ran bounded variable elimination, which in turned
  // triggered their 'elim' bit to be set.
  //
  for (auto idx : vars) {
    if (!active (idx))
      continue;
    if (frozen (idx))
      continue;
    if (!flags (idx).elim)
      continue;
    LOG ("scheduling %d for elimination initially", idx);
    schedule.push_back (idx);
  }
 
  schedule.shrink ();
 
#ifndef CADICAL_QUIET
  int64_t scheduled = schedule.size ();
#endif
 
  PHASE ("fastelim-round", stats.elimfastrounds,
         "scheduled %" PRId64 " variables %.0f%% for elimination",
         scheduled, percent (scheduled, active ()));
 
  // Connect irredundant clauses.
  //
  for (const auto &c : clauses)
    if (!c->garbage && !c->redundant)
      for (const auto &lit : *c)
        if (active (lit))
          occs (lit).push_back (c);
 
#ifndef CADICAL_QUIET
  const int64_t old_resolutions = stats.elimres;
#endif
  const int old_eliminated = stats.all.eliminated;
  const int old_fixed = stats.all.fixed;
 
  // Limit on garbage literals during variable elimination. If the limit is
  // hit a garbage collection is performed.
  //
  const int64_t garbage_limit = (2 * stats.irrlits / 3) + (1 << 20);
 
  // Main loops tries to eliminate variables according to the schedule. The
  // schedule is updated dynamically and variables are potentially
  // rescheduled to be tried again if they occur in a removed clause.
  //
#ifndef CADICAL_QUIET
  int64_t tried = 0;
#endif
  while (!unsat && !terminated_asynchronously () &&
         stats.elimres <= resolution_limit && !schedule.empty ()) {
    int idx = schedule.front ();
    schedule.pop_front ();
    flags (idx).elim = false;
    try_to_fasteliminate_variable (eliminator, idx, deleted_binary_clause);
#ifndef CADICAL_QUIET
    tried++;
#endif
    if (stats.garbage.literals <= garbage_limit)
      continue;
    mark_redundant_clauses_with_eliminated_variables_as_garbage ();
    garbage_collection ();
  }
 
  // If the schedule is empty all variables have been tried (even
  // rescheduled ones).  Otherwise asynchronous termination happened or we
  // ran into the resolution limit (or derived unsatisfiability).
  //
  completed = !schedule.size ();
 
  PHASE ("fastelim-round", stats.elimfastrounds,
         "tried to eliminate %" PRId64 " variables %.0f%% (%zd remain)",
         tried, percent (tried, scheduled), schedule.size ());
 
  schedule.erase ();
 
  reset_occs ();
  reset_noccs ();
 
  // Mark all redundant clauses with eliminated variables as garbage.
  //
  if (!unsat)
    mark_redundant_clauses_with_eliminated_variables_as_garbage ();
 
  int eliminated = stats.all.eliminated - old_eliminated;
  stats.all.fasteliminated += eliminated;
#ifndef CADICAL_QUIET
  int64_t resolutions = stats.elimres - old_resolutions;
  PHASE ("fastelim-round", stats.elimfastrounds,
         "eliminated %d variables %.0f%% in %" PRId64 " resolutions",
         eliminated, percent (eliminated, scheduled), resolutions);
#endif
 
  const int units = stats.all.fixed - old_fixed;
  report ('e', !opts.reportall && !(eliminated + units));
  STOP_SIMPLIFIER (fastelim, ELIM);
 
  return eliminated; // non-zero if successful
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ enlarge()

void CaDiCaL::Internal::enlarge ( int new_max_var )

Definition at line 121 of file cadical_internal.cpp.

                                       {
  // New variables can be created that can invoke enlarge anytime (via calls
  // during ipasir-up call-backs), thus assuming (!level) is not correct
  size_t new_vsize = vsize ? 2 * vsize : 1 + (size_t) new_max_var;
  while (new_vsize <= (size_t) new_max_var)
    new_vsize *= 2;
  LOG ("enlarge internal size from %zd to new size %zd", vsize, new_vsize);
  // Ordered in the size of allocated memory (larger block first).
  if (lrat || frat)
    enlarge_zero (unit_clauses_idx, 2 * new_vsize);
  enlarge_only (wtab, 2 * new_vsize);
  enlarge_only (vtab, new_vsize);
  enlarge_zero (parents, new_vsize);
  enlarge_only (links, new_vsize);
  enlarge_zero (btab, new_vsize);
  enlarge_zero (gtab, new_vsize);
  enlarge_zero (stab, new_vsize);
  enlarge_init (ptab, 2 * new_vsize, -1);
  enlarge_only (ftab, new_vsize);
  enlarge_vals (new_vsize);
  vsize = new_vsize;
  if (external)
    enlarge_zero (relevanttab, new_vsize);
  const signed char val = opts.phase ? 1 : -1;
  enlarge_init (phases.saved, new_vsize, val);
  enlarge_zero (phases.forced, new_vsize);
  enlarge_zero (phases.target, new_vsize);
  enlarge_zero (phases.best, new_vsize);
  enlarge_zero (phases.prev, new_vsize);
  enlarge_zero (phases.min, new_vsize);
  enlarge_zero (marks, new_vsize);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ enlarge_vals()

void CaDiCaL::Internal::enlarge_vals ( size_t new_vsize )

Definition at line 102 of file cadical_internal.cpp.

                                             {
  signed char *new_vals;
  const size_t bytes = 2u * new_vsize;
  new_vals = new signed char[bytes]; // g++-4.8 does not like ... { 0 };
  memset (new_vals, 0, bytes);
  ignore_clang_analyze_memory_leak_warning = new_vals;
  new_vals += new_vsize;
 
  if (vals) {
    memcpy (new_vals - max_var, vals - max_var, 2u * max_var + 1u);
    vals -= vsize;
    delete[] vals;
  } else
    CADICAL_assert (!vsize);
  vals = new_vals;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ error()

void CaDiCaL::Internal::error	(	const char *	fmt,
			... )

Definition at line 181 of file cadical_message.cpp.

                                          {
  va_list ap;
  va_start (ap, fmt);
  verror (fmt, ap);
  va_end (ap); // unreachable
}

Here is the call graph for this function:

◆ error_message_end()

void CaDiCaL::Internal::error_message_end ( )

Definition at line 168 of file cadical_message.cpp.

                                  {
  fputc ('\n', stderr);
  fflush (stderr);
  // TODO add possibility to use call back instead.
  exit (1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ error_message_start()

void CaDiCaL::Internal::error_message_start ( )

Definition at line 158 of file cadical_message.cpp.

                                    {
  fflush (stdout);
  terr.bold ();
  fputs ("cadical: ", stderr);
  terr.red (1);
  fputs ("error:", stderr);
  terr.normal ();
  fputc (' ', stderr);
}

Here is the caller graph for this function:

◆ explain_external_propagations()

void CaDiCaL::Internal::explain_external_propagations ( )

Definition at line 583 of file cadical_external_propagate.cpp.

                                              {
  CADICAL_assert (conflict);
  CADICAL_assert (clause.empty ());
 
  Clause *reason = conflict;
  std::vector<int> seen_lits;
  int open = 0; // Seen but not explained literal
 
  explain_reason (0, reason, open); // marks conflict clause lits as seen
  int i = trail.size ();            // Start at end-of-trail
  while (i > 0) {
    const int lit = trail[--i];
    if (!flags (lit).seen)
      continue;
    seen_lits.push_back (lit);
    Var &v = var (lit);
    if (!v.level)
      continue;
    if (v.reason) {
      open--;
      explain_reason (lit, v.reason, open);
    }
    if (!open)
      break;
  }
  CADICAL_assert (!open);
 
  if (!opts.exteagerrecalc) {
    for (auto lit : seen_lits) {
      Flags &f = flags (lit);
      f.seen = false;
    }
#ifndef CADICAL_NDEBUG
    for (auto idx : vars) {
      CADICAL_assert (!flags (idx).seen);
    }
#endif
  }
 
  // Traverse now in the opposite direction (from lower to higher levels)
  // and calculate the actual assignment level for the seen assignments.
  for (auto it = seen_lits.rbegin (); it != seen_lits.rend (); ++it) {
    const int lit = *it;
    Flags &f = flags (lit);
    Var &v = var (lit);
    if (v.reason) {
      int real_level = 0;
      for (const auto &other : *v.reason) {
        if (other == lit)
          continue;
        int tmp = var (other).level;
        if (tmp > real_level)
          real_level = tmp;
      }
      if (v.level && !real_level) {
        build_chain_for_units (lit, v.reason, 1);
        learn_unit_clause (lit);
        lrat_chain.clear ();
        v.reason = 0;
      }
      CADICAL_assert (v.level >= real_level);
      if (v.level > real_level) {
        v.level = real_level;
      }
    }
    f.seen = false;
  }
 
#if 0 // has been fuzzed extensively
  for (auto idx : vars) {
    CADICAL_assert (!flags (idx).seen);
  }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ explain_reason()

void CaDiCaL::Internal::explain_reason	(	int	lit,
		Clause *	reason,
		int &	open )

Definition at line 534 of file cadical_external_propagate.cpp.

                                                                  {
  if (!opts.exteagerreasons)
    return;
#ifndef CADICAL_NDEBUG
  LOG (reason, "explain_reason of %d (open: %d)", ilit, open);
#endif
  CADICAL_assert (reason);
  CADICAL_assert (reason != external_reason);
  for (const auto &other : *reason) {
    if (other == ilit)
      continue;
    Flags &f = flags (other);
    if (f.seen)
      continue;
    Var &v = var (other);
    if (!v.level)
      continue;
    CADICAL_assert (val (other) < 0);
    CADICAL_assert (v.level <= level);
    if (v.reason == external_reason) {
      v.reason = learn_external_reason_clause (-other, 0, true);
    }
    if (v.level && v.reason) {
      f.seen = true;
      open++;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ external_check_solution()

bool CaDiCaL::Internal::external_check_solution ( )

Definition at line 830 of file cadical_external_propagate.cpp.

                                        {
  if (!external_prop)
    return true;
 
  bool trail_changed = true;
  bool added_new_clauses = false;
  while (trail_changed || added_new_clauses) {
    notify_assignments ();
    if (!satisfied ())
      break;
    trail_changed = false; // to be on the safe side
    added_new_clauses = false;
    LOG ("Final check by external propagator is invoked.");
    stats.ext_prop.echeck_call++;
    external->reset_extended ();
    external->extend ();
 
    std::vector<int> etrail;
 
    // Here the variables must be filtered by external->is_observed,
    // because fixed variables are internally not necessarily observed
    // anymore.
    for (int idx = 1; idx <= external->max_var; idx++) {
      if (!external->is_observed[idx])
        continue;
      const int lit = external->ival (idx);
      etrail.push_back (lit);
#ifndef CADICAL_NDEBUG
#ifdef LOGGING
      bool p = external->vals[idx];
      LOG ("evals[%d]: %d ival(%d): %d", idx, p, idx, lit);
#endif
#endif
    }
 
    bool is_consistent =
        external->propagator->cb_check_found_model (etrail);
    stats.ext_prop.ext_cb++;
    if (is_consistent) {
      LOG ("Found solution is approved by external propagator.");
      return true;
    }
 
    bool has_external_clause = ask_external_clause ();
 
    stats.ext_prop.ext_cb++;
    stats.ext_prop.elearn_call++;
 
    if (has_external_clause)
      LOG (
          "Found solution triggered new clauses from external propagator.");
 
    while (has_external_clause) {
      int level_before = level;
      size_t assigned = num_assigned;
      add_external_clause (0);
      bool trail_changed =
          (num_assigned != assigned || level != level_before ||
           propagated < trail.size ());
      added_new_clauses = true;
      //
      // There are many possible scenarios here:
      // - Learned conflicting clause: return to CDCL loop (conflict true)
      // - Learned conflicting unit clause that after backtrack+BCP leads to
      //   a new complete solution: force the outer loop to check the new
      //   model (trail_changed is true, but (conflict & unsat) is false)
      // - Learned empty clause: return to CDCL loop (unsat true)
      // - Learned a non-conflicting unit clause:
      //   Though it does not invalidate the current solution, the solver
      //   will backtrack to the root level and will repropagate it. The
      //   search will start again (saved phases hopefully make it quick),
      //   but it is needed in order to guarantee that every fixed variable
      //   is properly handled+notified (important for incremental use
      //   cases).
      // - Otherwise: the solution is considered approved and the CDCL-loop
      //   can return with res = 10.
      //
      if (unsat || conflict || trail_changed)
        break;
      has_external_clause = ask_external_clause ();
      stats.ext_prop.ext_cb++;
      stats.ext_prop.elearn_call++;
    }
    LOG ("No more external clause to add.");
    if (unsat || conflict)
      break;
  }
 
  if (!unsat && conflict) {
    const int conflict_level = var (conflict->literals[0]).level;
    if (conflict_level != level) {
      backtrack (conflict_level);
    }
  }
 
  return !conflict;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ external_propagate()

bool CaDiCaL::Internal::external_propagate ( )

Definition at line 235 of file cadical_external_propagate.cpp.

                                   {
  if (level)
    require_mode (SEARCH);
  CADICAL_assert (!unsat);
 
  size_t before = num_assigned;
  bool cb_repropagate_needed = true;
  while (cb_repropagate_needed && !conflict && external_prop &&
         !external_prop_is_lazy && !private_steps) {
#ifndef CADICAL_NDEBUG
    LOG ("external propagation starts (decision level: %d, trail size: "
         "%zd, notified %zd)",
         level, trail.size (), notified);
#endif
    cb_repropagate_needed = false;
    // external->reset_extended (); //TODO for inprocessing
 
    notify_assignments ();
 
    int elit = external->propagator->cb_propagate ();
    stats.ext_prop.ext_cb++;
    stats.ext_prop.eprop_call++;
    while (elit) {
      CADICAL_assert (external->is_observed[abs (elit)]);
      int ilit = external->e2i[abs (elit)];
      if (elit < 0)
        ilit = -ilit;
      int tmp = val (ilit);
#ifndef CADICAL_NDEBUG
      CADICAL_assert (fixed (ilit) || observed (ilit));
      LOG ("External propagation of e%d (i%d val: %d)", elit, ilit, tmp);
#endif
      if (!tmp) {
        // variable is not assigned, it can be propagated
        if (!level) {
          Clause *res = learn_external_reason_clause (ilit, elit);
#ifndef LOGGING
          LOG (res, "reason clause of external propagation of %d:", elit);
#endif
          (void) res;
        } else
          search_assign_external (ilit);
        stats.ext_prop.eprop_prop++;
 
        if (unsat || conflict)
          break;
        propagate ();
        if (unsat || conflict)
          break;
        notify_assignments ();
      } else if (tmp < 0) {
        LOG ("External propgation of %d is falsified under current trail",
             ilit);
        stats.ext_prop.eprop_conf++;
        int level_before = level;
        size_t assigned = num_assigned;
        Clause *res = learn_external_reason_clause (ilit, elit);
#ifndef LOGGING
        LOG (res, "reason clause of external propagation of %d:", elit);
#endif
        (void) res;
        bool trail_changed =
            (num_assigned != assigned || level != level_before ||
             propagated < trail.size ());
 
        if (unsat || conflict)
          break;
 
        if (trail_changed) {
          propagate ();
          if (unsat || conflict)
            break;
          notify_assignments ();
        }
      } // else (tmp > 0) -> the case of a satisfied literal is ignored
      elit = external->propagator->cb_propagate ();
      stats.ext_prop.ext_cb++;
      stats.ext_prop.eprop_call++;
    }
 
#ifndef CADICAL_NDEBUG
    LOG ("External propagation ends (decision level: %d, trail size: %zd, "
         "notified %zd)",
         level, trail.size (), notified);
#endif
    if (!unsat && !conflict) {
      int level_before = level;
      size_t assigned = num_assigned;
      bool has_external_clause = ask_external_clause ();
      // New observed variable might have triggered a backtrack during this
      // ask_external_clause call, so we need to propagate before continuing
      stats.ext_prop.ext_cb++;
      stats.ext_prop.elearn_call++;
 
      bool trail_changed =
          (num_assigned != assigned || level != level_before ||
           propagated < trail.size ());
      if (trail_changed) {
        propagate (); // unsat or conflict will be caught later
        if (!unsat || !conflict)
          notify_assignments ();
      }
 
#ifndef CADICAL_NDEBUG
      if (has_external_clause)
        LOG ("New external clauses are to be added.");
      else
        LOG ("No external clauses to be added.");
#endif
 
      while (has_external_clause) {
        level_before = level;
        assigned = num_assigned;
 
        add_external_clause (0);
        trail_changed =
            (num_assigned != assigned || level != level_before ||
             propagated < trail.size ());
        cb_repropagate_needed = true;
 
        if (unsat || conflict) {
          cb_repropagate_needed = false;
          break;
        }
 
        if (trail_changed) {
          propagate ();
          if (unsat || conflict) {
            cb_repropagate_needed = false;
            break;
          }
 
          notify_assignments ();
        }
        has_external_clause = ask_external_clause ();
        stats.ext_prop.ext_cb++;
        stats.ext_prop.elearn_call++;
      }
    }
#ifndef CADICAL_NDEBUG
    LOG ("External clause addition ends on decision level %d at trail "
         "size "
         "%zd (notified %zd)",
         level, trail.size (), notified);
#endif
  }
  if (before < num_assigned)
    did_external_prop = true;
  return !conflict;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ externalize()

int CaDiCaL::Internal::externalize ( int lit )

inline

Definition at line 1557 of file internal.hpp.

                            {
    CADICAL_assert (lit != INT_MIN);
    const int idx = abs (lit);
    CADICAL_assert (idx);
    CADICAL_assert (idx <= max_var);
    int res = i2e[idx];
    if (lit < 0)
      res = -res;
    return res;
  }

Here is the caller graph for this function:

◆ extract_gates()

bool CaDiCaL::Internal::extract_gates ( )

Definition at line 7429 of file cadical_congruence.cpp.

                              {
  if (unsat)
    return false;
  if (!opts.congruence)
    return false;
  if (level)
    backtrack ();
  if (!propagate ()) {
    learn_empty_clause ();
    return false;
  }
  if (congruence_delay.bumpreasons.limit) {
    LOG ("delaying congruence %" PRId64 " more times",
         congruence_delay.bumpreasons.limit);
    congruence_delay.bumpreasons.limit--;
    return false;
  }
 
  // to remove false literals from clauses
  // It makes the technique stronger as long clauses
  // can become binary / ternary
  //  garbage_collection ();
 
  const int64_t old = stats.congruence.congruent;
  const int old_merged = stats.congruence.congruent;
 
  // congruencebinary is already doing it (and more actually)
  if (!internal->opts.congruencebinaries) {
    const bool dedup = opts.deduplicate;
    opts.deduplicate = true;
    mark_duplicated_binary_clauses_as_garbage ();
    opts.deduplicate = dedup;
  }
  ++stats.congruence.rounds;
  clear_watches ();
  //  connect_binary_watches ();
 
  START_SIMPLIFIER (congruence, CONGRUENCE);
  Closure closure (this);
 
  closure.init_closure ();
  CADICAL_assert (unsat || closure.chain.empty ());
  CADICAL_assert (unsat || lrat_chain.empty ());
  closure.extract_binaries ();
  CADICAL_assert (unsat || closure.chain.empty ());
  CADICAL_assert (unsat || lrat_chain.empty ());
  closure.extract_gates ();
  CADICAL_assert (unsat || closure.chain.empty ());
  CADICAL_assert (unsat || lrat_chain.empty ());
  internal->clear_watches ();
  internal->connect_watches ();
  closure.reset_extraction ();
 
  if (!unsat) {
    closure.find_units ();
    CADICAL_assert (unsat || closure.chain.empty ());
    CADICAL_assert (unsat || lrat_chain.empty ());
    if (!internal->unsat) {
      closure.find_equivalences ();
      CADICAL_assert (unsat || closure.chain.empty ());
      CADICAL_assert (unsat || lrat_chain.empty ());
 
      if (!unsat) {
        const int propagated = closure.propagate_units_and_equivalences ();
        CADICAL_assert (unsat || closure.chain.empty ());
        if (!unsat && propagated)
          closure.forward_subsume_matching_clauses ();
      }
    }
  }
 
  closure.reset_closure ();
  internal->clear_watches ();
  internal->connect_watches ();
  if (!internal->unsat) {
    propagated2 = propagated = 0;
    propagate ();
  }
  CADICAL_assert (closure.new_unwatched_binary_clauses.empty ());
  internal->reset_occs ();
  internal->reset_noccs ();
  CADICAL_assert (!internal->occurring ());
  CADICAL_assert (lrat_chain.empty ());
 
  const int64_t new_merged = stats.congruence.congruent;
 
#ifndef CADICAL_QUIET
  phase ("congruence-phase", stats.congruence.rounds, "merged %ld literals",
         new_merged - old_merged);
#endif
  if (!unsat && !internal->propagate ())
    unsat = true;
 
  STOP_SIMPLIFIER (congruence, CONGRUENCE);
  report ('c', !opts.reportall && !(stats.congruence.congruent - old));
#ifndef CADICAL_NDEBUG
  size_t watched = 0;
  for (auto v : vars) {
    for (auto sgn = -1; sgn <= 1; sgn += 2) {
      const int lit = v * sgn;
      for (auto w : watches (lit)) {
        if (w.binary ())
          CADICAL_assert (!w.clause->garbage);
        if (w.clause->garbage)
          continue;
        ++watched;
        LOG (w.clause, "watched");
      }
    }
  }
  LOG ("and now the clauses:");
  size_t nb_clauses = 0;
  for (auto c : clauses) {
    if (c->garbage)
      continue;
    LOG (c, "watched");
    ++nb_clauses;
  }
  CADICAL_assert (watched == nb_clauses * 2);
#endif
  CADICAL_assert (!internal->occurring ());
 
  if (new_merged == old_merged) {
    congruence_delay.bumpreasons.interval++;
  } else {
    congruence_delay.bumpreasons.interval /= 2;
  }
 
  LOG ("delay congruence internal %" PRId64,
       congruence_delay.bumpreasons.interval);
  congruence_delay.bumpreasons.limit =
      congruence_delay.bumpreasons.interval;
 
  return new_merged != old_merged;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ factor()

bool CaDiCaL::Internal::factor ( )

Definition at line 859 of file cadical_factor.cpp.

                       {
  if (unsat)
    return false;
  if (terminated_asynchronously ())
    return false;
  if (!opts.factor)
    return false;
  // The following CADICAL_assertion fails if there are *only* user propagator
  // clauses (which are redundant).
  // CADICAL_assert (stats.mark.factor || clauses.empty ());
  if (last.factor.marked >= stats.mark.factor) {
    VERBOSE (3,
             "factorization skipped as no literals have been"
             "marked to be added (%" PRIu64 " < %" PRIu64 ")",
             last.factor.marked, stats.mark.factor);
    return false;
  }
  CADICAL_assert (!level);
 
  SET_EFFORT_LIMIT (limit, factor, stats.factor);
  if (!stats.factor)
    limit += opts.factoriniticks * 1e6;
 
  START_SIMPLIFIER (factor, FACTOR);
  stats.factor++;
 
#ifndef CADICAL_QUIET
  struct {
    int64_t variables, clauses, ticks;
  } before, after, delta;
  before.variables = stats.variables_extension + stats.variables_original;
  before.ticks = stats.ticks.factor;
  before.clauses = stats.current.irredundant;
#endif
 
  factor_mode ();
  bool completed = run_factorization (limit);
  reset_factor_mode ();
 
  propagated = 0;
  if (!unsat && !propagate ()) {
    learn_empty_clause ();
  }
 
#ifndef CADICAL_QUIET
  after.variables = stats.variables_extension + stats.variables_original;
  after.clauses = stats.current.irredundant;
  after.ticks = stats.ticks.factor;
  delta.variables = after.variables - before.variables;
  delta.clauses = before.clauses - after.clauses;
  delta.ticks = after.ticks - before.ticks;
  VERBOSE (2, "used %f million factorization ticks", delta.ticks * 1e-6);
  phase ("factorization", stats.factor,
         "introduced %" PRId64 " extension variables %.0f%%",
         delta.variables, percent (delta.variables, before.variables));
  phase ("factorization", stats.factor,
         "removed %" PRId64 " irredundant clauses %.0f%%", delta.clauses,
         percent (delta.clauses, before.clauses));
#endif
 
  if (completed)
    last.factor.marked = stats.mark.factor;
  STOP_SIMPLIFIER (factor, FACTOR);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ factor_mode()

void CaDiCaL::Internal::factor_mode ( )

Definition at line 24 of file cadical_factor.cpp.

                            {
  reset_watches ();
 
  CADICAL_assert (!watching ());
  init_occs ();
 
  const int size_limit = opts.factorsize;
 
  vector<unsigned> bincount, largecount;
  const unsigned max_lit = 2 * (max_var + 1);
  enlarge_zero (bincount, max_lit);
  if (size_limit > 2)
    enlarge_zero (largecount, max_lit);
 
  vector<Clause *> candidates;
  int64_t &ticks = stats.ticks.factor;
  ticks += 1 + cache_lines (clauses.size (), sizeof (Clause *));
 
  // push binary clauses on the occurrence stack.
  for (const auto &c : clauses) {
    ticks++;
    if (c->garbage)
      continue;
    if (c->redundant && c->size > 2)
      continue;
    if (c->size > size_limit)
      continue;
    if (c->size == 2) {
      const int lit = c->literals[0];
      const int other = c->literals[1];
      bincount[vlit (lit)]++;
      bincount[vlit (other)]++;
      occs (lit).push_back (c);
      occs (other).push_back (c);
      continue;
    }
    candidates.push_back (c);
    for (const auto &lit : *c) {
      largecount[vlit (lit)]++;
    }
  }
  if (size_limit == 2)
    return;
 
  // iterate counts of larger clauses rounds often
  const unsigned rounds = opts.factorcandrounds;
  unsigned candidates_before = 0;
  for (unsigned round = 1; round <= rounds; round++) {
    LOG ("factor round %d", round);
    if (candidates.size () == candidates_before)
      break;
    ticks += 1 + cache_lines (candidates.size (), sizeof (Clause *));
    candidates_before = candidates.size ();
    vector<unsigned> newlargecount;
    enlarge_zero (newlargecount, max_lit);
    const auto begin = candidates.begin ();
    auto p = candidates.begin ();
    auto q = p;
    const auto end = candidates.end ();
    while (p != end) {
      Clause *c = *q++ = *p++;
      ticks++;
      for (const auto &lit : *c) {
        const auto idx = vlit (lit);
        if (bincount[idx] + largecount[idx] < 2) {
          q--;
          goto CONTINUE_WITH_NEXT_CLAUSE;
        }
      }
      for (const auto &lit : *c) {
        const auto idx = vlit (lit);
        newlargecount[idx]++;
      }
    CONTINUE_WITH_NEXT_CLAUSE:
      continue;
    }
    candidates.resize (q - begin);
    largecount.swap (newlargecount);
  }
 
  // finally push remaining clause on the occurrence stack
  for (const auto &c : candidates)
    for (const auto &lit : *c)
      occs (lit).push_back (c);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ factorize_next()

void CaDiCaL::Internal::factorize_next	(	Factoring &	factoring,
		int	next,
		unsigned	expected_next_count )

Definition at line 391 of file cadical_factor.cpp.

                                                             {
  Quotient *last_quotient = factoring.quotients.last;
  Quotient *next_quotient = new_quotient (factoring, next);
 
  CADICAL_assert (last_quotient);
  vector<Clause *> &last_clauses = last_quotient->qlauses;
  vector<Clause *> &next_clauses = next_quotient->qlauses;
  vector<size_t> &matches = next_quotient->matches;
  vector<Clause *> &flauses = factoring.flauses;
  CADICAL_assert (flauses.empty ());
 
  int64_t ticks = 1 + cache_lines (last_clauses.size (), sizeof (Clause *));
 
  size_t i = 0;
 
  for (auto c : last_clauses) {
    CADICAL_assert (!c->swept);
    int min_lit = 0;
    unsigned factors = 0;
    size_t min_size = 0;
    ticks++;
    for (const auto &other : *c) {
      if (getfact (other, FACTORS)) {
        if (factors++)
          break;
      } else {
        CADICAL_assert (!getfact (other, QUOTIENT));
        markfact (other, QUOTIENT);
        const size_t other_size = occs (other).size ();
        if (!min_lit || other_size < min_size) {
          min_lit = other;
          min_size = other_size;
        }
      }
    }
    CADICAL_assert (factors);
    if (factors == 1) {
      CADICAL_assert (min_lit);
      const int c_size = c->size;
      ticks += 1 + cache_lines (occs (min_lit).size (), sizeof (Clause *));
      for (auto d : occs (min_lit)) {
        if (c == d)
          continue;
        ticks++;
        if (d->swept)
          continue;
        if (d->size != c_size)
          continue;
        for (const auto &other : *d) {
          if (getfact (other, QUOTIENT))
            continue;
          if (other != next)
            goto CONTINUE_WITH_NEXT_MIN_WATCH;
        }
        LOG (c, "matched");
        LOG (d, "keeping");
 
        next_clauses.push_back (d);
        matches.push_back (i);
        flauses.push_back (d);
        d->swept = true;
        break;
 
      CONTINUE_WITH_NEXT_MIN_WATCH:;
      }
    }
    for (const auto &other : *c)
      if (getfact (other, QUOTIENT))
        unmarkfact (other, QUOTIENT);
    i++;
  }
  clear_flauses (flauses);
  stats.ticks.factor += ticks;
 
  CADICAL_assert (expected_next_count <= next_clauses.size ());
  (void) expected_next_count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ failed()

bool CaDiCaL::Internal::failed ( int lit )

Definition at line 453 of file cadical_assume.cpp.

                              {
  if (!marked_failed) {
    if (!conflict_id)
      failing ();
    marked_failed = true;
  }
  conclude_unsat ();
  Flags &f = flags (lit);
  const unsigned bit = bign (lit);
  return (f.failed & bit) != 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ failed_constraint()

bool CaDiCaL::Internal::failed_constraint ( )

Definition at line 57 of file cadical_constrain.cpp.

57{ return unsat_constraint; }

◆ failed_literal()

void CaDiCaL::Internal::failed_literal ( int lit )

Definition at line 517 of file cadical_probe.cpp.

                                         {
 
  LOG ("analyzing failed literal probe %d", failed);
  stats.failed++;
  stats.probefailed++;
 
  CADICAL_assert (!unsat);
  CADICAL_assert (conflict);
  CADICAL_assert (level == 1);
  CADICAL_assert (analyzed.empty ());
  CADICAL_assert (lrat_chain.empty ());
 
  START (analyze);
 
  LOG (conflict, "analyzing failed literal conflict");
 
  int uip = 0;
  for (const auto &lit : *conflict) {
    const int other = -lit;
    if (!var (other).level) {
      CADICAL_assert (val (other) > 0);
      continue;
    }
    uip = uip ? probe_dominator (uip, other) : other;
  }
  probe_dominator_lrat (uip, conflict);
  if (lrat)
    clear_analyzed_literals ();
 
  LOG ("found probing UIP %d", uip);
  CADICAL_assert (uip);
 
  vector<int> work;
 
  int parent = uip;
  while (parent != failed) {
    const int next = get_parent_reason_literal (parent);
    parent = next;
    CADICAL_assert (parent);
    work.push_back (parent);
  }
 
  backtrack ();
  conflict = 0;
 
  CADICAL_assert (!val (uip));
  probe_assign_unit (-uip);
  lrat_chain.clear ();
 
  if (!probe_propagate ())
    learn_empty_clause ();
 
  size_t j = 0;
  while (!unsat && j < work.size ()) {
    // CADICAL_assert (!opts.probehbr);        CADICAL_assertion fails ...
    const int parent = work[j++];
    const signed char tmp = val (parent);
    if (tmp > 0) {
      CADICAL_assert (!opts.probehbr); // ... CADICAL_assertion should hold here
      get_probehbr_lrat (parent, uip);
      LOG ("clashing failed parent %d", parent);
      learn_empty_clause ();
    } else if (tmp == 0) {
      CADICAL_assert (!opts.probehbr); // ... and here
      LOG ("found unassigned failed parent %d", parent);
      get_probehbr_lrat (parent, uip); // this is computed during
      probe_assign_unit (-parent);     // propagation and can include
      lrat_chain.clear ();             // multiple chains where only one
      if (!probe_propagate ())
        learn_empty_clause (); // is needed!
    }
    uip = parent;
  }
  work.clear ();
  erase_vector (work);
 
  STOP (analyze);
 
  CADICAL_assert (unsat || val (failed) < 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ failing()

void CaDiCaL::Internal::failing ( )

Definition at line 81 of file cadical_assume.cpp.

                        {
 
  START (analyze);
 
  LOG ("analyzing failing assumptions");
 
  CADICAL_assert (analyzed.empty ());
  CADICAL_assert (clause.empty ());
  CADICAL_assert (lrat_chain.empty ());
  CADICAL_assert (!marked_failed);
  CADICAL_assert (!conflict_id);
 
  if (!unsat_constraint) {
    // Search for failing assumptions in the (internal) assumption stack.
 
    // There are in essence three cases: (1) An assumption is falsified on
    // the root-level and then 'failed_unit' is set to that assumption, (2)
    // two clashing assumptions are assumed and then 'failed_clashing' is
    // set to the second assumed one, or otherwise (3) there is a failing
    // assumption 'first_failed' with minimum (non-zero) decision level
    // 'failed_level'.
 
    int failed_unit = 0;
    int failed_clashing = 0;
    int first_failed = 0;
    int failed_level = INT_MAX;
    int efailed = 0;
 
    for (auto &elit : external->assumptions) {
      int lit = external->e2i[abs (elit)];
      if (elit < 0)
        lit = -lit;
      if (val (lit) >= 0)
        continue;
      const Var &v = var (lit);
      if (!v.level) {
        failed_unit = lit;
        efailed = elit;
        break;
      }
      if (failed_clashing)
        continue;
      if (v.reason == external_reason) {
        Var &ev = var (lit);
        ev.reason = learn_external_reason_clause (-lit);
        if (!ev.reason) {
          ev.level = 0;
          failed_unit = lit;
          efailed = elit;
          break;
        }
        ev.level = 0;
        // Recalculate assignment level
        for (const auto &other : *ev.reason) {
          if (other == -lit)
            continue;
          CADICAL_assert (val (other));
          int tmp = var (other).level;
          if (tmp > ev.level)
            ev.level = tmp;
        }
        if (!ev.level) {
          failed_unit = lit;
          efailed = elit;
          break;
        }
      }
      CADICAL_assert (v.reason != external_reason);
      if (!v.reason) {
        failed_clashing = lit;
        efailed = elit;
      } else if (!first_failed || v.level < failed_level) {
        first_failed = lit;
        efailed = elit;
        failed_level = v.level;
      }
    }
 
    CADICAL_assert (clause.empty ());
 
    // Get the 'failed' assumption from one of the three cases.
    int failed;
    if (failed_unit)
      failed = failed_unit;
    else if (failed_clashing)
      failed = failed_clashing;
    else
      failed = first_failed;
    CADICAL_assert (failed);
    CADICAL_assert (efailed);
 
    // In any case mark literal 'failed' as failed assumption.
    {
      Flags &f = flags (failed);
      const unsigned bit = bign (failed);
      CADICAL_assert (!(f.failed & bit));
      f.failed |= bit;
    }
 
    // First case (1).
    if (failed_unit) {
      CADICAL_assert (failed == failed_unit);
      LOG ("root-level falsified assumption %d", failed);
      if (proof) {
        if (lrat) {
          unsigned eidx = (efailed > 0) + 2u * (unsigned) abs (efailed);
          CADICAL_assert ((size_t) eidx < external->ext_units.size ());
          const int64_t id = external->ext_units[eidx];
          if (id) {
            lrat_chain.push_back (id);
          } else {
            int64_t id = unit_id (-failed_unit);
            lrat_chain.push_back (id);
          }
        }
        proof->add_assumption_clause (++clause_id, -efailed, lrat_chain);
        conclusion.push_back (clause_id);
        lrat_chain.clear ();
      }
      goto DONE;
    }
 
    // Second case (2).
    if (failed_clashing) {
      CADICAL_assert (failed == failed_clashing);
      LOG ("clashing assumptions %d and %d", failed, -failed);
      Flags &f = flags (-failed);
      const unsigned bit = bign (-failed);
      CADICAL_assert (!(f.failed & bit));
      f.failed |= bit;
      if (proof) {
        vector<int> clash = {externalize (failed), externalize (-failed)};
        proof->add_assumption_clause (++clause_id, clash, lrat_chain);
        conclusion.push_back (clause_id);
      }
      goto DONE;
    }
 
    // Fall through to third case (3).
    LOG ("starting with assumption %d falsified on minimum decision level "
         "%d",
         first_failed, failed_level);
 
    CADICAL_assert (first_failed);
    CADICAL_assert (failed_level > 0);
 
    // The 'analyzed' stack serves as working stack for a BFS through the
    // implication graph until decisions, which are all assumptions, or
    // units are reached.  This is simpler than corresponding code in
    // 'analyze'.
    {
      LOG ("failed assumption %d", first_failed);
      Flags &f = flags (first_failed);
      CADICAL_assert (!f.seen);
      f.seen = true;
      CADICAL_assert (f.failed & bign (first_failed));
      analyzed.push_back (-first_failed);
      clause.push_back (-first_failed);
    }
  } else {
    // unsat_constraint
    // The assumptions necessary to fail each literal in the constraint are
    // collected.
    for (auto lit : constraint) {
      lit *= -1;
      CADICAL_assert (lit != INT_MIN);
      flags (lit).seen = true;
      analyzed.push_back (lit);
    }
  }
 
  {
    // used for unsat_constraint lrat
    vector<vector<int64_t>> constraint_chains;
    vector<vector<int>> constraint_clauses;
    vector<int> sum_constraints;
    vector<int> econstraints;
    for (auto &elit : external->constraint) {
      int lit = external->e2i[abs (elit)];
      if (elit < 0)
        lit = -lit;
      if (!lit)
        continue;
      Flags &f = flags (lit);
      if (f.seen)
        continue;
      if (std::find (econstraints.begin (), econstraints.end (), elit) !=
          econstraints.end ())
        continue;
      econstraints.push_back (elit);
    }
 
    // no LRAT do bfs as it was before
    if (!lrat) {
      size_t next = 0;
      while (next < analyzed.size ()) {
        const int lit = analyzed[next++];
        CADICAL_assert (val (lit) > 0);
        Var &v = var (lit);
        if (!v.level)
          continue;
        if (v.reason == external_reason) {
          v.reason = wrapped_learn_external_reason_clause (lit);
          if (!v.reason) {
            v.level = 0;
            continue;
          }
        }
        CADICAL_assert (v.reason != external_reason);
        if (v.reason) {
          CADICAL_assert (v.level);
          LOG (v.reason, "analyze reason");
          for (const auto &other : *v.reason) {
            Flags &f = flags (other);
            if (f.seen)
              continue;
            f.seen = true;
            CADICAL_assert (val (other) < 0);
            analyzed.push_back (-other);
          }
        } else {
          CADICAL_assert (assumed (lit));
          LOG ("failed assumption %d", lit);
          clause.push_back (-lit);
          Flags &f = flags (lit);
          const unsigned bit = bign (lit);
          CADICAL_assert (!(f.failed & bit));
          f.failed |= bit;
        }
      }
      clear_analyzed_literals ();
    } else if (!unsat_constraint) { // LRAT for case (3)
      CADICAL_assert (clause.size () == 1);
      const int lit = clause[0];
      Var &v = var (lit);
      CADICAL_assert (v.reason);
      if (v.reason == external_reason) { // does this even happen?
        v.reason = wrapped_learn_external_reason_clause (lit);
      }
      CADICAL_assert (v.reason != external_reason);
      if (v.reason)
        assume_analyze_reason (lit, v.reason);
      else {
        int64_t id = unit_id (lit);
        lrat_chain.push_back (id);
      }
      for (auto &lit : clause) {
        Flags &f = flags (lit);
        const unsigned bit = bign (-lit);
        if (!(f.failed & bit))
          f.failed |= bit;
      }
      clear_analyzed_literals ();
    } else { // LRAT for unsat_constraint
      CADICAL_assert (clause.empty ());
      clear_analyzed_literals ();
      for (auto lit : constraint) {
        // make sure nothing gets marked failed twice
        // also might shortcut the case where
        // lrat_chain is empty because clause is tautological
        CADICAL_assert (lit != INT_MIN);
        assume_analyze_literal (lit);
        vector<int64_t> empty;
        vector<int> empty2;
        constraint_chains.push_back (empty);
        constraint_clauses.push_back (empty2);
        for (auto ign : clause) {
          constraint_clauses.back ().push_back (ign);
          Flags &f = flags (ign);
          const unsigned bit = bign (-ign);
          if (!(f.failed & bit)) {
            sum_constraints.push_back (ign);
            CADICAL_assert (!(f.failed & bit));
            f.failed |= bit;
          }
        }
        clause.clear ();
        clear_analyzed_literals ();
        for (auto p : lrat_chain) {
          constraint_chains.back ().push_back (p);
        }
        lrat_chain.clear ();
      }
      for (auto &lit : sum_constraints)
        clause.push_back (lit);
    }
    clear_analyzed_literals ();
 
    // Doing clause minimization here does not do anything because
    // the clause already contains only one literal of each level
    // and minimization can never reduce the number of levels
 
    VERBOSE (1, "found %zd failed assumptions %.0f%%", clause.size (),
             percent (clause.size (), assumptions.size ()));
 
    // We do not actually need to learn this clause, since the conflict is
    // forced already by some other clauses.  There is also no bumping
    // of variables nor clauses necessary.  But we still want to check
    // correctness of the claim that the determined subset of failing
    // assumptions are a high-level core or equivalently their negations
    // form a unit-implied clause.
    //
    if (!unsat_constraint) {
      external->check_learned_clause ();
      if (proof) {
        vector<int> eclause;
        for (auto &lit : clause)
          eclause.push_back (externalize (lit));
        proof->add_assumption_clause (++clause_id, eclause, lrat_chain);
        conclusion.push_back (clause_id);
      }
    } else {
      CADICAL_assert (!lrat || (constraint.size () == constraint_clauses.size () &&
                        constraint.size () == constraint_chains.size ()));
      for (auto p = constraint.rbegin (); p != constraint.rend (); p++) {
        const auto &lit = *p;
        if (lrat) {
          clause.clear ();
          for (auto &ign : constraint_clauses.back ())
            clause.push_back (ign);
          constraint_clauses.pop_back ();
        }
        clause.push_back (-lit);
        external->check_learned_clause ();
        if (proof) {
          if (lrat) {
            for (auto p : constraint_chains.back ()) {
              lrat_chain.push_back (p);
            }
            constraint_chains.pop_back ();
            LOG (lrat_chain, "assume proof chain with constraints");
          }
          vector<int> eclause;
          for (auto &lit : clause)
            eclause.push_back (externalize (lit));
          proof->add_assumption_clause (++clause_id, eclause, lrat_chain);
          conclusion.push_back (clause_id);
          lrat_chain.clear ();
        }
        clause.pop_back ();
      }
      if (proof) {
        for (auto &elit : econstraints) {
          if (lrat) {
            unsigned eidx = (elit > 0) + 2u * (unsigned) abs (elit);
            CADICAL_assert ((size_t) eidx < external->ext_units.size ());
            const int64_t id = external->ext_units[eidx];
            if (id) {
              lrat_chain.push_back (id);
            } else {
              int lit = external->e2i[abs (elit)];
              if (elit < 0)
                lit = -lit;
              int64_t id = unit_id (-lit);
              lrat_chain.push_back (id);
            }
          }
          proof->add_assumption_clause (++clause_id, -elit, lrat_chain);
          conclusion.push_back (clause_id);
          lrat_chain.clear ();
        }
      }
    }
    lrat_chain.clear ();
    clause.clear ();
  }
 
DONE:
 
  STOP (analyze);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finalize()

void CaDiCaL::Internal::finalize ( int res )

Definition at line 1041 of file cadical_internal.cpp.

                                {
  if (!proof)
    return;
  LOG ("finalizing");
  // finalize external units
  if (frat) {
    for (const auto &evar : external->vars) {
      CADICAL_assert (evar > 0);
      const auto eidx = 2 * evar;
      int sign = 1;
      int64_t id = external->ext_units[eidx];
      if (!id) {
        sign = -1;
        id = external->ext_units[eidx + 1];
      }
      if (id) {
        proof->finalize_external_unit (id, evar * sign);
      }
    }
    // finalize internal units
    for (const auto &lit : lits) {
      const auto elit = externalize (lit);
      if (elit) {
        const unsigned eidx = (elit < 0) + 2u * (unsigned) abs (elit);
        const int64_t id = external->ext_units[eidx];
        if (id) {
          CADICAL_assert (unit_clauses (vlit (lit)) == id);
          continue;
        }
      }
      const int64_t id = unit_clauses (vlit (lit));
      if (!id)
        continue;
      proof->finalize_unit (id, lit);
    }
    // See the discussion in 'propagate' on why garbage binary clauses stick
    // around.
    for (const auto &c : clauses)
      if (!c->garbage || (c->size == 2 && !c->flushed))
        proof->finalize_clause (c);
 
    // finalize conflict and proof
    if (conflict_id) {
      proof->finalize_clause (conflict_id, {});
    }
  }
  proof->report_status (res, conflict_id);
  if (res == 10)
    external->conclude_sat ();
  else if (res == 20)
    conclude_unsat ();
  else if (!res)
    external->conclude_unknown ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_and_gate()

void CaDiCaL::Internal::find_and_gate	(	Eliminator &	eliminator,
		int	pivot )

Definition at line 323 of file cadical_gates.cpp.

                                                               {
 
  if (!opts.elimands)
    return;
 
  CADICAL_assert (opts.elimsubst);
 
  if (unsat)
    return;
  if (val (pivot))
    return;
  if (!eliminator.gates.empty ())
    return;
 
  mark_binary_literals (eliminator, pivot);
  if (unsat || val (pivot))
    goto DONE;
 
  for (const auto &c : occs (-pivot)) {
 
    if (c->garbage)
      continue;
    if (c->size < 3)
      continue;
 
    bool all_literals_marked = true;
    unsigned arity = 0;
    int satisfied = 0;
 
    for (const auto &lit : *c) {
      if (lit == -pivot)
        continue;
      CADICAL_assert (lit != pivot);
      signed char tmp = val (lit);
      if (tmp < 0)
        continue;
      if (tmp > 0) {
        satisfied = lit;
        break;
      }
      tmp = marked (lit);
      if (tmp < 0) {
        arity++;
        continue;
      }
      all_literals_marked = false;
      break;
    }
 
    if (!all_literals_marked)
      continue;
 
    if (satisfied) {
      LOG (c, "satisfied by %d candidate base clause", satisfied);
      mark_garbage (c);
      continue;
    }
 
#ifdef LOGGING
    if (opts.log) {
      Logger::print_log_prefix (this);
      tout.magenta ();
      printf ("found arity %u AND gate %d = ", arity, -pivot);
      bool first = true;
      for (const auto &lit : *c) {
        if (lit == -pivot)
          continue;
        CADICAL_assert (lit != pivot);
        if (!first)
          fputs (" & ", stdout);
        printf ("%d", -lit);
        first = false;
      }
      fputc ('\n', stdout);
      tout.normal ();
      fflush (stdout);
    }
#endif
    stats.elimands++;
    stats.elimgates++;
    eliminator.gatetype = AND;
 
    (void) arity;
    CADICAL_assert (!c->gate);
    c->gate = true;
    eliminator.gates.push_back (c);
    for (const auto &lit : *c) {
      if (lit == -pivot)
        continue;
      CADICAL_assert (lit != pivot);
      signed char tmp = val (lit);
      if (tmp < 0)
        continue;
      CADICAL_assert (!tmp);
      CADICAL_assert (marked (lit) < 0);
      marks[vidx (lit)] *= 2;
    }
 
    unsigned count = 0;
    for (const auto &d : occs (pivot)) {
      if (d->garbage)
        continue;
      const int other =
          second_literal_in_binary_clause (eliminator, d, pivot);
      if (!other)
        continue;
      const int tmp = marked (other);
      if (tmp != 2)
        continue;
      LOG (d, "AND gate binary side clause");
      CADICAL_assert (!d->gate);
      d->gate = true;
      eliminator.gates.push_back (d);
      count++;
    }
    CADICAL_assert (count >= arity);
    (void) count;
 
    break;
  }
 
DONE:
  unmark_binary_literals (eliminator);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_binary_clause()

Clause * CaDiCaL::Internal::find_binary_clause	(	int	first,
		int	second )

Definition at line 94 of file cadical_gates.cpp.

                                                           {
  int best = first;
  int other = second;
  if (occs (first).size () > occs (second).size ()) {
    best = second;
    other = first;
  }
  for (auto c : occs (best))
    if (second_literal_in_binary_clause_lrat (c, best) == other)
      return c;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_clause()

Clause * CaDiCaL::Internal::find_clause ( const vector< int > & lits )

Definition at line 621 of file cadical_gates.cpp.

                                                      {
  int best = 0;
  size_t len = 0;
  for (const auto &lit : lits) {
    size_t l = occs (lit).size ();
    if (best && l >= len)
      continue;
    len = l, best = lit;
  }
  for (auto c : occs (best))
    if (is_clause (c, lits))
      return c;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_conflict_level()

int CaDiCaL::Internal::find_conflict_level ( int & forced )

inline

Definition at line 575 of file cadical_analyze.cpp.

                                                     {
 
  CADICAL_assert (conflict);
  CADICAL_assert (opts.chrono || opts.otfs || external_prop);
 
  int res = 0, count = 0;
 
  forced = 0;
 
  for (const auto &lit : *conflict) {
    const int tmp = var (lit).level;
    if (tmp > res) {
      res = tmp;
      forced = lit;
      count = 1;
    } else if (tmp == res) {
      count++;
      if (res == level && count > 1)
        break;
    }
  }
 
  LOG ("%d literals on actual conflict level %d", count, res);
 
  const int size = conflict->size;
  int *lits = conflict->literals;
 
  // Move the two highest level literals to the front.
  //
  for (int i = 0; i < 2; i++) {
 
    const int lit = lits[i];
 
    int highest_position = i;
    int highest_literal = lit;
    int highest_level = var (highest_literal).level;
 
    for (int j = i + 1; j < size; j++) {
      const int other = lits[j];
      const int tmp = var (other).level;
      if (highest_level >= tmp)
        continue;
      highest_literal = other;
      highest_position = j;
      highest_level = tmp;
      if (highest_level == res)
        break;
    }
 
    // No unwatched higher assignment level literal.
    //
    if (highest_position == i)
      continue;
 
    if (highest_position > 1) {
      LOG (conflict, "unwatch %d in", lit);
      remove_watch (watches (lit), conflict);
    }
 
    lits[highest_position] = lit;
    lits[i] = highest_literal;
 
    if (highest_position > 1)
      watch_literal (highest_literal, lits[!i], conflict);
  }
 
  // Only if the number of highest level literals in the conflict is one
  // then we can reuse the conflict clause as driving clause for 'forced'.
  //
  if (count != 1)
    forced = 0;
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_definition()

void CaDiCaL::Internal::find_definition	(	Eliminator &	eliminator,
		int	lit )

Definition at line 182 of file cadical_definition.cpp.

                                                               {
  if (!opts.elimdef)
    return;
  if (unsat)
    return;
  if (val (lit))
    return;
  if (!eliminator.gates.empty ())
    return;
  CADICAL_assert (!val (lit));
  CADICAL_assert (!level);
  CADICAL_assert (citten);
  const int not_lit = -lit;
  definition_extractor extractor;
  extractor.lit = lit;
  extractor.clauses[0] = occs (lit);
  extractor.clauses[1] = occs (not_lit);
  extractor.eliminator = &eliminator;
  extractor.internal = internal;
  citten_clear_track_log_terminate ();
  unsigned exported = 0;
  for (unsigned sign = 0; sign < 2; sign++) {
    const unsigned except = sign ? lit2citten (not_lit) : lit2citten (lit);
    for (auto c : extractor.clauses[sign]) {
      // to avoid copying the literals of c in their unsigned
      // representation we instead implement the translation in cadical_kitten
      if (!c->garbage) {
        LOG (c, "adding to cadical_kitten");
        citten_clause_with_id_and_exception (citten, exported, c->size,
                                             c->literals, except);
      }
      exported++;
    }
  }
  stats.definitions_checked++;
  const size_t limit = opts.elimdefticks;
  cadical_kitten_set_ticks_limit (citten, limit);
  int status = cadical_kitten_solve (citten);
  if (!exported)
    goto ABORT;
  if (status == 20) {
    LOG ("sub-solver result UNSAT shows definition exists");
    uint64_t learned;
    unsigned reduced = cadical_kitten_compute_clausal_core (citten, &learned);
    LOG ("1st sub-solver core of size %u original clauses out of %u",
         reduced, exported);
    for (int i = 2; i <= opts.elimdefcores; i++) {
      cadical_kitten_shrink_to_clausal_core (citten);
      cadical_kitten_shuffle_clauses (citten);
      cadical_kitten_set_ticks_limit (citten, 10 * limit);
      int tmp = cadical_kitten_solve (citten);
      CADICAL_assert (!tmp || tmp == 20);
      if (!tmp) {
        LOG ("aborting core extraction");
        goto ABORT;
      }
#ifndef CADICAL_NDEBUG
      unsigned previous = reduced;
#endif
      reduced = cadical_kitten_compute_clausal_core (citten, &learned);
      LOG ("%d sub-solver core of size %u original clauses out of %u", i,
           reduced, exported);
      CADICAL_assert (reduced <= previous);
#if not defined(LOGGING) && defined(CADICAL_NDEBUG)
      (void) reduced;
#endif
    }
    stats.definitions_extracted++;
    eliminator.gatetype = DEF;
    eliminator.definition_unit = 0;
    cadical_kitten_traverse_core_ids (citten, &extractor, traverse_definition_core);
    CADICAL_assert (eliminator.definition_unit);
    int unit = 0;
    if (eliminator.definition_unit == 2) {
      unit = not_lit;
    } else if (eliminator.definition_unit == 1)
      unit = lit;
 
    if (unit) {
      stats.definition_units++;
      VERBOSE (2, "one sided core "
                  "definition extraction yields "
                  "failed literal");
      if (proof) {
        if (lrat) {
          extractor.unit = unit;
          cadical_kitten_trace_core (citten, &extractor,
                             traverse_one_sided_core_lemma_with_lrat);
        } else {
          extractor.unit = unit;
          cadical_kitten_traverse_core_clauses (citten, &extractor,
                                        traverse_one_sided_core_lemma);
        }
      } else
        assign_unit (unit);
      elim_propagate (eliminator, unit);
    }
  } else {
  ABORT:
    LOG ("sub-solver failed to show that definition exists");
  }
  stats.definition_ticks += cadical_kitten_current_ticks (citten);
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_equivalence()

void CaDiCaL::Internal::find_equivalence	(	Eliminator &	eliminator,
		int	pivot )

Definition at line 204 of file cadical_gates.cpp.

                                                                  {
 
  if (!opts.elimequivs)
    return;
 
  CADICAL_assert (opts.elimsubst);
 
  if (unsat)
    return;
  if (val (pivot))
    return;
  if (!eliminator.gates.empty ())
    return;
 
  mark_binary_literals (eliminator, pivot);
  if (unsat || val (pivot))
    goto DONE;
 
  for (const auto &c : occs (-pivot)) {
 
    if (c->garbage)
      continue;
 
    const int second =
        second_literal_in_binary_clause (eliminator, c, -pivot);
    if (!second)
      continue;
    const int tmp = marked (second);
    if (tmp > 0) {
      LOG ("found binary resolved unit %d", second);
      // did not find a bug where units could occur multiple times here
      // still solved potential issues with flags
      if (lrat) {
        Clause *d = find_binary_clause (pivot, second);
        CADICAL_assert (d);
        for (auto &lit : *d) {
          if (lit == pivot || lit == second)
            continue;
          CADICAL_assert (val (lit) < 0);
          Flags &f = flags (lit);
          if (f.seen)
            continue;
          analyzed.push_back (lit);
          f.seen = true;
          int64_t id = unit_id (-lit);
          lrat_chain.push_back (id);
          // LOG ("gates added id %" PRId64, id);
        }
        for (auto &lit : *c) {
          if (lit == -pivot || lit == second)
            continue;
          CADICAL_assert (val (lit) < 0);
          Flags &f = flags (lit);
          if (f.seen)
            continue;
          analyzed.push_back (lit);
          f.seen = true;
          int64_t id = unit_id (-lit);
          lrat_chain.push_back (id);
          // LOG ("gates added id %" PRId64, id);
        }
        lrat_chain.push_back (c->id);
        lrat_chain.push_back (d->id);
        clear_analyzed_literals ();
        // LOG ("gates added id %" PRId64, c->id);
        // LOG ("gates added id %" PRId64, d->id);
      }
      assign_unit (second);
      elim_propagate (eliminator, second);
      if (val (pivot))
        break;
      if (unsat)
        break;
    }
    if (tmp >= 0)
      continue;
 
    LOG ("found equivalence %d = %d", pivot, -second);
    stats.elimequivs++;
    stats.elimgates++;
 
    LOG (c, "first gate clause");
    CADICAL_assert (!c->gate);
    c->gate = true;
    eliminator.gates.push_back (c);
 
    Clause *d = 0;
    const Occs &ps = occs (pivot);
    for (const auto &e : ps) {
      if (e->garbage)
        continue;
      const int other =
          second_literal_in_binary_clause (eliminator, e, pivot);
      if (other == -second) {
        d = e;
        break;
      }
    }
    CADICAL_assert (d);
 
    LOG (d, "second gate clause");
    CADICAL_assert (!d->gate);
    d->gate = true;
    eliminator.gates.push_back (d);
    eliminator.gatetype = EQUI;
 
    break;
  }
 
DONE:
  unmark_binary_literals (eliminator);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_gate_clauses()

void CaDiCaL::Internal::find_gate_clauses	(	Eliminator &	eliminator,
		int	pivot )

Definition at line 739 of file cadical_gates.cpp.

                                                                   {
  if (!opts.elimsubst)
    return;
 
  if (unsat)
    return;
  if (val (pivot))
    return;
 
  CADICAL_assert (eliminator.gates.empty ());
 
  find_equivalence (eliminator, pivot);
  find_and_gate (eliminator, pivot);
  find_and_gate (eliminator, -pivot);
  find_if_then_else (eliminator, pivot);
  find_xor_gate (eliminator, pivot);
  find_definition (eliminator, pivot);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_if_then_else()

void CaDiCaL::Internal::find_if_then_else	(	Eliminator &	eliminator,
		int	pivot )

Definition at line 505 of file cadical_gates.cpp.

                                                                   {
 
  if (!opts.elimites)
    return;
 
  CADICAL_assert (opts.elimsubst);
 
  if (unsat)
    return;
  if (val (pivot))
    return;
  if (!eliminator.gates.empty ())
    return;
 
  const Occs &os = occs (pivot);
  const auto end = os.end ();
  for (auto i = os.begin (); i != end; i++) {
    Clause *di = *i;
    int ai, bi, ci;
    if (!get_ternary_clause (di, ai, bi, ci))
      continue;
    if (bi == pivot)
      swap (ai, bi);
    if (ci == pivot)
      swap (ai, ci);
    CADICAL_assert (ai == pivot);
    for (auto j = i + 1; j != end; j++) {
      Clause *dj = *j;
      int aj, bj, cj;
      if (!get_ternary_clause (dj, aj, bj, cj))
        continue;
      if (bj == pivot)
        swap (aj, bj);
      if (cj == pivot)
        swap (aj, cj);
      CADICAL_assert (aj == pivot);
      if (abs (bi) == abs (cj))
        swap (bj, cj);
      if (abs (ci) == abs (cj))
        continue;
      if (bi != -bj)
        continue;
      Clause *d1 = find_ternary_clause (-pivot, bi, -ci);
      if (!d1)
        continue;
      Clause *d2 = find_ternary_clause (-pivot, bj, -cj);
      if (!d2)
        continue;
      LOG (di, "1st if-then-else");
      LOG (dj, "2nd if-then-else");
      LOG (d1, "3rd if-then-else");
      LOG (d2, "4th if-then-else");
      LOG ("found ITE gate %d == (%d ? %d : %d)", pivot, -bi, -ci, -cj);
      CADICAL_assert (!di->gate);
      CADICAL_assert (!dj->gate);
      CADICAL_assert (!d1->gate);
      CADICAL_assert (!d2->gate);
      di->gate = true;
      dj->gate = true;
      d1->gate = true;
      d2->gate = true;
      eliminator.gates.push_back (di);
      eliminator.gates.push_back (dj);
      eliminator.gates.push_back (d1);
      eliminator.gates.push_back (d2);
      stats.elimgates++;
      stats.elimites++;
      eliminator.gatetype = ITE;
      return;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_ternary_clause()

Clause * CaDiCaL::Internal::find_ternary_clause	(	int	a,
		int	b,
		int	c )

Definition at line 490 of file cadical_gates.cpp.

                                                          {
  if (occs (b).size () > occs (c).size ())
    swap (b, c);
  if (occs (a).size () > occs (b).size ())
    swap (a, b);
  for (auto d : occs (a))
    if (match_ternary_clause (d, a, b, c))
      return d;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_xor_gate()

void CaDiCaL::Internal::find_xor_gate	(	Eliminator &	eliminator,
		int	pivot )

Definition at line 636 of file cadical_gates.cpp.

                                                               {
 
  if (!opts.elimxors)
    return;
 
  CADICAL_assert (opts.elimsubst);
 
  if (unsat)
    return;
  if (val (pivot))
    return;
  if (!eliminator.gates.empty ())
    return;
 
  vector<int> lits;
 
  for (auto d : occs (pivot)) {
 
    if (!get_clause (d, lits))
      continue;
 
    const int size = lits.size (); // clause size
    const int arity = size - 1;    // arity of XOR
 
    if (size < 3)
      continue;
    if (arity > opts.elimxorlim)
      continue;
 
    CADICAL_assert (eliminator.gates.empty ());
 
    unsigned needed = (1u << arity) - 1; // additional clauses
    unsigned signs = 0;                  // literals to negate
 
    do {
      const unsigned prev = signs;
      while (parity (++signs))
        ;
      for (int j = 0; j < size; j++) {
        const unsigned bit = 1u << j;
        int lit = lits[j];
        if ((prev & bit) != (signs & bit))
          lits[j] = lit = -lit;
      }
      Clause *e = find_clause (lits);
      if (!e)
        break;
      eliminator.gates.push_back (e);
    } while (--needed);
 
    if (needed) {
      eliminator.gates.clear ();
      continue;
    }
 
    eliminator.gates.push_back (d);
    CADICAL_assert (eliminator.gates.size () == (1u << arity));
 
#ifdef LOGGING
    if (opts.log) {
      Logger::print_log_prefix (this);
      tout.magenta ();
      printf ("found arity %u XOR gate %d = ", arity, -pivot);
      bool first = true;
      for (const auto &lit : *d) {
        if (lit == pivot)
          continue;
        CADICAL_assert (lit != -pivot);
        if (!first)
          fputs (" ^ ", stdout);
        printf ("%d", lit);
        first = false;
      }
      fputc ('\n', stdout);
      tout.normal ();
      fflush (stdout);
    }
#endif
    stats.elimgates++;
    stats.elimxors++;
    const auto end = eliminator.gates.end ();
    auto j = eliminator.gates.begin ();
    for (auto i = j; i != end; i++) {
      Clause *e = *i;
      if (e->gate)
        continue;
      e->gate = true;
      LOG (e, "contributing");
      *j++ = e;
    }
    eliminator.gates.resize (j - eliminator.gates.begin ());
    eliminator.gatetype = XOR;
    break;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finish_added_clause_with_id()

void CaDiCaL::Internal::finish_added_clause_with_id	(	int64_t	id,
		bool	restore = false )

Definition at line 219 of file cadical_internal.cpp.

                                                                    {
  if (proof) {
    // Use the external form of the clause for printing in proof
    // Externalize(internalized literal) != external literal
    CADICAL_assert (!original.size () || !external->eclause.empty ());
    proof->add_external_original_clause (id, false, external->eclause,
                                         restore);
  }
  add_new_original_clause (id);
  original.clear ();
}

Here is the call graph for this function:

◆ first_factor()

size_t CaDiCaL::Internal::first_factor	(	Factoring &	factoring,
		int	factor )

Definition at line 184 of file cadical_factor.cpp.

                                                               {
  CADICAL_assert (!factoring.quotients.first);
  Quotient *quotient = new_quotient (factoring, factor);
  vector<Clause *> &qlauses = quotient->qlauses;
  int64_t ticks = 0;
  for (const auto &c : occs (factor)) {
    qlauses.push_back (c);
    ticks++;
  }
  size_t res = qlauses.size ();
  LOG ("quotient[0] factor %d size %zu", factor, res);
  // This invariant can of course be broken by previous factorings
  // CADICAL_assert (res > 1);
  stats.ticks.factor += ticks;
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fixed()

int CaDiCaL::Internal::fixed ( int lit )

inline

Definition at line 1542 of file internal.hpp.

                      {
    CADICAL_assert (-max_var <= lit);
    CADICAL_assert (lit);
    CADICAL_assert (lit <= max_var);
    const int idx = vidx (lit);
    int res = vals[idx];
    if (res && vtab[idx].level)
      res = 0;
    if (lit < 0)
      res = -res;
    return res;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flags() [1/2]

Flags & CaDiCaL::Internal::flags ( int lit )

inline

Definition at line 454 of file internal.hpp.

454{ return ftab[vidx (lit)]; }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flags() [2/2]

const Flags & CaDiCaL::Internal::flags ( int lit ) const

inline

Definition at line 459 of file internal.hpp.

459{ return ftab[vidx (lit)]; }

Here is the call graph for this function:

◆ flip()

bool CaDiCaL::Internal::flip ( int lit )

Definition at line 9 of file cadical_flip.cpp.

                            {
 
  // Do not try to flip inactive literals except for unused variables.
 
  if (!active (lit) && !flags (lit).unused ())
    return false;
 
  /*
  if (flags (lit).unused ()) {
    CADICAL_assert (lit <= max_var);
    mark_active (lit);
    set_val (lit, 1);
    return true;
  }
  */
 
  // TODO: Unused case is not handled yet.
  // if (flags (lit).unused ()) return false;
 
  // Need to reestablish proper watching invariants as if there are no
  // blocking literals as flipping in principle does not work with them.
 
  if (propergated < trail.size ())
    propergate ();
 
  LOG ("trying to flip %d", lit);
 
  const int idx = vidx (lit);
  const signed char original_value = vals[idx];
  CADICAL_assert (original_value);
  lit = original_value < 0 ? -idx : idx;
  CADICAL_assert (val (lit) > 0);
 
  // Here we go over all the clauses in which 'lit' is watched by 'lit' and
  // check whether assigning 'lit' to false would break watching invariants
  // or even make the clause false.  We also try to find replacement
  // watches in case this fixes the watching invariant.  This code is very
  // similar to propagation of a literal in 'Internal::propagate'.
 
  bool res = true;
 
  Watches &ws = watches (lit);
  const const_watch_iterator eow = ws.end ();
  watch_iterator bow = ws.begin ();
 
  // We first go over binary watches/clauses first as this is cheaper and
  // has higher chance of failure and we can not use blocking literals.
 
  for (const_watch_iterator i = bow; i != eow; i++) {
    const Watch w = *i;
    if (!w.binary ())
      continue;
    const signed char b = val (w.blit);
    if (b > 0)
      continue;
    CADICAL_assert (b < 0);
    res = false;
    break;
  }
 
  if (res) {
    const_watch_iterator i = bow;
    watch_iterator j = bow;
 
    while (i != eow) {
 
      const Watch w = *j++ = *i++;
 
      if (w.binary ())
        continue;
 
      if (w.clause->garbage) {
        j--;
        continue;
      }
 
      literal_iterator lits = w.clause->begin ();
 
      const int other = lits[0] ^ lits[1] ^ lit;
      const signed char u = val (other);
      if (u > 0)
        continue;
 
      const int size = w.clause->size;
      const literal_iterator middle = lits + w.clause->pos;
      const const_literal_iterator end = lits + size;
      literal_iterator k = middle;
 
      int r = 0;
      signed char v = -1;
      while (k != end && (v = val (r = *k)) < 0)
        k++;
      if (v < 0) {
        k = lits + 2;
        CADICAL_assert (w.clause->pos <= size);
        while (k != middle && (v = val (r = *k)) < 0)
          k++;
      }
 
      if (v < 0) {
        res = false;
        break;
      }
 
      CADICAL_assert (v > 0);
      CADICAL_assert (lits + 2 <= k), CADICAL_assert (k <= w.clause->end ());
      w.clause->pos = k - lits;
      lits[0] = other, lits[1] = r, *k = lit;
      watch_literal (r, lit, w.clause);
      j--;
    }
 
    if (j != i) {
 
      while (i != eow)
        *j++ = *i++;
 
      ws.resize (j - ws.begin ());
    }
  }
#ifdef LOGGING
  if (res)
    LOG ("literal %d can be flipped", lit);
  else
    LOG ("literal %d can not be flipped", lit);
#endif
 
  if (res) {
 
    const int idx = vidx (lit);
    const signed char original_value = vals[idx];
    CADICAL_assert (original_value);
    lit = original_value < 0 ? -idx : idx;
    CADICAL_assert (val (lit) > 0);
 
    LOG ("flipping value of %d = 1 to %d = -1", lit, lit);
 
    set_val (idx, -original_value);
    CADICAL_assert (val (-lit) > 0);
    CADICAL_assert (val (lit) < 0);
 
    Var &v = var (idx);
    CADICAL_assert (trail[v.trail] == lit);
    trail[v.trail] = -lit;
    if (opts.ilb) {
      if (!tainted_literal)
        tainted_literal = lit;
      else {
        CADICAL_assert (val (tainted_literal));
        if (v.level < var (tainted_literal).level) {
          tainted_literal = lit;
        }
      }
    }
  } else
    LOG ("flipping value of %d failed", lit);
 
  return res;
}

Here is the call graph for this function:

◆ flip_backbone_literals()

void CaDiCaL::Internal::flip_backbone_literals ( struct Sweeper & sweeper )

Definition at line 774 of file cadical_sweep.cpp.

                                                       {
  const unsigned max_rounds = opts.sweepfliprounds;
  if (!max_rounds)
    return;
  CADICAL_assert (sweeper.backbone.size ());
  if (cadical_kitten_status (citten) != 10)
    return;
#ifdef LOGGING
  unsigned total_flipped = 0;
#endif
  unsigned flipped, round = 0;
  do {
    round++;
    flipped = 0;
    bool refine = false;
    auto begin = sweeper.backbone.begin (), q = begin, p = q;
    const auto end = sweeper.backbone.end ();
    bool limit_hit = false;
    while (p != end) {
      const int lit = *p++;
      stats.sweep_flip_backbone++;
      if (limit_hit || terminated_asynchronously ()) {
        break;
      } else if (sweep_flip (lit)) {
        LOG ("flipping backbone candidate %d succeeded", lit);
#ifdef LOGGING
        total_flipped++;
#endif
        stats.sweep_flipped_backbone++;
        flipped++;
      } else {
        LOG ("flipping backbone candidate %d failed", lit);
        *q++ = lit;
      }
    }
    while (p != end)
      *q++ = *p++;
    sweeper.backbone.resize (q - sweeper.backbone.begin ());
    LOG ("flipped %u backbone candidates in round %u", flipped, round);
 
    if (limit_hit)
      break;
    if (terminated_asynchronously ())
      break;
    if (cadical_kitten_ticks_limit_hit (sweeper, "backbone flipping"))
      break;
    if (refine)
      sweep_refine (sweeper);
  } while (flipped && round < max_rounds);
  LOG ("flipped %u backbone candidates in total in %u rounds",
       total_flipped, round);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flip_partition_literals()

void CaDiCaL::Internal::flip_partition_literals ( struct Sweeper & sweeper )

Definition at line 1273 of file cadical_sweep.cpp.

                                                        {
  const unsigned max_rounds = opts.sweepfliprounds;
  if (!max_rounds)
    return;
  CADICAL_assert (sweeper.partition.size ());
  if (cadical_kitten_status (citten) != 10)
    return;
#ifdef LOGGING
  unsigned total_flipped = 0;
#endif
  unsigned flipped, round = 0;
  do {
    round++;
    flipped = 0;
    bool refine = false;
    bool limit_hit = false;
    auto begin = sweeper.partition.begin (), dst = begin, src = dst;
    const auto end = sweeper.partition.end ();
    while (src != end) {
      auto end_src = src;
      while (CADICAL_assert (end_src != end), *end_src != 0)
        end_src++;
      unsigned size = end_src - src;
      CADICAL_assert (size > 1);
      auto q = dst;
      for (auto p = src; p != end_src; p++) {
        const int lit = *p;
        if (limit_hit) {
          *q++ = lit;
          continue;
        } else if (cadical_kitten_ticks_limit_hit (sweeper, "partition flipping")) {
          *q++ = lit;
          limit_hit = true;
          continue;
        } else if (sweep_flip (lit)) {
          LOG ("flipping equivalence candidate %d succeeded", lit);
#ifdef LOGGING
          total_flipped++;
#endif
          flipped++;
          if (--size < 2)
            break;
        } else {
          LOG ("flipping equivalence candidate %d failed", lit);
          *q++ = lit;
        }
        stats.sweep_flip_equivalences++;
      }
      if (size > 1) {
        *q++ = 0;
        dst = q;
      }
      src = end_src + 1;
    }
    stats.sweep_flipped_equivalences += flipped;
    sweeper.partition.resize (dst - sweeper.partition.begin ());
    LOG ("flipped %u equivalence candidates in round %u", flipped, round);
    if (terminated_asynchronously ())
      break;
    if (cadical_kitten_ticks_limit_hit (sweeper, "partition flipping"))
      break;
    if (refine)
      sweep_refine (sweeper);
  } while (flipped && round < max_rounds);
  LOG ("flipped %u equivalence candidates in total in %u rounds",
       total_flipped, round);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flippable()

bool CaDiCaL::Internal::flippable ( int lit )

Definition at line 169 of file cadical_flip.cpp.

                                 {
 
  // Can not check inactive literals except for unused variables.
 
  if (!active (lit) && !flags (lit).unused ())
    return false;
 
  /*
  if (flags (lit).unused ()) {
    CADICAL_assert (lit <= max_var);
    mark_active (lit);
    return true;
  }
  */
  // TODO: Unused case is not handled yet
  // if (flags (lit).unused ()) return false;
 
  // Need to reestablish proper watching invariants as if there are no
  // blocking literals as flipping in principle does not work with them.
 
  if (propergated < trail.size ())
    propergate ();
 
  LOG ("checking whether %d is flippable", lit);
 
  const int idx = vidx (lit);
  const signed char original_value = vals[idx];
  CADICAL_assert (original_value);
  lit = original_value < 0 ? -idx : idx;
  CADICAL_assert (val (lit) > 0);
 
  // Here we go over all the clauses in which 'lit' is watched by 'lit' and
  // check whether assigning 'lit' to false would break watching invariants
  // or even make the clause false.  In contrast to 'flip' we do not try to
  // find replacement literals but do use blocking literals'.  Therefore we
  // also do not split the traversal code into two parts.
 
  bool res = true;
 
  Watches &ws = watches (lit);
  const const_watch_iterator eow = ws.end ();
  for (watch_iterator i = ws.begin (); i != eow; i++) {
 
    const Watch w = *i;
    const signed char b = val (w.blit);
    if (b > 0)
      continue;
    CADICAL_assert (b < 0);
 
    if (w.binary ()) {
      res = false;
      break;
    }
 
    if (w.clause->garbage)
      continue;
 
    literal_iterator lits = w.clause->begin ();
 
    const int other = lits[0] ^ lits[1] ^ lit;
    const signed char u = val (other);
    if (u > 0) {
      i->blit = other;
      continue;
    }
 
    const int size = w.clause->size;
    const literal_iterator middle = lits + w.clause->pos;
    const const_literal_iterator end = lits + size;
    literal_iterator k = middle;
 
    int r = 0;
    signed char v = -1;
    while (k != end && (v = val (r = *k)) < 0)
      k++;
    if (v < 0) {
      k = lits + 2;
      CADICAL_assert (w.clause->pos <= size);
      while (k != middle && (v = val (r = *k)) < 0)
        k++;
    }
 
    if (v < 0) {
      res = false;
      break;
    }
 
    CADICAL_assert (v > 0);
    CADICAL_assert (lits + 2 <= k);
    CADICAL_assert (k <= w.clause->end ());
    w.clause->pos = k - lits;
    i->blit = r;
  }
 
#ifdef LOGGING
  if (res)
    LOG ("literal %d can be flipped", lit);
  else
    LOG ("literal %d can not be flipped", lit);
#endif
 
  return res;
}

Here is the call graph for this function:

◆ flush_all_occs_and_watches()

void CaDiCaL::Internal::flush_all_occs_and_watches ( )

Definition at line 232 of file cadical_collect.cpp.

                                           {
  if (occurring ())
    for (auto idx : vars)
      flush_occs (idx), flush_occs (-idx);
 
  if (watching ()) {
    Watches tmp;
    for (auto idx : vars)
      flush_watches (idx, tmp), flush_watches (-idx, tmp);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flush_elimfast_occs()

int64_t CaDiCaL::Internal::flush_elimfast_occs ( int lit )

Definition at line 19 of file cadical_elimfast.cpp.

                                              {
  const int64_t occslim = opts.fastelimbound;
  const int64_t clslim = opts.fastelimocclim;
  const int64_t failed = occslim + 1;
  Occs &os = occs (lit);
  const const_occs_iterator end = os.end ();
  occs_iterator j = os.begin (), i = j;
  int64_t res = 0;
  while (i != end) {
    Clause *c = *i++;
    if (c->collect ())
      continue;
    *j++ = c;
    if (c->size > clslim) {
      res = failed;
      break;
    }
    if (++res > occslim) {
      CADICAL_assert (opts.fastelimbound < 0 || res == failed);
      break;
    }
  }
  if (i != j) {
    while (i != end)
      *j++ = *i++;
    os.resize (j - os.begin ());
    shrink_occs (os);
  }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flush_occs()

size_t CaDiCaL::Internal::flush_occs ( int lit )

Definition at line 176 of file cadical_collect.cpp.

                                    {
  Occs &os = occs (lit);
  const const_occs_iterator end = os.end ();
  occs_iterator j = os.begin ();
  const_occs_iterator i;
  size_t res = 0;
  Clause *c;
  for (i = j; i != end; i++) {
    c = *i;
    if (c->collect ())
      continue;
    *j++ = c->moved ? c->copy : c;
    // CADICAL_assert (!c->redundant); // -> not true in sweeping
    res++;
  }
  os.resize (j - os.begin ());
  shrink_occs (os);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flush_probes()

void CaDiCaL::Internal::flush_probes ( )

Definition at line 702 of file cadical_probe.cpp.

                             {
 
  CADICAL_assert (!probes.empty ());
  int64_t &ticks = stats.ticks.probe;
 
  init_noccs ();
  ticks += 1 + cache_lines (clauses.size (), sizeof (Clause *));
  for (const auto &c : clauses) {
    int a, b;
    ticks++;
    if (!is_binary_clause (c, a, b))
      continue;
    noccs (a)++;
    noccs (b)++;
  }
 
  const auto eop = probes.end ();
  auto j = probes.begin ();
  for (auto i = j; i != eop; i++) {
    int lit = *i;
    if (!active (lit))
      continue;
    ticks += 2;
    const bool have_pos_bin_occs = noccs (lit) > 0;
    const bool have_neg_bin_occs = noccs (-lit) > 0;
    if (have_pos_bin_occs == have_neg_bin_occs)
      continue;
    if (have_pos_bin_occs)
      lit = -lit;
    CADICAL_assert (!noccs (lit)), CADICAL_assert (noccs (-lit) > 0);
    if (propfixed (lit) >= stats.all.fixed)
      continue;
    LOG ("keeping probe %d negated occs %" PRId64 "", lit, noccs (-lit));
    *j++ = lit;
  }
  size_t remain = j - probes.begin ();
#ifndef CADICAL_QUIET
  size_t flushed = probes.size () - remain;
#endif
  probes.resize (remain);
 
  rsort (probes.begin (), probes.end (), probe_negated_noccs_rank (this));
 
  reset_noccs ();
  shrink_vector (probes);
 
  PHASE ("probe-round", stats.probingrounds,
         "flushed %zd literals %.0f%% remaining %zd", flushed,
         percent (flushed, remain + flushed), remain);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flush_trace()

void CaDiCaL::Internal::flush_trace ( bool stats = false )

Definition at line 195 of file cadical_proof.cpp.

                                      {
  for (auto &tracer : file_tracers)
    tracer->flush (print);
}

◆ flush_unmatched_clauses()

void CaDiCaL::Internal::flush_unmatched_clauses ( Quotient * q )

Definition at line 479 of file cadical_factor.cpp.

                                                   {
  Quotient *prev = q->prev;
  vector<size_t> &q_matches = q->matches, &prev_matches = prev->matches;
  vector<Clause *> &q_clauses = q->qlauses, &prev_clauses = prev->qlauses;
  const size_t n = q_clauses.size ();
  CADICAL_assert (n == q_matches.size ());
  bool prev_is_first = !prev->id;
  size_t i = 0;
  while (i < q_matches.size ()) {
    size_t j = q_matches[i];
    q_matches[i] = i;
    CADICAL_assert (i <= j);
    if (!prev_is_first) {
      size_t matches = prev_matches[j];
      prev_matches[i] = matches;
    }
    Clause *c = prev_clauses[j];
    prev_clauses[i] = c;
    i++;
  }
  LOG ("flushing %zu clauses of quotient[%zu]", prev_clauses.size () - n,
       prev->id);
  if (!prev_is_first)
    prev_matches.resize (n);
  prev_clauses.resize (n);
}

Here is the caller graph for this function:

◆ flush_vivification_schedule()

void CaDiCaL::Internal::flush_vivification_schedule	(	std::vector< Clause * > &	schedule,
		int64_t &	ticks )

Definition at line 456 of file cadical_vivify.cpp.

                                                            {
  ticks += 1 + 3 * cache_lines (schedule.size (), sizeof (Clause *));
  stable_sort (schedule.begin (), schedule.end (), vivify_flush_smaller ());
 
  const auto end = schedule.end ();
  auto j = schedule.begin (), i = j;
 
  Clause *prev = 0;
  int64_t subsumed = 0;
  for (; i != end; i++) {
    ticks++;
    Clause *c = *j++ = *i;
    if (!prev || c->size < prev->size) {
      prev = c;
      continue;
    }
    const auto eop = prev->end ();
    auto k = prev->begin ();
    for (auto l = c->begin (); k != eop; k++, l++)
      if (*k != *l)
        break;
    if (k == eop) {
      LOG (c, "found subsumed");
      LOG (prev, "subsuming");
      CADICAL_assert (!c->garbage);
      CADICAL_assert (!prev->garbage);
      CADICAL_assert (c->redundant || !prev->redundant);
      mark_garbage (c);
      subsumed++;
      j--;
    } else
      prev = c;
  }
 
  if (subsumed)
    PHASE ("vivify", stats.vivifications,
           "flushed %" PRId64 " subsumed scheduled clauses", subsumed);
 
  stats.vivifysubs += subsumed;
 
  if (subsumed) {
    schedule.resize (j - schedule.begin ());
    shrink_vector (schedule);
  } else
    CADICAL_assert (j == end);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flush_watches()

void CaDiCaL::Internal::flush_watches	(	int	lit,
		Watches &	saved )

inline

Definition at line 202 of file cadical_collect.cpp.

                                                            {
  CADICAL_assert (saved.empty ());
  Watches &ws = watches (lit);
  const const_watch_iterator end = ws.end ();
  watch_iterator j = ws.begin ();
  const_watch_iterator i;
  for (i = j; i != end; i++) {
    Watch w = *i;
    Clause *c = w.clause;
    if (c->collect ())
      continue;
    if (c->moved)
      c = w.clause = c->copy;
    w.size = c->size;
    const int new_blit_pos = (c->literals[0] == lit);
    LOG (c, "clause in flush_watch starting from %d", lit);
    CADICAL_assert (c->literals[!new_blit_pos] == lit); /*FW1*/
    w.blit = c->literals[new_blit_pos];
    if (w.binary ())
      *j++ = w;
    else
      saved.push_back (w);
  }
  ws.resize (j - ws.begin ());
  for (const auto &w : saved)
    ws.push_back (w);
  saved.clear ();
  shrink_vector (ws);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flushing()

bool CaDiCaL::Internal::flushing ( )

Definition at line 30 of file cadical_reduce.cpp.

                         {
  if (!opts.flush)
    return false;
  return stats.conflicts >= lim.flush;
}

Here is the caller graph for this function:

◆ force_backtrack()

void CaDiCaL::Internal::force_backtrack ( size_t new_level )

Definition at line 214 of file cadical_external_propagate.cpp.

                                                {
  if (!forced_backt_allowed || level <= 0 || new_level >= (size_t) level)
    return;
 
#ifndef CADICAL_NDEBUG
  LOG ("external propagator forces backtrack to decision level"
       "%zd (from level %d)",
       new_level, level);
#endif
  backtrack (new_level);
}

Here is the call graph for this function:

◆ force_lrat()

void CaDiCaL::Internal::force_lrat ( )

Definition at line 27 of file cadical_proof.cpp.

                           {
  if (lrat)
    return;
  CADICAL_assert (proof);
  lrat = true;
}

Here is the caller graph for this function:

◆ forward_false_satisfiable()

int CaDiCaL::Internal::forward_false_satisfiable ( )

Definition at line 154 of file cadical_lucky.cpp.

                                         {
  LOG ("checking increasing variable index false assignment");
  CADICAL_assert (!unsat);
  CADICAL_assert (!level);
  CADICAL_assert (assumptions.empty ());
  for (auto idx : vars) {
  START:
    if (terminated_asynchronously (100))
      return unlucky (-1);
    if (val (idx))
      continue;
    if (lucky_propagate_discrepency (-idx)) {
      if (unsat)
        return 20;
      else
        return unlucky (0);
    } else
      goto START;
  }
  VERBOSE (1, "forward assuming variables false satisfies formula");
  CADICAL_assert (satisfied ());
  stats.lucky.forward.zero++;
  return 10;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ forward_true_satisfiable()

int CaDiCaL::Internal::forward_true_satisfiable ( )

Definition at line 179 of file cadical_lucky.cpp.

                                        {
  LOG ("checking increasing variable index true assignment");
  CADICAL_assert (!unsat);
  CADICAL_assert (!level);
  CADICAL_assert (assumptions.empty ());
  for (auto idx : vars) {
  START:
    if (terminated_asynchronously (10))
      return unlucky (-1);
    if (val (idx))
      continue;
    if (lucky_propagate_discrepency (idx)) {
      if (unsat)
        return 20;
      else
        return unlucky (0);
    } else
      goto START;
  }
  VERBOSE (1, "forward assuming variables true satisfies formula");
  CADICAL_assert (satisfied ());
  stats.lucky.forward.one++;
  return 10;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ freeze()

void CaDiCaL::Internal::freeze ( int lit )

inline

Definition at line 1570 of file internal.hpp.

                        {
    int idx = vidx (lit);
    if ((size_t) idx >= frozentab.size ()) {
      size_t new_vsize = vsize ? 2 * vsize : 1 + (size_t) max_var;
      while (new_vsize <= (size_t) max_var)
        new_vsize *= 2;
      frozentab.resize (new_vsize);
    }
    unsigned &ref = frozentab[idx];
    if (ref < UINT_MAX) {
      ref++;
      LOG ("variable %d frozen %u times", idx, ref);
    } else
      LOG ("variable %d remains frozen forever", idx);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ frozen()

bool CaDiCaL::Internal::frozen ( int lit )

inline

Definition at line 1602 of file internal.hpp.

                        {
    return (size_t) vidx (lit) < frozentab.size () &&
           frozentab[vidx (lit)] > 0;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ garbage_collection()

void CaDiCaL::Internal::garbage_collection ( )

Definition at line 529 of file cadical_collect.cpp.

                                   {
  if (unsat)
    return;
  START (collect);
  report ('G', 1);
  stats.collections++;
  mark_satisfied_clauses_as_garbage ();
  if (!protected_reasons)
    protect_reasons ();
  if (arenaing ())
    copy_non_garbage_clauses ();
  else
    delete_garbage_clauses ();
  check_clause_stats ();
  check_var_stats ();
  unprotect_reasons ();
  report ('C', 1);
  STOP (collect);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_cubes()

CubesWithStatus CaDiCaL::Internal::generate_cubes	(	int	depth,
		int	min_depth )

Definition at line 408 of file cadical_lookahead.cpp.

                                                                  {
  if (!active () || depth == 0) {
    CubesWithStatus cubes;
    cubes.status = 0;
    cubes.cubes.push_back (std::vector<int> ());
    return cubes;
  }
 
  lookingahead = true;
  START (lookahead);
  MSG ("Generating cubes of depth %i", depth);
 
  // presimplify required due to assumptions
 
  termination_forced = false;
  int res = already_solved ();
  if (res == 0)
    res = restore_clauses ();
  if (unsat)
    res = 10;
  if (res != 0)
    res = solve (true);
  if (res != 0) {
    MSG ("Solved during preprocessing");
    CubesWithStatus cubes;
    cubes.status = res;
    lookingahead = false;
    STOP (lookahead);
    return cubes;
  }
 
  reset_limits ();
  MSG ("generate cubes with %zu assumptions\n", assumptions.size ());
 
  CADICAL_assert (ntab.empty ());
  std::vector<int> current_assumptions{assumptions};
  std::vector<std::vector<int>> cubes{{assumptions}};
  auto loccs{lookahead_populate_locc ()};
  LOG ("loccs populated\n");
  CADICAL_assert (ntab.empty ());
 
  for (int i = 0; i < depth; ++i) {
    LOG ("Probing at depth %i, currently %zu have been generated", i,
         cubes.size ());
    std::vector<std::vector<int>> cubes2{std::move (cubes)};
    cubes.clear ();
 
    for (size_t j = 0; j < cubes2.size (); ++j) {
      CADICAL_assert (ntab.empty ());
      CADICAL_assert (!unsat);
      reset_assumptions ();
      for (auto lit : cubes2[j])
        assume (lit);
      restore_clauses ();
      propagate ();
      // preprocess_round(0); //uncomment maybe
 
      if (unsat) {
        LOG ("current cube is unsat; skipping");
        unsat = false;
        continue;
      }
 
      int res = terminating_asked () ? lookahead_locc (loccs)
                                     : lookahead_probing ();
      if (unsat) {
        LOG ("current cube is unsat; skipping");
        unsat = false;
        continue;
      }
 
      if (res == 0) {
        LOG ("no lit to split %i", res);
        cubes.push_back (cubes2[j]);
        continue;
      }
 
      CADICAL_assert (res != 0);
      LOG ("splitting on lit %i", res);
      std::vector<int> cube1{cubes2[j]};
      cube1.push_back (res);
      std::vector<int> cube2{std::move (cubes2[j])};
      cube2.push_back (-res);
      cubes.push_back (cube1);
      cubes.push_back (cube2);
    }
 
    if (terminating_asked () && i >= min_depth)
      break;
  }
 
  CADICAL_assert (std::for_each (
      std::begin (cubes), std::end (cubes),
      [] (std::vector<int> cube) { return non_tautological_cube (cube); }));
  reset_assumptions ();
 
  for (auto lit : current_assumptions)
    assume (lit);
 
  STOP (lookahead);
  lookingahead = false;
 
  if (unsat) {
    LOG ("Solved during preprocessing");
    CubesWithStatus cubes;
    cubes.status = 20;
    return cubes;
  }
 
  CubesWithStatus rcubes;
  rcubes.status = 0;
  rcubes.cubes = cubes;
 
  return rcubes;
}

Here is the call graph for this function:

◆ generate_probes()

void CaDiCaL::Internal::generate_probes ( )

Definition at line 637 of file cadical_probe.cpp.

                                {
 
  CADICAL_assert (probes.empty ());
 
  int64_t &ticks = stats.ticks.probe;
 
  // First determine all the literals which occur in binary clauses. It is
  // way faster to go over the clauses once, instead of walking the watch
  // lists for each literal.
  //
  init_noccs ();
  ticks += 1 + cache_lines (clauses.size (), sizeof (Clause *));
  for (const auto &c : clauses) {
    int a, b;
    ticks++;
    if (!is_binary_clause (c, a, b))
      continue;
    noccs (a)++;
    noccs (b)++;
  }
 
  for (auto idx : vars) {
 
    // Then focus on roots of the binary implication graph, which are
    // literals occurring negatively in a binary clause, but not positively.
    // If neither 'idx' nor '-idx' is a root it makes less sense to probe
    // this variable.
 
    // This argument requires that equivalent literal substitution through
    // 'decompose' is performed, because otherwise there might be 'cyclic
    // roots' which are not tried, i.e., -1 2 0, 1 -2 0, 1 2 3 0, 1 2 -3 0.
 
    ticks += 2;
 
    const bool have_pos_bin_occs = noccs (idx) > 0;
    const bool have_neg_bin_occs = noccs (-idx) > 0;
 
    if (have_pos_bin_occs == have_neg_bin_occs)
      continue;
 
    int probe = have_neg_bin_occs ? idx : -idx;
 
    // See the discussion where 'propfixed' is used below.
    //
    if (propfixed (probe) >= stats.all.fixed)
      continue;
 
    LOG ("scheduling probe %d negated occs %" PRId64 "", probe,
         noccs (-probe));
    probes.push_back (probe);
  }
 
  rsort (probes.begin (), probes.end (), probe_negated_noccs_rank (this));
 
  reset_noccs ();
  shrink_vector (probes);
 
  PHASE ("probe-round", stats.probingrounds,
         "scheduled %zd literals %.0f%%", probes.size (),
         percent (probes.size (), 2u * max_var));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_clause()

bool CaDiCaL::Internal::get_clause	(	Clause *	c,
		vector< int > &	l )

Definition at line 582 of file cadical_gates.cpp.

                                                    {
  if (c->garbage)
    return false;
  l.clear ();
  for (const auto &lit : *c) {
    if (val (lit) < 0)
      continue;
    if (val (lit) > 0) {
      l.clear ();
      return false;
    }
    l.push_back (lit);
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_new_extension_variable()

int CaDiCaL::Internal::get_new_extension_variable ( )

Definition at line 845 of file cadical_factor.cpp.

                                          {
  const int current_max_external = external->max_var;
  const int new_external = current_max_external + 1;
  const int new_internal = external->internalize (new_external, true);
  // one sideeffect of internalize is enlarging the internal datastructures
  // which can initialize the watches (wtab)
  if (watching ())
    reset_watches ();
  // it does not enlarge otab, however, so we do this manually
  init_occs ();
  CADICAL_assert (vlit (new_internal));
  return new_internal;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_parent_reason_literal()

int CaDiCaL::Internal::get_parent_reason_literal ( int lit )

inline

Definition at line 34 of file cadical_probe.cpp.

                                                       {
  const int idx = vidx (lit);
  int res = parents[idx];
  if (lit < 0)
    res = -res;
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_probehbr_lrat()

void CaDiCaL::Internal::get_probehbr_lrat	(	int	lit,
		int	uip )

Definition at line 90 of file cadical_probe.cpp.

                                                  {
  if (!lrat || opts.probehbr)
    return;
  CADICAL_assert (lit);
  CADICAL_assert (lrat_chain.empty ());
  CADICAL_assert (val (uip) < 0);
  lrat_chain = probehbr_chains[vlit (lit)][vlit (uip)];
  int64_t id = unit_id (-uip);
  lrat_chain.push_back (id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_ternary_clause()

bool CaDiCaL::Internal::get_ternary_clause	(	Clause *	d,
		int &	a,
		int &	b,
		int &	c )

Definition at line 452 of file cadical_gates.cpp.

                                                                    {
  if (d->garbage)
    return false;
  if (d->size < 3)
    return false;
  int found = 0;
  a = b = c = 0;
  for (const auto &lit : *d) {
    if (val (lit))
      continue;
    if (++found == 1)
      a = lit;
    else if (found == 2)
      b = lit;
    else if (found == 3)
      c = lit;
    else
      return false;
  }
  return found == 3;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getbit()

bool CaDiCaL::Internal::getbit	(	int	lit,
		int	bit ) const

inline

Definition at line 536 of file internal.hpp.

                                       {
    CADICAL_assert (0 <= bit), CADICAL_assert (bit < 6);
    return marks[vidx (lit)] & (1 << bit);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getfact()

bool CaDiCaL::Internal::getfact	(	int	lit,
		int	fact ) const

inline

Definition at line 568 of file internal.hpp.

                                         {
    CADICAL_assert (fact == 1 || fact == 2 || fact == 4);
    int res = marks[vidx (lit)];
    if (lit < 0) {
      res >>= 3;
    } else {
      res &= 7;
    }
    // CADICAL_assert (!res || res == 1 || res == 2 || res == 4);
    return res & fact;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_external_clause()

void CaDiCaL::Internal::handle_external_clause ( Clause * res )

Definition at line 744 of file cadical_external_propagate.cpp.

                                                  {
  if (from_propagator)
    stats.ext_prop.elearned++;
  // at level 0 we have to do nothing...
  if (!level)
    return;
  if (!res) {
    if (from_propagator)
      stats.ext_prop.elearn_prop++;
    // new unit clause. For now just backtrack.
    CADICAL_assert (!force_no_backtrack);
    CADICAL_assert (level);
    // if (!opts.chrono) {
    backtrack ();
    // }
    return;
  }
  if (from_propagator)
    stats.ext_prop.elearned++;
  CADICAL_assert (res->size >= 2);
  const int pos0 = res->literals[0];
  const int pos1 = res->literals[1];
  if (force_no_backtrack) {
    CADICAL_assert (val (pos1) < 0);
    CADICAL_assert (val (pos0) >= 0);
    return;
    // TODO: maybe fix levels
  }
  const int l1 = var (pos1).level;
  if (val (pos0) < 0) { // conflicting or propagating clause
    CADICAL_assert (0 < l1 && l1 <= var (pos0).level);
    if (!opts.chrono) {
      backtrack (l1);
    }
    if (val (pos0) < 0) {
      conflict = res;
      if (!from_propagator) {
        // its better to backtrack instead of analyze
        backtrack (l1 - 1);
        conflict = 0;
        CADICAL_assert (!val (pos0) && !val (pos1));
      }
    } else {
      search_assign_driving (pos0, res);
    }
    if (from_propagator)
      stats.ext_prop.elearn_conf++;
    return;
  }
  if (val (pos1) < 0 && !val (pos0)) { // propagating clause
    if (!opts.chrono) {
      backtrack (l1);
    }
    search_assign_driving (pos0, res);
    if (from_propagator)
      stats.ext_prop.elearn_conf++;
    return;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hyper_binary_resolve()

int CaDiCaL::Internal::hyper_binary_resolve ( Clause * reason )

inline

Definition at line 222 of file cadical_probe.cpp.

                                                         {
  require_mode (PROBE);
  CADICAL_assert (level == 1);
  CADICAL_assert (reason->size > 2);
  const const_literal_iterator end = reason->end ();
  const int *lits = reason->literals;
  const_literal_iterator k;
#ifndef CADICAL_NDEBUG
  // First literal unassigned, all others false.
  CADICAL_assert (!val (lits[0]));
  for (k = lits + 1; k != end; k++)
    CADICAL_assert (val (*k) < 0);
  CADICAL_assert (var (lits[1]).level == 1);
#endif
  LOG (reason, "hyper binary resolving");
  stats.hbrs++;
  stats.hbrsizes += reason->size;
  const int lit = lits[1];
  int dom = -lit, non_root_level_literals = 0;
  for (k = lits + 2; k != end; k++) {
    const int other = -*k;
    CADICAL_assert (val (other) > 0);
    if (!var (other).level)
      continue;
    dom = probe_dominator (dom, other);
    non_root_level_literals++;
  }
  probe_reason = reason;
  if (non_root_level_literals && opts.probehbr) { // !(A)
    bool contained = false;
    for (k = lits + 1; !contained && k != end; k++)
      contained = (*k == -dom);
    const bool red = !contained || reason->redundant;
    if (red)
      stats.hbreds++;
    LOG ("new %s hyper binary resolvent %d %d",
         (red ? "redundant" : "irredundant"), -dom, lits[0]);
    CADICAL_assert (clause.empty ());
    clause.push_back (-dom);
    clause.push_back (lits[0]);
    probe_dominator_lrat (dom, reason);
    if (lrat)
      clear_analyzed_literals ();
    Clause *c = new_hyper_binary_resolved_clause (red, 2);
    probe_reason = c;
    if (red)
      c->hyper = true;
    clause.clear ();
    lrat_chain.clear ();
    if (contained) {
      stats.hbrsubs++;
      LOG (reason, "subsumed original");
      mark_garbage (reason);
    }
  } else if (non_root_level_literals && lrat) {
    // still calculate LRAT and remember for later
    CADICAL_assert (!opts.probehbr);
    probe_dominator_lrat (dom, reason);
    clear_analyzed_literals ();
    set_probehbr_lrat (dom, lits[0]);
  }
  return dom;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hyper_ternary_resolve()

bool CaDiCaL::Internal::hyper_ternary_resolve	(	Clause *	c,
		int	pivot,
		Clause *	d )

Definition at line 113 of file cadical_ternary.cpp.

                                                                     {
  LOG ("hyper binary resolving on pivot %d", pivot);
  LOG (c, "1st antecedent");
  LOG (d, "2nd antecedent");
  stats.ternres++;
  CADICAL_assert (c->size == 3);
  CADICAL_assert (d->size == 3);
  CADICAL_assert (clause.empty ());
  for (const auto &lit : *c)
    if (lit != pivot)
      clause.push_back (lit);
  for (const auto &lit : *d) {
    if (lit == -pivot)
      continue;
    if (lit == clause[0])
      continue;
    if (lit == -clause[0])
      return false;
    if (lit == clause[1])
      continue;
    if (lit == -clause[1])
      return false;
    clause.push_back (lit);
  }
  size_t size = clause.size ();
  if (size > 3)
    return false;
  if (size == 2 && ternary_find_binary_clause (clause[0], clause[1]))
    return false;
  if (size == 3 &&
      ternary_find_ternary_clause (clause[0], clause[1], clause[2]))
    return false;
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ implied()

void CaDiCaL::Internal::implied ( std::vector< int > & entrailed )

Definition at line 418 of file cadical_internal.cpp.

                                                 {
  int last_assumption_level = assumptions.size ();
  if (constraint.size ())
    last_assumption_level++;
  
  size_t trail_limit = trail.size();
  if (level > last_assumption_level) 
    trail_limit = control[last_assumption_level + 1].trail;
 
  for (size_t i = 0; i < trail_limit; i++)
    entrailed.push_back (trail[i]);
}

Here is the caller graph for this function:

◆ in_mode()

bool CaDiCaL::Internal::in_mode ( Mode m ) const

inline

Definition at line 164 of file internal.hpp.

164{ return (mode & m) != 0; }

◆ incomplete_variables()

unsigned CaDiCaL::Internal::incomplete_variables ( )

Definition at line 1793 of file cadical_sweep.cpp.

                                         {
  unsigned res = 0;
  for (const auto &idx : vars) {
    Flags &f = flags (idx);
    if (!f.active ())
      continue;
    if (f.sweep)
      res++;
  }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ increase_elimination_bound()

void CaDiCaL::Internal::increase_elimination_bound ( )

Definition at line 966 of file cadical_elim.cpp.

                                           {
 
  if (lim.elimbound >= opts.elimboundmax)
    return;
 
  if (lim.elimbound < 0)
    lim.elimbound = 0;
  else if (!lim.elimbound)
    lim.elimbound = 1;
  else
    lim.elimbound *= 2;
 
  if (lim.elimbound > opts.elimboundmax)
    lim.elimbound = opts.elimboundmax;
 
  PHASE ("elim-phase", stats.elimphases,
         "new elimination bound %" PRId64 "", lim.elimbound);
 
  // Now reschedule all active variables for elimination again.
  //
#ifdef LOGGING
  int count = 0;
#endif
  for (auto idx : vars) {
    if (!active (idx))
      continue;
    if (flags (idx).elim)
      continue;
    mark_elim (idx);
#ifdef LOGGING
    count++;
#endif
  }
  LOG ("marked %d variables as elimination candidates", count);
 
  report ('^');
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ineliminating()

bool CaDiCaL::Internal::ineliminating ( )

Definition at line 65 of file cadical_elim.cpp.

                              {
 
  if (!opts.elim)
    return false;
  if (!preprocessing && !opts.inprocessing)
    return false;
  if (preprocessing)
    CADICAL_assert (lim.preprocessing);
 
  // Respect (increasing) conflict limit.
  //
  if (lim.elim >= stats.conflicts)
    return false;
 
  // Wait until there are new units or new removed variables
  // (in removed or shrunken irredundant clauses and thus marked).
  //
  if (last.elim.fixed < stats.all.fixed)
    return true;
  if (last.elim.marked < stats.mark.elim)
    return true;
 
  // VERBOSE (3, "elim not scheduled due to fixpoint");
  return false;
}

Here is the caller graph for this function:

◆ init_averages()

void CaDiCaL::Internal::init_averages ( )

Definition at line 9 of file cadical_averages.cpp.

                              {
 
  LOG ("initializing averages");
 
  INIT_EMA (averages.current.jump, opts.emajump);
  INIT_EMA (averages.current.level, opts.emalevel);
  INIT_EMA (averages.current.size, opts.emasize);
 
  INIT_EMA (averages.current.glue.fast, opts.emagluefast);
  INIT_EMA (averages.current.glue.slow, opts.emaglueslow);
 
  INIT_EMA (averages.current.decisions, opts.emadecisions);
 
  INIT_EMA (averages.current.trail.fast, opts.ematrailfast);
  INIT_EMA (averages.current.trail.slow, opts.ematrailslow);
 
  CADICAL_assert (!averages.swapped);
}

Here is the caller graph for this function:

◆ init_backbone_and_partition()

void CaDiCaL::Internal::init_backbone_and_partition ( Sweeper & sweeper )

Definition at line 632 of file cadical_sweep.cpp.

                                                            {
  LOG ("initializing backbone and equivalent literals candidates");
  sweeper.backbone.clear ();
  sweeper.partition.clear ();
  for (const auto &idx : sweeper.vars) {
    if (!active (idx))
      continue;
    CADICAL_assert (idx > 0);
    const int lit = idx;
    const int not_lit = -lit;
    const signed char tmp = cadical_kitten_signed_value (citten, lit);
    const int candidate = (tmp < 0) ? not_lit : lit;
    LOG ("sweeping candidate %d", candidate);
    sweeper.backbone.push_back (candidate);
    sweeper.partition.push_back (candidate);
  }
  sweeper.partition.push_back (0);
 
  LOG (sweeper.backbone, "initialized backbone candidates");
  LOG (sweeper.partition, "initialized equivalence candidates");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_bins()

void CaDiCaL::Internal::init_bins ( )

Definition at line 13 of file cadical_bins.cpp.

                          {
  CADICAL_assert (big.empty ());
  if (big.size () < 2 * vsize)
    big.resize (2 * vsize, Bins ());
  LOG ("initialized binary implication graph");
}

Here is the caller graph for this function:

◆ init_citten()

void CaDiCaL::Internal::init_citten ( )

Definition at line 1004 of file cadical_elim.cpp.

                            {
  if (!opts.elimdef)
    return;
  CADICAL_assert (!citten);
  citten = cadical_kitten_init ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_enqueue()

void CaDiCaL::Internal::init_enqueue ( int idx )

inline

Definition at line 12 of file cadical_queue.cpp.

                                           {
  Link &l = links[idx];
  if (opts.reverse) {
    l.prev = 0;
    if (queue.first) {
      CADICAL_assert (!links[queue.first].prev);
      links[queue.first].prev = idx;
      btab[idx] = btab[queue.first] - 1;
    } else {
      CADICAL_assert (!queue.last);
      queue.last = idx;
      btab[idx] = 0;
    }
    CADICAL_assert (btab[idx] <= stats.bumped);
    l.next = queue.first;
    queue.first = idx;
    if (!queue.unassigned)
      update_queue_unassigned (queue.last);
  } else {
    l.next = 0;
    if (queue.last) {
      CADICAL_assert (!links[queue.last].next);
      links[queue.last].next = idx;
    } else {
      CADICAL_assert (!queue.first);
      queue.first = idx;
    }
    btab[idx] = ++stats.bumped;
    l.prev = queue.last;
    queue.last = idx;
    update_queue_unassigned (queue.last);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_noccs()

void CaDiCaL::Internal::init_noccs ( )

Definition at line 36 of file cadical_occs.cpp.

                           {
  CADICAL_assert (ntab.empty ());
  if (ntab.size () < 2 * vsize)
    ntab.resize (2 * vsize, 0);
  LOG ("initialized two-sided occurrence counters");
}

Here is the caller graph for this function:

◆ init_occs()

void CaDiCaL::Internal::init_occs ( )

Definition at line 13 of file cadical_occs.cpp.

                          {
  if (otab.size () < 2 * vsize)
    otab.resize (2 * vsize, Occs ());
  LOG ("initialized occurrence lists");
}

Here is the caller graph for this function:

◆ init_preprocessing_limits()

void CaDiCaL::Internal::init_preprocessing_limits ( )

Definition at line 443 of file cadical_internal.cpp.

                                          {
 
  const bool incremental = lim.initialized;
  if (incremental)
    LOG ("reinitializing preprocessing limits incrementally");
  else
    LOG ("initializing preprocessing limits and increments");
 
  const char *mode = 0;
 
  /*----------------------------------------------------------------------*/
 
  if (incremental)
    mode = "keeping";
  else {
    last.elim.marked = -1;
    lim.elim = stats.conflicts + scale (opts.elimint);
    mode = "initial";
  }
  (void) mode;
  LOG ("%s elim limit %" PRId64 " after %" PRId64 " conflicts", mode,
       lim.elim, lim.elim - stats.conflicts);
 
  // Initialize and reset elimination bounds in any case.
 
  lim.elimbound = opts.elimboundmin;
  LOG ("elimination bound %" PRId64 "", lim.elimbound);
 
  /*----------------------------------------------------------------------*/
 
  if (!incremental) {
 
    last.ternary.marked = -1; // TODO this should not be necessary...
 
    lim.compact = stats.conflicts + opts.compactint;
    LOG ("initial compact limit %" PRId64 " increment %" PRId64 "",
         lim.compact, lim.compact - stats.conflicts);
  }
 
  /*----------------------------------------------------------------------*/
 
  if (incremental)
    mode = "keeping";
  else {
    double delta = log10 (stats.added.irredundant);
    delta = delta * delta;
    lim.inprobe = stats.conflicts + opts.inprobeint * delta;
    mode = "initial";
  }
  (void) mode;
  LOG ("%s probe limit %" PRId64 " after %" PRId64 " conflicts", mode,
       lim.inprobe, lim.inprobe - stats.conflicts);
 
  /*----------------------------------------------------------------------*/
 
  if (incremental)
    mode = "keeping";
  else {
    lim.condition = stats.conflicts + opts.conditionint;
    mode = "initial";
  }
  LOG ("%s condition limit %" PRId64 " increment %" PRId64, mode,
       lim.condition, lim.condition - stats.conflicts);
 
  /*----------------------------------------------------------------------*/
 
  // Initial preprocessing rounds.
 
  if (inc.preprocessing <= 0) {
    lim.preprocessing = 0;
    LOG ("no preprocessing");
  } else {
    lim.preprocessing = inc.preprocessing;
    LOG ("limiting to %" PRId64 " preprocessing rounds", lim.preprocessing);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_probehbr_lrat()

void CaDiCaL::Internal::init_probehbr_lrat ( )

Definition at line 70 of file cadical_probe.cpp.

                                   {
  if (!lrat || opts.probehbr)
    return;
  const size_t size = 2 * (1 + (size_t) max_var);
  probehbr_chains.resize (size);
  for (size_t i = 0; i < size; i++) {
    probehbr_chains[i].resize (size);
    // commented because not needed... should be empty already
    /*
    for (size_t j = 0; j < size; j++) {
      vector<int64_t> empty;
      probehbr_chains[i][j] = empty;
    }
    */
  }
}

Here is the caller graph for this function:

◆ init_queue()

void CaDiCaL::Internal::init_queue	(	int	old_max_var,
		int	new_max_var )

Definition at line 51 of file cadical_queue.cpp.

                                                           {
  LOG ("initializing VMTF queue from %d to %d", old_max_var + 1,
       new_max_var);
  CADICAL_assert (old_max_var < new_max_var);
  // New variables can be created that can invoke enlarge anytime (eg via
  // calls during ipasir-up call-backs), thus assuming (!level) is not
  // correct
  for (int idx = old_max_var; idx < new_max_var; idx++)
    init_enqueue (idx + 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_report_limits()

void CaDiCaL::Internal::init_report_limits ( )

Definition at line 437 of file cadical_internal.cpp.

                                   {
  reported = false;
  lim.report = 0;
  lim.recompute_tier = 5000;
}

Here is the caller graph for this function:

◆ init_scores()

void CaDiCaL::Internal::init_scores	(	int	old_max_var,
		int	new_max_var )

Definition at line 13 of file cadical_score.cpp.

                                                            {
  LOG ("initializing EVSIDS scores from %d to %d", old_max_var + 1,
       new_max_var);
  for (int i = old_max_var; i < new_max_var; i++)
    scores.push_back (i + 1);
}

Here is the caller graph for this function:

◆ init_search_limits()

void CaDiCaL::Internal::init_search_limits ( )

Definition at line 520 of file cadical_internal.cpp.

                                   {
 
  const bool incremental = lim.initialized;
  if (incremental)
    LOG ("reinitializing search limits incrementally");
  else
    LOG ("initializing search limits and increments");
 
  const char *mode = 0;
 
  /*----------------------------------------------------------------------*/
 
  if (incremental)
    mode = "keeping";
  else {
    last.reduce.conflicts = -1;
    lim.reduce = stats.conflicts + opts.reduceinit;
    mode = "initial";
  }
  (void) mode;
  LOG ("%s reduce limit %" PRId64 " after %" PRId64 " conflicts", mode,
       lim.reduce, lim.reduce - stats.conflicts);
 
  /*----------------------------------------------------------------------*/
 
  if (incremental)
    mode = "keeping";
  else {
    lim.flush = opts.flushint;
    inc.flush = opts.flushint;
    mode = "initial";
  }
  (void) mode;
  LOG ("%s flush limit %" PRId64 " interval %" PRId64 "", mode, lim.flush,
       inc.flush);
 
  /*----------------------------------------------------------------------*/
 
  // Initialize or reset 'rephase' limits in any case.
 
  lim.rephase = stats.conflicts + opts.rephaseint;
  lim.rephased[0] = lim.rephased[1] = 0;
  LOG ("new rephase limit %" PRId64 " after %" PRId64 " conflicts",
       lim.rephase, lim.rephase - stats.conflicts);
 
  /*----------------------------------------------------------------------*/
 
  // Initialize or reset 'restart' limits in any case.
 
  lim.restart = stats.conflicts + opts.restartint;
  LOG ("new restart limit %" PRId64 " increment %" PRId64 "", lim.restart,
       lim.restart - stats.conflicts);
 
  /*----------------------------------------------------------------------*/
 
  if (!incremental) {
    stable = opts.stabilize && opts.stabilizeonly;
    if (stable)
      LOG ("starting in always forced stable phase");
    else
      LOG ("starting in default non-stable phase");
    init_averages ();
  } else if (opts.stabilize && opts.stabilizeonly) {
    LOG ("keeping always forced stable phase");
    CADICAL_assert (stable);
  } else if (stable) {
    LOG ("switching back to default non-stable phase");
    stable = false;
    swap_averages ();
  } else
    LOG ("keeping non-stable phase");
 
  if (!incremental) {
    inc.stabilize = 0;
    lim.stabilize = stats.conflicts + opts.stabilizeinit;
    LOG ("initial stabilize limit %" PRId64 " after %d conflicts",
         lim.stabilize, (int) opts.stabilizeinit);
  }
 
  if (opts.stabilize && opts.reluctant) {
    LOG ("new restart reluctant doubling sequence period %d",
         opts.reluctant);
    reluctant.enable (opts.reluctant, opts.reluctantmax);
  } else
    reluctant.disable ();
 
  /*----------------------------------------------------------------------*/
 
  // Conflict and decision limits.
 
  if (inc.conflicts < 0) {
    lim.conflicts = -1;
    LOG ("no limit on conflicts");
  } else {
    lim.conflicts = stats.conflicts + inc.conflicts;
    LOG ("conflict limit after %" PRId64 " conflicts at %" PRId64
         " conflicts",
         inc.conflicts, lim.conflicts);
  }
 
  if (inc.decisions < 0) {
    lim.decisions = -1;
    LOG ("no limit on decisions");
  } else {
    lim.decisions = stats.decisions + inc.decisions;
    LOG ("conflict limit after %" PRId64 " decisions at %" PRId64
         " decisions",
         inc.decisions, lim.decisions);
  }
 
  /*----------------------------------------------------------------------*/
 
  // Initial preprocessing rounds.
 
  if (inc.localsearch <= 0) {
    lim.localsearch = 0;
    LOG ("no local search");
  } else {
    lim.localsearch = inc.localsearch;
    LOG ("limiting to %" PRId64 " local search rounds", lim.localsearch);
  }
 
  /*----------------------------------------------------------------------*/
 
  lim.initialized = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_sweeper()

void CaDiCaL::Internal::init_sweeper ( Sweeper & sweeper )

Definition at line 216 of file cadical_sweep.cpp.

                                             {
  sweeper.encoded = 0;
  enlarge_zero (sweeper.depths, max_var + 1);
  sweeper.reprs = new int[2 * max_var + 1];
  sweeper.reprs += max_var;
  enlarge_zero (sweeper.prev, max_var + 1);
  enlarge_zero (sweeper.next, max_var + 1);
  for (const auto &lit : lits)
    sweeper.reprs[lit] = lit;
  sweeper.first = sweeper.last = 0;
  sweeper.current_ticks =
      2 *
      clauses
          .size (); // initialize with the cost of building full occ list.
  sweeper.current_ticks +=
      2 + 2 * cache_lines (clauses.size (), sizeof (Clause *));
  CADICAL_assert (!citten);
  citten = cadical_kitten_init ();
  citten_clear_track_log_terminate ();
 
  sweep_dense_mode_and_watch_irredundant (); // full occurence list
 
  if (lrat) {
    sweeper.prev_units.push_back (0);
    for (const auto &idx : vars) {
      sweeper.prev_units.push_back (val (idx) != 0);
    }
  }
 
  unsigned completed = stats.sweep_completed;
  const unsigned max_completed = 32;
  if (completed > max_completed)
    completed = max_completed;
 
  uint64_t vars_limit = opts.sweepvars;
  vars_limit <<= completed;
  const unsigned max_vars_limit = opts.sweepmaxvars;
  if (vars_limit > max_vars_limit)
    vars_limit = max_vars_limit;
  sweeper.limit.vars = vars_limit;
  VERBOSE (3, "sweeper variable limit %u", sweeper.limit.vars);
 
  uint64_t depth_limit = stats.sweep_completed;
  depth_limit += opts.sweepdepth;
  const unsigned max_depth = opts.sweepmaxdepth;
  if (depth_limit > max_depth)
    depth_limit = max_depth;
  sweeper.limit.depth = depth_limit;
  VERBOSE (3, "sweeper depth limit %u", sweeper.limit.depth);
 
  uint64_t clause_limit = opts.sweepclauses;
  clause_limit <<= completed;
  const unsigned max_clause_limit = opts.sweepmaxclauses;
  if (clause_limit > max_clause_limit)
    clause_limit = max_clause_limit;
  sweeper.limit.clauses = clause_limit;
  VERBOSE (3, "sweeper clause limit %u", sweeper.limit.clauses);
}

Here is the call graph for this function:

◆ init_vars()

void CaDiCaL::Internal::init_vars ( int new_max_var )

Definition at line 154 of file cadical_internal.cpp.

                                         {
  if (new_max_var <= max_var)
    return;
  // New variables can be created that can invoke enlarge anytime (via calls
  // during ipasir-up call-backs), thus assuming (!level) is not correct
  LOG ("initializing %d internal variables from %d to %d",
       new_max_var - max_var, max_var + 1, new_max_var);
  if ((size_t) new_max_var >= vsize)
    enlarge (new_max_var);
#ifndef CADICAL_NDEBUG
  for (int64_t i = -new_max_var; i < -max_var; i++)
    CADICAL_assert (!vals[i]);
  for (unsigned i = max_var + 1; i <= (unsigned) new_max_var; i++)
    CADICAL_assert (!vals[i]), CADICAL_assert (!btab[i]), CADICAL_assert (!gtab[i]);
  for (uint64_t i = 2 * ((uint64_t) max_var + 1);
       i <= 2 * (uint64_t) new_max_var + 1; i++)
    CADICAL_assert (ptab[i] == -1);
#endif
  CADICAL_assert (!btab[0]);
  int old_max_var = max_var;
  max_var = new_max_var;
  init_queue (old_max_var, new_max_var);
  init_scores (old_max_var, new_max_var);
  int initialized = new_max_var - old_max_var;
  stats.vars += initialized;
  stats.unused += initialized;
  stats.inactive += initialized;
  LOG ("finished initializing %d internal variables", initialized);
}

Here is the call graph for this function:

◆ init_watches()

void CaDiCaL::Internal::init_watches ( )

Definition at line 9 of file cadical_watch.cpp.

                             {
  CADICAL_assert (wtab.empty ());
  if (wtab.size () < 2 * vsize)
    wtab.resize (2 * vsize, Watches ());
  LOG ("initialized watcher tables");
}

Here is the caller graph for this function:

◆ inprobe()

void CaDiCaL::Internal::inprobe ( bool update_limits = true )

Definition at line 918 of file cadical_probe.cpp.

                                                 {
 
  if (unsat)
    return;
  if (level)
    backtrack ();
  if (!propagate ()) {
    learn_empty_clause ();
    return;
  }
 
  stats.inprobingphases++;
  if (external_prop) {
    CADICAL_assert (!level);
    private_steps = true;
  }
  const int before = active ();
  const int before_extended = stats.variables_extension;
 
  // schedule of inprobing techniques.
  //
  {
    mark_duplicated_binary_clauses_as_garbage ();
    decompose ();
    if (ternary ())
      decompose (); // If we derived a binary clause
    if (probe ())
      decompose ();
 
    if (extract_gates ())
      decompose ();
    if (sweep ())     // full occurrence list
      decompose ();   // ... and (ELS) afterwards.
    (void) vivify (); // resets watches
    transred ();      // builds big.
    factor ();   // resets watches, partial occurrence list
  }
 
  if (external_prop) {
    CADICAL_assert (!level);
    private_steps = false;
  }
 
  if (!update_limits)
    return;
 
  const int after = active ();
  const int after_extended = stats.variables_extension;
  const int diff_extended = after_extended - before_extended;
  CADICAL_assert (diff_extended >= 0);
  const int removed = before - after + diff_extended;
  CADICAL_assert (removed >= 0);
 
  if (removed) {
    stats.inprobesuccess++;
    PHASE ("probe-phase", stats.inprobingphases,
           "successfully removed %d active variables %.0f%%", removed,
           percent (removed, before));
  } else
    PHASE ("probe-phase", stats.inprobingphases,
           "could not remove any active variable");
 
  const int64_t delta =
      25 * opts.inprobeint * log10 (stats.inprobingphases + 9);
  lim.inprobe = stats.conflicts + delta;
 
  PHASE ("probe-phase", stats.inprobingphases,
         "new limit at %" PRId64 " conflicts after %" PRId64 " conflicts",
         lim.inprobe, delta);
 
  last.inprobe.reductions = stats.reductions;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inprobing()

bool CaDiCaL::Internal::inprobing ( )

Definition at line 20 of file cadical_probe.cpp.

                          {
  if (!opts.inprobing)
    return false;
  if (!preprocessing && !opts.inprocessing)
    return false;
  if (preprocessing)
    CADICAL_assert (lim.preprocessing);
  if (stats.inprobingphases && last.inprobe.reductions == stats.reductions)
    return false;
  return lim.inprobe <= stats.conflicts;
}

Here is the caller graph for this function:

◆ inst_assign()

void CaDiCaL::Internal::inst_assign ( int lit )

inline

Definition at line 68 of file cadical_instantiate.cpp.

                                          {
  LOG ("instantiate assign %d", lit);
  CADICAL_assert (!val (lit));
  CADICAL_assert ((int) num_assigned < max_var);
  num_assigned++;
  set_val (lit, 1);
  trail.push_back (lit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inst_propagate()

bool CaDiCaL::Internal::inst_propagate ( )

Definition at line 82 of file cadical_instantiate.cpp.

                               { // Adapted from 'propagate'.
  START (propagate);
  int64_t before = propagated;
  bool ok = true;
  while (ok && propagated != trail.size ()) {
    const int lit = -trail[propagated++];
    LOG ("instantiate propagating %d", -lit);
    Watches &ws = watches (lit);
    const const_watch_iterator eow = ws.end ();
    const_watch_iterator i = ws.begin ();
    watch_iterator j = ws.begin ();
    while (i != eow) {
      const Watch w = *j++ = *i++;
      const signed char b = val (w.blit);
      if (b > 0)
        continue;
      if (w.binary ()) {
        if (b < 0) {
          ok = false;
          LOG (w.clause, "conflict");
          if (lrat) {
            inst_chain.push_back (w.clause);
          }
          break;
        } else {
          if (lrat) {
            inst_chain.push_back (w.clause);
          }
          inst_assign (w.blit);
        }
      } else {
        literal_iterator lits = w.clause->begin ();
        const int other = lits[0] ^ lits[1] ^ lit;
        lits[0] = other, lits[1] = lit;
        const signed char u = val (other);
        if (u > 0)
          j[-1].blit = other;
        else {
          const int size = w.clause->size;
          const const_literal_iterator end = lits + size;
          const literal_iterator middle = lits + w.clause->pos;
          literal_iterator k = middle;
          signed char v = -1;
          int r = 0;
          while (k != end && (v = val (r = *k)) < 0)
            k++;
          if (v < 0) {
            k = lits + 2;
            CADICAL_assert (w.clause->pos <= size);
            while (k != middle && (v = val (r = *k)) < 0)
              k++;
          }
          w.clause->pos = k - lits;
          CADICAL_assert (lits + 2 <= k), CADICAL_assert (k <= w.clause->end ());
          if (v > 0) {
            j[-1].blit = r;
          } else if (!v) {
            LOG (w.clause, "unwatch %d in", r);
            lits[1] = r;
            *k = lit;
            watch_literal (r, lit, w.clause);
            j--;
          } else if (!u) {
            CADICAL_assert (v < 0);
            if (lrat) {
              inst_chain.push_back (w.clause);
            }
            inst_assign (other);
          } else {
            CADICAL_assert (u < 0);
            CADICAL_assert (v < 0);
            if (lrat) {
              inst_chain.push_back (w.clause);
            }
            LOG (w.clause, "conflict");
            ok = false;
            break;
          }
        }
      }
    }
    if (j != i) {
      while (i != eow)
        *j++ = *i++;
      ws.resize (j - ws.begin ());
    }
  }
  int64_t delta = propagated - before;
  stats.propagations.instantiate += delta;
  STOP (propagate);
  return ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ instantiate()

void CaDiCaL::Internal::instantiate ( Instantiator & instantiator )

Definition at line 316 of file cadical_instantiate.cpp.

                                                      {
  CADICAL_assert (opts.instantiate);
  START (instantiate);
  stats.instrounds++;
#ifndef CADICAL_QUIET
  const int64_t candidates = instantiator.candidates.size ();
  int64_t tried = 0;
#endif
  int64_t instantiated = 0;
  init_watches ();
  connect_watches ();
  if (propagated < trail.size ()) {
    if (!propagate ()) {
      LOG ("propagation after connecting watches failed");
      learn_empty_clause ();
      CADICAL_assert (unsat);
    }
  }
  PHASE ("instantiate", stats.instrounds,
         "attempting to instantiate %" PRId64
         " candidate literal clause pairs",
         candidates);
  while (!unsat && !terminated_asynchronously () &&
         !instantiator.candidates.empty ()) {
    Instantiator::Candidate cand = instantiator.candidates.back ();
    instantiator.candidates.pop_back ();
#ifndef CADICAL_QUIET
    tried++;
#endif
    if (!active (cand.lit))
      continue;
    LOG (cand.clause,
         "trying to instantiate %d with "
         "%zd negative occurrences in",
         cand.lit, cand.negoccs);
    if (!instantiate_candidate (cand.lit, cand.clause))
      continue;
    instantiated++;
    VERBOSE (2,
             "instantiation %" PRId64 " (%.1f%%) succeeded "
             "(%.1f%%) with %zd negative occurrences in size %d clause",
             tried, percent (tried, candidates),
             percent (instantiated, tried), cand.negoccs, cand.size);
  }
  PHASE ("instantiate", stats.instrounds,
         "instantiated %" PRId64 " candidate successfully "
         "out of %" PRId64 " tried %.1f%%",
         instantiated, tried, percent (instantiated, tried));
  report ('I', !instantiated);
  reset_watches ();
  STOP (instantiate);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ instantiate_candidate()

bool CaDiCaL::Internal::instantiate_candidate	(	int	lit,
		Clause *	c )

Definition at line 179 of file cadical_instantiate.cpp.

                                                        {
  stats.instried++;
  if (c->garbage)
    return false;
  CADICAL_assert (!level);
  bool found = false, satisfied = false, inactive = false;
  int unassigned = 0;
  for (const auto &other : *c) {
    if (other == lit)
      found = true;
    const signed char tmp = val (other);
    if (tmp > 0) {
      satisfied = true;
      break;
    }
    if (!tmp && !active (other)) {
      inactive = true;
      break;
    }
    if (!tmp)
      unassigned++;
  }
  if (!found)
    return false;
  if (inactive)
    return false;
  if (satisfied)
    return false;
  if (unassigned < 3)
    return false;
  size_t before = trail.size ();
  CADICAL_assert (propagated == before);
  CADICAL_assert (active (lit));
  CADICAL_assert (inst_chain.empty ());
  LOG (c, "trying to instantiate %d in", lit);
  CADICAL_assert (!c->garbage);
  c->instantiated = true;
  CADICAL_assert (lrat_chain.empty ());
  level++;
  inst_assign (lit); // Assume 'lit' to true.
  for (const auto &other : *c) {
    if (other == lit)
      continue;
    const signed char tmp = val (other);
    if (tmp) {
      CADICAL_assert (tmp < 0);
      continue;
    }
    inst_assign (-other); // Assume other to false.
  }
  bool ok = inst_propagate ();  // Propagate.
  CADICAL_assert (lrat_chain.empty ()); // chain will be built here
  if (ok) {
    inst_chain.clear ();
  } else if (lrat) { // analyze conflict for lrat
    CADICAL_assert (inst_chain.size ());
    Clause *reason = inst_chain.back ();
    inst_chain.pop_back ();
    lrat_chain.push_back (reason->id);
    for (const auto &other : *reason) {
      Flags &f = flags (other);
      CADICAL_assert (!f.seen);
      f.seen = true;
      analyzed.push_back (other);
    }
  }
  while (trail.size () > before) { // Backtrack.
    const int other = trail.back ();
    LOG ("instantiate unassign %d", other);
    trail.pop_back ();
    CADICAL_assert (val (other) > 0);
    num_assigned--;
    set_val (other, 0);
    // this is a variant of conflict analysis which is only needed for lrat
    if (!ok && inst_chain.size () && lrat) {
      Flags &f = flags (other);
      if (f.seen) {
        Clause *reason = inst_chain.back ();
        lrat_chain.push_back (reason->id);
        for (const auto &other : *reason) {
          Flags &f = flags (other);
          if (f.seen)
            continue;
          f.seen = true;
          analyzed.push_back (other);
        }
        f.seen = false;
      }
      inst_chain.pop_back ();
    }
  }
  CADICAL_assert (inst_chain.empty ());
  // post processing step for lrat
  if (!ok && lrat) {
    if (flags (lit).seen)
      lrat_chain.push_back (c->id);
    for (const auto &other : *c) {
      Flags &f = flags (other);
      f.seen = false;
    }
    for (int other : analyzed) {
      Flags &f = flags (other);
      if (!f.seen) {
        f.seen = true;
        continue;
      }
      int64_t id = unit_id (-other);
      lrat_chain.push_back (id);
    }
    clear_analyzed_literals ();
    reverse (lrat_chain.begin (), lrat_chain.end ());
  }
  CADICAL_assert (analyzed.empty ());
  propagated = before;
  CADICAL_assert (level == 1);
  level = 0;
  if (ok) {
    CADICAL_assert (lrat_chain.empty ());
    LOG ("instantiation failed");
    return false;
  }
  unwatch_clause (c);
  LOG (lrat_chain, "instantiate proof chain");
  strengthen_clause (c, lit);
  watch_clause (c);
  lrat_chain.clear ();
  CADICAL_assert (c->size > 1);
  LOG ("instantiation succeeded");
  stats.instantiated++;
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ irredundant()

int64_t CaDiCaL::Internal::irredundant ( ) const

inline

Definition at line 383 of file internal.hpp.

383{ return stats.current.irredundant; }

Here is the caller graph for this function:

◆ is_autarky_literal()

bool CaDiCaL::Internal::is_autarky_literal ( int lit ) const

inline

Definition at line 105 of file cadical_condition.cpp.

                                                       {
  return val (lit) > 0 && !getbit (lit, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_binary_clause()

bool CaDiCaL::Internal::is_binary_clause	(	Clause *	c,
		int &	a,
		int &	b )

Definition at line 600 of file cadical_probe.cpp.

                                                          {
  CADICAL_assert (!level);
  if (c->garbage)
    return false;
  int first = 0, second = 0;
  for (const auto &lit : *c) {
    const signed char tmp = val (lit);
    if (tmp > 0)
      return false;
    if (tmp < 0)
      continue;
    if (second)
      return false;
    if (first)
      second = lit;
    else
      first = lit;
  }
  if (!second)
    return false;
  a = first, b = second;
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_blocked_clause()

bool CaDiCaL::Internal::is_blocked_clause	(	Clause *	c,
		int	pivot )

Definition at line 47 of file cadical_block.cpp.

                                                    {
 
  LOG (c, "trying to block on %d", lit);
 
  CADICAL_assert (c->size >= opts.blockminclslim);
  CADICAL_assert (c->size <= opts.blockmaxclslim);
  CADICAL_assert (active (lit));
  CADICAL_assert (!val (lit));
  CADICAL_assert (!c->garbage);
  CADICAL_assert (!c->redundant);
  CADICAL_assert (!level);
 
  mark (c); // First mark all literals in 'c'.
 
  Occs &os = occs (-lit);
  LOG ("resolving against at most %zd clauses with %d", os.size (), -lit);
 
  bool res = true; // Result is true if all resolvents tautological.
 
  // Can not use 'auto' here since we update 'os' during traversal.
  //
  const auto end_of_os = os.end ();
  auto i = os.begin ();
 
  Clause *prev_d = 0; // Previous non-tautological clause.
 
  for (; i != end_of_os; i++) {
    // Move the first clause with non-tautological resolvent to the front of
    // the occurrence list to improve finding it faster later.
    //
    Clause *d = *i;
 
    CADICAL_assert (!d->garbage);
    CADICAL_assert (!d->redundant);
    CADICAL_assert (d->size <= opts.blockmaxclslim);
 
    *i = prev_d; // Move previous non-tautological clause
    prev_d = d;  // backwards but remember clause at this position.
 
    LOG (d, "resolving on %d against", lit);
    stats.blockres++;
 
    int prev_other = 0; // Previous non-tautological literal.
 
    // No 'auto' since we update literals of 'd' during traversal.
    //
    const const_literal_iterator end_of_d = d->end ();
    literal_iterator l;
 
    for (l = d->begin (); l != end_of_d; l++) {
      // Same move-to-front mechanism for literals within a clause.  It
      // moves the first negatively marked literal to the front to find it
      // faster in the future.
      //
      const int other = *l;
      *l = prev_other;
      prev_other = other;
      if (other == -lit)
        continue;
      CADICAL_assert (other != lit);
      CADICAL_assert (active (other));
      CADICAL_assert (!val (other));
      if (marked (other) < 0) {
        LOG ("found tautological literal %d", other);
        d->literals[0] = other; // Move to front of 'd'.
        break;
      }
    }
 
    if (l == end_of_d) {
      LOG ("no tautological literal found");
      //
      // Since we did not find a tautological literal we restore the old
      // order of literals in the clause.
      //
      const const_literal_iterator begin_of_d = d->begin ();
      while (l-- != begin_of_d) {
        const int other = *l;
        *l = prev_other;
        prev_other = other;
      }
      res = false; // Now 'd' is a witness that 'c' is not blocked.
      os[0] = d;   // Move it to the front of the occurrence list.
      break;
    }
  }
  unmark (c); // ... all literals of the candidate clause.
 
  // If all resolvents are tautological and thus the clause is blocked we
  // restore the old order of clauses in the occurrence list of '-lit'.
  //
  if (res) {
    CADICAL_assert (i == end_of_os);
    const auto boc = os.begin ();
    while (i != boc) {
      Clause *d = *--i;
      *i = prev_d;
      prev_d = d;
    }
  }
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_clause()

bool CaDiCaL::Internal::is_clause	(	Clause *	c,
		const vector< int > &	lits )

Definition at line 600 of file cadical_gates.cpp.

                                                            {
  if (c->garbage)
    return false;
  int size = lits.size ();
  if (c->size < size)
    return false;
  int found = 0;
  for (const auto &lit : *c) {
    if (val (lit) < 0)
      continue;
    if (val (lit) > 0)
      return false;
    const auto it = find (lits.begin (), lits.end (), lit);
    if (it == lits.end ())
      return false;
    if (++found > size)
      return false;
  }
  return found == size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_conditional_literal()

bool CaDiCaL::Internal::is_conditional_literal ( int lit ) const

inline

Definition at line 101 of file cadical_condition.cpp.

                                                           {
  return val (lit) > 0 && getbit (lit, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_decision()

bool CaDiCaL::Internal::is_decision ( int ilit )

Definition at line 196 of file cadical_external_propagate.cpp.

                                    {
  if (!level || fixed (ilit) || !val (ilit))
    return false;
 
  const int idx = vidx (ilit);
  Var &v = var (idx);
#ifndef CADICAL_NDEBUG
  LOG (v.reason,
       "is_decision: i%d (current level: %d, is_fixed: %d, v.level: %d, "
       "is_external_reason: %d, v.reason: )",
       ilit, level, fixed (ilit), v.level, v.reason == external_reason);
#endif
  if (!v.level || v.reason)
    return false;
  CADICAL_assert (!v.reason);
  return true;
}

Here is the call graph for this function:

◆ is_external_forgettable()

bool CaDiCaL::Internal::is_external_forgettable ( int64_t id )

Definition at line 1058 of file cadical_external_propagate.cpp.

                                                  {
  CADICAL_assert (opts.check);
  return (external->forgettable_original.find (id) !=
          external->forgettable_original.end ());
}

Here is the caller graph for this function:

◆ is_in_candidate_clause()

bool CaDiCaL::Internal::is_in_candidate_clause ( int lit ) const

inline

Definition at line 130 of file cadical_condition.cpp.

                                                           {
  return marked67 (lit) > 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_valid_limit()

bool CaDiCaL::Internal::is_valid_limit ( const char * name )

static

Definition at line 93 of file cadical_limit.cpp.

                                               {
  if (!strcmp (name, "terminate"))
    return true;
  if (!strcmp (name, "conflicts"))
    return true;
  if (!strcmp (name, "decisions"))
    return true;
  if (!strcmp (name, "preprocessing"))
    return true;
  if (!strcmp (name, "localsearch"))
    return true;
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iterate()

void CaDiCaL::Internal::iterate ( )

Definition at line 1278 of file cadical_analyze.cpp.

                        {
  iterating = false;
  report ('i');
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ learn_empty_clause()

void CaDiCaL::Internal::learn_empty_clause ( )

Definition at line 19 of file cadical_analyze.cpp.

                                   {
  CADICAL_assert (!unsat);
  build_chain_for_empty ();
  LOG ("learned empty clause");
  external->check_learned_empty_clause ();
  int64_t id = ++clause_id;
  if (proof) {
    proof->add_derived_empty_clause (id, lrat_chain);
  }
  unsat = true;
  conflict_id = id;
  marked_failed = true;
  conclusion.push_back (id);
  lrat_chain.clear ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ learn_external_reason_clause()

Clause * CaDiCaL::Internal::learn_external_reason_clause	(	int	lit,
		int	falsified_elit = 0,
		bool	no_backtrack = false )

Definition at line 668 of file cadical_external_propagate.cpp.

                                                                   {
  CADICAL_assert (external->propagator);
  // we cannot modify clause during analysis
  auto clause_tmp = std::move (clause);
 
  CADICAL_assert (clause.empty ());
  CADICAL_assert (original.empty ());
 
  stats.ext_prop.eprop_expl++;
 
  int elit = 0;
  if (!falsified_elit) {
    CADICAL_assert (!fixed (ilit));
    elit = externalize (ilit);
  } else
    elit = falsified_elit;
 
  LOG ("ilit: %d, elit: %d", ilit, elit);
  add_external_clause (elit, no_backtrack);
 
#ifndef CADICAL_NDEBUG
  if (!falsified_elit && newest_clause) {
    // Check if external propagation is correct wrt to the topological order
    // defined by the trail. In case it is a falsified external propagation
    // step, the order does not matter, the reason simply supposed to be a
    // falsified clause.
    const int propagated_ilit = ilit;
    for (auto const reason_ilit : *newest_clause) {
      CADICAL_assert (var (reason_ilit).trail <= var (propagated_ilit).trail);
    }
  }
#endif
 
  clause = std::move (clause_tmp);
  return newest_clause;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ learn_unit_clause()

void CaDiCaL::Internal::learn_unit_clause ( int lit )

Definition at line 35 of file cadical_analyze.cpp.

                                         {
  CADICAL_assert (!unsat);
  LOG ("learned unit clause %d, stored at position %d", lit, vlit (lit));
  external->check_learned_unit_clause (lit);
  int64_t id = ++clause_id;
  if (lrat || frat) {
    const unsigned uidx = vlit (lit);
    unit_clauses (uidx) = id;
  }
  if (proof) {
    proof->add_derived_unit_clause (id, lit, lrat_chain);
  }
  mark_fixed (lit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ likely_phase()

int CaDiCaL::Internal::likely_phase ( int idx )

Definition at line 89 of file cadical_decide.cpp.

89{ return decide_phase (idx, false); }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ likely_to_be_kept_clause()

bool CaDiCaL::Internal::likely_to_be_kept_clause ( Clause * c )

inline

Definition at line 1006 of file internal.hpp.

                                            {
    if (!c->redundant)
      return true;
    if (c->glue <= tier2[false])
      return true;
    if (c->glue > lim.keptglue)
      return false;
    if (c->size > lim.keptsize)
      return false;
    return true;
  }

Here is the caller graph for this function:

◆ limit()

bool CaDiCaL::Internal::limit	(	const char *	name,
		int	l )

Definition at line 107 of file cadical_limit.cpp.

                                             {
  bool res = true;
  if (!strcmp (name, "terminate"))
    limit_terminate (l);
  else if (!strcmp (name, "conflicts"))
    limit_conflicts (l);
  else if (!strcmp (name, "decisions"))
    limit_decisions (l);
  else if (!strcmp (name, "preprocessing"))
    limit_preprocessing (l);
  else if (!strcmp (name, "localsearch"))
    limit_local_search (l);
  else
    res = false;
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ limit_conflicts()

void CaDiCaL::Internal::limit_conflicts ( int l )

Definition at line 45 of file cadical_limit.cpp.

                                     {
  if (l < 0 && inc.conflicts < 0) {
    LOG ("keeping unbounded conflict limit");
  } else if (l < 0) {
    LOG ("reset conflict limit to be unbounded");
    inc.conflicts = -1;
  } else {
    inc.conflicts = l;
    LOG ("new conflict limit of %d conflicts", l);
  }
}

Here is the caller graph for this function:

◆ limit_decisions()

void CaDiCaL::Internal::limit_decisions ( int l )

Definition at line 57 of file cadical_limit.cpp.

                                     {
  if (l < 0 && inc.decisions < 0) {
    LOG ("keeping unbounded decision limit");
  } else if (l < 0) {
    LOG ("reset decision limit to be unbounded");
    inc.decisions = -1;
  } else {
    inc.decisions = l;
    LOG ("new decision limit of %d decisions", l);
  }
}

Here is the caller graph for this function:

◆ limit_local_search()

void CaDiCaL::Internal::limit_local_search ( int l )

Definition at line 81 of file cadical_limit.cpp.

                                        {
  if (l < 0) {
    LOG ("ignoring invalid local search limit %d", l);
  } else if (!l) {
    LOG ("reset local search limit to no local search");
    inc.localsearch = 0;
  } else {
    inc.localsearch = l;
    LOG ("new local search limit of %d local search rounds", l);
  }
}

Here is the caller graph for this function:

◆ limit_preprocessing()

void CaDiCaL::Internal::limit_preprocessing ( int l )

Definition at line 69 of file cadical_limit.cpp.

                                         {
  if (l < 0) {
    LOG ("ignoring invalid preprocessing limit %d", l);
  } else if (!l) {
    LOG ("reset preprocessing limit to no preprocessing");
    inc.preprocessing = 0;
  } else {
    inc.preprocessing = l;
    LOG ("new preprocessing limit of %d preprocessing rounds", l);
  }
}

Here is the caller graph for this function:

◆ limit_terminate()

void CaDiCaL::Internal::limit_terminate ( int l )

Definition at line 33 of file cadical_limit.cpp.

                                     {
  if (l <= 0 && !lim.terminate.forced) {
    LOG ("keeping unbounded terminate limit");
  } else if (l <= 0) {
    LOG ("reset terminate limit to be unbounded");
    lim.terminate.forced = 0;
  } else {
    lim.terminate.forced = l;
    LOG ("new terminate limit of %d calls", l);
  }
}

Here is the caller graph for this function:

◆ link()

Link & CaDiCaL::Internal::link ( int lit )

inline

Definition at line 453 of file internal.hpp.

453{ return links[vidx (lit)]; }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lit2citten()

unsigned CaDiCaL::Internal::lit2citten ( int lit )

inline

Definition at line 429 of file internal.hpp.

                                {
    int idx = vidx (lit) - 1;
    return (lit < 0) + 2u * (unsigned) idx;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ local_search()

int CaDiCaL::Internal::local_search ( )

Definition at line 850 of file cadical_internal.cpp.

                            {
 
  if (unsat)
    return 0;
  if (!max_var)
    return 0;
  if (!opts.walk)
    return 0;
  if (constraint.size ())
    return 0;
 
  int res = 0;
 
  for (int i = 1; !res && i <= lim.localsearch; i++)
    res = local_search_round (i);
 
  if (res == 10) {
    LOG ("local search determined formula to be satisfiable");
    CADICAL_assert (!stats.walk.minimum);
    res = try_to_satisfy_formula_by_saved_phases ();
  } else if (res == 20) {
    LOG ("local search determined assumptions to be inconsistent");
    CADICAL_assert (!assumptions.empty ());
    produce_failed_assumptions ();
  }
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ local_search_round()

int CaDiCaL::Internal::local_search_round ( int round )

Definition at line 817 of file cadical_internal.cpp.

                                           {
 
  CADICAL_assert (round > 0);
 
  if (unsat)
    return false;
  if (!max_var)
    return false;
 
  START_OUTER_WALK ();
  CADICAL_assert (!localsearching);
  localsearching = true;
 
  // Determine propagation limit quadratically scaled with rounds.
  //
  int64_t limit = opts.walkmineff;
  limit *= round;
  if (LONG_MAX / round > limit)
    limit *= round;
  else
    limit = LONG_MAX;
 
  int res = walk_round (limit, true);
 
  CADICAL_assert (localsearching);
  localsearching = false;
  STOP_OUTER_WALK ();
 
  report ('L');
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lookahead()

int CaDiCaL::Internal::lookahead ( )

Definition at line 1004 of file cadical_internal.cpp.

                         {
  CADICAL_assert (clause.empty ());
  START (lookahead);
  CADICAL_assert (!lookingahead);
  lookingahead = true;
  if (external_prop) {
    if (level) {
      // Combining lookahead with external propagator is limited
      // Note that lookahead_probing (); would also force backtrack anyway
      backtrack ();
    }
    LOG ("external notifications are turned off during preprocessing.");
    private_steps = true;
  }
  int tmp = already_solved ();
  if (!tmp)
    tmp = restore_clauses ();
  int res = 0;
  if (!tmp)
    res = lookahead_probing ();
  if (res == INT_MIN)
    res = 0;
  reset_solving ();
  report_solving (tmp);
  CADICAL_assert (lookingahead);
  lookingahead = false;
  STOP (lookahead);
  if (external_prop) {
    private_steps = false;
    LOG ("external notifications are turned back on.");
    notify_assignments (); // In case fixed assignments were found.
  }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lookahead_flush_probes()

void CaDiCaL::Internal::lookahead_flush_probes ( )

Definition at line 98 of file cadical_lookahead.cpp.

                                       {
 
  CADICAL_assert (!probes.empty ());
 
  init_noccs ();
  for (const auto &c : clauses) {
    int a, b;
    if (!is_binary_clause (c, a, b))
      continue;
    noccs (a)++;
    noccs (b)++;
  }
 
  const auto eop = probes.end ();
  auto j = probes.begin ();
  for (auto i = j; i != eop; i++) {
    int lit = *i;
    if (!active (lit))
      continue;
    const bool have_pos_bin_occs = noccs (lit) > 0;
    const bool have_neg_bin_occs = noccs (-lit) > 0;
    if (have_pos_bin_occs == have_neg_bin_occs)
      continue;
    if (have_pos_bin_occs)
      lit = -lit;
    CADICAL_assert (!noccs (lit)), CADICAL_assert (noccs (-lit) > 0);
    if (propfixed (lit) >= stats.all.fixed)
      continue;
    MSG ("keeping probe %d negated occs %" PRId64 "", lit, noccs (-lit));
    *j++ = lit;
  }
  size_t remain = j - probes.begin ();
#ifndef CADICAL_QUIET
  size_t flushed = probes.size () - remain;
#endif
  probes.resize (remain);
 
  rsort (probes.begin (), probes.end (), probe_negated_noccs_rank (this));
 
  reset_noccs ();
  shrink_vector (probes);
 
  PHASE ("probe-round", stats.probingrounds,
         "flushed %zd literals %.0f%% remaining %zd", flushed,
         percent (flushed, remain + flushed), remain);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lookahead_generate_probes()

void CaDiCaL::Internal::lookahead_generate_probes ( )

Definition at line 145 of file cadical_lookahead.cpp.

                                          {
 
  CADICAL_assert (probes.empty ());
 
  // First determine all the literals which occur in binary clauses. It is
  // way faster to go over the clauses once, instead of walking the watch
  // lists for each literal.
  //
  init_noccs ();
  for (const auto &c : clauses) {
    int a, b;
    if (!is_binary_clause (c, a, b))
      continue;
    noccs (a)++;
    noccs (b)++;
  }
 
  for (int idx = 1; idx <= max_var; idx++) {
 
    // Then focus on roots of the binary implication graph, which are
    // literals occurring negatively in a binary clause, but not positively.
    // If neither 'idx' nor '-idx' is a root it makes less sense to probe
    // this variable.
 
    // This argument requires that equivalent literal substitution through
    // 'decompose' is performed, because otherwise there might be 'cyclic
    // roots' which are not tried, i.e., -1 2 0, 1 -2 0, 1 2 3 0, 1 2 -3 0.
 
    const bool have_pos_bin_occs = noccs (idx) > 0;
    const bool have_neg_bin_occs = noccs (-idx) > 0;
 
    // if (have_pos_bin_occs == have_neg_bin_occs) continue;
 
    if (have_pos_bin_occs) {
      int probe = -idx;
 
      // See the discussion where 'propfixed' is used below.
      //
      if (propfixed (probe) >= stats.all.fixed)
        continue;
 
      MSG ("scheduling probe %d negated occs %" PRId64 "", probe,
           noccs (-probe));
      probes.push_back (probe);
    }
 
    if (have_neg_bin_occs) {
      int probe = idx;
 
      // See the discussion where 'propfixed' is used below.
      //
      if (propfixed (probe) >= stats.all.fixed)
        continue;
 
      MSG ("scheduling probe %d negated occs %" PRId64 "", probe,
           noccs (-probe));
      probes.push_back (probe);
    }
  }
 
  rsort (probes.begin (), probes.end (), probe_negated_noccs_rank (this));
 
  reset_noccs ();
  shrink_vector (probes);
 
  PHASE ("probe-round", stats.probingrounds,
         "scheduled %zd literals %.0f%%", probes.size (),
         percent (probes.size (), 2 * max_var));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lookahead_locc()

int CaDiCaL::Internal::lookahead_locc ( const std::vector< int > & loccs )

Definition at line 39 of file cadical_lookahead.cpp.

                                                         {
  for (auto lit : loccs)
    if (active (abs (lit)) && !assumed (lit) && !assumed (-lit) &&
        !val (lit))
      return lit;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lookahead_next_probe()

int CaDiCaL::Internal::lookahead_next_probe ( )

Definition at line 215 of file cadical_lookahead.cpp.

                                    {
 
  int generated = 0;
 
  for (;;) {
 
    if (probes.empty ()) {
      if (generated++)
        return 0;
      lookahead_generate_probes ();
    }
 
    while (!probes.empty ()) {
 
      int probe = probes.back ();
      probes.pop_back ();
 
      // Eliminated or assigned.
      //
      if (!active (probe) || assumed (probe) || assumed (-probe))
        continue;
 
      // There is now new unit since the last time we propagated this probe,
      // thus we propagated it before without obtaining a conflict and
      // nothing changed since then.  Thus there is no need to propagate it
      // again.  This observation was independently made by Partik Simons
      // et.al. in the context of implementing 'smodels' (see for instance
      // Alg. 4 in his JAIR article from 2002) and it has also been
      // contributed to the thesis work of Yacine Boufkhad.
      //
      if (propfixed (probe) >= stats.all.fixed)
        continue;
 
      return probe;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lookahead_populate_locc()

std::vector< int > CaDiCaL::Internal::lookahead_populate_locc ( )

Definition at line 21 of file cadical_lookahead.cpp.

                                                  {
  std::vector<literal_occ> loccs ((std::size_t) max_var + 1);
  for (std::size_t lit = 0; lit < loccs.size (); ++lit) {
    loccs[lit].lit = lit;
  }
  for (const auto &c : clauses)
    if (!c->redundant)
      for (const auto &lit : *c)
        if (active (lit))
          ++loccs[std::abs (lit)];
  std::sort (begin (loccs), end (loccs));
  std::vector<int> locc_map;
  locc_map.reserve (max_var);
  for (const auto &locc : loccs)
    locc_map.push_back (locc.lit);
  return locc_map;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lookahead_probing()

int CaDiCaL::Internal::lookahead_probing ( )

Definition at line 290 of file cadical_lookahead.cpp.

                                 {
 
  if (!active ())
    return 0;
 
  MSG ("lookahead-probe-round %" PRId64
       " without propagations limit and %zu assumptions",
       stats.probingrounds, assumptions.size ());
 
  termination_forced = false;
 
#ifndef CADICAL_QUIET
  int old_failed = stats.failed;
  int64_t old_probed = stats.probed;
#endif
  int64_t old_hbrs = stats.hbrs;
 
  if (unsat)
    return INT_MIN;
  if (level)
    backtrack ();
  if (!propagate ()) {
    MSG ("empty clause before probing");
    learn_empty_clause ();
    return INT_MIN;
  }
 
  if (terminating_asked ())
    return most_occurring_literal ();
 
  decompose ();
 
  if (ternary ()) // If we derived a binary clause
    decompose (); // then start another round of ELS.
 
  // Remove duplicated binary clauses and perform in essence hyper unary
  // resolution, i.e., derive the unit '2' from '1 2' and '-1 2'.
  //
  mark_duplicated_binary_clauses_as_garbage ();
 
  lim.conflicts = -1;
 
  if (!probes.empty ())
    lookahead_flush_probes ();
 
  // We reset 'propfixed' since there was at least another conflict thus
  // a new learned clause, which might produce new propagations (and hyper
  // binary resolvents).  During 'generate_probes' we keep the old value.
  //
  for (int idx = 1; idx <= max_var; idx++)
    propfixed (idx) = propfixed (-idx) = -1;
 
  CADICAL_assert (unsat || propagated == trail.size ());
  propagated = propagated2 = trail.size ();
 
  int probe;
  int res = most_occurring_literal ();
  int max_hbrs = -1;
 
  set_mode (PROBE);
 
  MSG ("unsat = %d, terminating_asked () = %d ", unsat,
       terminating_asked ());
  init_probehbr_lrat ();
  while (!unsat && !terminating_asked () &&
         (probe = lookahead_next_probe ())) {
    stats.probed++;
    int hbrs;
 
    probe_assign_decision (probe);
    if (probe_propagate ())
      hbrs = trail.size (), backtrack ();
    else
      hbrs = 0, failed_literal (probe);
    clean_probehbr_lrat ();
    if (max_hbrs < hbrs ||
        (max_hbrs == hbrs &&
         internal->bumped (probe) > internal->bumped (res))) {
      res = probe;
      max_hbrs = hbrs;
    }
  }
 
  reset_mode (PROBE);
 
  if (unsat) {
    MSG ("probing derived empty clause");
    res = INT_MIN;
  } else if (propagated < trail.size ()) {
    MSG ("probing produced %zd units",
         (size_t) (trail.size () - propagated));
    if (!propagate ()) {
      MSG ("propagating units after probing results in empty clause");
      learn_empty_clause ();
      res = INT_MIN;
    } else
      sort_watches ();
  }
 
#ifndef CADICAL_QUIET
  int failed = stats.failed - old_failed;
  int64_t probed = stats.probed - old_probed;
#endif
  int64_t hbrs = stats.hbrs - old_hbrs;
 
  MSG ("lookahead-probe-round %" PRId64 " probed %" PRId64
       " and found %d failed literals",
       stats.probingrounds, probed, failed);
 
  if (hbrs)
    PHASE ("lookahead-probe-round", stats.probingrounds,
           "found %" PRId64 " hyper binary resolvents", hbrs);
 
  MSG ("lookahead literal %d with %d\n", res, max_hbrs);
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lucky_phases()

int CaDiCaL::Internal::lucky_phases ( )

Definition at line 386 of file cadical_lucky.cpp.

                            {
  CADICAL_assert (!level);
  require_mode (SEARCH);
  if (!opts.lucky)
    return 0;
 
  // TODO: Some of the lucky assignments can also be found if there are
  // assumptions, but this is not completely implemented nor tested yet.
  // Nothing done for constraint either.
  // External propagator assumes a CDCL loop, so lucky is not tried here.
  if (!assumptions.empty () || !constraint.empty () || external_prop)
    return 0;
 
  START (search);
  START (lucky);
  CADICAL_assert (!searching_lucky_phases);
  searching_lucky_phases = true;
  stats.lucky.tried++;
  const int64_t active_before = stats.active;
  int res = trivially_false_satisfiable ();
  if (!res)
    res = trivially_true_satisfiable ();
  if (!res)
    res = forward_true_satisfiable ();
  if (!res)
    res = forward_false_satisfiable ();
  if (!res)
    res = backward_false_satisfiable ();
  if (!res)
    res = backward_true_satisfiable ();
  if (!res)
    res = positive_horn_satisfiable ();
  if (!res)
    res = negative_horn_satisfiable ();
  if (res < 0)
    CADICAL_assert (termination_forced), res = 0;
  if (res == 10)
    stats.lucky.succeeded++;
  report ('l', !res);
  CADICAL_assert (searching_lucky_phases);
 
  const int64_t units = active_before - stats.active;
 
  if (!res && units)
    LOG ("lucky %zd units", units);
  searching_lucky_phases = false;
  STOP (lucky);
  STOP (search);
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lucky_propagate_discrepency()

bool CaDiCaL::Internal::lucky_propagate_discrepency ( int dec )

inline

Definition at line 129 of file cadical_lucky.cpp.

                                                          {
  search_assume_decision (dec);
  bool no_conflict = propagate ();
  if (no_conflict)
    return false;
  if (level > 1) {
    backtrack (level - 1);
    search_assume_decision (-dec);
    no_conflict = propagate ();
    if (no_conflict)
      return false;
    return true;
  } else {
    analyze ();
    CADICAL_assert (!level);
    no_conflict = propagate ();
    if (!no_conflict) {
      analyze ();
      LOG ("lucky inconsistency backward assigning to true");
      return true;
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark() [1/2]

void CaDiCaL::Internal::mark ( Clause * c )

Definition at line 13 of file cadical_clause.cpp.

                              {
  for (const auto &lit : *c)
    mark (lit);
}

◆ mark() [2/2]

void CaDiCaL::Internal::mark ( int lit )

inline

Definition at line 484 of file internal.hpp.

                      {
    CADICAL_assert (!marked (lit));
    marks[vidx (lit)] = sign (lit);
    CADICAL_assert (marked (lit) > 0);
    CADICAL_assert (marked (-lit) < 0);
  }

Here is the call graph for this function:

◆ mark2() [1/2]

void CaDiCaL::Internal::mark2 ( Clause * c )

Definition at line 18 of file cadical_clause.cpp.

                               {
  for (const auto &lit : *c)
    mark2 (lit);
}

Here is the call graph for this function:

◆ mark2() [2/2]

void CaDiCaL::Internal::mark2 ( int lit )

inline

Definition at line 561 of file internal.hpp.

                       {
    marks[vidx (lit)] |= bign (lit);
    CADICAL_assert (marked2 (lit));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark67()

void CaDiCaL::Internal::mark67 ( int lit )

inline

Definition at line 504 of file internal.hpp.

                        {
    signed char &m = marks[vidx (lit)];
    const signed char mask = 0x3f;
#ifndef CADICAL_NDEBUG
    const signed char bits = m & mask;
#endif
    m = (m & mask) | (sign (lit) << 6);
    CADICAL_assert (marked (lit) > 0);
    CADICAL_assert (marked (-lit) < 0);
    CADICAL_assert ((m & mask) == bits);
    CADICAL_assert (marked67 (lit) > 0);
    CADICAL_assert (marked67 (-lit) < 0);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_active()

void CaDiCaL::Internal::mark_active ( int lit )

Definition at line 80 of file cadical_flags.cpp.

                                   {
  Flags &f = flags (lit);
  CADICAL_assert (f.status == Flags::UNUSED);
  f.status = Flags::ACTIVE;
  LOG ("activate %d previously unused", abs (lit));
  CADICAL_assert (stats.inactive);
  stats.inactive--;
  CADICAL_assert (stats.unused);
  stats.unused--;
  stats.active++;
  CADICAL_assert (active (lit));
}

Here is the call graph for this function:

◆ mark_added() [1/2]

void CaDiCaL::Internal::mark_added ( Clause * c )

Definition at line 73 of file cadical_clause.cpp.

                                    {
  LOG (c, "marking added");
  CADICAL_assert (likely_to_be_kept_clause (c));
  for (const auto &lit : *c)
    mark_added (lit, c->size, c->redundant);
}

Here is the call graph for this function:

◆ mark_added() [2/2]

void CaDiCaL::Internal::mark_added	(	int	lit,
		int	size,
		bool	redundant )

inline

Definition at line 63 of file cadical_clause.cpp.

                                                                   {
  mark_subsume (lit);
  if (size == 3)
    mark_ternary (lit);
  if (!redundant)
    mark_block (lit);
  if (!redundant || size == 2)
    mark_factor (lit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_as_conditional_literal()

void CaDiCaL::Internal::mark_as_conditional_literal ( int lit )

inline

Definition at line 109 of file cadical_condition.cpp.

                                                          {
  LOG ("marking %d as conditional literal", lit);
  CADICAL_assert (val (lit) > 0);
  setbit (lit, 0);
  CADICAL_assert (is_conditional_literal (lit));
  CADICAL_assert (!is_autarky_literal (lit));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_binary_literals()

void CaDiCaL::Internal::mark_binary_literals	(	Eliminator &	eliminator,
		int	pivot )

Definition at line 113 of file cadical_gates.cpp.

                                                                      {
 
  if (unsat)
    return;
  if (val (first))
    return;
  if (!eliminator.gates.empty ())
    return;
 
  CADICAL_assert (!marked (first));
  CADICAL_assert (eliminator.marked.empty ());
 
  const Occs &os = occs (first);
  for (const auto &c : os) {
    if (c->garbage)
      continue;
    const int second =
        second_literal_in_binary_clause (eliminator, c, first);
    if (!second)
      continue;
    const int tmp = marked (second);
    if (tmp < 0) {
      // had a bug where units could occur multiple times here
      // solved with flags
      LOG ("found binary resolved unit %d", first);
      if (lrat) {
        Clause *d = find_binary_clause (first, -second);
        CADICAL_assert (d);
        for (auto &lit : *d) {
          if (lit == first || lit == -second)
            continue;
          CADICAL_assert (val (lit) < 0);
          Flags &f = flags (lit);
          if (f.seen)
            continue;
          analyzed.push_back (lit);
          f.seen = true;
          int64_t id = unit_id (-lit);
          lrat_chain.push_back (id);
          // LOG ("gates added id %" PRId64, id);
        }
        for (auto &lit : *c) {
          if (lit == first || lit == second)
            continue;
          CADICAL_assert (val (lit) < 0);
          Flags &f = flags (lit);
          if (f.seen)
            continue;
          analyzed.push_back (lit);
          f.seen = true;
          int64_t id = unit_id (-lit);
          lrat_chain.push_back (id);
          // LOG ("gates added id %" PRId64, id);
        }
        lrat_chain.push_back (c->id);
        lrat_chain.push_back (d->id);
        // LOG ("gates added id %" PRId64, c->id);
        // LOG ("gates added id %" PRId64, d->id);
        clear_analyzed_literals ();
      }
      assign_unit (first);
      elim_propagate (eliminator, first);
      return;
    }
    if (tmp > 0) {
      LOG (c, "duplicated actual binary clause");
      elim_update_removed_clause (eliminator, c);
      mark_garbage (c);
      continue;
    }
    eliminator.marked.push_back (second);
    mark (second);
    LOG ("marked second literal %d in binary clause %d %d", second, first,
         second);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_block()

void CaDiCaL::Internal::mark_block ( int lit )

inline

Definition at line 1072 of file internal.hpp.

                            {
    Flags &f = flags (lit);
    const unsigned bit = bign (lit);
    if (f.block & bit)
      return;
    LOG ("marking %d as blocking literal candidate", lit);
    stats.mark.block++;
    f.block |= bit;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_clause()

void CaDiCaL::Internal::mark_clause ( )

Definition at line 28 of file cadical_clause.cpp.

                            {
  for (const auto &lit : clause)
    mark (lit);
}

◆ mark_clauses_to_be_flushed()

void CaDiCaL::Internal::mark_clauses_to_be_flushed ( )

Definition at line 38 of file cadical_reduce.cpp.

                                           {
  const int tier1limit = tier1[false];
  const int tier2limit = max (tier1limit, tier2[false]);
  for (const auto &c : clauses) {
    if (!c->redundant)
      continue; // keep irredundant
    if (c->garbage)
      continue; // already marked as garbage
    if (c->reason)
      continue; // need to keep reasons
    const unsigned used = c->used;
    if (used)
      c->used--;
    if (c->glue < tier1limit && used)
      continue;
    if (c->glue < tier2limit && used >= max_used - 1)
      continue;
    mark_garbage (c); // flush unused clauses
    if (c->hyper)
      stats.flush.hyper++;
    else
      stats.flush.learned++;
  }
  // No change to 'lim.kept{size,glue}'.
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_decomposed()

void CaDiCaL::Internal::mark_decomposed ( int lit )

inline

Definition at line 1119 of file internal.hpp.

                                 {
    Flags &f = flags (lit);
    const unsigned bit = bign (lit);
    CADICAL_assert ((f.marked_signed & bit) == 0);
    sign_marked.push_back (lit);
    f.marked_signed |= bit;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_duplicated_binary_clauses_as_garbage()

void CaDiCaL::Internal::mark_duplicated_binary_clauses_as_garbage ( )

Definition at line 24 of file cadical_deduplicate.cpp.

                                                          {
 
  if (!opts.deduplicate)
    return;
  if (unsat)
    return;
  if (terminated_asynchronously ())
    return;
 
  START_SIMPLIFIER (deduplicate, DEDUP);
  stats.deduplications++;
 
  CADICAL_assert (!level);
  CADICAL_assert (watching ());
 
  vector<int> stack; // To save marked literals and unmark them later.
 
  int64_t subsumed = 0;
  int64_t units = 0;
 
  for (auto idx : vars) {
 
    if (unsat)
      break;
    if (!active (idx))
      continue;
    int unit = 0;
 
    for (int sign = -1; !unit && sign <= 1; sign += 2) {
 
      const int lit = sign * idx; // Consider all literals.
 
      CADICAL_assert (stack.empty ());
      Watches &ws = watches (lit);
 
      // We are removing references to garbage clause. Thus no 'auto'.
 
      const const_watch_iterator end = ws.end ();
      watch_iterator j = ws.begin ();
      const_watch_iterator i;
 
      for (i = j; !unit && i != end; i++) {
        Watch w = *j++ = *i;
        if (!w.binary ())
          continue;
        int other = w.blit;
        const int tmp = marked (other);
        Clause *c = w.clause;
 
        if (tmp > 0) { // Found duplicated binary clause.
 
          if (c->garbage) {
            j--;
            continue;
          }
          LOG (c, "found duplicated");
 
          // The previous identical clause 'd' might be redundant and if the
          // second clause 'c' is not (so irredundant), then we have to keep
          // 'c' instead of 'd', thus we search for it and replace it.
 
          if (!c->redundant) {
            watch_iterator k;
            for (k = ws.begin ();; k++) {
              CADICAL_assert (k != i);
              if (!k->binary ())
                continue;
              if (k->blit != other)
                continue;
              Clause *d = k->clause;
              if (d->garbage)
                continue;
              c = d;
              break;
            }
            *k = w;
          }
 
          LOG (c, "mark garbage duplicated");
          stats.subsumed++;
          stats.deduplicated++;
          subsumed++;
          mark_garbage (c);
          j--;
 
        } else if (tmp < 0) { // Hyper unary resolution.
 
          LOG ("found %d %d and %d %d which produces unit %d", lit, -other,
               lit, other, lit);
          unit = lit;
          if (lrat) {
            // taken from fradical
            CADICAL_assert (lrat_chain.empty ());
            lrat_chain.push_back (c->id);
            // We've forgotten where the other binary clause is, so go find
            // it again
            for (watch_iterator k = ws.begin ();; k++) {
              CADICAL_assert (k != i);
              if (!k->binary ())
                continue;
              if (k->blit != -other)
                continue;
              lrat_chain.push_back (k->clause->id);
              break;
            }
          }
          j = ws.begin (); // Flush 'ws'.
          units++;
 
        } else {
          if (c->garbage)
            continue;
          mark (other);
          stack.push_back (other);
        }
      }
 
      if (j == ws.begin ())
        erase_vector (ws);
      else if (j != end)
        ws.resize (j - ws.begin ()); // Shrink watchers.
 
      for (const auto &other : stack)
        unmark (other);
 
      stack.clear ();
    }
 
    // Propagation potentially messes up the watches and thus we can not
    // propagate the unit immediately after finding it.  Instead we break
    // out of both loops and assign and propagate the unit here.
 
    if (unit) {
 
      stats.failed++;
      stats.hyperunary++;
      assign_unit (unit);
      // lrat_chain.clear ();   done in search_assign
 
      if (!propagate ()) {
        LOG ("empty clause after propagating unit");
        learn_empty_clause ();
      }
    }
  }
  STOP_SIMPLIFIER (deduplicate, DEDUP);
 
  report ('2', !opts.reportall && !(subsumed + units));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_elim()

void CaDiCaL::Internal::mark_elim ( int lit )

inline

Definition at line 1064 of file internal.hpp.

                           {
    Flags &f = flags (lit);
    if (f.elim)
      return;
    LOG ("marking %d as elimination literal candidate", lit);
    stats.mark.elim++;
    f.elim = true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_eliminated()

void CaDiCaL::Internal::mark_eliminated ( int lit )

Definition at line 38 of file cadical_flags.cpp.

                                       {
  Flags &f = flags (lit);
  CADICAL_assert (f.status == Flags::ACTIVE);
  f.status = Flags::ELIMINATED;
  LOG ("eliminated %d", abs (lit));
  stats.all.eliminated++;
  stats.now.eliminated++;
  stats.inactive++;
  CADICAL_assert (stats.active);
  stats.active--;
  CADICAL_assert (!active (lit));
  CADICAL_assert (f.eliminated ());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_eliminated_clauses_as_garbage()

void CaDiCaL::Internal::mark_eliminated_clauses_as_garbage	(	Eliminator &	eliminator,
		int	pivot,
		bool &	deleted_binary_clause )

Definition at line 616 of file cadical_elim.cpp.

                                                                    {
  CADICAL_assert (!unsat);
 
  LOG ("marking irredundant clauses with %d as garbage", pivot);
 
  const int64_t substitute = eliminator.gates.size ();
  if (substitute)
    LOG ("pushing %" PRId64 " gate clauses on extension stack", substitute);
#ifndef CADICAL_NDEBUG
  int64_t pushed = 0;
#endif
  Occs &ps = occs (pivot);
  for (const auto &c : ps) {
    if (c->garbage)
      continue;
    CADICAL_assert (!c->redundant);
    if (!substitute || c->gate) {
      if (proof)
        proof->weaken_minus (c);
      if (c->size == 2)
        deleted_binary_clause = true;
      external->push_clause_on_extension_stack (c, pivot);
#ifndef CADICAL_NDEBUG
      pushed++;
#endif
    }
    mark_garbage (c);
    elim_update_removed_clause (eliminator, c, pivot);
  }
  erase_occs (ps);
 
  LOG ("marking irredundant clauses with %d as garbage", -pivot);
 
  Occs &ns = occs (-pivot);
  for (const auto &d : ns) {
    if (d->garbage)
      continue;
    CADICAL_assert (!d->redundant);
    if (!substitute || d->gate) {
      if (proof)
        proof->weaken_minus (d);
      if (d->size == 2)
        deleted_binary_clause = true;
      external->push_clause_on_extension_stack (d, -pivot);
#ifndef CADICAL_NDEBUG
      pushed++;
#endif
    }
    mark_garbage (d);
    elim_update_removed_clause (eliminator, d, -pivot);
  }
  erase_occs (ns);
 
  if (substitute)
    CADICAL_assert (pushed <= substitute);
 
  // Unfortunately, we can not use the trick by Niklas Soerensson anymore,
  // which avoids saving all clauses on the extension stack.  This would
  // break our new incremental 'restore' logic.
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_factor()

void CaDiCaL::Internal::mark_factor ( int lit )

inline

Definition at line 1043 of file internal.hpp.

                             {
    Flags &f = flags (lit);
    const unsigned bit = bign (lit);
    if (f.factor & bit)
      return;
    LOG ("marking %d as factor literal candidate", lit);
    stats.mark.factor++;
    f.factor |= bit;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_fixed()

void CaDiCaL::Internal::mark_fixed ( int lit )

Definition at line 9 of file cadical_flags.cpp.

                                  {
  if (external->fixed_listener) {
    int elit = externalize (lit);
    CADICAL_assert (elit);
    const int eidx = abs (elit);
    if (!external->ervars[eidx])
      external->fixed_listener->notify_fixed_assignment (elit);
  }
  Flags &f = flags (lit);
  CADICAL_assert (f.status == Flags::ACTIVE);
  f.status = Flags::FIXED;
  LOG ("fixed %d", abs (lit));
  stats.all.fixed++;
  stats.now.fixed++;
  stats.inactive++;
  CADICAL_assert (stats.active);
  stats.active--;
  CADICAL_assert (!active (lit));
  CADICAL_assert (f.fixed ());
 
  if (external_prop && private_steps) {
    // If pre/inprocessing found a fixed assignment, we want the propagator
    // to know about it.
    // But at that point it is not guaranteed to be already on the trail, so
    // notification will happen only later.
    CADICAL_assert (!level);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_garbage()

void CaDiCaL::Internal::mark_garbage ( Clause * c )

Definition at line 301 of file cadical_clause.cpp.

                                      {
 
  CADICAL_assert (!c->garbage);
 
  // Delay tracing deletion of binary clauses.  See the discussion above in
  // 'delete_clause' and also in 'propagate'.
  //
  if (proof && (c->size != 2 || !watching ())) {
    c->flushed = true;
    proof->delete_clause (c);
  }
 
  // Because of the internal model checking, external forgettable clauses
  // must be marked as removed already upon mark_garbage, can not wait until
  // actual deletion.
  if (opts.check && is_external_forgettable (c->id))
    mark_garbage_external_forgettable (c->id);
 
  CADICAL_assert (stats.current.total > 0);
  stats.current.total--;
 
  size_t bytes = c->bytes ();
  if (c->redundant) {
    CADICAL_assert (stats.current.redundant > 0);
    stats.current.redundant--;
  } else {
    CADICAL_assert (stats.current.irredundant > 0);
    stats.current.irredundant--;
    CADICAL_assert (stats.irrlits >= c->size);
    stats.irrlits -= c->size;
    mark_removed (c);
  }
  stats.garbage.bytes += bytes;
  stats.garbage.clauses++;
  stats.garbage.literals += c->size;
  c->garbage = true;
  c->used = 0;
 
  LOG (c, "marked garbage pointer %p", (void *) c);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_garbage_external_forgettable()

void CaDiCaL::Internal::mark_garbage_external_forgettable ( int64_t id )

Definition at line 1070 of file cadical_external_propagate.cpp.

                                                            {
  CADICAL_assert (opts.check);
  CADICAL_assert (is_external_forgettable (id));
 
  LOG (external->forgettable_original[id],
       "forgettable external lemma is deleted:");
  // Mark as removed by flipping the first flag to false.
  external->forgettable_original[id][0] = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_in_candidate_clause()

void CaDiCaL::Internal::mark_in_candidate_clause ( int lit )

inline

Definition at line 134 of file cadical_condition.cpp.

                                                       {
  LOG ("marking %d as literal of the candidate clause", lit);
  mark67 (lit);
  CADICAL_assert (is_in_candidate_clause (lit));
  CADICAL_assert (!is_in_candidate_clause (-lit));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_incomplete()

void CaDiCaL::Internal::mark_incomplete ( Sweeper & sweeper )

Definition at line 1805 of file cadical_sweep.cpp.

                                                {
  unsigned marked = 0;
  for (all_scheduled (idx)) {
    if (!flags (idx).sweep) {
      flags (idx).sweep = true;
      marked++;
    }
  }
  sweep_incomplete = true;
#ifndef CADICAL_QUIET
  VERBOSE (2, "marked %u scheduled sweeping variables as incomplete",
           marked);
#else
  (void) marked;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_pure()

void CaDiCaL::Internal::mark_pure ( int lit )

Definition at line 52 of file cadical_flags.cpp.

                                 {
  Flags &f = flags (lit);
  CADICAL_assert (f.status == Flags::ACTIVE);
  f.status = Flags::PURE;
  LOG ("pure %d", abs (lit));
  stats.all.pure++;
  stats.now.pure++;
  stats.inactive++;
  CADICAL_assert (stats.active);
  stats.active--;
  CADICAL_assert (!active (lit));
  CADICAL_assert (f.pure ());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_redundant_clauses_with_eliminated_variables_as_garbage()

void CaDiCaL::Internal::mark_redundant_clauses_with_eliminated_variables_as_garbage ( )

Definition at line 741 of file cadical_elim.cpp.

                                                                   {
  for (const auto &c : clauses) {
    if (c->garbage || !c->redundant)
      continue;
    bool clean = true;
    for (const auto &lit : *c) {
      Flags &f = flags (lit);
      if (f.eliminated ()) {
        clean = false;
        break;
      }
      if (f.pure ()) {
        clean = false;
        break;
      }
    }
    if (!clean)
      mark_garbage (c);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_removed() [1/2]

void CaDiCaL::Internal::mark_removed	(	Clause *	c,
		int	except = 0 )

Definition at line 46 of file cadical_clause.cpp.

                                                  {
  LOG (c, "marking removed");
  CADICAL_assert (!c->redundant);
  for (const auto &lit : *c)
    if (lit != except)
      mark_removed (lit);
}

Here is the call graph for this function:

◆ mark_removed() [2/2]

void CaDiCaL::Internal::mark_removed ( int lit )

inline

Definition at line 1081 of file internal.hpp.

                              {
    mark_elim (lit);
    mark_block (-lit);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_satisfied_clauses_as_garbage()

void CaDiCaL::Internal::mark_satisfied_clauses_as_garbage ( )

Definition at line 77 of file cadical_collect.cpp.

                                                  {
 
  if (last.collect.fixed >= stats.all.fixed)
    return;
  last.collect.fixed = stats.all.fixed;
 
  LOG ("marking satisfied clauses and removing falsified literals");
 
  for (const auto &c : clauses) {
    if (c->garbage)
      continue;
    const int tmp = clause_contains_fixed_literal (c);
    if (tmp > 0)
      mark_garbage (c);
    else if (tmp < 0)
      remove_falsified_literals (c);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_shrinkable_as_removable()

void CaDiCaL::Internal::mark_shrinkable_as_removable	(	int	blevel,
		std::vector< int >::size_type	minimized_start )

Definition at line 26 of file cadical_shrink.cpp.

                                                         {
#ifdef LOGGING
  size_t marked = 0, reset = 0;
#endif
#ifndef CADICAL_NDEBUG
  unsigned kept = 0, minireset = 0;
  for (; minimized_start < minimized.size (); ++minimized_start) {
    const int lit = minimized[minimized_start];
    Flags &f = flags (lit);
    const Var &v = var (lit);
    if (v.level == blevel) {
      CADICAL_assert (!f.poison);
      ++minireset;
    } else
      ++kept;
  }
  (void) kept;
  (void) minireset;
#else
  (void) blevel;
  (void) minimized_start;
#endif
 
  for (const int lit : shrinkable) {
    Flags &f = flags (lit);
    CADICAL_assert (f.shrinkable);
    CADICAL_assert (!f.poison);
    f.shrinkable = false;
#ifdef LOGGING
    ++reset;
#endif
    if (f.removable)
      continue;
    f.removable = true;
    minimized.push_back (lit);
#ifdef LOGGING
    ++marked;
#endif
  }
  LOG ("resetting %zu shrinkable variables", reset);
  LOG ("marked %zu removable variables", marked);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_skip()

void CaDiCaL::Internal::mark_skip ( int lit )

inline

Definition at line 1103 of file internal.hpp.

                           {
    Flags &f = flags (lit);
    const unsigned bit = bign (lit);
    if (f.skip & bit)
      return;
    LOG ("marking %d to be skipped as blocking literal", lit);
    f.skip |= bit;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_substituted()

void CaDiCaL::Internal::mark_substituted ( int lit )

Definition at line 66 of file cadical_flags.cpp.

                                        {
  Flags &f = flags (lit);
  CADICAL_assert (f.status == Flags::ACTIVE);
  f.status = Flags::SUBSTITUTED;
  LOG ("substituted %d", abs (lit));
  stats.all.substituted++;
  stats.now.substituted++;
  stats.inactive++;
  CADICAL_assert (stats.active);
  stats.active--;
  CADICAL_assert (!active (lit));
  CADICAL_assert (f.substituted ());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_subsume()

void CaDiCaL::Internal::mark_subsume ( int lit )

inline

Definition at line 1027 of file internal.hpp.

                              {
    Flags &f = flags (lit);
    if (f.subsume)
      return;
    LOG ("marking %d as subsuming literal candidate", abs (lit));
    stats.mark.subsume++;
    f.subsume = true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_ternary()

void CaDiCaL::Internal::mark_ternary ( int lit )

inline

Definition at line 1035 of file internal.hpp.

                              {
    Flags &f = flags (lit);
    if (f.ternary)
      return;
    LOG ("marking %d as ternary resolution literal candidate", abs (lit));
    stats.mark.ternary++;
    f.ternary = true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mark_useless_redundant_clauses_as_garbage()

void CaDiCaL::Internal::mark_useless_redundant_clauses_as_garbage ( )

Definition at line 92 of file cadical_reduce.cpp.

                                                          {
 
  // We use a separate stack for sorting candidates for removal.  This uses
  // (slightly) more memory but has the advantage to keep the relative order
  // in 'clauses' intact, which actually due to using stable sorting goes
  // into the candidate selection (more recently learned clauses are kept if
  // they otherwise have the same glue and size).
 
  vector<Clause *> stack;
  const int tier1limit = tier1[false];
  const int tier2limit = max (tier1limit, tier2[false]);
 
  stack.reserve (stats.current.redundant);
 
  for (const auto &c : clauses) {
    if (!c->redundant)
      continue; // Keep irredundant.
    if (c->garbage)
      continue; // Skip already marked.
    if (c->reason)
      continue; // Need to keep reasons.
    const unsigned used = c->used;
    if (used)
      c->used--;
    if (c->glue <= tier1limit && used)
      continue;
    if (c->glue <= tier2limit && used >= max_used - 1)
      continue;
    if (c->hyper) {          // Hyper binary and ternary resolvents
      CADICAL_assert (c->size <= 3); // are only kept for one reduce round
      if (!used)
        mark_garbage (c); // unless
      continue;           //  used recently.
    }
    stack.push_back (c);
  }
 
  stable_sort (stack.begin (), stack.end (), reduce_less_useful ());
  size_t target = 1e-2 * opts.reducetarget * stack.size ();
 
  // This is defensive code, which I usually consider a bug, but here I am
  // just not sure that using floating points in the line above is precise
  // in all situations and instead of figuring that out, I just use this.
  //
  if (target > stack.size ())
    target = stack.size ();
 
  PHASE ("reduce", stats.reductions, "reducing %zd clauses %.0f%%", target,
         percent (target, stats.current.redundant));
 
  auto i = stack.begin ();
  const auto t = i + target;
  while (i != t) {
    Clause *c = *i++;
    LOG (c, "marking useless to be collected");
    mark_garbage (c);
    stats.reduced++;
  }
 
  lim.keptsize = lim.keptglue = 0;
 
  const auto end = stack.end ();
  for (i = t; i != end; i++) {
    Clause *c = *i;
    LOG (c, "keeping");
    if (c->size > lim.keptsize)
      lim.keptsize = c->size;
    if (c->glue > lim.keptglue)
      lim.keptglue = c->glue;
  }
 
  erase_vector (stack);
 
  PHASE ("reduce", stats.reductions, "maximum kept size %d glue %d",
         lim.keptsize, lim.keptglue);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ marked()

signed char CaDiCaL::Internal::marked ( int lit ) const

inline

Definition at line 478 of file internal.hpp.

                                     {
    signed char res = marks[vidx (lit)];
    if (lit < 0)
      res = -res;
    return res;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ marked2()

bool CaDiCaL::Internal::marked2 ( int lit ) const

inline

Definition at line 555 of file internal.hpp.

                               {
    unsigned res = marks[vidx (lit)];
    CADICAL_assert (res <= 3);
    unsigned bit = bign (lit);
    return (res & bit) != 0;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ marked67()

signed char CaDiCaL::Internal::marked67 ( int lit ) const

inline

Definition at line 498 of file internal.hpp.

                                       {
    signed char res = marks[vidx (lit)] >> 6;
    if (lit < 0)
      res = -res;
    return res;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ marked_block()

bool CaDiCaL::Internal::marked_block ( int lit ) const

inline

Definition at line 1089 of file internal.hpp.

                                    {
    const Flags &f = flags (lit);
    const unsigned bit = bign (lit);
    return (f.block & bit) != 0;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ marked_decomposed()

bool CaDiCaL::Internal::marked_decomposed ( int lit )

inline

Definition at line 1131 of file internal.hpp.

                                   {
    const Flags &f = flags (lit);
    const unsigned bit = bign (lit);
    return (f.marked_signed & bit) != 0;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ marked_skip()

bool CaDiCaL::Internal::marked_skip ( int lit )

inline

Definition at line 1111 of file internal.hpp.

                             {
    const Flags &f = flags (lit);
    const unsigned bit = bign (lit);
    return (f.skip & bit) != 0;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ marked_subsume()

bool CaDiCaL::Internal::marked_subsume ( int lit ) const

inline

Definition at line 1055 of file internal.hpp.

1055{ return flags (lit).subsume; }

Here is the call graph for this function:

◆ markfact()

void CaDiCaL::Internal::markfact	(	int	lit,
		int	fact )

inline

Definition at line 580 of file internal.hpp.

                                    {
    CADICAL_assert (fact == 1 || fact == 2 || fact == 4);
    CADICAL_assert (!getfact (lit, fact));
#ifndef CADICAL_NDEBUG
    int before = getfact (-lit, fact);
#endif
    int res = marks[vidx (lit)];
    if (lit < 0) {
      res |= fact << 3;
    } else {
      res |= fact;
    }
    marks[vidx (lit)] = res;
    CADICAL_assert (getfact (lit, fact));
#ifndef CADICAL_NDEBUG
    CADICAL_assert (getfact (-lit, fact) == before);
#endif
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ match_ternary_clause()

bool CaDiCaL::Internal::match_ternary_clause	(	Clause *	d,
		int	a,
		int	b,
		int	c )

Definition at line 476 of file cadical_gates.cpp.

                                                                   {
  if (d->garbage)
    return false;
  int found = 0;
  for (const auto &lit : *d) {
    if (val (lit))
      continue;
    if (a != lit && b != lit && c != lit)
      return false;
    found++;
  }
  return found == 3;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ melt()

void CaDiCaL::Internal::melt ( int lit )

inline

Definition at line 1585 of file internal.hpp.

                      {
    int idx = vidx (lit);
    unsigned &ref = frozentab[idx];
    if (ref < UINT_MAX) {
      if (!--ref) {
        if (relevanttab[idx]) {
          LOG ("variable %d is observed, can not be completely molten",
               idx);
          ref++;
        } else
          LOG ("variable %d completely molten", idx);
      } else
        LOG ("variable %d melted once but remains frozen %u times", lit,
             ref);
    } else
      LOG ("variable %d remains frozen forever", idx);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ minimize_and_shrink_block()

std::vector< int >::reverse_iterator CaDiCaL::Internal::minimize_and_shrink_block	(	std::vector< int >::reverse_iterator &	,
		unsigned int &	,
		unsigned int &	,
		const int	)

Definition at line 371 of file cadical_shrink.cpp.

{
  LOG ("shrinking block");
  CADICAL_assert (rbegin_block < clause.rend () - 1);
  int blevel;
  unsigned open = 0;
  unsigned max_trail;
 
  // find begining of block;
  std::vector<int>::reverse_iterator rend_block;
  {
    CADICAL_assert (rbegin_block <= clause.rend ());
    const int lit = *rbegin_block;
    const int idx = vidx (lit);
    blevel = vtab[idx].level;
    max_trail = vtab[idx].trail;
    LOG ("Block at level %i (first lit: %i)", blevel, lit);
 
    rend_block = rbegin_block;
    bool finished;
    do {
      CADICAL_assert (rend_block < clause.rend () - 1);
      const int lit = *(++rend_block);
      const int idx = vidx (lit);
      finished = (blevel != vtab[idx].level);
      if (!finished && (unsigned) vtab[idx].trail > max_trail)
        max_trail = vtab[idx].trail;
      ++open;
      LOG (
          "testing if lit %i is on the same level (of lit: %i, global: %i)",
          lit, vtab[idx].level, blevel);
 
    } while (!finished);
  }
  CADICAL_assert (open > 0);
  CADICAL_assert (open < clause.size ());
  CADICAL_assert (rbegin_block < clause.rend ());
  CADICAL_assert (rend_block < clause.rend ());
 
  unsigned block_shrunken = 0, block_minimized = 0;
  if (open < 2) {
    flags (*rbegin_block).keep = true;
    minimized.push_back (*rbegin_block);
  } else
    block_shrunken = shrink_block (rbegin_block, rend_block, blevel, open,
                                   block_minimized, uip0, max_trail);
 
  LOG ("shrunken %u literals on level %u (including %u minimized)",
       block_shrunken, blevel, block_minimized);
 
  total_shrunken += block_shrunken;
  total_minimized += block_minimized;
 
  return rend_block;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ minimize_clause()

void CaDiCaL::Internal::minimize_clause ( )

Definition at line 114 of file cadical_minimize.cpp.

                                {
  START (minimize);
  LOG (clause, "minimizing first UIP clause");
 
  external->check_learned_clause (); // check 1st UIP learned clause first
  minimize_sort_clause ();
 
  CADICAL_assert (minimized.empty ());
  CADICAL_assert (minimize_chain.empty ());
  const auto end = clause.end ();
  auto j = clause.begin (), i = j;
  std::vector<int> stack;
  for (; i != end; i++) {
    if (minimize_literal (-*i)) {
      if (lrat) {
        CADICAL_assert (mini_chain.empty ());
        calculate_minimize_chain (-*i, stack);
        for (auto p : mini_chain) {
          minimize_chain.push_back (p);
        }
        mini_chain.clear ();
      }
      stats.minimized++;
    } else
      flags (*j++ = *i).keep = true;
  }
  LOG ("minimized %zd literals", (size_t) (clause.end () - j));
  if (j != end)
    clause.resize (j - clause.begin ());
  clear_minimized_literals ();
  for (auto p = minimize_chain.rbegin (); p != minimize_chain.rend ();
       p++) {
    lrat_chain.push_back (*p);
  }
  minimize_chain.clear ();
  STOP (minimize);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ minimize_literal()

bool CaDiCaL::Internal::minimize_literal	(	int	lit,
		int	depth = 0 )

Definition at line 21 of file cadical_minimize.cpp.

                                                   {
  LOG ("attempt to minimize lit %d at depth %d", lit, depth);
  CADICAL_assert (val (lit) > 0);
  Flags &f = flags (lit);
  Var &v = var (lit);
  if (!v.level || f.removable || f.keep)
    return true;
  if (!v.reason || f.poison || v.level == level)
    return false;
  const Level &l = control[v.level];
  if (!depth && l.seen.count < 2)
    return false; // Don Knuth's idea
  if (v.trail <= l.seen.trail)
    return false; // new early abort
  if (depth > opts.minimizedepth)
    return false;
  bool res = true;
  CADICAL_assert (v.reason);
  if (opts.minimizeticks)
    stats.ticks.search[stable]++;
  if (v.reason == external_reason) {
    CADICAL_assert (!opts.exteagerreasons);
    v.reason = learn_external_reason_clause (lit, 0, true);
    if (!v.reason) {
      CADICAL_assert (!v.level);
      return true;
    }
  }
  CADICAL_assert (v.reason != external_reason);
  const const_literal_iterator end = v.reason->end ();
  const_literal_iterator i;
  for (i = v.reason->begin (); res && i != end; i++) {
    const int other = *i;
    if (other == lit)
      continue;
    res = minimize_literal (-other, depth + 1);
  }
  if (res)
    f.removable = true;
  else
    f.poison = true;
  minimized.push_back (lit);
  if (!depth) {
    LOG ("minimizing %d %s", lit, res ? "succeeded" : "failed");
  }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ minimize_sort_clause()

void CaDiCaL::Internal::minimize_sort_clause ( )

Definition at line 209 of file cadical_minimize.cpp.

                                     {
  MSORT (opts.radixsortlim, clause.begin (), clause.end (),
         minimize_trail_positive_rank (this),
         minimize_trail_smaller (this));
}

Here is the caller graph for this function:

◆ most_occurring_literal()

int CaDiCaL::Internal::most_occurring_literal ( )

Definition at line 51 of file cadical_lookahead.cpp.

                                      {
  init_noccs ();
  for (const auto &c : clauses)
    if (!c->redundant)
      for (const auto &lit : *c)
        if (active (lit))
          noccs (lit)++;
  int64_t max_noccs = 0;
  int res = 0;
 
  if (unsat)
    return INT_MIN;
 
  propagate ();
  for (int idx = 1; idx <= max_var; idx++) {
    if (!active (idx) || assumed (idx) || assumed (-idx) || val (idx))
      continue;
    for (int sign = -1; sign <= 1; sign += 2) {
      const int lit = sign * idx;
      if (!active (lit))
        continue;
      int64_t tmp = noccs (lit);
      if (tmp <= max_noccs)
        continue;
      max_noccs = tmp;
      res = lit;
    }
  }
  MSG ("maximum occurrence %" PRId64 " of literal %d", max_noccs, res);
  reset_noccs ();
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ move_literals_to_watch()

void CaDiCaL::Internal::move_literals_to_watch ( )

Definition at line 404 of file cadical_external_propagate.cpp.

                                       {
  if (clause.size () < 2)
    return;
  if (!level)
    return;
 
  for (int i = 0; i < 2; i++) {
    int highest_position = i;
    int highest_literal = clause[i];
 
    int highest_level = var (highest_literal).level;
    int highest_value = val (highest_literal);
 
    for (size_t j = i + 1; j < clause.size (); j++) {
      const int other = clause[j];
      const int other_level = var (other).level;
      const int other_value = val (other);
 
      if (other_value < 0) {
        if (highest_value >= 0)
          continue;
        if (other_level <= highest_level)
          continue;
      } else if (other_value > 0) {
        if (highest_value > 0 && other_level >= highest_level)
          continue;
      } else {
        if (highest_value >= 0)
          continue;
      }
 
      highest_position = j;
      highest_literal = other;
      highest_level = other_level;
      highest_value = other_value;
    }
#ifndef CADICAL_NDEBUG
    LOG ("highest position: %d highest level: %d highest value: %d",
         highest_position, highest_level, highest_value);
#endif
 
    if (highest_position == i)
      continue;
    if (highest_position > i) {
      std::swap (clause[i], clause[highest_position]);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ negative_horn_satisfiable()

int CaDiCaL::Internal::negative_horn_satisfiable ( )

Definition at line 323 of file cadical_lucky.cpp.

                                         {
  LOG ("checking that all clauses are negative horn satisfiable");
  CADICAL_assert (!level);
  CADICAL_assert (assumptions.empty ());
  for (const auto &c : clauses) {
    if (terminated_asynchronously (10))
      return unlucky (-1);
    if (c->garbage)
      continue;
    if (c->redundant)
      continue;
    int negative_literal = 0;
    bool satisfied = false;
    for (const auto &lit : *c) {
      const signed char tmp = val (lit);
      if (tmp > 0) {
        satisfied = true;
        break;
      }
      if (tmp < 0)
        continue;
      if (lit > 0)
        continue;
      negative_literal = lit;
      break;
    }
    if (satisfied)
      continue;
    if (!negative_literal) {
      if (level > 0)
        backtrack ();
      LOG (c, "no negative unassigned literal in");
      return unlucky (0);
    }
    CADICAL_assert (negative_literal < 0);
    LOG (c, "found negative literal %d in", negative_literal);
    search_assume_decision (negative_literal);
    if (propagate ())
      continue;
    LOG ("propagation of negative literal %d leads to conflict",
         negative_literal);
    return unlucky (0);
  }
  for (auto idx : vars) {
    if (terminated_asynchronously (10))
      return unlucky (-1);
    if (val (idx))
      continue;
    search_assume_decision (idx);
    if (propagate ())
      continue;
    LOG ("propagation of remaining literal %d leads to conflict", idx);
    return unlucky (0);
  }
  VERBOSE (1, "clauses are negative horn satisfied");
  CADICAL_assert (!conflict);
  CADICAL_assert (satisfied ());
  stats.lucky.horn.negative++;
  return 10;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_clause()

Clause * CaDiCaL::Internal::new_clause	(	bool	red,
		int	glue = 0 )

Definition at line 82 of file cadical_clause.cpp.

                                                {
 
  CADICAL_assert (clause.size () <= (size_t) INT_MAX);
  const int size = (int) clause.size ();
  CADICAL_assert (size >= 2);
 
  if (glue > size)
    glue = size;
 
  size_t bytes = Clause::bytes (size);
  Clause *c = (Clause *) new char[bytes];
  DeferDeleteArray<char> clause_delete ((char *) c);
 
  c->id = ++clause_id;
 
  c->conditioned = false;
  c->covered = false;
  c->enqueued = false;
  c->frozen = false;
  c->garbage = false;
  c->gate = false;
  c->hyper = false;
  c->instantiated = false;
  c->moved = false;
  c->reason = false;
  c->redundant = red;
  c->transred = false;
  c->subsume = false;
  c->swept = false;
  c->flushed = false;
  c->vivified = false;
  c->vivify = false;
  c->used = 0;
 
  c->glue = glue;
  c->size = size;
  c->pos = 2;
 
  for (int i = 0; i < size; i++)
    c->literals[i] = clause[i];
 
  // Just checking that we did not mess up our sophisticated memory layout.
  // This might be compiler dependent though. Crucial for correctness.
  //
  CADICAL_assert (c->bytes () == bytes);
 
  stats.current.total++;
  stats.added.total++;
 
  if (red) {
    stats.current.redundant++;
    stats.added.redundant++;
  } else {
    stats.irrlits += size;
    stats.current.irredundant++;
    stats.added.irredundant++;
  }
 
  clauses.push_back (c);
  clause_delete.release ();
  LOG (c, "new pointer %p", (void *) c);
 
  if (likely_to_be_kept_clause (c))
    mark_added (c);
 
  return c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_clause_as()

Clause * CaDiCaL::Internal::new_clause_as ( const Clause * orig )

Definition at line 622 of file cadical_clause.cpp.

                                                   {
  external->check_learned_clause ();
  const int new_glue = orig->glue;
  Clause *res = new_clause (orig->redundant, new_glue);
  if (proof) {
    proof->add_derived_clause (res, lrat_chain);
  }
  CADICAL_assert (watching ());
  watch_clause (res);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_driving_clause()

Clause * CaDiCaL::Internal::new_driving_clause	(	const int	glue,
		int &	jump )

Definition at line 506 of file cadical_analyze.cpp.

                                                               {
 
  const size_t size = clause.size ();
  Clause *res;
 
  if (!size) {
 
    jump = 0;
    res = 0;
 
  } else if (size == 1) {
 
    iterating = true;
    jump = 0;
    res = 0;
 
  } else {
 
    CADICAL_assert (clause.size () > 1);
 
    // We have to get the last assigned literals into the watch position.
    // Sorting all literals with respect to reverse assignment order is
    // overkill but seems to get slightly faster run-time.  For 'minimize'
    // we sort the literals too heuristically along the trail order (so in
    // the opposite order) with the hope to hit the recursion limit less
    // frequently.  Thus sorting effort is doubled here.
    //
    MSORT (opts.radixsortlim, clause.begin (), clause.end (),
           analyze_trail_negative_rank (this), analyze_trail_larger (this));
 
    jump = var (clause[1]).level;
    res = new_learned_redundant_clause (glue);
    res->used = 1 + (glue <= opts.reducetier2glue);
  }
 
  LOG ("jump level %d", jump);
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_factor_clause()

Clause * CaDiCaL::Internal::new_factor_clause ( )

Definition at line 585 of file cadical_clause.cpp.

                                     {
  external->check_learned_clause ();
  stats.factor_added++;
  stats.literals_factored += clause.size ();
  Clause *res = new_clause (false, 0);
  if (proof) {
    proof->add_derived_clause (res, lrat_chain);
  }
  CADICAL_assert (!watching ());
  CADICAL_assert (occurring ());
  for (const auto &lit : *res) {
    occs (lit).push_back (res);
  }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_hyper_binary_resolved_clause()

Clause * CaDiCaL::Internal::new_hyper_binary_resolved_clause	(	bool	red,
		int	glue )

Definition at line 561 of file cadical_clause.cpp.

                                                                      {
  external->check_learned_clause ();
  Clause *res = new_clause (red, glue);
  if (proof) {
    proof->add_derived_clause (res, lrat_chain);
  }
  CADICAL_assert (watching ());
  watch_clause (res);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_hyper_ternary_resolved_clause()

Clause * CaDiCaL::Internal::new_hyper_ternary_resolved_clause ( bool red )

Definition at line 574 of file cadical_clause.cpp.

                                                             {
  external->check_learned_clause ();
  size_t size = clause.size ();
  Clause *res = new_clause (red, size);
  if (proof) {
    proof->add_derived_clause (res, lrat_chain);
  }
  CADICAL_assert (!watching ());
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_hyper_ternary_resolved_clause_and_watch()

Clause * CaDiCaL::Internal::new_hyper_ternary_resolved_clause_and_watch	(	bool	red,
		bool	full_watching )

Definition at line 604 of file cadical_clause.cpp.

                                                                           {
  external->check_learned_clause ();
  size_t size = clause.size ();
  Clause *res = new_clause (red, size);
  if (proof) {
    proof->add_derived_clause (res, lrat_chain);
  }
  if (full_watching) {
    CADICAL_assert (watching ());
    watch_clause (res);
  }
  return res;
}

Here is the call graph for this function:

◆ new_learned_redundant_clause()

Clause * CaDiCaL::Internal::new_learned_redundant_clause ( int glue )

Definition at line 542 of file cadical_clause.cpp.

                                                        {
  CADICAL_assert (clause.size () > 1);
#ifndef CADICAL_NDEBUG
  for (size_t i = 2; i < clause.size (); i++)
    CADICAL_assert (var (clause[0]).level >= var (clause[i]).level),
        CADICAL_assert (var (clause[1]).level >= var (clause[i]).level);
#endif
  external->check_learned_clause ();
  Clause *res = new_clause (true, glue);
  if (proof) {
    proof->add_derived_clause (res, lrat_chain);
  }
  CADICAL_assert (watching ());
  watch_clause (res);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_proof_on_demand()

void CaDiCaL::Internal::new_proof_on_demand ( )

Definition at line 15 of file cadical_proof.cpp.

                                    {
  if (!proof) {
    LOG ("connecting proof to internal solver");
    proof = new Proof (this);
  }
}

Here is the caller graph for this function:

◆ new_quotient()

Quotient * CaDiCaL::Internal::new_quotient	(	Factoring &	factoring,
		int	factor )

Definition at line 149 of file cadical_factor.cpp.

                                                                  {
  CADICAL_assert (!getfact (factor, FACTORS));
  markfact (factor, FACTORS);
  Quotient *res = new Quotient (factor);
  res->next = 0;
  res->matched = 0;
  Quotient *last = factoring.quotients.last;
  res->bid = 0;
  if (last) {
    CADICAL_assert (factoring.quotients.first);
    CADICAL_assert (!last->next);
    last->next = res;
    res->id = last->id + 1;
  } else {
    CADICAL_assert (!factoring.quotients.first);
    factoring.quotients.first = res;
    res->id = 0;
  }
  factoring.quotients.last = res;
  res->prev = last;
  LOG ("new quotient[%zu] with factor %d", res->id, factor);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_resolved_irredundant_clause()

Clause * CaDiCaL::Internal::new_resolved_irredundant_clause ( )

Definition at line 637 of file cadical_clause.cpp.

                                                   {
  external->check_learned_clause ();
  if (proof) {
    proof->add_derived_clause (clause_id + 1, false, clause, lrat_chain);
  }
  Clause *res = new_clause (false);
  CADICAL_assert (!watching ());
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_trail_level()

void CaDiCaL::Internal::new_trail_level ( int lit )

Definition at line 95 of file cadical_decide.cpp.

                                       {
  level++;
  control.push_back (Level (lit, trail.size ()));
}

Here is the caller graph for this function:

◆ next_decision_variable()

int CaDiCaL::Internal::next_decision_variable ( )

Definition at line 44 of file cadical_decide.cpp.

                                      {
  if (use_scores ())
    return next_decision_variable_with_best_score ();
  else
    return next_decision_variable_on_queue ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ next_decision_variable_on_queue()

int CaDiCaL::Internal::next_decision_variable_on_queue ( )

Definition at line 16 of file cadical_decide.cpp.

                                               {
  int64_t searched = 0;
  int res = queue.unassigned;
  while (val (res))
    res = link (res).prev, searched++;
  if (searched) {
    stats.searched += searched;
    update_queue_unassigned (res);
  }
  LOG ("next queue decision variable %d bumped %" PRId64 "", res,
       bumped (res));
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ next_decision_variable_with_best_score()

int CaDiCaL::Internal::next_decision_variable_with_best_score ( )

Definition at line 32 of file cadical_decide.cpp.

                                                      {
  int res = 0;
  for (;;) {
    res = scores.front ();
    if (!val (res))
      break;
    (void) scores.pop_front ();
  }
  LOG ("next decision variable %d with score %g", res, score (res));
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ next_factor()

int CaDiCaL::Internal::next_factor	(	Factoring &	factoring,
		unsigned *	next_count_ptr )

Definition at line 253 of file cadical_factor.cpp.

                                                                         {
  Quotient *last_quotient = factoring.quotients.last;
  CADICAL_assert (last_quotient);
  vector<Clause *> &last_clauses = last_quotient->qlauses;
  vector<unsigned> &count = factoring.count;
  vector<int> &counted = factoring.counted;
  vector<Clause *> &flauses = factoring.flauses;
  CADICAL_assert (counted.empty ());
  CADICAL_assert (flauses.empty ());
  const int initial = factoring.initial;
  int64_t ticks = 1 + cache_lines (last_clauses.size (), sizeof (Clause *));
  for (auto c : last_clauses) {
    CADICAL_assert (!c->swept);
    int min_lit = 0;
    unsigned factors = 0;
    size_t min_size = 0;
    ticks++;
    for (const auto &other : *c) {
      if (getfact (other, FACTORS)) {
        if (factors++)
          break;
      } else {
        CADICAL_assert (!getfact (other, QUOTIENT));
        markfact (other, QUOTIENT);
        const size_t other_size = occs (other).size ();
        if (!min_lit || other_size < min_size) {
          min_lit = other;
          min_size = other_size;
        }
      }
    }
    CADICAL_assert (factors);
    if (factors == 1) {
      CADICAL_assert (min_lit);
      const int c_size = c->size;
      vector<int> &nounted = factoring.nounted;
      CADICAL_assert (nounted.empty ());
      ticks += 1 + cache_lines (occs (min_lit).size (), sizeof (Clause *));
      for (auto d : occs (min_lit)) {
        if (c == d)
          continue;
        ticks++;
        if (d->swept)
          continue;
        if (d->size != c_size)
          continue;
        int next = 0;
        for (const auto &other : *d) {
          if (getfact (other, QUOTIENT))
            continue;
          if (getfact (other, FACTORS))
            goto CONTINUE_WITH_NEXT_MIN_WATCH;
          if (getfact (other, NOUNTED))
            goto CONTINUE_WITH_NEXT_MIN_WATCH;
          if (next)
            goto CONTINUE_WITH_NEXT_MIN_WATCH;
          next = other;
        }
        CADICAL_assert (next);
        if (abs (next) > abs (initial))
          continue;
        if (!active (next))
          continue;
        CADICAL_assert (!getfact (next, FACTORS));
        CADICAL_assert (!getfact (next, NOUNTED));
        markfact (next, NOUNTED);
        nounted.push_back (next);
        d->swept = true;
        flauses.push_back (d);
        if (!count[vlit (next)])
          counted.push_back (next);
        count[vlit (next)]++;
      CONTINUE_WITH_NEXT_MIN_WATCH:;
      }
      clear_nounted (nounted);
    }
    for (const auto &other : *c)
      if (getfact (other, QUOTIENT))
        unmarkfact (other, QUOTIENT);
    stats.ticks.factor += ticks;
    ticks = 0;
    if (stats.ticks.factor > factoring.limit)
      break;
  }
  clear_flauses (flauses);
  unsigned next_count = 0;
  int next = 0;
  if (stats.ticks.factor <= factoring.limit) {
    unsigned ties = 0;
    for (const auto &lit : counted) {
      const unsigned lit_count = count[vlit (lit)];
      if (lit_count < next_count)
        continue;
      if (lit_count == next_count) {
        CADICAL_assert (lit_count);
        ties++;
      } else {
        CADICAL_assert (lit_count > next_count);
        next_count = lit_count;
        next = lit;
        ties = 1;
      }
    }
    if (next_count < 2) {
      LOG ("next factor count %u smaller than 2", next_count);
      next = 0;
    } else if (ties > 1) {
      LOG ("found %u tied next factor candidate literals with count %u",
           ties, next_count);
      double next_score = -1;
      for (const auto &lit : counted) {
        const unsigned lit_count = count[vlit (lit)];
        if (lit_count != next_count)
          continue;
        double lit_score = tied_next_factor_score (lit);
        CADICAL_assert (lit_score >= 0);
        LOG ("score %g of next factor candidate %d", lit_score, lit);
        if (lit_score <= next_score)
          continue;
        next_score = lit_score;
        next = lit;
      }
      CADICAL_assert (next_score >= 0);
      CADICAL_assert (next);
      LOG ("best score %g of next factor %d", next_score, next);
    } else {
      CADICAL_assert (ties == 1);
      LOG ("single next factor %d with count %u", next, next_count);
    }
  }
  for (const auto &lit : counted)
    count[vlit (lit)] = 0;
  counted.clear ();
  CADICAL_assert (!next || next_count > 1);
  *next_count_ptr = next_count;
  return next;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ next_probe()

int CaDiCaL::Internal::next_probe ( )

Definition at line 753 of file cadical_probe.cpp.

                          {
 
  int generated = 0;
 
  for (;;) {
 
    if (probes.empty ()) {
      if (generated++)
        return 0;
      generate_probes ();
    }
 
    while (!probes.empty ()) {
 
      int probe = probes.back ();
      probes.pop_back ();
 
      // Eliminated or assigned.
      //
      if (!active (probe))
        continue;
 
      // There is now new unit since the last time we propagated this probe,
      // thus we propagated it before without obtaining a conflict and
      // nothing changed since then.  Thus there is no need to propagate it
      // again.  This observation was independently made by Partik Simons
      // et.al. in the context of implementing 'smodels' (see for instance
      // Alg. 4 in his JAIR article from 2002) and it has also been
      // contributed to the thesis work of Yacine Boufkhad.
      //
      if (propfixed (probe) >= stats.all.fixed)
        continue;
 
      return probe;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ next_scheduled()

int CaDiCaL::Internal::next_scheduled ( Sweeper & sweeper )

Definition at line 1008 of file cadical_sweep.cpp.

                                              {
  int res = sweeper.last;
  if (res == 0) {
    LOG ("no more scheduled variables left");
    return 0;
  }
  CADICAL_assert (res > 0);
  LOG ("dequeuing next scheduled %d", res);
  const unsigned prev = sweeper.prev[res];
  CADICAL_assert (sweeper.next[res] == 0);
  sweeper.prev[res] = 0;
  if (prev == 0) {
    CADICAL_assert (sweeper.first == res);
    sweeper.first = 0;
  } else {
    CADICAL_assert (sweeper.next[prev] == res);
    sweeper.next[prev] = 0;
  }
  sweeper.last = prev;
  return res;
}

Here is the caller graph for this function:

◆ noccs()

int64_t & CaDiCaL::Internal::noccs ( int lit )

inline

Definition at line 466 of file internal.hpp.

466{ return ntab[vlit (lit)]; }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_assignments()

void CaDiCaL::Internal::notify_assignments ( )

Definition at line 932 of file cadical_external_propagate.cpp.

                                   {
  if (!external_prop || external_prop_is_lazy || private_steps)
    return;
 
  const size_t end_of_trail = trail.size ();
 
  if (notified >= end_of_trail)
    return;
 
  LOG ("notify external propagator about new assignments");
  std::vector<int> assigned;
 
  while (notified < end_of_trail) {
    int ilit = trail[notified++];
    if (!observed (ilit))
      continue;
 
    int elit = externalize (ilit); // TODO: double-check tainting
    CADICAL_assert (elit);
    if (external->ervars[abs (elit)])
      continue;
    // Fixed variables might get mapped (during compact) to another
    // non-observed but fixed variable.
    // This happens on root level, so notification about their assignment is
    // already done.
    CADICAL_assert (external->observed (elit) ||
            (fixed (ilit) && !external->ervars[abs (elit)]));
    assigned.push_back (elit);
  }
 
  external->propagator->notify_assignment (assigned);
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_backtrack()

void CaDiCaL::Internal::notify_backtrack ( size_t new_level )

Definition at line 987 of file cadical_external_propagate.cpp.

                                                 {
  if (!external_prop || external_prop_is_lazy || private_steps)
    return;
  external->propagator->notify_backtrack (new_level);
}

Here is the caller graph for this function:

◆ notify_decision()

void CaDiCaL::Internal::notify_decision ( )

Definition at line 977 of file cadical_external_propagate.cpp.

                                {
  if (!external_prop || external_prop_is_lazy || private_steps)
    return;
  external->propagator->notify_new_decision_level ();
}

Here is the caller graph for this function:

◆ observed()

bool CaDiCaL::Internal::observed ( int ilit ) const

Definition at line 72 of file cadical_external_propagate.cpp.

                                       {
  CADICAL_assert ((size_t) vidx (ilit) < relevanttab.size ());
  return relevanttab[vidx (ilit)] > 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ occs()

Occs & CaDiCaL::Internal::occs ( int lit )

inline

Definition at line 465 of file internal.hpp.

465{ return otab[vlit (lit)]; }

Here is the call graph for this function:

◆ occurring()

bool CaDiCaL::Internal::occurring ( ) const

inline

Definition at line 461 of file internal.hpp.

461{ return !otab.empty (); }

Here is the caller graph for this function:

◆ on_the_fly_strengthen()

Clause * CaDiCaL::Internal::on_the_fly_strengthen	(	Clause *	conflict,
		int	lit )

Definition at line 773 of file cadical_analyze.cpp.

                                                                      {
  CADICAL_assert (new_conflict);
  CADICAL_assert (new_conflict->size > 2);
  LOG (new_conflict, "applying OTFS on lit %d", uip);
  auto sorted = std::vector<int> ();
  sorted.reserve (new_conflict->size);
  CADICAL_assert (sorted.empty ());
  ++stats.otfs.strengthened;
 
  int *lits = new_conflict->literals;
 
  CADICAL_assert (lits[0] == uip || lits[1] == uip);
  const int other_init = lits[0] ^ lits[1] ^ uip;
 
  CADICAL_assert (mini_chain.empty ());
 
  const int old_size = new_conflict->size;
  int new_size = 0;
  for (int i = 0; i < old_size; ++i) {
    const int other = lits[i];
    sorted.push_back (other);
    if (var (other).level)
      lits[new_size++] = other;
  }
 
  LOG (new_conflict, "removing all units in");
 
  CADICAL_assert (lits[0] == uip || lits[1] == uip);
  const int other = lits[0] ^ lits[1] ^ uip;
  lits[0] = other;
  lits[1] = lits[--new_size];
  LOG (new_conflict, "putting uip at pos 1");
 
  if (other_init != other)
    remove_watch (watches (other_init), new_conflict);
  remove_watch (watches (uip), new_conflict);
 
  CADICAL_assert (!lrat || lrat_chain.back () == new_conflict->id);
  if (lrat) {
    CADICAL_assert (!lrat_chain.empty ());
    for (const auto &id : unit_chain) {
      mini_chain.push_back (id);
    }
    const auto end = lrat_chain.rend ();
    const auto begin = lrat_chain.rbegin ();
    for (auto i = begin; i != end; i++) {
      const auto id = *i;
      mini_chain.push_back (id);
    }
    lrat_chain.clear ();
    clear_unit_analyzed_literals ();
    unit_chain.clear ();
  }
  CADICAL_assert (unit_analyzed.empty ());
  // sort the clause
  {
    int highest_pos = 0;
    int highest_level = 0;
    for (int i = 1; i < new_size; i++) {
      const unsigned other = lits[i];
      CADICAL_assert (val (other) < 0);
      const int level = var (other).level;
      CADICAL_assert (level);
      LOG ("checking %d", other);
      if (level <= highest_level)
        continue;
      highest_pos = i;
      highest_level = level;
    }
    LOG ("highest lit is %d", lits[highest_pos]);
    if (highest_pos != 1)
      swap (lits[1], lits[highest_pos]);
    LOG ("removing %d literals", new_conflict->size - new_size);
 
    if (new_size == 1) {
      LOG (new_conflict, "new size = 1, so interrupting");
      CADICAL_assert (!opts.exteagerreasons);
      return 0;
    } else {
      otfs_strengthen_clause (new_conflict, uip, new_size, sorted);
      CADICAL_assert (new_size == new_conflict->size);
    }
  }
 
  if (other_init != other)
    watch_literal (other, lits[1], new_conflict);
  else {
    update_watch_size (watches (other), lits[1], new_conflict);
  }
  watch_literal (lits[1], other, new_conflict);
 
  LOG (new_conflict, "strengthened clause by OTFS");
  sorted.clear ();
 
  return new_conflict;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ otfs_find_backtrack_level()

int CaDiCaL::Internal::otfs_find_backtrack_level ( int & forced )

inline

Definition at line 551 of file cadical_analyze.cpp.

                                                           {
  CADICAL_assert (opts.otfs);
  int res = 0;
 
  for (const auto &lit : *conflict) {
    const int tmp = var (lit).level;
    if (tmp == level) {
      forced = lit;
    } else if (tmp > res) {
      res = tmp;
      LOG ("bt level is now %d due to %d", res, lit);
    }
  }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ otfs_strengthen_clause()

void CaDiCaL::Internal::otfs_strengthen_clause	(	Clause *	c,
		int	lit,
		int	new_size,
		const std::vector< int > &	old )

Definition at line 903 of file cadical_analyze.cpp.

                                                                  {
  stats.strengthened++;
  CADICAL_assert (c->size > 2);
  (void) shrink_clause (c, new_size);
  if (proof) {
    proof->otfs_strengthen_clause (c, old, mini_chain);
  }
  if (!c->redundant) {
    mark_removed (lit);
  }
  mini_chain.clear ();
  c->used = true;
  LOG (c, "strengthened");
  external->check_shrunken_clause (c);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ otfs_subsume_clause()

void CaDiCaL::Internal::otfs_subsume_clause	(	Clause *	subsuming,
		Clause *	subsumed )

inline

Definition at line 871 of file cadical_analyze.cpp.

                                                             {
  stats.subsumed++;
  CADICAL_assert (subsuming->size <= subsumed->size);
  LOG (subsumed, "subsumed");
  if (subsumed->redundant)
    stats.subred++;
  else
    stats.subirr++;
  if (subsumed->redundant || !subsuming->redundant) {
    mark_garbage (subsumed);
    return;
  }
  LOG ("turning redundant subsuming clause into irredundant clause");
  subsuming->redundant = false;
  if (proof)
    proof->strengthen (subsuming->id);
  mark_garbage (subsumed);
  stats.current.irredundant++;
  stats.added.irredundant++;
  stats.irrlits += subsuming->size;
  CADICAL_assert (stats.current.redundant > 0);
  stats.current.redundant--;
  CADICAL_assert (stats.added.redundant > 0);
  stats.added.redundant--;
  // ... and keep 'stats.added.total'.
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_dimacs() [1/2]

const char * CaDiCaL::Internal::parse_dimacs ( const char * )

◆ parse_dimacs() [2/2]

const char * CaDiCaL::Internal::parse_dimacs ( FILE * )

◆ parse_solution()

const char * CaDiCaL::Internal::parse_solution ( const char * )

◆ phase()

void CaDiCaL::Internal::phase ( int lit )

Definition at line 23 of file cadical_phases.cpp.

                             {
  const int idx = vidx (lit);
  signed char old_forced_phase = phases.forced[idx];
  signed char new_forced_phase = sign (lit);
  if (old_forced_phase == new_forced_phase) {
    LOG ("forced phase remains at %d", old_forced_phase * idx);
    return;
  }
  if (old_forced_phase)
    LOG ("overwriting old forced phase %d", old_forced_phase * idx);
  LOG ("new forced phase %d", new_forced_phase * idx);
  phases.forced[idx] = new_forced_phase;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ positive_horn_satisfiable()

int CaDiCaL::Internal::positive_horn_satisfiable ( )

Definition at line 264 of file cadical_lucky.cpp.

                                         {
  LOG ("checking that all clauses are positive horn satisfiable");
  CADICAL_assert (!level);
  CADICAL_assert (assumptions.empty ());
  for (const auto &c : clauses) {
    if (terminated_asynchronously (10))
      return unlucky (-1);
    if (c->garbage)
      continue;
    if (c->redundant)
      continue;
    int positive_literal = 0;
    bool satisfied = false;
    for (const auto &lit : *c) {
      const signed char tmp = val (lit);
      if (tmp > 0) {
        satisfied = true;
        break;
      }
      if (tmp < 0)
        continue;
      if (lit < 0)
        continue;
      positive_literal = lit;
      break;
    }
    if (satisfied)
      continue;
    if (!positive_literal) {
      LOG (c, "no positive unassigned literal in");
      return unlucky (0);
    }
    CADICAL_assert (positive_literal > 0);
    LOG (c, "found positive literal %d in", positive_literal);
    search_assume_decision (positive_literal);
    if (propagate ())
      continue;
    LOG ("propagation of positive literal %d leads to conflict",
         positive_literal);
    return unlucky (0);
  }
  for (auto idx : vars) {
    if (terminated_asynchronously (10))
      return unlucky (-1);
    if (val (idx))
      continue;
    search_assume_decision (-idx);
    if (propagate ())
      continue;
    LOG ("propagation of remaining literal %d leads to conflict", -idx);
    return unlucky (0);
  }
  VERBOSE (1, "clauses are positive horn satisfied");
  CADICAL_assert (!conflict);
  CADICAL_assert (satisfied ());
  stats.lucky.horn.positive++;
  return 10;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ preprocess()

int CaDiCaL::Internal::preprocess ( )

Definition at line 740 of file cadical_internal.cpp.

                          {
  preprocess_quickly ();
  for (int i = 0; i < lim.preprocessing; i++)
    if (!preprocess_round (i))
      break;
  if (unsat)
    return 20;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ preprocess_quickly()

void CaDiCaL::Internal::preprocess_quickly ( )

Definition at line 696 of file cadical_internal.cpp.

                                   {
  if (unsat)
    return;
  if (!max_var)
    return;
  if (!opts.preprocesslight)
    return;
  START (preprocess);
  struct {
    int64_t vars, clauses;
  } before, after;
  before.vars = active ();
  before.clauses = stats.current.irredundant;
  // stats.preprocessings++;
  CADICAL_assert (!preprocessing);
  preprocessing = true;
  PHASE ("preprocessing", stats.preprocessings,
         "starting with %" PRId64 " variables and %" PRId64 " clauses",
         before.vars, before.clauses);
 
  if (extract_gates ())
    decompose ();
 
  if (sweep ())
    decompose ();
 
  if (opts.factor)
    factor ();
 
  if (opts.fastelim)
    elimfast ();
  // if (opts.condition)
  // condition (false);
  after.vars = active ();
  after.clauses = stats.current.irredundant;
  CADICAL_assert (preprocessing);
  preprocessing = false;
  PHASE ("preprocessing", stats.preprocessings,
         "finished with %" PRId64 " variables and %" PRId64 " clauses",
         after.vars, after.clauses);
  STOP (preprocess);
  report ('P');
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ preprocess_round()

bool CaDiCaL::Internal::preprocess_round ( int round )

Definition at line 649 of file cadical_internal.cpp.

                                          {
  (void) round;
  if (unsat)
    return false;
  if (!max_var)
    return false;
  START (preprocess);
  struct {
    int64_t vars, clauses;
  } before, after;
  before.vars = active ();
  before.clauses = stats.current.irredundant;
  stats.preprocessings++;
  CADICAL_assert (!preprocessing);
  preprocessing = true;
  PHASE ("preprocessing", stats.preprocessings,
         "starting round %d with %" PRId64 " variables and %" PRId64
         " clauses",
         round, before.vars, before.clauses);
  int old_elimbound = lim.elimbound;
  if (opts.inprobing)
    inprobe (false);
  if (opts.elim)
    elim (false);
  if (opts.condition)
    condition (false);
 
  after.vars = active ();
  after.clauses = stats.current.irredundant;
  CADICAL_assert (preprocessing);
  preprocessing = false;
  PHASE ("preprocessing", stats.preprocessings,
         "finished round %d with %" PRId64 " variables and %" PRId64
         " clauses",
         round, after.vars, after.clauses);
  STOP (preprocess);
  report ('P');
  if (unsat)
    return false;
  if (after.vars < before.vars)
    return true;
  if (old_elimbound < lim.elimbound)
    return true;
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_resource_usage()

void CaDiCaL::Internal::print_resource_usage ( )

Definition at line 756 of file cadical_stats.cpp.

                                     {
#ifndef CADICAL_QUIET
  SECTION ("resources");
  uint64_t m = maximum_resident_set_size ();
  MSG ("total process time since initialization: %12.2f    seconds",
       internal->process_time ());
  MSG ("total real time since initialization:    %12.2f    seconds",
       internal->real_time ());
  MSG ("maximum resident set size of process:    %12.2f    MB",
       m / (double) (1l << 20));
#endif
}

Here is the call graph for this function:

◆ print_statistics()

void CaDiCaL::Internal::print_statistics ( )

Definition at line 1098 of file cadical_internal.cpp.

                                 {
  stats.print (this);
  for (auto &st : stat_tracers)
    st->print_stats ();
}

◆ probe()

bool CaDiCaL::Internal::probe ( )

Definition at line 791 of file cadical_probe.cpp.

                      {
 
  if (!opts.probe)
    return false;
  if (unsat)
    return false;
  if (terminated_asynchronously ())
    return false;
 
  SET_EFFORT_LIMIT (limit, probe, true);
 
  START_SIMPLIFIER (probe, PROBE);
  stats.probingrounds++;
 
  // Probing is limited in terms of non-probing propagations
  // 'stats.propagations'. We allow a certain percentage 'opts.probeeffort'
  // (say %5) of probing propagations in each probing with a lower bound of
  // 'opts.probmineff'.
  //
 
  PHASE ("probe-round", stats.probingrounds,
         "probing limit of %" PRId64 " propagations ", limit);
 
  int old_failed = stats.failed;
#ifndef CADICAL_QUIET
  int64_t old_probed = stats.probed;
#endif
  int64_t old_hbrs = stats.hbrs;
 
  if (!probes.empty ())
    flush_probes ();
 
  // We reset 'propfixed' since there was at least another conflict thus
  // a new learned clause, which might produce new propagations (and hyper
  // binary resolvents).  During 'generate_probes' we keep the old value.
  //
  for (auto idx : vars)
    propfixed (idx) = propfixed (-idx) = -1;
 
  CADICAL_assert (unsat || propagated == trail.size ());
  propagated = propagated2 = trail.size ();
 
  int probe;
  init_probehbr_lrat ();
  while (!unsat && !terminated_asynchronously () &&
         stats.ticks.probe < limit && (probe = next_probe ())) {
    stats.probed++;
    LOG ("probing %d", probe);
    probe_assign_decision (probe);
    if (probe_propagate ())
      backtrack ();
    else
      failed_literal (probe);
    clean_probehbr_lrat ();
  }
 
  if (unsat)
    LOG ("probing derived empty clause");
  else if (propagated < trail.size ()) {
    LOG ("probing produced %zd units",
         (size_t) (trail.size () - propagated));
    if (!propagate ()) {
      LOG ("propagating units after probing results in empty clause");
      learn_empty_clause ();
    } else
      sort_watches ();
  }
 
  int failed = stats.failed - old_failed;
#ifndef CADICAL_QUIET
  int64_t probed = stats.probed - old_probed;
#endif
  int64_t hbrs = stats.hbrs - old_hbrs;
 
  PHASE ("probe-round", stats.probingrounds,
         "probed %" PRId64 " and found %d failed literals", probed, failed);
 
  if (hbrs)
    PHASE ("probe-round", stats.probingrounds,
           "found %" PRId64 " hyper binary resolvents", hbrs);
 
  STOP_SIMPLIFIER (probe, PROBE);
 
  report ('p', !opts.reportall && !(unsat + failed + hbrs));
 
  return !unsat && failed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ probe_assign()

void CaDiCaL::Internal::probe_assign	(	int	lit,
		int	parent )

inline

Definition at line 296 of file cadical_probe.cpp.

                                                       {
  require_mode (PROBE);
  int idx = vidx (lit);
  CADICAL_assert (!val (idx));
  CADICAL_assert (!flags (idx).eliminated () || !parent);
  CADICAL_assert (!parent || val (parent) > 0);
  Var &v = var (idx);
  v.level = level;
  v.trail = (int) trail.size ();
  CADICAL_assert ((int) num_assigned < max_var);
  num_assigned++;
  v.reason = level ? probe_reason : 0;
  probe_reason = 0;
  set_parent_reason_literal (lit, parent);
  if (!level)
    learn_unit_clause (lit);
  else
    CADICAL_assert (level == 1);
  const signed char tmp = sign (lit);
  set_val (idx, tmp);
  CADICAL_assert (val (lit) > 0);
  CADICAL_assert (val (-lit) < 0);
  trail.push_back (lit);
 
  // Do not save the current phase during inprocessing but remember the
  // number of units on the trail of the last time this literal was
  // assigned.  This allows us to avoid some redundant failed literal
  // probing attempts.  Search for 'propfixed' in 'probe.cpp' for details.
  //
  if (level)
    propfixed (lit) = stats.all.fixed;
 
  if (parent)
    LOG ("probe assign %d parent %d", lit, parent);
  else if (level)
    LOG ("probe assign %d probe", lit);
  else
    LOG ("probe assign %d negated failed literal UIP", lit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ probe_assign_decision()

void CaDiCaL::Internal::probe_assign_decision ( int lit )

Definition at line 336 of file cadical_probe.cpp.

                                             {
  require_mode (PROBE);
  CADICAL_assert (!level);
  CADICAL_assert (propagated == trail.size ());
  level++;
  control.push_back (Level (lit, trail.size ()));
  probe_assign (lit, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ probe_assign_unit()

void CaDiCaL::Internal::probe_assign_unit ( int lit )

Definition at line 345 of file cadical_probe.cpp.

                                         {
  require_mode (PROBE);
  CADICAL_assert (!level);
  CADICAL_assert (active (lit));
  probe_assign (lit, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ probe_dominator()

int CaDiCaL::Internal::probe_dominator	(	int	a,
		int	b )

Definition at line 154 of file cadical_probe.cpp.

                                           {
  require_mode (PROBE);
  int l = a, k = b;
  Var *u = &var (l), *v = &var (k);
  CADICAL_assert (val (l) > 0), CADICAL_assert (val (k) > 0);
  CADICAL_assert (u->level == 1), CADICAL_assert (v->level == 1);
  while (l != k) {
    if (u->trail > v->trail)
      swap (l, k), swap (u, v);
    if (!get_parent_reason_literal (l))
      return l;
    int parent = get_parent_reason_literal (k);
    CADICAL_assert (parent), CADICAL_assert (val (parent) > 0);
    v = &var (k = parent);
    CADICAL_assert (v->level == 1);
  }
  LOG ("dominator %d of %d and %d", l, a, b);
  CADICAL_assert (val (l) > 0);
  return l;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ probe_dominator_lrat()

void CaDiCaL::Internal::probe_dominator_lrat	(	int	dom,
		Clause *	reason )

Definition at line 117 of file cadical_probe.cpp.

                                                            {
  if (!lrat || !dom)
    return;
  LOG (reason, "probe dominator LRAT for %d from", dom);
  for (const auto lit : *reason) {
    if (val (lit) >= 0)
      continue;
    const auto other = -lit;
    if (other == dom)
      continue;
    Flags &f = flags (other);
    if (f.seen)
      continue;
    f.seen = true;
    analyzed.push_back (other);
    Var u = var (other);
    if (u.level) {
      if (!u.reason) {
        LOG ("this may be a problem %d", other);
        continue;
      }
      probe_dominator_lrat (dom, u.reason);
      continue;
    }
    int64_t id = unit_id (other);
    lrat_chain.push_back (id);
  }
  lrat_chain.push_back (reason->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ probe_lrat_for_units()

void CaDiCaL::Internal::probe_lrat_for_units ( int lit )

inline

Definition at line 356 of file cadical_probe.cpp.

                                                   {
  if (!lrat)
    return;
  if (level)
    return; // not decision level 0
  LOG ("building chain for units");
  CADICAL_assert (lrat_chain.empty ());
  CADICAL_assert (probe_reason);
  for (auto &reason_lit : *probe_reason) {
    if (lit == reason_lit)
      continue;
    CADICAL_assert (val (reason_lit));
    if (!val (reason_lit))
      continue;
    const int signed_reason_lit = val (reason_lit) * reason_lit;
    int64_t id = unit_id (signed_reason_lit);
    lrat_chain.push_back (id);
  }
  lrat_chain.push_back (probe_reason->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ probe_post_dominator_lrat()

void CaDiCaL::Internal::probe_post_dominator_lrat	(	vector< Clause * > &	,
		int	,
		int	)

Here is the call graph for this function:

◆ probe_propagate()

bool CaDiCaL::Internal::probe_propagate ( )

Definition at line 416 of file cadical_probe.cpp.

                                {
  require_mode (PROBE);
  CADICAL_assert (!unsat);
  START (propagate);
  int64_t before = propagated2 = propagated;
  int64_t &ticks = stats.ticks.probe;
  while (!conflict) {
    if (propagated2 != trail.size ())
      probe_propagate2 ();
    else if (propagated != trail.size ()) {
      const int lit = -trail[propagated++];
      LOG ("probe propagating %d over large clauses", -lit);
      Watches &ws = watches (lit);
      ticks += 1 + cache_lines (ws.size (),
                                sizeof (sizeof (const_watch_iterator *)));
      size_t i = 0, j = 0;
      while (i != ws.size ()) {
        const Watch w = ws[j++] = ws[i++];
        if (w.binary ())
          continue;
        const signed char b = val (w.blit);
        if (b > 0)
          continue;
        ticks++;
        if (w.clause->garbage)
          continue;
        const literal_iterator lits = w.clause->begin ();
        const int other = lits[0] ^ lits[1] ^ lit;
        // lits[0] = other, lits[1] = lit;
        const signed char u = val (other);
        if (u > 0)
          ws[j - 1].blit = other;
        else {
          const int size = w.clause->size;
          const const_literal_iterator end = lits + size;
          const literal_iterator middle = lits + w.clause->pos;
          literal_iterator k = middle;
          int r = 0;
          signed char v = -1;
          while (k != end && (v = val (r = *k)) < 0)
            k++;
          if (v < 0) {
            k = lits + 2;
            CADICAL_assert (w.clause->pos <= size);
            while (k != middle && (v = val (r = *k)) < 0)
              k++;
          }
          w.clause->pos = k - lits;
          CADICAL_assert (lits + 2 <= k), CADICAL_assert (k <= w.clause->end ());
          if (v > 0)
            ws[j - 1].blit = r;
          else if (!v) {
            ticks++;
            LOG (w.clause, "unwatch %d in", r);
            *k = lit;
            lits[0] = other;
            lits[1] = r;
            watch_literal (r, lit, w.clause);
            j--;
          } else if (!u) {
            ticks++;
            if (level == 1) {
              lits[0] = other, lits[1] = lit;
              CADICAL_assert (lrat_chain.empty ());
              CADICAL_assert (!probe_reason);
              int dom = hyper_binary_resolve (w.clause);
              probe_assign (other, dom);
            } else {
              ticks++;
              CADICAL_assert (lrat_chain.empty ());
              CADICAL_assert (!probe_reason);
              probe_reason = w.clause;
              probe_lrat_for_units (other);
              probe_assign_unit (other);
              lrat_chain.clear ();
            }
            probe_propagate2 ();
          } else
            conflict = w.clause;
        }
      }
      if (j != i) {
        while (i != ws.size ())
          ws[j++] = ws[i++];
        ws.resize (j);
      }
    } else
      break;
  }
  int64_t delta = propagated2 - before;
  stats.propagations.probe += delta;
  if (conflict)
    LOG (conflict, "conflict");
  STOP (propagate);
  return !conflict;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ probe_propagate2()

void CaDiCaL::Internal::probe_propagate2 ( )

inline

Definition at line 387 of file cadical_probe.cpp.

                                        {
  require_mode (PROBE);
  int64_t &ticks = stats.ticks.probe;
  while (propagated2 != trail.size ()) {
    const int lit = -trail[propagated2++];
    LOG ("probe propagating %d over binary clauses", -lit);
    Watches &ws = watches (lit);
    ticks += 1 + cache_lines (ws.size (), sizeof (const_watch_iterator *));
    for (const auto &w : ws) {
      if (!w.binary ())
        continue;
      const signed char b = val (w.blit);
      if (b > 0)
        continue;
      ticks++;
      if (b < 0)
        conflict = w.clause; // but continue
      else {
        CADICAL_assert (lrat_chain.empty ());
        CADICAL_assert (!probe_reason);
        probe_reason = w.clause;
        probe_lrat_for_units (w.blit);
        probe_assign (w.blit, -lit);
        lrat_chain.clear ();
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_time()

double CaDiCaL::Internal::process_time ( ) const

Definition at line 105 of file cadical_resources.cpp.

                                     {
  return absolute_process_time () - stats.time.process;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ produce_failed_assumptions()

void CaDiCaL::Internal::produce_failed_assumptions ( )

Definition at line 796 of file cadical_internal.cpp.

                                           {
  LOG ("producing failed assumptions");
  CADICAL_assert (!level);
  CADICAL_assert (!assumptions.empty ());
  while (!unsat) {
    CADICAL_assert (!satisfied ());
    notify_assignments ();
    if (decide ())
      break;
    while (!unsat && !propagate ())
      analyze ();
  }
  notify_assignments ();
  if (unsat)
    LOG ("formula is actually unsatisfiable unconditionally");
  else
    LOG ("assumptions indeed failing");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ promote_clause()

void CaDiCaL::Internal::promote_clause	(	Clause *	c,
		int	new_glue )

Definition at line 152 of file cadical_clause.cpp.

                                                      {
  CADICAL_assert (c->redundant);
  const int tier1limit = tier1[false];
  const int tier2limit = max (tier1limit, tier2[false]);
  if (!c->redundant)
    return;
  if (c->hyper)
    return;
  int old_glue = c->glue;
  if (new_glue >= old_glue)
    return;
  if (old_glue > tier1limit && new_glue <= tier1limit) {
    LOG (c, "promoting with new glue %d to tier1", new_glue);
    stats.promoted1++;
    c->used = max_used;
  } else if (old_glue > tier2limit && new_glue <= tier2limit) {
    LOG (c, "promoting with new glue %d to tier2", new_glue);
    stats.promoted2++;
  } else if (old_glue <= tier2limit)
    LOG (c, "keeping with new glue %d in tier2", new_glue);
  else
    LOG (c, "keeping with new glue %d in tier3", new_glue);
  stats.improvedglue++;
  c->glue = new_glue;
}

Here is the caller graph for this function:

◆ promote_clause_glue_only()

void CaDiCaL::Internal::promote_clause_glue_only	(	Clause *	c,
		int	new_glue )

Definition at line 179 of file cadical_clause.cpp.

                                                                {
  CADICAL_assert (c->redundant);
  if (c->hyper)
    return;
  int old_glue = c->glue;
  const int tier1limit = tier1[false];
  const int tier2limit = max (tier1limit, tier2[false]);
  if (new_glue >= old_glue)
    return;
  if (new_glue <= tier1limit) {
    LOG (c, "promoting with new glue %d to tier1", new_glue);
    stats.promoted1++;
    c->used = max_used;
  } else if (old_glue > tier2limit && new_glue <= tier2limit) {
    LOG (c, "promoting with new glue %d to tier2", new_glue);
    stats.promoted2++;
  } else if (old_glue <= tier2limit)
    LOG (c, "keeping with new glue %d in tier2", new_glue);
  else
    LOG (c, "keeping with new glue %d in tier3", new_glue);
  stats.improvedglue++;
  c->glue = new_glue;
}

Here is the caller graph for this function:

◆ propagate()

bool CaDiCaL::Internal::propagate ( )

Definition at line 232 of file cadical_propagate.cpp.

                          {
 
  if (level)
    require_mode (SEARCH);
  CADICAL_assert (!unsat);
  LOG ("starting propagate");
  START (propagate);
 
  // Updating statistics counter in the propagation loops is costly so we
  // delay until propagation ran to completion.
  //
  int64_t before = propagated;
  int64_t ticks = 0;
 
  while (!conflict && propagated != trail.size ()) {
 
    const int lit = -trail[propagated++];
    LOG ("propagating %d", -lit);
    Watches &ws = watches (lit);
 
    const const_watch_iterator eow = ws.end ();
    watch_iterator j = ws.begin ();
    const_watch_iterator i = j;
    ticks += 1 + cache_lines (ws.size (), sizeof *i);
 
    while (i != eow) {
 
      const Watch w = *j++ = *i++;
      const signed char b = val (w.blit);
      LOG (w.clause, "checking");
 
      if (b > 0)
        continue; // blocking literal satisfied
 
      if (w.binary ()) {
 
        // CADICAL_assert (w.clause->redundant || !w.clause->garbage);
 
        // In principle we can ignore garbage binary clauses too, but that
        // would require to dereference the clause pointer all the time with
        //
        // if (w.clause->garbage) { j--; continue; } // (*)
        //
        // This is too costly.  It is however necessary to produce correct
        // proof traces if binary clauses are traced to be deleted ('d ...'
        // line) immediately as soon they are marked as garbage.  Actually
        // finding instances where this happens is pretty difficult (six
        // parallel fuzzing jobs in parallel took an hour), but it does
        // occur.  Our strategy to avoid generating incorrect proofs now is
        // to delay tracing the deletion of binary clauses marked as garbage
        // until they are really deleted from memory.  For large clauses
        // this is not necessary since we have to access the clause anyhow.
        //
        // Thanks go to Mathias Fleury, who wanted me to explain why the
        // line '(*)' above was in the code. Removing it actually really
        // improved running times and thus I tried to find concrete
        // instances where this happens (which I found), and then
        // implemented the described fix.
 
        // Binary clauses are treated separately since they do not require
        // to access the clause at all (only during conflict analysis, and
        // there also only to simplify the code).
 
        if (b < 0)
          conflict = w.clause; // but continue ...
        else {
          build_chain_for_units (w.blit, w.clause, 0);
          search_assign (w.blit, w.clause);
          // lrat_chain.clear (); done in search_assign
          ticks++;
        }
 
      } else {
        CADICAL_assert (w.clause->size > 2);
 
        if (conflict)
          break; // Stop if there was a binary conflict already.
 
        // The cache line with the clause data is forced to be loaded here
        // and thus this first memory access below is the real hot-spot of
        // the solver.  Note, that this check is positive very rarely and
        // thus branch prediction should be almost perfect here.
 
        ticks++;
 
        if (w.clause->garbage) {
          j--;
          continue;
        }
 
        literal_iterator lits = w.clause->begin ();
 
        // Simplify code by forcing 'lit' to be the second literal in the
        // clause.  This goes back to MiniSAT.  We use a branch-less version
        // for conditionally swapping the first two literals, since it
        // turned out to be substantially faster than this one
        //
        //  if (lits[0] == lit) swap (lits[0], lits[1]);
        //
        // which achieves the same effect, but needs a branch.
        //
        const int other = lits[0] ^ lits[1] ^ lit;
        const signed char u = val (other); // value of the other watch
 
        if (u > 0)
          j[-1].blit = other; // satisfied, just replace blit
        else {
 
          // This follows Ian Gent's (JAIR'13) idea of saving the position
          // of the last watch replacement.  In essence it needs two copies
          // of the default search for a watch replacement (in essence the
          // code in the 'if (v < 0) { ... }' block below), one starting at
          // the saved position until the end of the clause and then if that
          // one failed to find a replacement another one starting at the
          // first non-watched literal until the saved position.
 
          const int size = w.clause->size;
          const literal_iterator middle = lits + w.clause->pos;
          const const_literal_iterator end = lits + size;
          literal_iterator k = middle;
 
          // Find replacement watch 'r' at position 'k' with value 'v'.
 
          int r = 0;
          signed char v = -1;
 
          while (k != end && (v = val (r = *k)) < 0)
            k++;
 
          if (v < 0) { // need second search starting at the head?
 
            k = lits + 2;
            CADICAL_assert (w.clause->pos <= size);
            while (k != middle && (v = val (r = *k)) < 0)
              k++;
          }
 
          w.clause->pos = k - lits; // always save position
 
          CADICAL_assert (lits + 2 <= k), CADICAL_assert (k <= w.clause->end ());
 
          if (v > 0) {
 
            // Replacement satisfied, so just replace 'blit'.
 
            j[-1].blit = r;
 
          } else if (!v) {
 
            // Found new unassigned replacement literal to be watched.
 
            LOG (w.clause, "unwatch %d in", lit);
 
            lits[0] = other;
            lits[1] = r;
            *k = lit;
 
            watch_literal (r, lit, w.clause);
 
            j--; // Drop this watch from the watch list of 'lit'.
 
            ticks++;
 
          } else if (!u) {
 
            CADICAL_assert (v < 0);
 
            // The other watch is unassigned ('!u') and all other literals
            // assigned to false (still 'v < 0'), thus we found a unit.
            //
            build_chain_for_units (other, w.clause, 0);
            search_assign (other, w.clause);
            // lrat_chain.clear (); done in search_assign
            ticks++;
 
            // Similar code is in the implementation of the SAT'18 paper on
            // chronological backtracking but in our experience, this code
            // first does not really seem to be necessary for correctness,
            // and further does not improve running time either.
            //
            if (opts.chrono > 1) {
 
              const int other_level = var (other).level;
 
              if (other_level > var (lit).level) {
 
                // The assignment level of the new unit 'other' is larger
                // than the assignment level of 'lit'.  Thus we should find
                // another literal in the clause at that higher assignment
                // level and watch that instead of 'lit'.
 
                CADICAL_assert (size > 2);
 
                int pos, s = 0;
 
                for (pos = 2; pos < size; pos++)
                  if (var (s = lits[pos]).level == other_level)
                    break;
 
                CADICAL_assert (s);
                CADICAL_assert (pos < size);
 
                LOG (w.clause, "unwatch %d in", lit);
                lits[pos] = lit;
                lits[0] = other;
                lits[1] = s;
                watch_literal (s, lit, w.clause);
 
                j--; // Drop this watch from the watch list of 'lit'.
              }
            }
          } else {
 
            CADICAL_assert (u < 0);
            CADICAL_assert (v < 0);
 
            // The other watch is assigned false ('u < 0') and all other
            // literals as well (still 'v < 0'), thus we found a conflict.
 
            conflict = w.clause;
            break;
          }
        }
      }
    }
 
    if (j != i) {
 
      while (i != eow)
        *j++ = *i++;
 
      ws.resize (j - ws.begin ());
    }
  }
 
  if (searching_lucky_phases) {
 
    if (conflict)
      LOG (conflict, "ignoring lucky conflict");
 
  } else {
 
    // Avoid updating stats eagerly in the hot-spot of the solver.
    //
    stats.propagations.search += propagated - before;
    stats.ticks.search[stable] += ticks;
 
    if (!conflict)
      no_conflict_until = propagated;
    else {
 
      if (stable)
        stats.stabconflicts++;
      stats.conflicts++;
 
      LOG (conflict, "conflict");
 
      // The trail before the current decision level was conflict free.
      //
      no_conflict_until = control[level].trail;
    }
  }
 
  STOP (propagate);
 
  return !conflict;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ propagate_assumptions()

int CaDiCaL::Internal::propagate_assumptions ( )

Definition at line 347 of file cadical_internal.cpp.

                                     {
  if (proof)
    proof->solve_query ();
  if (opts.ilb) {
    if (opts.ilbassumptions)
      sort_and_reuse_assumptions ();
    stats.ilbtriggers++;
    stats.ilbsuccess += (level > 0);
    stats.levelsreused += level;
    if (level) {
      CADICAL_assert (control.size () > 1);
      stats.literalsreused += num_assigned - control[1].trail;
    }
  }
  init_search_limits ();
  init_report_limits ();
 
  int res = already_solved (); // root-level propagation is done here
 
  int last_assumption_level = assumptions.size ();
  if (constraint.size ())
    last_assumption_level++;
 
  if (!res) {
    restore_clauses ();
    while (!res) {
      if (unsat)
        res = 20;
      else if (unsat_constraint)
        res = 20;
      else if (!propagate ()) {
        // let analyze run to get failed assumptions
        analyze ();
      } else if (!external_propagate () || unsat) { // external propagation
        if (unsat)
          continue;
        else
          analyze ();
      } else if (satisfied ()) { // found model
        if (!external_check_solution () || unsat) {
          if (unsat)
            continue;
          else
            analyze ();
        } else if (satisfied ())
          res = 10;
      } else if (search_limits_hit ())
        break;                               // decision or conflict limit
      else if (terminated_asynchronously ()) // externally terminated
        break;
      else {
        if (level >= last_assumption_level)
          break;
        res = decide ();
      }
    }
  }
 
  if (unsat || unsat_constraint)
    res = 20;
 
  if (!res && satisfied ())
    res = 10;
 
  finalize (res);
  reset_solving ();
  report_solving (res);
 
  return res;
}

Here is the call graph for this function:

◆ propagate_out_of_order_units()

bool CaDiCaL::Internal::propagate_out_of_order_units ( )

Definition at line 176 of file cadical_reduce.cpp.

                                             {
  if (!level)
    return true;
  int oou = 0;
  for (size_t i = control[1].trail; !oou && i < trail.size (); i++) {
    const int lit = trail[i];
    CADICAL_assert (val (lit) > 0);
    if (var (lit).level)
      continue;
    LOG ("found out-of-order assigned unit %d", oou);
    oou = lit;
  }
  if (!oou)
    return true;
  CADICAL_assert (opts.chrono || external_prop);
  backtrack (0);
  if (propagate ())
    return true;
  learn_empty_clause ();
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ propergate()

void CaDiCaL::Internal::propergate ( )

Definition at line 502 of file cadical_propagate.cpp.

                           {
 
  CADICAL_assert (!conflict);
  CADICAL_assert (propagated == trail.size ());
 
  while (propergated != trail.size ()) {
 
    const int lit = -trail[propergated++];
    LOG ("propergating %d", -lit);
    Watches &ws = watches (lit);
 
    const const_watch_iterator eow = ws.end ();
    watch_iterator j = ws.begin ();
    const_watch_iterator i = j;
 
    while (i != eow) {
 
      const Watch w = *j++ = *i++;
 
      if (w.binary ()) {
        CADICAL_assert (val (w.blit) > 0);
        continue;
      }
      if (w.clause->garbage) {
        j--;
        continue;
      }
 
      literal_iterator lits = w.clause->begin ();
 
      const int other = lits[0] ^ lits[1] ^ lit;
      const signed char u = val (other);
 
      // TODO: check if u == 0 can happen.
      if (u > 0)
        continue;
      CADICAL_assert (u < 0);
 
      const int size = w.clause->size;
      const literal_iterator middle = lits + w.clause->pos;
      const const_literal_iterator end = lits + size;
      literal_iterator k = middle;
 
      int r = 0;
      signed char v = -1;
 
      while (k != end && (v = val (r = *k)) < 0)
        k++;
 
      if (v < 0) {
        k = lits + 2;
        CADICAL_assert (w.clause->pos <= size);
        while (k != middle && (v = val (r = *k)) < 0)
          k++;
      }
 
      CADICAL_assert (lits + 2 <= k), CADICAL_assert (k <= w.clause->end ());
      w.clause->pos = k - lits;
 
      CADICAL_assert (v > 0);
 
      LOG (w.clause, "unwatch %d in", lit);
 
      lits[0] = other;
      lits[1] = r;
      *k = lit;
 
      watch_literal (r, lit, w.clause);
 
      j--;
    }
 
    if (j != i) {
 
      while (i != eow)
        *j++ = *i++;
 
      ws.resize (j - ws.begin ());
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ propfixed()

int & CaDiCaL::Internal::propfixed ( int lit )

inline

Definition at line 456 of file internal.hpp.

456{ return ptab[vlit (lit)]; }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ protect_reasons()

void CaDiCaL::Internal::protect_reasons ( )

Definition at line 107 of file cadical_collect.cpp.

                                {
  LOG ("protecting reason clauses of all assigned variables on trail");
  CADICAL_assert (!protected_reasons);
#ifdef LOGGING
  size_t count = 0;
#endif
  for (const auto &lit : trail) {
    if (!active (lit))
      continue;
    CADICAL_assert (val (lit));
    Var &v = var (lit);
    CADICAL_assert (v.level > 0);
    Clause *reason = v.reason;
    if (!reason)
      continue;
    if (reason == external_reason)
      continue;
    LOG (reason, "protecting assigned %d reason %p", lit, (void *) reason);
    CADICAL_assert (!reason->reason);
    reason->reason = true;
#ifdef LOGGING
    count++;
#endif
  }
  LOG ("protected %zd reason clauses referenced on trail", count);
  protected_reasons = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ push_literals_of_block()

void CaDiCaL::Internal::push_literals_of_block	(	const std::vector< int >::reverse_iterator &	rbegin_block,
		const std::vector< int >::reverse_iterator &	rend_block,
		int	blevel,
		unsigned	max_trail )

Definition at line 185 of file cadical_shrink.cpp.

                        {
  CADICAL_assert (rbegin_block < rend_block);
  for (auto p = rbegin_block; p != rend_block; ++p) {
    CADICAL_assert (p != clause.rend () - 1);
    CADICAL_assert (!flags (*p).keep);
    const int lit = *p;
    LOG ("pushing lit %i of blevel %i", lit, var (lit).level);
#ifndef CADICAL_NDEBUG
    int tmp =
#endif
        shrink_literal (lit, blevel, max_trail);
    CADICAL_assert (tmp > 0);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reactivate()

void CaDiCaL::Internal::reactivate ( int lit )

Definition at line 93 of file cadical_flags.cpp.

                                  {
  CADICAL_assert (!active (lit));
  Flags &f = flags (lit);
  CADICAL_assert (f.status != Flags::FIXED);
  CADICAL_assert (f.status != Flags::UNUSED);
#ifdef LOGGING
  const char *msg = 0;
#endif
  switch (f.status) {
  default:
  case Flags::ELIMINATED:
    CADICAL_assert (f.status == Flags::ELIMINATED);
    CADICAL_assert (stats.now.eliminated > 0);
    stats.now.eliminated--;
#ifdef LOGGING
    msg = "eliminated";
#endif
    break;
  case Flags::SUBSTITUTED:
#ifdef LOGGING
    msg = "substituted";
#endif
    CADICAL_assert (stats.now.substituted > 0);
    stats.now.substituted--;
    break;
  case Flags::PURE:
#ifdef LOGGING
    msg = "pure literal";
#endif
    CADICAL_assert (stats.now.pure > 0);
    stats.now.pure--;
    break;
  }
#ifdef LOGGING
  CADICAL_assert (msg);
  LOG ("reactivate previously %s %d", msg, abs (lit));
#endif
  f.status = Flags::ACTIVE;
  f.sweep = false;
  CADICAL_assert (active (lit));
  stats.reactivated++;
  CADICAL_assert (stats.inactive > 0);
  stats.inactive--;
  stats.active++;
}

Here is the call graph for this function:

◆ real_time()

double CaDiCaL::Internal::real_time ( ) const

Definition at line 101 of file cadical_resources.cpp.

                                  {
  return absolute_real_time () - stats.time.real;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ recompute_glue()

int CaDiCaL::Internal::recompute_glue ( Clause * c )

Definition at line 210 of file cadical_analyze.cpp.

                                       {
  int res = 0;
  const int64_t stamp = ++stats.recomputed;
  for (const auto &lit : *c) {
    int level = var (lit).level;
    CADICAL_assert (gtab[level] <= stamp);
    if (gtab[level] == stamp)
      continue;
    gtab[level] = stamp;
    res++;
  }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ recompute_tier()

void CaDiCaL::Internal::recompute_tier ( )

Definition at line 9 of file cadical_tier.cpp.

                               {
  if (!opts.recomputetier)
    return;
 
  ++stats.tierecomputed;
  const int64_t delta =
      stats.tierecomputed >= 16 ? 1u << 16 : (1u << stats.tierecomputed);
  lim.recompute_tier = stats.conflicts + delta;
  LOG ("rescheduling in %zd at %zd (conflicts at %zd)", delta,
       lim.recompute_tier, stats.conflicts);
#ifndef CADICAL_NDEBUG
  uint64_t total_used = 0;
  for (auto u : stats.used[stable])
    total_used += u;
  CADICAL_assert (total_used == stats.bump_used[stable]);
#endif
 
  if (!stats.bump_used[stable]) {
    tier1[stable] = opts.reducetier1glue;
    tier2[stable] = opts.reducetier2glue;
    LOG ("tier1 limit = %d", tier1[stable]);
    LOG ("tier2 limit = %d", tier2[stable]);
    return;
  } else {
    uint64_t accumulated_tier1_limit =
        stats.bump_used[stable] * opts.tier1limit / 100;
    uint64_t accumulated_tier2_limit =
        stats.bump_used[stable] * opts.tier2limit / 100;
    uint64_t accumulated_used = 0;
    for (size_t glue = 0; glue < stats.used[stable].size (); ++glue) {
      const uint64_t u = stats.used[stable][glue];
      accumulated_used += u;
      if (accumulated_used <= accumulated_tier1_limit) {
        tier1[stable] = glue;
      }
      if (accumulated_used >= accumulated_tier2_limit) {
        tier2[stable] = glue;
        break;
      }
    }
  }
 
  LOG ("tier1 limit = %d in %s mode", tier1[stable],
       stable ? "stable" : "focused");
  LOG ("tier2 limit = %d in %s mode", tier2[stable],
       stable ? "stable" : "focused");
}

Here is the caller graph for this function:

◆ reduce()

void CaDiCaL::Internal::reduce ( )

Definition at line 217 of file cadical_reduce.cpp.

                       {
  START (reduce);
 
  stats.reductions++;
  report ('.', 1);
 
  bool flush = flushing ();
  if (flush)
    stats.flush.count++;
 
  if (!propagate_out_of_order_units ())
    goto DONE;
 
  mark_satisfied_clauses_as_garbage ();
  protect_reasons ();
  if (flush)
    mark_clauses_to_be_flushed ();
  else
    mark_useless_redundant_clauses_as_garbage ();
  garbage_collection ();
 
  {
    int64_t delta = opts.reduceint;
    double factor = stats.reductions + 1;
    if (opts.reduceopt ==
        0) // adjust delta such this is the same as reduceopt=1
      delta = delta * delta / 2;
    else if (opts.reduceopt == 1) {
      // this is the same as reduceopt=0 if reduceint = sqrt (reduceint) =
      // 17
      factor = sqrt ((double) stats.conflicts);
    } else if (opts.reduceopt == 2)
      // log scaling instead
      factor = log ((double) stats.conflicts);
    if (factor < 1)
      factor = 1;
    delta = delta * factor;
    if (irredundant () > 1e5) {
      delta *= log (irredundant () / 1e4) / log (10);
    }
    if (delta < 1)
      delta = 1;
    lim.reduce = stats.conflicts + delta;
    PHASE ("reduce", stats.reductions,
           "new reduce limit %" PRId64 " after %" PRId64 " conflicts",
           lim.reduce, delta);
  }
 
  if (flush) {
    PHASE ("flush", stats.flush.count, "new flush increment %" PRId64 "",
           inc.flush);
    inc.flush *= opts.flushfactor;
    lim.flush = stats.conflicts + inc.flush;
    PHASE ("flush", stats.flush.count, "new flush limit %" PRId64 "",
           lim.flush);
  }
 
  last.reduce.conflicts = stats.conflicts;
 
DONE:
 
  report (flush ? 'f' : '-');
  STOP (reduce);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reducing()

bool CaDiCaL::Internal::reducing ( )

Definition at line 18 of file cadical_reduce.cpp.

                         {
  if (!opts.reduce)
    return false;
  if (!stats.current.redundant)
    return false;
  return stats.conflicts >= lim.reduce;
}

Here is the caller graph for this function:

◆ redundant()

int64_t CaDiCaL::Internal::redundant ( ) const

inline

Definition at line 381 of file internal.hpp.

381{ return stats.current.redundant; }

Here is the caller graph for this function:

◆ release_quotients()

void CaDiCaL::Internal::release_quotients ( Factoring & factoring )

Definition at line 173 of file cadical_factor.cpp.

                                                      {
  for (Quotient *q = factoring.quotients.first, *next; q; q = next) {
    next = q->next;
    int factor = q->factor;
    CADICAL_assert (getfact (factor, FACTORS));
    unmarkfact (factor, FACTORS);
    delete q;
  }
  factoring.quotients.first = factoring.quotients.last = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ release_sweeper()

void CaDiCaL::Internal::release_sweeper ( Sweeper & sweeper )

Definition at line 275 of file cadical_sweep.cpp.

                                                {
 
  sweeper.reprs -= max_var;
  delete[] sweeper.reprs;
 
  erase_vector (sweeper.depths);
  erase_vector (sweeper.prev);
  erase_vector (sweeper.next);
  erase_vector (sweeper.vars);
  erase_vector (sweeper.clause);
  erase_vector (sweeper.backbone);
  erase_vector (sweeper.partition);
  erase_vector (sweeper.prev_units);
  for (unsigned i = 0; i < 2; i++)
    erase_vector (sweeper.core[i]);
 
  cadical_kitten_release (citten);
  citten = 0;
  stats.ticks.sweep += sweeper.current_ticks;
  sweep_sparse_mode ();
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_falsified_literals()

void CaDiCaL::Internal::remove_falsified_literals ( Clause * c )

Definition at line 44 of file cadical_collect.cpp.

                                                   {
  const const_literal_iterator end = c->end ();
  const_literal_iterator i;
  int num_non_false = 0;
  for (i = c->begin (); num_non_false < 2 && i != end; i++)
    if (fixed (*i) >= 0)
      num_non_false++;
  if (num_non_false < 2)
    return;
  if (proof) {
    // Flush changes the clause id, external forgettables need to be
    // marked here (or the new id could be used instead of old one)
    if (opts.check && is_external_forgettable (c->id))
      mark_garbage_external_forgettable (c->id);
    proof->flush_clause (c);
  }
  literal_iterator j = c->begin ();
  for (i = j; i != end; i++) {
    const int lit = *j++ = *i, tmp = fixed (lit);
    CADICAL_assert (tmp <= 0);
    if (tmp >= 0)
      continue;
    LOG ("flushing %d", lit);
    j--;
  }
  stats.collected += shrink_clause (c, j - c->begin ());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_garbage_binaries()

void CaDiCaL::Internal::remove_garbage_binaries ( )

Definition at line 477 of file cadical_collect.cpp.

                                        {
  if (unsat)
    return;
  START (collect);
 
  if (!protected_reasons)
    protect_reasons ();
  int backtrack_level = level + 1;
  Watches saved;
  for (auto v : vars) {
    for (auto lit : {-v, v}) {
      CADICAL_assert (saved.empty ());
      Watches &ws = watches (lit);
      const const_watch_iterator end = ws.end ();
      watch_iterator j = ws.begin ();
      const_watch_iterator i;
      for (i = j; i != end; i++) {
        Watch w = *i;
        *j++ = w;
        Clause *c = w.clause;
        COVER (!w.binary () && c->size == 2);
        if (!w.binary ())
          continue;
        if (c->reason && c->garbage) {
          COVER (true);
          CADICAL_assert (c->size == 2);
          backtrack_level =
              min (backtrack_level, var (c->literals[0]).level);
          LOG ("need to backtrack to before level %d", backtrack_level);
          --j;
          continue;
        }
        if (!c->collect ())
          continue;
        LOG (c, "removing from watch list");
        --j;
      }
      ws.resize (j - ws.begin ());
      shrink_vector (ws);
    }
  }
  delete_garbage_clauses ();
  unprotect_reasons ();
  if (backtrack_level - 1 < level)
    backtrack (backtrack_level - 1);
  STOP (collect);
}

Here is the call graph for this function:

◆ remove_observed_var()

void CaDiCaL::Internal::remove_observed_var ( int ilit )

Definition at line 45 of file cadical_external_propagate.cpp.

                                            {
  if (!fixed (ilit) && level) {
    backtrack ();
  }
 
  CADICAL_assert (fixed (ilit) || !level);
 
  const int idx = vidx (ilit);
  CADICAL_assert ((size_t) idx < relevanttab.size ());
  unsigned &ref = relevanttab[idx];
  CADICAL_assert (fixed (ilit) || ref > 0);
  if (fixed (ilit))
    ref = 0;
  else if (ref < UINT_MAX) {
    if (!--ref) {
      LOG ("variable %d is not observed anymore", idx);
    } else
      LOG ("variable %d is unobserved once but remains observed %u times",
           ilit, ref);
  } else
    LOG ("variable %d remains observed forever", idx);
}

Here is the call graph for this function:

◆ renotify_full_trail()

void CaDiCaL::Internal::renotify_full_trail ( )

Definition at line 130 of file cadical_external_propagate.cpp.

                                    {
  const size_t end_of_trail = trail.size ();
  if (level) {
    notified = 0; // TODO: save the last notified root-level position
                  // somewhere and use it here
    notify_backtrack (0);
  }
  std::vector<int> assigned;
 
  int prev_max_level = 0;
  int current_level = 0;
  int propagator_level = 0;
 
  while (notified < end_of_trail) {
    int ilit = trail[notified++];
    // In theory, 0 ilit can happen due to pseudo-decision levels
    if (!ilit)
      current_level = prev_max_level + 1;
    else
      current_level = var (ilit).level;
 
    if (current_level > propagator_level) {
      if (assigned.size ())
        external->propagator->notify_assignment (assigned);
      while (current_level > propagator_level) {
        external->propagator->notify_new_decision_level ();
        propagator_level++;
      }
      assigned.clear ();
    }
    // Current level can be smaller than prev_max_level due to chrono
    if (current_level > prev_max_level)
      prev_max_level = current_level;
 
    if (!observed (ilit))
      continue;
 
    int elit = externalize (ilit); // TODO: double-check tainting
    CADICAL_assert (elit);
    // Fixed variables might get mapped (during compact) to another
    // non-observed but fixed variable.
    // This happens on root level, so notification about their assignment is
    // already done.
    CADICAL_assert (external->observed (elit) || fixed (ilit));
    if (!external->ervars[abs (elit)])
      assigned.push_back (elit);
  }
  if (assigned.size ())
    external->propagator->notify_assignment (assigned);
  assigned.clear ();
 
  // In case there are some left over empty levels on the top of the trail,
  // the external propagtor must be notified about them so the levels are
  // synced
  while (level > propagator_level) {
    external->propagator->notify_new_decision_level ();
    propagator_level++;
  }
 
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ renotify_trail_after_ilb()

void CaDiCaL::Internal::renotify_trail_after_ilb ( )

Definition at line 101 of file cadical_external_propagate.cpp.

                                         {
  if (!external_prop || external_prop_is_lazy || !trail.size () ||
      !opts.ilb) {
    return;
  }
  LOG ("notify external propagator about new assignments (after ilb)");
#ifndef CADICAL_NDEBUG
  LOG ("(decision level: %d, trail size: %zd, notified %zd)", level,
       trail.size (), notified);
#endif
  renotify_full_trail ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ renotify_trail_after_local_search()

void CaDiCaL::Internal::renotify_trail_after_local_search ( )

Definition at line 114 of file cadical_external_propagate.cpp.

                                                  {
  if (!external_prop || external_prop_is_lazy || !trail.size ()) {
    return;
  }
  LOG ("notify external propagator about new assignments (after local "
       "search)");
#ifndef CADICAL_NDEBUG
  LOG ("(decision level: %d, trail size: %zd, notified %zd)", level,
       trail.size (), notified);
#endif
  renotify_full_trail ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rephase()

void CaDiCaL::Internal::rephase ( )

Definition at line 108 of file cadical_rephase.cpp.

                        {
 
  stats.rephased.total++;
  PHASE ("rephase", stats.rephased.total,
         "reached rephase limit %" PRId64 " after %" PRId64 " conflicts",
         lim.rephase, stats.conflicts);
 
  // Report current 'target' and 'best' and then set 'rephased' below, which
  // will trigger reporting the new 'target' and 'best' after updating it in
  // the next 'update_target_and_best' called from the next 'backtrack'.
  //
  report ('~', 1);
 
  backtrack ();
  clear_phases (phases.target);
  target_assigned = 0;
 
  size_t count = lim.rephased[stable]++;
  bool single;
  char type;
 
  if (opts.stabilize && opts.stabilizeonly)
    single = true;
  else
    single = !opts.stabilize;
 
  if (single && !opts.walk) {
    // (inverted,best,flipping,best,random,best,original,best)^\omega
    switch (count % 8) {
    case 0:
      type = rephase_inverted ();
      break;
    case 1:
      type = rephase_best ();
      break;
    case 2:
      type = rephase_flipping ();
      break;
    case 3:
      type = rephase_best ();
      break;
    case 4:
      type = rephase_random ();
      break;
    case 5:
      type = rephase_best ();
      break;
    case 6:
      type = rephase_original ();
      break;
    case 7:
      type = rephase_best ();
      break;
    default:
      type = 0;
      break;
    }
  } else if (single && opts.walk) {
    // (inverted,best,walk,
    //  flipping,best,walk,
    //    random,best,walk,
    //  original,best,walk)^\omega
    switch (count % 12) {
    case 0:
      type = rephase_inverted ();
      break;
    case 1:
      type = rephase_best ();
      break;
    case 2:
      type = rephase_walk ();
      break;
    case 3:
      type = rephase_flipping ();
      break;
    case 4:
      type = rephase_best ();
      break;
    case 5:
      type = rephase_walk ();
      break;
    case 6:
      type = rephase_random ();
      break;
    case 7:
      type = rephase_best ();
      break;
    case 8:
      type = rephase_walk ();
      break;
    case 9:
      type = rephase_original ();
      break;
    case 10:
      type = rephase_best ();
      break;
    case 11:
      type = rephase_walk ();
      break;
    default:
      type = 0;
      break;
    }
  } else if (stable && !opts.walk) {
    // original,inverted,(best,original,best,inverted)^\omega
    if (!count)
      type = rephase_original ();
    else if (count == 1)
      type = rephase_inverted ();
    else
      switch ((count - 2) % 4) {
      case 0:
        type = rephase_best ();
        break;
      case 1:
        type = rephase_original ();
        break;
      case 2:
        type = rephase_best ();
        break;
      case 3:
        type = rephase_inverted ();
        break;
      default:
        type = 0;
        break;
      }
  } else if (stable && opts.walk) {
    // original,inverted,(best,walk,original,best,walk,inverted)^\omega
    if (!count)
      type = rephase_original ();
    else if (count == 1)
      type = rephase_inverted ();
    else
      switch ((count - 2) % 6) {
      case 0:
        type = rephase_best ();
        break;
      case 1:
        type = rephase_walk ();
        break;
      case 2:
        type = rephase_original ();
        break;
      case 3:
        type = rephase_best ();
        break;
      case 4:
        type = rephase_walk ();
        break;
      case 5:
        type = rephase_inverted ();
        break;
      default:
        type = 0;
        break;
      }
  } else if (!stable && (!opts.walk || !opts.walknonstable)) {
    // flipping,(random,best,flipping,best)^\omega
    if (!count)
      type = rephase_flipping ();
    else
      switch ((count - 1) % 4) {
      case 0:
        type = rephase_random ();
        break;
      case 1:
        type = rephase_best ();
        break;
      case 2:
        type = rephase_flipping ();
        break;
      case 3:
        type = rephase_best ();
        break;
      default:
        type = 0;
        break;
      }
  } else {
    CADICAL_assert (!stable && opts.walk && opts.walknonstable);
    // flipping,(random,best,walk,flipping,best,walk)^\omega
    if (!count)
      type = rephase_flipping ();
    else
      switch ((count - 1) % 6) {
      case 0:
        type = rephase_random ();
        break;
      case 1:
        type = rephase_best ();
        break;
      case 2:
        type = rephase_walk ();
        break;
      case 3:
        type = rephase_flipping ();
        break;
      case 4:
        type = rephase_best ();
        break;
      case 5:
        type = rephase_walk ();
        break;
      default:
        type = 0;
        break;
      }
  }
  CADICAL_assert (type);
 
  int64_t delta = opts.rephaseint * (stats.rephased.total + 1);
  lim.rephase = stats.conflicts + delta;
 
  PHASE ("rephase", stats.rephased.total,
         "new rephase limit %" PRId64 " after %" PRId64 " conflicts",
         lim.rephase, delta);
 
  // This will trigger to report the effect of this new set of phases at the
  // 'backtrack' (actually 'update_target_and_best') after the next
  // conflict, as well as resetting 'best_assigned' then to allow to compute
  // a new "best" assignment at that point.
  //
  last.rephase.conflicts = stats.conflicts;
  rephased = type;
 
  if (stable)
    shuffle_scores ();
  else
    shuffle_queue ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rephase_best()

char CaDiCaL::Internal::rephase_best ( )

Definition at line 85 of file cadical_rephase.cpp.

                             {
  stats.rephased.best++;
  PHASE ("rephase", stats.rephased.total,
         "overwriting saved phases by best phases");
  signed char val;
  for (auto idx : vars)
    if ((val = phases.best[idx]))
      phases.saved[idx] = val;
  return 'B';
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rephase_flipping()

char CaDiCaL::Internal::rephase_flipping ( )

Definition at line 61 of file cadical_rephase.cpp.

                                 {
  stats.rephased.flipped++;
  PHASE ("rephase", stats.rephased.total,
         "flipping all phases individually");
  for (auto idx : vars)
    phases.saved[idx] *= -1;
  return 'F';
}

Here is the caller graph for this function:

◆ rephase_inverted()

char CaDiCaL::Internal::rephase_inverted ( )

Definition at line 49 of file cadical_rephase.cpp.

                                 {
  stats.rephased.inverted++;
  signed char val = opts.phase ? -1 : 1; // original = -initial
  PHASE ("rephase", stats.rephased.total,
         "switching to inverted original phase %d", val);
  for (auto idx : vars)
    phases.saved[idx] = val;
  return 'I';
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rephase_original()

char CaDiCaL::Internal::rephase_original ( )

Definition at line 37 of file cadical_rephase.cpp.

                                 {
  stats.rephased.original++;
  signed char val = opts.phase ? 1 : -1; // original = initial
  PHASE ("rephase", stats.rephased.total, "switching to original phase %d",
         val);
  for (auto idx : vars)
    phases.saved[idx] = val;
  return 'O';
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rephase_random()

char CaDiCaL::Internal::rephase_random ( )

Definition at line 72 of file cadical_rephase.cpp.

                               {
  stats.rephased.random++;
  PHASE ("rephase", stats.rephased.total, "resetting all phases randomly");
  Random random (opts.seed);       // global seed
  random += stats.rephased.random; // different every time
  for (auto idx : vars)
    phases.saved[idx] = random.generate_bool () ? -1 : 1;
  return '#';
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rephase_walk()

char CaDiCaL::Internal::rephase_walk ( )

Definition at line 98 of file cadical_rephase.cpp.

                             {
  stats.rephased.walk++;
  PHASE ("rephase", stats.rephased.total,
         "starting local search to improve current phase");
  walk ();
  return 'W';
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rephasing()

bool CaDiCaL::Internal::rephasing ( )

Definition at line 25 of file cadical_rephase.cpp.

                          {
  if (!opts.rephase)
    return false;
  if (opts.forcephase)
    return false;
  return stats.conflicts > lim.rephase;
}

Here is the caller graph for this function:

◆ report()

void CaDiCaL::Internal::report	(	char	type,
		int	verbose_level = 0 )

Definition at line 296 of file cadical_report.cpp.

296{}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ report_solving()

void CaDiCaL::Internal::report_solving ( int res )

Definition at line 959 of file cadical_internal.cpp.

                                      {
  if (res == 10)
    report ('1');
  else if (res == 20)
    report ('0');
  else
    report ('?');
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ require_mode()

void CaDiCaL::Internal::require_mode ( Mode m ) const

inline

Definition at line 173 of file internal.hpp.

173{ CADICAL_assert (mode & m), (void) m; }

Here is the caller graph for this function:

◆ rescale_variable_scores()

void CaDiCaL::Internal::rescale_variable_scores ( )

Definition at line 89 of file cadical_analyze.cpp.

                                        {
  stats.rescored++;
  double divider = score_inc;
  for (auto idx : vars) {
    const double tmp = stab[idx];
    if (tmp > divider)
      divider = tmp;
  }
  PHASE ("rescore", stats.rescored, "rescoring %d variable scores by 1/%g",
         max_var, divider);
  CADICAL_assert (divider > 0);
  double factor = 1.0 / divider;
  for (auto idx : vars)
    stab[idx] *= factor;
  score_inc *= factor;
  PHASE ("rescore", stats.rescored,
         "new score increment %g after %" PRId64 " conflicts", score_inc,
         stats.conflicts);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reschedule_previously_remaining()

unsigned CaDiCaL::Internal::reschedule_previously_remaining ( Sweeper & sweeper )

Definition at line 1773 of file cadical_sweep.cpp.

                                                                    {
  unsigned rescheduled = 0;
  for (const auto &idx : sweep_schedule) {
    Flags &f = flags (idx);
    if (!f.active ())
      continue;
    if (scheduled_variable (sweeper, idx))
      continue;
    size_t occ;
    if (!scheduable_variable (sweeper, idx, &occ)) {
      f.sweep = false;
      continue;
    }
    schedule_inner (sweeper, idx);
    rescheduled++;
  }
  sweep_schedule.clear ();
  return rescheduled;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reserve_ids()

void CaDiCaL::Internal::reserve_ids ( int number )

Definition at line 233 of file cadical_internal.cpp.

                                      {
  // return;
  LOG ("reserving %d ids", number);
  CADICAL_assert (number >= 0);
  CADICAL_assert (!clause_id && !reserved_ids && !original_id);
  clause_id = reserved_ids = number;
  if (proof)
    proof->begin_proof (reserved_ids);
}

◆ reset_assumptions()

void CaDiCaL::Internal::reset_assumptions ( )

Definition at line 502 of file cadical_assume.cpp.

                                  {
  for (const auto &lit : assumptions) {
    Flags &f = flags (lit);
    const unsigned char bit = bign (lit);
    f.assumed &= ~bit;
    f.failed &= ~bit;
    melt (lit);
  }
  LOG ("cleared %zd assumptions", assumptions.size ());
  assumptions.clear ();
  marked_failed = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_bins()

void CaDiCaL::Internal::reset_bins ( )

Definition at line 20 of file cadical_bins.cpp.

                           {
  CADICAL_assert (!big.empty ());
  erase_vector (big);
  LOG ("reset binary implication graph");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_citten()

void CaDiCaL::Internal::reset_citten ( )

Definition at line 1011 of file cadical_elim.cpp.

                             {
  if (citten) {
    cadical_kitten_release (citten);
    citten = 0;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_concluded()

void CaDiCaL::Internal::reset_concluded ( )

Definition at line 485 of file cadical_assume.cpp.

                                {
  if (proof)
    proof->reset_assumptions ();
  if (concluded) {
    LOG ("reset concluded");
    concluded = false;
  }
  if (conflict_id) {
    CADICAL_assert (conclusion.size () == 1);
    return;
  }
  conclusion.clear ();
}

◆ reset_constraint()

void CaDiCaL::Internal::reset_constraint ( )

Definition at line 59 of file cadical_constrain.cpp.

                                 {
  for (auto lit : constraint)
    melt (lit);
  LOG ("cleared %zd constraint literals", constraint.size ());
  constraint.clear ();
  unsat_constraint = false;
  marked_failed = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_factor_mode()

void CaDiCaL::Internal::reset_factor_mode ( )

Definition at line 111 of file cadical_factor.cpp.

                                  {
  reset_occs ();
  init_watches ();
  connect_watches ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_limits()

void CaDiCaL::Internal::reset_limits ( )

Definition at line 124 of file cadical_limit.cpp.

                             {
  LOG ("reset limits");
  limit_terminate (0);
  limit_conflicts (-1);
  limit_decisions (-1);
  limit_preprocessing (0);
  limit_local_search (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_mode()

void CaDiCaL::Internal::reset_mode ( Mode m )

inline

Definition at line 169 of file internal.hpp.

                           {
    CADICAL_assert (mode & m);
    mode &= ~m;
  }

Here is the caller graph for this function:

◆ reset_noccs()

void CaDiCaL::Internal::reset_noccs ( )

Definition at line 50 of file cadical_occs.cpp.

                            {
  CADICAL_assert (!max_var || !ntab.empty ());
  erase_vector (ntab);
  LOG ("reset two-sided occurrence counters");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_occs()

void CaDiCaL::Internal::reset_occs ( )

Definition at line 19 of file cadical_occs.cpp.

                           {
  CADICAL_assert (occurring ());
  erase_vector (otab);
  LOG ("reset occurrence lists");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_shrinkable()

void CaDiCaL::Internal::reset_shrinkable ( )

Definition at line 10 of file cadical_shrink.cpp.

                                 {
#ifdef LOGGING
  size_t reset = 0;
#endif
  for (const auto &lit : shrinkable) {
    LOG ("resetting lit %i", lit);
    Flags &f = flags (lit);
    CADICAL_assert (f.shrinkable);
    f.shrinkable = false;
#ifdef LOGGING
    ++reset;
#endif
  }
  LOG ("resetting %zu shrinkable variables", reset);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_solving()

void CaDiCaL::Internal::reset_solving ( )

Definition at line 968 of file cadical_internal.cpp.

                              {
  if (termination_forced) {
 
    // TODO this leads potentially to a data race if the external
    // user is calling 'terminate' twice within one 'solve' call.
    // A proper solution would be to guard / protect setting the
    // 'termination_forced' flag and only allow it during solving and
    // ignore it otherwise thus also the second time it is called during a
    // 'solve' call.  We could move resetting it also the start of
    // 'solve'.
    //
    termination_forced = false;
 
    LOG ("reset forced termination");
  }
}

Here is the caller graph for this function:

◆ reset_subsume_bits()

void CaDiCaL::Internal::reset_subsume_bits ( )

Definition at line 9 of file cadical_var.cpp.

                                   {
  LOG ("marking all variables as not subsume");
  for (auto idx : vars)
    flags (idx).subsume = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_watches()

void CaDiCaL::Internal::reset_watches ( )

Definition at line 21 of file cadical_watch.cpp.

                              {
  CADICAL_assert (!wtab.empty ());
  erase_vector (wtab);
  LOG ("reset watcher tables");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resize_factoring()

void CaDiCaL::Internal::resize_factoring	(	Factoring &	factoring,
		int	lit )

Definition at line 472 of file cadical_factor.cpp.

                                                              {
  CADICAL_assert (lit > 0);
  size_t new_var_size = lit + 1;
  size_t new_lit_size = 2 * new_var_size;
  enlarge_zero (factoring.count, new_lit_size);
}

Here is the caller graph for this function:

◆ resize_unit_clauses_idx()

void CaDiCaL::Internal::resize_unit_clauses_idx ( )

Definition at line 22 of file cadical_proof.cpp.

                                        {
  size_t new_vsize = vsize ? 2 * vsize : 1 + (size_t) max_var;
  unit_clauses_idx.resize (2 * new_vsize, 0);
}

Here is the caller graph for this function:

◆ resolve_clauses()

bool CaDiCaL::Internal::resolve_clauses	(	Eliminator &	eliminator,
		Clause *	c,
		int	pivot,
		Clause *	d,
		bool	propagate_eagerly )

Definition at line 269 of file cadical_elim.cpp.

                                                              {
 
  CADICAL_assert (!c->redundant);
  CADICAL_assert (!d->redundant);
 
  stats.elimres++;
 
  if (c->garbage || d->garbage)
    return false;
  if (c->size > d->size) {
    pivot = -pivot;
    swap (c, d);
  }
 
  CADICAL_assert (!level);
  CADICAL_assert (clause.empty ());
 
  int satisfied = 0;    // Contains this satisfying literal.
  int tautological = 0; // Clashing literal if tautological.
 
  int s = 0; // Actual literals from 'c'.
  int t = 0; // Actual literals from 'd'.
 
  // First determine whether the first antecedent is satisfied, add its
  // literals to 'clause' and mark them (except for 'pivot').
  //
  for (const auto &lit : *c) {
    if (lit == pivot) {
      s++;
      continue;
    }
    CADICAL_assert (lit != -pivot);
    const signed char tmp = val (lit);
    if (tmp > 0) {
      satisfied = lit;
      break;
    } else if (tmp < 0) {
      if (!lrat)
        continue;
      Flags &f = flags (lit);
      if (f.seen)
        continue;
      analyzed.push_back (lit);
      f.seen = true;
      int64_t id = unit_id (-lit);
      lrat_chain.push_back (id);
      continue;
    } else
      mark (lit), clause.push_back (lit), s++;
  }
  if (satisfied) {
    LOG (c, "satisfied by %d antecedent", satisfied);
    elim_update_removed_clause (eliminator, c, satisfied);
    mark_garbage (c);
    clause.clear ();
    lrat_chain.clear ();
    clear_analyzed_literals ();
    unmark (c);
    return false;
  }
 
  // Then determine whether the second antecedent is satisfied, add its
  // literal to 'clause' and check whether a clashing literal is found, such
  // that the resolvent would be tautological.
  //
  for (const auto &lit : *d) {
    if (lit == -pivot) {
      t++;
      continue;
    }
    CADICAL_assert (lit != pivot);
    signed char tmp = val (lit);
    if (tmp > 0) {
      satisfied = lit;
      break;
    } else if (tmp < 0) {
      if (!lrat)
        continue;
      Flags &f = flags (lit);
      if (f.seen)
        continue;
      analyzed.push_back (lit);
      f.seen = true;
      int64_t id = unit_id (-lit);
      lrat_chain.push_back (id);
      continue;
    } else if ((tmp = marked (lit)) < 0) {
      tautological = lit;
      break;
    } else if (!tmp)
      clause.push_back (lit), t++;
    else
      CADICAL_assert (tmp > 0), t++;
  }
 
  clear_analyzed_literals ();
  unmark (c);
  const int64_t size = clause.size ();
 
  if (lrat) {
    lrat_chain.push_back (d->id);
    lrat_chain.push_back (c->id);
  }
 
  if (satisfied) {
    LOG (d, "satisfied by %d antecedent", satisfied);
    elim_update_removed_clause (eliminator, d, satisfied);
    mark_garbage (d);
    clause.clear ();
    lrat_chain.clear ();
    return false;
  }
 
  LOG (c, "first antecedent");
  LOG (d, "second antecedent");
 
  if (tautological) {
    clause.clear ();
    LOG ("resolvent tautological on %d", tautological);
    lrat_chain.clear ();
    return false;
  }
 
  if (!size) {
    clause.clear ();
    LOG ("empty resolvent");
    learn_empty_clause (); // already clears lrat_chain.
    return false;
  }
 
  if (size == 1) {
    int unit = clause[0];
    LOG ("unit resolvent %d", unit);
    clause.clear ();
    assign_unit (unit); // already clears lrat_chain.
    if (propagate_eagerly)
      elim_propagate (eliminator, unit);
    return false;
  }
 
  LOG (clause, "resolvent");
  CADICAL_assert (!lrat || !lrat_chain.empty ());
 
  // Double self-subsuming resolution.  The clauses 'c' and 'd' are
  // identical except for the pivot which occurs in different phase.  The
  // resolvent subsumes both antecedents.
 
  if (s > size && t > size) {
    CADICAL_assert (s == size + 1);
    CADICAL_assert (t == size + 1);
    clause.clear ();
    // LRAT is c + d (+ eventual units)
    elim_on_the_fly_self_subsumption (eliminator, c, pivot);
    LOG (d, "double pivot %d on-the-fly self-subsuming resolution", -pivot);
    stats.elimotfsub++;
    stats.subsumed++;
    elim_update_removed_clause (eliminator, d, -pivot);
    mark_garbage (d);
    return false;
  }
 
  // Single self-subsuming resolution:  The pivot can be removed from 'c',
  // which is implemented by adding a clause which is the same as 'c' but
  // with 'pivot' removed and then marking 'c' as garbage.
 
  if (s > size) {
    CADICAL_assert (s == size + 1);
    clause.clear ();
    // LRAT is c + d (+ eventual units)
    elim_on_the_fly_self_subsumption (eliminator, c, pivot);
    return false;
  }
 
  // Same single self-subsuming resolution situation, but only for 'd'.
 
  if (t > size) {
    CADICAL_assert (t == size + 1);
    clause.clear ();
    // LRAT is c + d (+ eventual units) -> same.
    elim_on_the_fly_self_subsumption (eliminator, d, -pivot);
    return false;
  }
  if (propagate_eagerly)
    lrat_chain.clear ();
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ restart()

void CaDiCaL::Internal::restart ( )

Definition at line 147 of file cadical_restart.cpp.

                        {
  START (restart);
  stats.restarts++;
  stats.restartlevels += level;
  if (stable)
    stats.restartstable++;
  LOG ("restart %" PRId64 "", stats.restarts);
  backtrack (reuse_trail ());
 
  lim.restart = stats.conflicts + opts.restartint;
  LOG ("new restart limit at %" PRId64 " conflicts", lim.restart);
 
  report ('R', 2);
  STOP (restart);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ restarting()

bool CaDiCaL::Internal::restarting ( )

Definition at line 89 of file cadical_restart.cpp.

                           {
  if (!opts.restart)
    return false;
  if ((size_t) level < assumptions.size () + 2)
    return false;
  if (stabilizing ())
    return reluctant;
  if (stats.conflicts <= lim.restart)
    return false;
  double f = averages.current.glue.fast;
  double margin = (100.0 + opts.restartmargin) / 100.0;
  double s = averages.current.glue.slow, l = margin * s;
  LOG ("EMA glue slow %.2f fast %.2f limit %.2f", s, f, l);
  return l <= f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ restore_clauses()

int CaDiCaL::Internal::restore_clauses ( )

Definition at line 985 of file cadical_internal.cpp.

                               {
  int res = 0;
  if (opts.restoreall <= 1 && external->tainted.empty ()) {
    LOG ("no tainted literals and nothing to restore");
    report ('*');
  } else {
    report ('+');
    // remove_garbage_binaries ();
    external->restore_clauses ();
    internal->report ('r');
    if (!unsat && !level && !propagate ()) {
      LOG ("root level propagation after restore produces conflict");
      learn_empty_clause ();
      res = 20;
    }
  }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reuse_trail()

int CaDiCaL::Internal::reuse_trail ( )

Definition at line 110 of file cadical_restart.cpp.

                           {
  const int trivial_decisions =
      assumptions.size ()
      // Plus 1 if the constraint is satisfied via implications of
      // assumptions and a pseudo-decision level was introduced.
      + !control[assumptions.size () + 1].decision;
  if (!opts.restartreusetrail)
    return trivial_decisions;
  int next_decision = next_decision_variable ();
  CADICAL_assert (1 <= next_decision);
  int res = trivial_decisions;
  if (use_scores ()) {
    while (res < level) {
      int decision = control[res + 1].decision;
      if (decision && score_smaller (this) (abs (decision), next_decision))
        break;
      res++;
    }
  } else {
    int64_t limit = bumped (next_decision);
    while (res < level) {
      int decision = control[res + 1].decision;
      if (decision && bumped (decision) < limit)
        break;
      res++;
    }
  }
  int reused = res - trivial_decisions;
  if (reused > 0) {
    stats.reused++;
    stats.reusedlevels += reused;
    if (stable)
      stats.reusedstable++;
  }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run_factorization()

bool CaDiCaL::Internal::run_factorization ( int64_t limit )

Definition at line 772 of file cadical_factor.cpp.

                                               {
  Factoring factoring = Factoring (this, limit);
  schedule_factorization (factoring);
  bool done = false;
#ifndef CADICAL_QUIET
  unsigned factored = 0;
#endif
  int64_t *ticks = &stats.ticks.factor;
  VERBOSE (3, "factorization limit of %" PRIu64 " ticks", limit - *ticks);
 
  while (!unsat && !done && !factoring.schedule.empty ()) {
    const unsigned ufirst = factoring.schedule.pop_front ();
    LOG ("next factor candidate %d", ufirst);
    const int first = u2i (ufirst);
    const int first_idx = vidx (first);
    if (!active (first_idx))
      continue;
    if (!occs (first).size ()) {
      factoring.schedule.clear ();
      break;
    }
    if (*ticks > limit) {
      VERBOSE (2, "factorization ticks limit hit");
      break;
    }
    if (terminated_asynchronously ())
      break;
    Flags &f = flags (first_idx);
    const unsigned bit = 1u << (first < 0);
    if (!(f.factor & bit))
      continue;
    f.factor &= ~bit;
    const size_t first_count = first_factor (factoring, first);
    if (first_count > 1) {
      for (;;) {
        unsigned next_count;
        const int next = next_factor (factoring, &next_count);
        if (next == 0)
          break;
        CADICAL_assert (next_count > 1);
        if (next_count < 2)
          break;
        factorize_next (factoring, next, next_count);
      }
      size_t reduction;
      Quotient *q = best_quotient (factoring, &reduction);
      if (q && (int) reduction > factoring.bound) {
        if (apply_factoring (factoring, q)) {
#ifndef CADICAL_QUIET
          factored++;
#endif
        } else
          done = true;
      }
    }
    release_quotients (factoring);
  }
 
  // since we cannot remove elements from the heap we check wether the
  // first element in the heap has occurences
  bool completed = factoring.schedule.empty ();
  if (!completed) {
    const unsigned idx = factoring.schedule.front ();
    completed = occs (u2i (idx)).empty ();
  }
  // kissat initializes scores for new variables at this point, however
  // this is actually done already during resize of internal
#ifndef CADICAL_QUIET
  report ('f', !factored);
#endif
  return completed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ satisfied()

bool CaDiCaL::Internal::satisfied ( )

Definition at line 102 of file cadical_decide.cpp.

                          {
  if ((size_t) level < assumptions.size () + (!!constraint.size ()))
    return false;
  if (num_assigned < (size_t) max_var)
    return false;
  CADICAL_assert (num_assigned == (size_t) max_var);
  if (propagated < trail.size ())
    return false;
  size_t assigned = num_assigned;
  return (assigned == (size_t) max_var);
}

Here is the caller graph for this function:

◆ save_add_clear_core()

void CaDiCaL::Internal::save_add_clear_core ( Sweeper & sweeper )

Definition at line 626 of file cadical_sweep.cpp.

                                                    {
  save_core (sweeper, 0);
  add_core (sweeper, 0);
  clear_core (sweeper, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save_core()

void CaDiCaL::Internal::save_core	(	Sweeper &	sweeper,
		unsigned	core )

Definition at line 599 of file cadical_sweep.cpp.

                                                         {
  LOG ("saving extracted core[%u] lemmas", core);
  CADICAL_assert (core == 0 || core == 1);
  CADICAL_assert (sweeper.core[core].empty ());
  sweeper.save = core;
  cadical_kitten_compute_clausal_core (citten, 0);
  if (lrat)
    cadical_kitten_trace_core (citten, &sweeper, save_core_clause_with_lrat);
  else
    cadical_kitten_traverse_core_clauses_with_id (citten, &sweeper,
                                          save_core_clause);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scale()

double CaDiCaL::Internal::scale ( double v ) const

Definition at line 13 of file cadical_limit.cpp.

                                      {
  const double ratio = clause_variable_ratio ();
  const double factor = (ratio <= 2) ? 1.0 : log (ratio) / log (2);
  double res = factor * v;
  if (res < 1)
    res = 1;
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scheduable_variable()

bool CaDiCaL::Internal::scheduable_variable	(	Sweeper &	sweeper,
		int	idx,
		size_t *	occ_ptr )

Definition at line 1726 of file cadical_sweep.cpp.

                                                     {
  const int lit = idx;
  const size_t pos = noccs (lit);
  if (!pos)
    return false;
  const unsigned max_occurrences = sweeper.limit.clauses;
  if (pos > max_occurrences)
    return false;
  const int not_lit = -lit;
  const size_t neg = noccs (not_lit);
  if (!neg)
    return false;
  if (neg > max_occurrences)
    return false;
  *occ_ptr = pos + neg;
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ schedule_all_other_not_scheduled_yet()

unsigned CaDiCaL::Internal::schedule_all_other_not_scheduled_yet ( Sweeper & sweeper )

Definition at line 1745 of file cadical_sweep.cpp.

                                                                         {
  vector<sweep_candidate> fresh;
  for (const auto &idx : vars) {
    Flags &f = flags (idx);
    if (!f.active ())
      continue;
    if (sweep_incomplete && !f.sweep)
      continue;
    if (scheduled_variable (sweeper, idx))
      continue;
    size_t occ;
    if (!scheduable_variable (sweeper, idx, &occ)) {
      f.sweep = false;
      continue;
    }
    sweep_candidate cand;
    cand.rank = occ;
    cand.idx = idx;
    fresh.push_back (cand);
  }
  const size_t size = fresh.size ();
  CADICAL_assert (size <= UINT_MAX);
  sort (fresh.begin (), fresh.end (), rank_sweep_candidate ());
  for (auto &cand : fresh)
    schedule_outer (sweeper, cand.idx);
  return size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ schedule_factorization()

void CaDiCaL::Internal::schedule_factorization ( Factoring & factoring )

Definition at line 753 of file cadical_factor.cpp.

                                                           {
  for (const auto &idx : vars) {
    if (active (idx)) {
      Flags &f = flags (idx);
      const int lit = idx;
      const int not_lit = -lit;
      if (f.factor & 1)
        update_factor_candidate (factoring, lit);
      if (f.factor & 2)
        update_factor_candidate (factoring, not_lit);
    }
  }
#ifndef CADICAL_QUIET
  size_t size_cands = factoring.schedule.size ();
  VERBOSE (2, "scheduled %zu factorization candidate literals %.0f %%",
           size_cands, percent (size_cands, max_var));
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ schedule_inner()

void CaDiCaL::Internal::schedule_inner	(	Sweeper &	sweeper,
		int	idx )

Definition at line 946 of file cadical_sweep.cpp.

                                                        {
  CADICAL_assert (idx);
  if (!active (idx))
    return;
  const int next = sweeper.next[idx];
  if (next != 0) {
    LOG ("rescheduling inner %d as last", idx);
    const unsigned prev = sweeper.prev[idx];
    CADICAL_assert (sweeper.prev[next] == idx);
    sweeper.prev[next] = prev;
    if (prev == 0) {
      CADICAL_assert (sweeper.first == idx);
      sweeper.first = next;
    } else {
      CADICAL_assert (sweeper.next[prev] == idx);
      sweeper.next[prev] = next;
    }
    const unsigned last = sweeper.last;
    if (last == 0) {
      CADICAL_assert (sweeper.first == 0);
      sweeper.first = idx;
    } else {
      CADICAL_assert (sweeper.next[last] == 0);
      sweeper.next[last] = idx;
    }
    sweeper.prev[idx] = last;
    sweeper.next[idx] = 0;
    sweeper.last = idx;
  } else if (sweeper.last != idx) {
    LOG ("scheduling inner %d as last", idx);
    const unsigned last = sweeper.last;
    if (last == 0) {
      CADICAL_assert (sweeper.first == 0);
      sweeper.first = idx;
    } else {
      CADICAL_assert (sweeper.next[last] == 0);
      sweeper.next[last] = idx;
    }
    CADICAL_assert (sweeper.next[idx] == 0);
    sweeper.prev[idx] = last;
    sweeper.last = idx;
  } else
    LOG ("keeping inner %d scheduled as last", idx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ schedule_outer()

void CaDiCaL::Internal::schedule_outer	(	Sweeper &	sweeper,
		int	idx )

Definition at line 991 of file cadical_sweep.cpp.

                                                        {
  CADICAL_assert (!scheduled_variable (sweeper, idx));
  CADICAL_assert (active (idx));
  const int first = sweeper.first;
  if (first == 0) {
    CADICAL_assert (sweeper.last == 0);
    sweeper.last = idx;
  } else {
    CADICAL_assert (sweeper.prev[first] == 0);
    sweeper.prev[first] = idx;
  }
  CADICAL_assert (sweeper.prev[idx] == 0);
  sweeper.next[idx] = first;
  sweeper.first = idx;
  LOG ("scheduling outer %d as first", idx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ schedule_sweeping()

unsigned CaDiCaL::Internal::schedule_sweeping ( Sweeper & sweeper )

Definition at line 1822 of file cadical_sweep.cpp.

                                                      {
  const unsigned rescheduled = reschedule_previously_remaining (sweeper);
  const unsigned fresh = schedule_all_other_not_scheduled_yet (sweeper);
  const unsigned scheduled = fresh + rescheduled;
  const unsigned incomplete = incomplete_variables ();
#ifndef CADICAL_QUIET
  PHASE ("sweep", stats.sweep,
         "scheduled %u variables %.0f%% "
         "(%u rescheduled %.0f%%, %u incomplete %.0f%%)",
         scheduled, percent (scheduled, active ()), rescheduled,
         percent (rescheduled, scheduled), incomplete,
         percent (incomplete, scheduled));
#endif
  if (incomplete)
    CADICAL_assert (sweep_incomplete);
  else {
    if (sweep_incomplete)
      stats.sweep_completed++;
    mark_incomplete (sweeper);
  }
  return scheduled;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scheduled_variable()

bool CaDiCaL::Internal::scheduled_variable	(	Sweeper &	sweeper,
		int	idx )

Definition at line 942 of file cadical_sweep.cpp.

                                                            {
  return sweeper.prev[idx] != 0 || sweeper.first == idx;
}

Here is the caller graph for this function:

◆ score()

double & CaDiCaL::Internal::score ( int lit )

inline

Definition at line 457 of file internal.hpp.

457{ return stab[vidx (lit)]; }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ search_assign()

void CaDiCaL::Internal::search_assign	(	int	lit,
		Clause *	reason )

inline

Definition at line 106 of file cadical_propagate.cpp.

                                                            {
 
  if (level)
    require_mode (SEARCH);
 
  const int idx = vidx (lit);
  const bool from_external = reason == external_reason;
  CADICAL_assert (!val (idx));
  CADICAL_assert (!flags (idx).eliminated () || reason == decision_reason ||
          reason == external_reason);
  Var &v = var (idx);
  int lit_level;
  CADICAL_assert (!lrat || level || reason == external_reason ||
          reason == decision_reason || !lrat_chain.empty ());
  // The following cases are explained in the two comments above before
  // 'decision_reason' and 'assignment_level'.
  //
  // External decision reason means that the propagation was done by
  // an external propagation and the reason clause not known (yet).
  // In that case it is assumed that the propagation is NOT out of
  // order (i.e. lit_level = level), because due to lazy explanation,
  // we can not calculate the real assignment level.
  // The function assignment_level () will also assign the current level
  // to literals with external reason.
  if (!reason)
    lit_level = 0; // unit
  else if (reason == decision_reason)
    lit_level = level, reason = 0;
  else if (opts.chrono)
    lit_level = assignment_level (lit, reason);
  else
    lit_level = level;
  if (!lit_level)
    reason = 0;
 
  v.level = lit_level;
  v.trail = trail.size ();
  v.reason = reason;
  CADICAL_assert ((int) num_assigned < max_var);
  CADICAL_assert (num_assigned == trail.size ());
  num_assigned++;
  if (!lit_level && !from_external)
    learn_unit_clause (lit); // increases 'stats.fixed'
  CADICAL_assert (lit_level || !from_external);
  const signed char tmp = sign (lit);
  set_val (idx, tmp);
  CADICAL_assert (val (lit) > 0);  // Just a bit paranoid but useful.
  CADICAL_assert (val (-lit) < 0); // Ditto.
  if (!searching_lucky_phases)
    phases.saved[idx] = tmp; // phase saving during search
  trail.push_back (lit);
#ifdef LOGGING
  if (!lit_level)
    LOG ("root-level unit assign %d @ 0", lit);
  else
    LOG (reason, "search assign %d @ %d", lit, lit_level);
#endif
 
  if (watching ()) {
    const Watches &ws = watches (-lit);
    if (!ws.empty ()) {
      const Watch &w = ws[0];
#ifndef WIN32
      __builtin_prefetch (&w, 0, 1);
#endif
    }
  }
  lrat_chain.clear ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ search_assign_driving()

void CaDiCaL::Internal::search_assign_driving	(	int	lit,
		Clause *	reason )

Definition at line 201 of file cadical_propagate.cpp.

                                                        {
  require_mode (SEARCH);
  search_assign (lit, c);
  notify_assignments ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ search_assign_external()

void CaDiCaL::Internal::search_assign_external ( int lit )

Definition at line 207 of file cadical_propagate.cpp.

                                              {
  require_mode (SEARCH);
  search_assign (lit, external_reason);
  notify_assignments ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ search_assume_decision()

void CaDiCaL::Internal::search_assume_decision ( int decision )

Definition at line 192 of file cadical_propagate.cpp.

                                              {
  require_mode (SEARCH);
  CADICAL_assert (propagated == trail.size ());
  new_trail_level (lit);
  notify_decision ();
  LOG ("search decide %d", lit);
  search_assign (lit, decision_reason);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ search_limits_hit()

bool CaDiCaL::Internal::search_limits_hit ( )

inline

Definition at line 1843 of file internal.hpp.

                                         {
  CADICAL_assert (!preprocessing);
  CADICAL_assert (!localsearching);
 
  if (lim.conflicts >= 0 && stats.conflicts >= lim.conflicts) {
    LOG ("conflict limit %" PRId64 " reached", lim.conflicts);
    return true;
  }
 
  if (lim.decisions >= 0 && stats.decisions >= lim.decisions) {
    LOG ("decision limit %" PRId64 " reached", lim.decisions);
    return true;
  }
 
  return false;
}

Here is the caller graph for this function:

◆ second_literal_in_binary_clause()

int CaDiCaL::Internal::second_literal_in_binary_clause	(	Eliminator &	eliminator,
		Clause *	c,
		int	first )

Definition at line 24 of file cadical_gates.cpp.

                                                                     {
  CADICAL_assert (!c->garbage);
  int second = 0;
  for (const auto &lit : *c) {
    if (lit == first)
      continue;
    const signed char tmp = val (lit);
    if (tmp < 0)
      continue;
    if (tmp > 0) {
      mark_garbage (c);
      elim_update_removed_clause (eliminator, c);
      return 0;
    }
    if (second) {
      second = INT_MIN;
      break;
    }
    second = lit;
  }
  if (!second)
    return 0;
  if (second == INT_MIN)
    return 0;
  CADICAL_assert (active (second));
#ifdef LOGGING
  if (c->size == 2)
    LOG (c, "found binary");
  else
    LOG (c, "found actual binary %d %d", first, second);
#endif
  return second;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ second_literal_in_binary_clause_lrat()

int CaDiCaL::Internal::second_literal_in_binary_clause_lrat	(	Clause *	c,
		int	first )

Definition at line 63 of file cadical_gates.cpp.

                                                                        {
  if (c->garbage)
    return 0;
  int second = 0;
  for (const auto &lit : *c) {
    if (lit == first)
      continue;
    const signed char tmp = val (lit);
    if (tmp < 0)
      continue;
    if (tmp > 0)
      return 0;
    if (!tmp) {
      if (second) {
        second = INT_MIN;
        break;
      }
      second = lit;
    }
  }
  if (!second)
    return 0;
  if (second == INT_MIN)
    return 0;
  return second;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ self_subsuming_factor()

bool CaDiCaL::Internal::self_subsuming_factor ( Quotient * q )

Definition at line 566 of file cadical_factor.cpp.

                                                 {
  Quotient *x = 0, *y = 0;
  bool found = false;
  for (Quotient *p = q; p; p = p->prev) {
    const int factor = p->factor;
    Flags &f = flags (factor);
    if (f.seen) {
      CADICAL_assert (std::find (analyzed.begin (), analyzed.end (), -factor) !=
              analyzed.end ());
      found = true;
      x = p;
      for (Quotient *r = q; r; r = r->prev) {
        if (r->factor != -factor)
          continue;
        y = r;
        break;
      }
      break;
    }
    analyzed.push_back (factor);
    f.seen = true;
  }
  CADICAL_assert (!found || (x && y));
  clear_analyzed_literals ();
  if (found) {
    add_self_subsuming_factor (x, y);
    return true;
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_mode()

void CaDiCaL::Internal::set_mode ( Mode m )

inline

Definition at line 165 of file internal.hpp.

                         {
    CADICAL_assert (!(mode & m));
    mode |= m;
  }

Here is the caller graph for this function:

◆ set_parent_reason_literal()

void CaDiCaL::Internal::set_parent_reason_literal	(	int	lit,
		int	reason )

inline

Definition at line 42 of file cadical_probe.cpp.

                                                                    {
  const int idx = vidx (lit);
  if (lit < 0)
    reason = -reason;
  parents[idx] = reason;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_probehbr_lrat()

void CaDiCaL::Internal::set_probehbr_lrat	(	int	lit,
		int	uip )

Definition at line 104 of file cadical_probe.cpp.

                                                  {
  if (!lrat || opts.probehbr)
    return;
  CADICAL_assert (lit);
  CADICAL_assert (lrat_chain.size ());
  CADICAL_assert (probehbr_chains[vlit (lit)][vlit (uip)].empty ());
  probehbr_chains[vlit (lit)][vlit (uip)] = lrat_chain;
  lrat_chain.clear ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_tainted_literal()

void CaDiCaL::Internal::set_tainted_literal ( )

Definition at line 81 of file cadical_external_propagate.cpp.

                                    {
  if (!opts.ilb) {
    return;
  }
  for (auto idx : vars) {
    if (!val (idx))
      continue;
    if (var (idx).reason != external_reason)
      continue;
    if (!tainted_literal) {
      tainted_literal = idx;
      continue;
    }
    CADICAL_assert (val (tainted_literal));
    if (var (idx).level < var (tainted_literal).level) {
      tainted_literal = idx;
    }
  }
}

Here is the call graph for this function:

◆ set_val()

void CaDiCaL::Internal::set_val	(	int	lit,
		signed char	val )

inline

Definition at line 1528 of file internal.hpp.

                                          {
    CADICAL_assert (-1 <= val);
    CADICAL_assert (val <= 1);
    CADICAL_assert (-max_var <= lit);
    CADICAL_assert (lit);
    CADICAL_assert (lit <= max_var);
    vals[lit] = val;
    vals[-lit] = -val;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setbit()

void CaDiCaL::Internal::setbit	(	int	lit,
		int	bit )

inline

Definition at line 540 of file internal.hpp.

                                 {
    CADICAL_assert (0 <= bit), CADICAL_assert (bit < 6);
    CADICAL_assert (!getbit (lit, bit));
    marks[vidx (lit)] |= (1 << bit);
    CADICAL_assert (getbit (lit, bit));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shrink_along_reason()

unsigned CaDiCaL::Internal::shrink_along_reason	(	int	uip,
		int	blevel,
		bool	resolve_large_clauses,
		bool &	failed_ptr,
		unsigned	max_trail )

inline

Definition at line 234 of file cadical_shrink.cpp.

                                                                   {
  LOG ("shrinking along the reason of lit %i", uip);
  unsigned open = 0;
#ifndef CADICAL_NDEBUG
  const Flags &f = flags (uip);
#endif
  const Var &v = var (uip);
 
  CADICAL_assert (f.shrinkable);
  CADICAL_assert (v.level == blevel);
  CADICAL_assert (v.reason);
 
  if (opts.minimizeticks)
    stats.ticks.search[stable]++;
 
  if (resolve_large_clauses || v.reason->size == 2) {
    const Clause &c = *v.reason;
    LOG (v.reason, "resolving with reason");
    for (int lit : c) {
      if (lit == uip)
        continue;
      CADICAL_assert (val (lit) < 0);
      int tmp = shrink_literal (lit, blevel, max_trail);
      if (tmp < 0) {
        failed_ptr = true;
        break;
      }
      if (tmp > 0) {
        ++open;
      }
    }
  } else {
    failed_ptr = true;
  }
  return open;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shrink_and_minimize_clause()

void CaDiCaL::Internal::shrink_and_minimize_clause ( )

Definition at line 430 of file cadical_shrink.cpp.

                                           {
  CADICAL_assert (opts.minimize || opts.shrink > 0);
  LOG (clause, "shrink first UIP clause");
 
  START (shrink);
  external->check_learned_clause (); // check 1st UIP learned clause first
  MSORT (opts.radixsortlim, clause.begin (), clause.end (),
         shrink_trail_negative_rank (this), shrink_trail_larger (this));
  unsigned total_shrunken = 0;
  unsigned total_minimized = 0;
 
  LOG (clause, "shrink first UIP clause (CADICAL_asserting lit: %i)", clause[0]);
 
  auto rend_lits = clause.rend () - 1;
  auto rend_block = clause.rbegin ();
  const int uip0 = clause[0];
 
  // for direct LRAT we remember how the clause used to look
  vector<int> old_clause_lrat;
  CADICAL_assert (minimize_chain.empty ());
  if (lrat)
    for (auto &i : clause)
      old_clause_lrat.push_back (i);
 
  while (rend_block != rend_lits) {
    rend_block = minimize_and_shrink_block (rend_block, total_shrunken,
                                            total_minimized, uip0);
  }
 
  LOG (clause,
       "post shrink pass (with uips, not removed) first UIP clause");
  LOG (old_clause_lrat, "(used for lratdirect) before shrink: clause");
#if defined(LOGGING) || !defined(CADICAL_NDEBUG)
  const unsigned old_size = clause.size ();
#endif
  std::vector<int> stack;
  {
    std::vector<int>::size_type i = 1;
    for (std::vector<int>::size_type j = 1; j < clause.size (); ++j) {
      CADICAL_assert (i <= j);
      clause[i] = clause[j];
      if (lrat) {
        CADICAL_assert (j < old_clause_lrat.size ());
        CADICAL_assert (mini_chain.empty ());
        if (clause[j] != old_clause_lrat[j]) {
          calculate_minimize_chain (-old_clause_lrat[j], stack);
          for (auto p : mini_chain) {
            minimize_chain.push_back (p);
          }
          mini_chain.clear ();
        }
      }
      if (clause[j] == uip0) {
        continue;
      }
      CADICAL_assert (flags (clause[i]).keep);
      ++i;
      LOG ("keeping literal %i", clause[j]);
    }
    clause.resize (i);
  }
  CADICAL_assert (old_size ==
          (unsigned) clause.size () + total_shrunken + total_minimized);
  LOG (clause, "after shrinking first UIP clause");
  LOG ("clause shrunken by %zd literals (including %u minimized)",
       old_size - clause.size (), total_minimized);
 
  stats.shrunken += total_shrunken;
  stats.minishrunken += total_minimized;
  STOP (shrink);
 
  START (minimize);
  clear_minimized_literals ();
  for (auto p = minimize_chain.rbegin (); p != minimize_chain.rend ();
       p++) {
    lrat_chain.push_back (*p);
  }
  minimize_chain.clear ();
  STOP (minimize);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shrink_block()

unsigned CaDiCaL::Internal::shrink_block	(	std::vector< int >::reverse_iterator &	rbegin_lits,
		std::vector< int >::reverse_iterator &	rend_block,
		int	blevel,
		unsigned &	open,
		unsigned &	block_minimized,
		const int	uip0,
		unsigned	max_trail )

Definition at line 275 of file cadical_shrink.cpp.

                                            {
  CADICAL_assert (shrinkable.empty ());
  CADICAL_assert (blevel <= this->level);
  CADICAL_assert (open < clause.size ());
  CADICAL_assert (rbegin_lits >= clause.rbegin ());
  CADICAL_assert (rend_block < clause.rend ());
  CADICAL_assert (rbegin_lits < rend_block);
  CADICAL_assert (opts.shrink);
 
#ifdef LOGGING
 
  LOG ("trying to shrink %u literals on level %u", open, blevel);
 
  const auto &t = &trail;
 
  LOG ("maximum trail position %zd on level %u", t->size (), blevel);
  if (opts.shrinkreap)
    LOG ("shrinking up to %u", max_trail);
#endif
 
  const bool resolve_large_clauses = (opts.shrink > 1);
  bool failed = false;
  unsigned block_shrunken = 0;
  std::vector<int>::size_type minimized_start = minimized.size ();
  int uip = uip0;
  unsigned max_trail2 = max_trail;
 
  if (!failed) {
    push_literals_of_block (rbegin_lits, rend_block, blevel, max_trail);
    CADICAL_assert (!opts.shrinkreap || reap.size () == open);
 
    CADICAL_assert (open > 0);
    while (!failed) {
      CADICAL_assert (!opts.shrinkreap || reap.size () == open);
      uip = shrink_next (blevel, open, max_trail);
      if (open == 0) {
        break;
      }
      open += shrink_along_reason (uip, blevel, resolve_large_clauses,
                                   failed, max_trail2);
      CADICAL_assert (open >= 1);
    }
 
    if (!failed)
      LOG ("shrinking found UIP %i on level %i (open: %d)", uip, blevel,
           open);
    else
      LOG ("shrinking failed on level %i", blevel);
  }
 
  if (failed)
    reset_shrinkable (), shrunken_block_no_uip (rbegin_lits, rend_block,
                                                block_minimized, uip0);
  else
    block_shrunken = shrunken_block_uip (uip, blevel, rbegin_lits,
                                         rend_block, minimized_start, uip0);
 
  if (opts.shrinkreap)
    reap.clear ();
  shrinkable.clear ();
  return block_shrunken;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shrink_clause()

size_t CaDiCaL::Internal::shrink_clause	(	Clause *	c,
		int	new_size )

Definition at line 213 of file cadical_clause.cpp.

                                                       {
  if (opts.check && is_external_forgettable (c->id))
    mark_garbage_external_forgettable (c->id);
  CADICAL_assert (new_size >= 2);
  int old_size = c->size;
  CADICAL_assert (new_size < old_size);
#ifndef CADICAL_NDEBUG
  for (int i = c->size; i < new_size; i++)
    c->literals[i] = 0;
#endif
 
  if (c->pos >= new_size)
    c->pos = 2;
 
  size_t old_bytes = c->bytes ();
  c->size = new_size;
  size_t new_bytes = c->bytes ();
  size_t res = old_bytes - new_bytes;
 
  if (c->redundant)
    promote_clause_glue_only (c, min (c->size - 1, c->glue));
  else {
    int delta_size = old_size - new_size;
    CADICAL_assert (stats.irrlits >= delta_size);
    stats.irrlits -= delta_size;
  }
 
  if (likely_to_be_kept_clause (c))
    mark_added (c);
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shrink_literal()

int CaDiCaL::Internal::shrink_literal	(	int	lit,
		int	blevel,
		unsigned	max_trail )

inline

Definition at line 70 of file cadical_shrink.cpp.

                                                         {
  CADICAL_assert (val (lit) < 0);
 
  Flags &f = flags (lit);
  Var &v = var (lit);
  CADICAL_assert (v.level <= blevel);
 
  if (!v.level) {
    LOG ("skipping root level assigned %d", (lit));
    return 0;
  }
 
  if (v.reason == external_reason) {
    CADICAL_assert (!opts.exteagerreasons);
    v.reason = learn_external_reason_clause (-lit, 0, true);
    if (!v.reason) {
      CADICAL_assert (!v.level);
      return 0;
    }
  }
  CADICAL_assert (v.reason != external_reason);
  if (f.shrinkable) {
    LOG ("skipping already shrinkable literal %d", (lit));
    return 0;
  }
 
  if (v.level < blevel) {
    if (f.removable) {
      LOG ("skipping removable thus shrinkable %d", (lit));
      return 0;
    }
    const bool always_minimize_on_lower_blevel = (opts.shrink > 2);
    if (always_minimize_on_lower_blevel && minimize_literal (-lit, 1)) {
      LOG ("minimized thus shrinkable %d", (lit));
      return 0;
    }
    LOG ("literal %d on lower blevel %u < %u not removable/shrinkable",
         (lit), v.level, blevel);
    return -1;
  }
 
  LOG ("marking %d as shrinkable", lit);
  f.shrinkable = true;
  f.poison = false;
  shrinkable.push_back (lit);
  if (opts.shrinkreap) {
    CADICAL_assert (max_trail < trail.size ());
    const unsigned dist = max_trail - v.trail;
    reap.push (dist);
  }
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shrink_next()

unsigned CaDiCaL::Internal::shrink_next	(	int	blevel,
		unsigned &	open,
		unsigned &	max_trail )

inline

Definition at line 203 of file cadical_shrink.cpp.

                                                            {
  const auto &t = &trail;
  if (opts.shrinkreap) {
    CADICAL_assert (!reap.empty ());
    const unsigned dist = reap.pop ();
    --open;
    CADICAL_assert (dist <= max_trail);
    const unsigned pos = max_trail - dist;
    CADICAL_assert (pos < t->size ());
    const int uip = (*t)[pos];
    CADICAL_assert (val (uip) > 0);
    LOG ("trying to shrink literal %d at trail[%u] and level %d", uip, pos,
         blevel);
    return uip;
  } else {
    int uip;
#ifndef CADICAL_NDEBUG
    unsigned init_max_trail = max_trail;
#endif
    do {
      CADICAL_assert (max_trail <= init_max_trail);
      uip = (*t)[max_trail--];
    } while (!flags (uip).shrinkable);
    --open;
    LOG ("open is now %d, uip = %d, level %d", open, uip, blevel);
    return uip;
  }
  (void) blevel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shrunken_block_no_uip()

void CaDiCaL::Internal::shrunken_block_no_uip	(	const std::vector< int >::reverse_iterator &	rbegin_block,
		const std::vector< int >::reverse_iterator &	rend_block,
		unsigned &	block_minimized,
		const int	uip0 )

inline

Definition at line 161 of file cadical_shrink.cpp.

                                               {
  STOP (shrink);
  START (minimize);
  CADICAL_assert (rend_block > rbegin_block);
  LOG ("no UIP found, now minimizing");
  for (auto p = rbegin_block; p != rend_block; ++p) {
    CADICAL_assert (p != clause.rend () - 1);
    const int lit = *p;
    if (opts.minimize && minimize_literal (-lit)) {
      CADICAL_assert (!flags (lit).keep);
      ++block_minimized;
      *p = uip0;
    } else {
      flags (lit).keep = true;
      CADICAL_assert (flags (lit).keep);
    }
  }
  STOP (minimize);
  START (shrink);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shrunken_block_uip()

unsigned CaDiCaL::Internal::shrunken_block_uip	(	int	uip,
		int	blevel,
		std::vector< int >::reverse_iterator &	rbegin_block,
		std::vector< int >::reverse_iterator &	rend_block,
		std::vector< int >::size_type	minimized_start,
		const int	uip0 )

Definition at line 124 of file cadical_shrink.cpp.

                                                             {
  CADICAL_assert (clause[0] == uip0);
 
  LOG ("UIP on level %u, uip: %i (replacing by %i)", blevel, uip, uip0);
  CADICAL_assert (rend_block > rbegin_block);
  CADICAL_assert (rend_block < clause.rend ());
  unsigned block_shrunken = 0;
  *rbegin_block = -uip;
  Var &v = var (-uip);
  Level &l = control[v.level];
  l.seen.trail = v.trail;
  l.seen.count = 1;
 
  Flags &f = flags (-uip);
  if (!f.seen) {
    analyzed.push_back (-uip);
    f.seen = true;
  }
 
  flags (-uip).keep = true;
  for (auto p = rbegin_block + 1; p != rend_block; ++p) {
    const int lit = *p;
    if (lit == -uip0)
      continue;
    *p = uip0;
    // if (lit == -uip) continue;
    ++block_shrunken;
    CADICAL_assert (clause[0] == uip0);
  }
  mark_shrinkable_as_removable (blevel, minimized_start);
  CADICAL_assert (clause[0] == uip0);
  return block_shrunken;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shuffle_queue()

void CaDiCaL::Internal::shuffle_queue ( )

Definition at line 64 of file cadical_queue.cpp.

                              {
  if (!opts.shuffle)
    return;
  if (!opts.shufflequeue)
    return;
  stats.shuffled++;
  LOG ("shuffling queue");
  vector<int> shuffle;
  if (opts.shufflerandom) {
    for (int idx = max_var; idx; idx--)
      shuffle.push_back (idx);
    Random random (opts.seed); // global seed
    random += stats.shuffled;  // different every time
    for (int i = 0; i <= max_var - 2; i++) {
      const int j = random.pick_int (i, max_var - 1);
      swap (shuffle[i], shuffle[j]);
    }
  } else {
    for (int idx = queue.last; idx; idx = links[idx].prev)
      shuffle.push_back (idx);
  }
  queue.first = queue.last = 0;
  for (const int idx : shuffle)
    queue.enqueue (links, idx);
  int64_t bumped = queue.bumped;
  for (int idx = queue.last; idx; idx = links[idx].prev)
    btab[idx] = bumped--;
  queue.unassigned = queue.last;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shuffle_scores()

void CaDiCaL::Internal::shuffle_scores ( )

Definition at line 22 of file cadical_score.cpp.

                               {
  if (!opts.shuffle)
    return;
  if (!opts.shufflescores)
    return;
  CADICAL_assert (!level);
  stats.shuffled++;
  LOG ("shuffling scores");
  vector<int> shuffle;
  if (opts.shufflerandom) {
    scores.erase ();
    for (int idx = max_var; idx; idx--)
      shuffle.push_back (idx);
    Random random (opts.seed); // global seed
    random += stats.shuffled;  // different every time
    for (int i = 0; i <= max_var - 2; i++) {
      const int j = random.pick_int (i, max_var - 1);
      swap (shuffle[i], shuffle[j]);
    }
  } else {
    while (!scores.empty ()) {
      int idx = scores.front ();
      (void) scores.pop_front ();
      shuffle.push_back (idx);
    }
  }
  score_inc = 0;
  for (const auto &idx : shuffle) {
    stab[idx] = score_inc++;
    scores.push_back (idx);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ solve()

int CaDiCaL::Internal::solve ( bool preprocess_only = false )

Definition at line 884 of file cadical_internal.cpp.

                                         {
  CADICAL_assert (clause.empty ());
  START (solve);
  if (proof)
    proof->solve_query ();
  if (opts.ilb) {
    if (opts.ilbassumptions)
      sort_and_reuse_assumptions ();
    stats.ilbtriggers++;
    stats.ilbsuccess += (level > 0);
    stats.levelsreused += level;
    if (level) {
      CADICAL_assert (control.size () > 1);
      stats.literalsreused += num_assigned - control[1].trail;
    }
    if (external->propagator)
      renotify_trail_after_ilb ();
  }
  if (preprocess_only)
    LOG ("internal solving in preprocessing only mode");
  else
    LOG ("internal solving in full mode");
  init_report_limits ();
  int res = already_solved ();
  if (!res && preprocess_only && level)
    backtrack ();
  if (!res)
    res = restore_clauses ();
  if (!res || (res == 10 && external_prop)) {
    init_preprocessing_limits ();
    if (!preprocess_only)
      init_search_limits ();
  }
  if (!preprocess_only) {
    if (!res && !level)
      res = local_search ();
  }
  if (!res && !level)
    res = preprocess ();
  if (!preprocess_only) {
    if (!res && !level)
      res = local_search ();
    if (!res && !level)
      res = lucky_phases ();
    if (!res || (res == 10 && external_prop)) {
      if (res == 10 && external_prop && level)
        backtrack ();
      res = cdcl_loop_with_inprocessing ();
    }
  }
  finalize (res);
  reset_solving ();
  report_solving (res);
  STOP (solve);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ solve_time()

double CaDiCaL::Internal::solve_time ( )

◆ sort_and_reuse_assumptions()

void CaDiCaL::Internal::sort_and_reuse_assumptions ( )

Definition at line 554 of file cadical_assume.cpp.

                                           {
  CADICAL_assert (opts.ilbassumptions);
  if (assumptions.empty ())
    return;
  MSORT (opts.radixsortlim, assumptions.begin (), assumptions.end (),
         sort_assumptions_positive_rank (this),
         sort_assumptions_smaller (this));
 
  unsigned max_level = 0;
  // assumptions are sorted by level, with unset at the end
  for (auto lit : assumptions) {
    if (val (lit))
      max_level = var (lit).level;
    else
      break;
  }
 
  const unsigned size = min (level + 1u, max_level + 1);
  CADICAL_assert ((size_t) level == control.size () - 1);
  LOG (assumptions, "sorted assumptions");
  int target = 0;
  for (unsigned i = 1, j = 0; i < size;) {
    const Level &l = control[i];
    const int lit = l.decision;
    const int alit = assumptions[j];
    const int lev = i;
    target = lev;
    if (val (alit) > 0 &&
        var (alit).level < lev) { // we can ignore propagated assumptions
      LOG ("ILB skipping propagation %d", alit);
      ++j;
      continue;
    }
    if (!lit) { // skip fake decisions
      target = lev - 1;
      break;
    }
    ++i, ++j;
    CADICAL_assert (var (lit).level == lev);
    if (l.decision == alit) {
      continue;
    }
    target = lev - 1;
    LOG ("first different literal %d on the trail and %d from the "
         "assumptions",
         lit, alit);
    break;
  }
  if (target < level)
    backtrack (target);
  LOG ("assumptions allow for reuse of trail up to level %d", level);
  //  COVER (target > 1);
  if ((size_t) level > assumptions.size ())
    stats.assumptionsreused += assumptions.size ();
  else
    stats.assumptionsreused += level;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sort_watches()

void CaDiCaL::Internal::sort_watches ( )

Definition at line 103 of file cadical_watch.cpp.

                             {
  CADICAL_assert (watching ());
  LOG ("sorting watches");
  Watches saved;
  for (auto lit : lits) {
    Watches &ws = watches (lit);
 
    const const_watch_iterator end = ws.end ();
    watch_iterator j = ws.begin ();
    const_watch_iterator i;
 
    CADICAL_assert (saved.empty ());
 
    for (i = j; i != end; i++) {
      const Watch w = *i;
      if (w.binary ())
        *j++ = w;
      else
        saved.push_back (w);
    }
 
    std::copy (saved.cbegin (), saved.cend (), j);
 
    saved.clear ();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stabilizing()

bool CaDiCaL::Internal::stabilizing ( )

Definition at line 22 of file cadical_restart.cpp.

                            {
  if (!opts.stabilize)
    return false;
  if (stable && opts.stabilizeonly)
    return true;
  if (!inc.stabilize) {
    CADICAL_assert (!stable);
    if (stats.conflicts <= lim.stabilize)
      return false;
  } else if (stats.ticks.search[stable] <= lim.stabilize)
    return stable;
  report (stable ? ']' : '}');
  if (stable)
    STOP (stable);
  else
    STOP (unstable);
  const int64_t delta_conflicts =
      stats.conflicts - last.stabilize.conflicts;
  const int64_t delta_ticks =
      stats.ticks.search[stable] - last.stabilize.ticks;
  const char *current_mode = stable ? "stable" : "unstable";
  const char *next_mode = stable ? "unstable" : "stable";
  PHASE ("stabilizing", stats.stabphases,
         "reached %s stabilization limit %" PRId64 " after %" PRId64
         " conflicts and %" PRId64 " ticks at %" PRId64
         " conflicts and %" PRId64 " ticks",
         current_mode, lim.stabilize, delta_conflicts, delta_ticks,
         stats.conflicts, stats.ticks.search[stable]);
  if (!inc.stabilize)
    inc.stabilize = delta_ticks;
  if (!inc.stabilize) // rare occurence in incremental calls requiring no
                      // ticks
    inc.stabilize = 1;
 
  stable = !stable; // Switch!!!!!
 
  int64_t next_delta_ticks = inc.stabilize;
  int64_t stabphases = stats.stabphases + 1;
  next_delta_ticks *= stabphases * stabphases;
 
  lim.stabilize = stats.ticks.search[stable] + next_delta_ticks;
  if (lim.stabilize <= stats.ticks.search[stable])
    lim.stabilize = stats.ticks.search[stable] + 1;
 
  if (stable)
    stats.stabphases++;
 
  swap_averages ();
  PHASE ("stabilizing", stats.stabphases,
         "next %s stabilization limit %" PRId64
         " at ticks interval %" PRId64,
         next_mode, lim.stabilize, next_delta_ticks);
  report (stable ? '[' : '{');
  if (stable)
    START (stable);
  else
    START (unstable);
  return stable;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ strengthen_clause()

void CaDiCaL::Internal::strengthen_clause	(	Clause *	c,
		int	lit )

Definition at line 160 of file cadical_subsume.cpp.

                                                    {
  if (opts.check && is_external_forgettable (c->id))
    mark_garbage_external_forgettable (c->id);
  stats.strengthened++;
  CADICAL_assert (c->size > 2);
  LOG (c, "removing %d in", lit);
  if (proof) {
    LOG (lrat_chain, "strengthening clause with chain");
    proof->strengthen_clause (c, lit, lrat_chain);
  }
  if (!c->redundant)
    mark_removed (lit);
  auto new_end = remove (c->begin (), c->end (), lit);
  CADICAL_assert (new_end + 1 == c->end ()), (void) new_end;
  (void) shrink_clause (c, c->size - 1);
  // bump_clause2 (c);
  LOG (c, "strengthened");
  external->check_shrunken_clause (c);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ substitute_connected_clauses()

void CaDiCaL::Internal::substitute_connected_clauses	(	Sweeper &	sweeper,
		int	lit,
		int	other,
		int64_t	id )

Definition at line 1051 of file cadical_sweep.cpp.

                                                                   {
  if (unsat)
    return;
  if (val (lit))
    return;
  if (val (repr))
    return;
  LOG ("substituting %d with %d in all irredundant clauses", lit, repr);
 
  CADICAL_assert (lit != repr);
  CADICAL_assert (lit != -repr);
 
  CADICAL_assert (active (lit));
  CADICAL_assert (active (repr));
 
  uint64_t &ticks = sweeper.current_ticks;
 
  {
    ticks += 1 + cache_lines (occs (lit).size (), sizeof (Clause *));
    Occs &ns = occs (lit);
    auto const begin = ns.begin ();
    const auto end = ns.end ();
    auto q = begin;
    auto p = q;
    while (p != end) {
      Clause *c = *q++ = *p++;
      ticks++;
      if (c->garbage)
        continue;
      CADICAL_assert (clause.empty ());
      bool satisfied = false;
      bool repr_already_watched = false;
      const int not_repr = -repr;
#ifndef CADICAL_NDEBUG
      bool found = false;
#endif
      for (const auto &other : *c) {
        if (other == lit) {
#ifndef CADICAL_NDEBUG
          CADICAL_assert (!found);
          found = true;
#endif
          clause.push_back (repr);
          continue;
        }
        CADICAL_assert (other != -lit);
        if (other == repr) {
          CADICAL_assert (!repr_already_watched);
          repr_already_watched = true;
          continue;
        }
        if (other == not_repr) {
          satisfied = true;
          break;
        }
        const signed char tmp = val (other);
        if (tmp < 0)
          continue;
        if (tmp > 0) {
          satisfied = true;
          break;
        }
        clause.push_back (other);
      }
      if (satisfied) {
        clause.clear ();
        mark_garbage (c);
        sweep_update_noccs (c);
        continue;
      }
      CADICAL_assert (found);
      const unsigned new_size = clause.size ();
      sweep_substitute_lrat (c, id);
      if (new_size == 0) {
        LOG (c, "substituted empty clause");
        CADICAL_assert (!unsat);
        learn_empty_clause ();
        break;
      }
      ticks++;
      if (new_size == 1) {
        LOG (c, "reduces to unit");
        const int unit = clause[0];
        clause.clear ();
        assign_unit (unit);
        sweeper.propagate.push_back (unit);
        mark_garbage (c);
        sweep_update_noccs (c);
        stats.sweep_units++;
        break;
      }
      CADICAL_assert (c->size >= 2);
      if (!c->redundant)
        mark_removed (c);
      uint64_t new_id = ++clause_id;
      if (proof) {
        proof->add_derived_clause (new_id, c->redundant, clause,
                                   lrat_chain);
        proof->delete_clause (c);
      }
      c->id = new_id;
      lrat_chain.clear ();
      size_t l;
      int *literals = c->literals;
      for (l = 0; l < clause.size (); l++)
        literals[l] = clause[l];
      int flushed = c->size - (int) l;
      if (flushed) {
        LOG ("flushed %d literals", flushed);
        (void) shrink_clause (c, l);
      } else if (likely_to_be_kept_clause (c))
        mark_added (c);
      LOG (c, "substituted");
      if (!repr_already_watched) {
        occs (repr).push_back (c);
        noccs (repr)++;
      }
      clause.clear ();
      q--;
    }
    while (p != end)
      *q++ = *p++;
    ns.resize (q - ns.begin ());
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ subsume()

void CaDiCaL::Internal::subsume ( )

Definition at line 611 of file cadical_subsume.cpp.

                        {
 
  if (!stats.current.redundant && !stats.current.irredundant)
    return;
 
  if (unsat)
    return;
 
  backtrack ();
  if (!propagate ()) {
    learn_empty_clause ();
    return;
  }
 
  stats.subsumephases++;
 
  if (external_prop) {
    CADICAL_assert (!level);
    private_steps = true;
  }
 
  if (opts.subsume) {
    reset_watches ();
    subsume_round ();
    init_watches ();
    connect_watches ();
    if (!unsat && !propagate ()) {
      LOG ("propagation after subsume rounds results in inconsistency");
      learn_empty_clause ();
    }
  }
 
  transred ();
  if (external_prop) {
    CADICAL_assert (!level);
    private_steps = false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ subsume_check()

int CaDiCaL::Internal::subsume_check	(	Clause *	subsuming,
		Clause *	subsumed )

inline

Definition at line 78 of file cadical_subsume.cpp.

                                                                       {
#ifdef CADICAL_NDEBUG
  (void) subsumed;
#endif
  // Only use 'subsumed' for these following CADICAL_assertion checks.  Otherwise we
  // only require that 'subsumed' has all its literals marked.
  //
  CADICAL_assert (!subsumed->garbage);
  CADICAL_assert (!subsuming->garbage);
  CADICAL_assert (subsuming != subsumed);
  CADICAL_assert (subsuming->size <= subsumed->size);
 
  stats.subchecks++;
  if (subsuming->size == 2)
    stats.subchecks2++;
 
  int flipped = 0, prev = 0;
  bool failed = false;
  const auto eoc = subsuming->end ();
  for (auto i = subsuming->begin (); !failed && i != eoc; i++) {
    int lit = *i;
    *i = prev;
    prev = lit;
    const int tmp = marked (lit);
    if (!tmp)
      failed = true;
    else if (tmp > 0)
      continue;
    else if (flipped)
      failed = true;
    else
      flipped = lit;
  }
  CADICAL_assert (prev);
  CADICAL_assert (!subsuming->literals[0]);
  subsuming->literals[0] = prev;
  if (failed)
    return 0;
 
  if (!flipped)
    return INT_MIN; // subsumed!!
  else if (!opts.subsumestr)
    return 0;
  else
    return flipped; // strengthen!!
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ subsume_clause()

void CaDiCaL::Internal::subsume_clause	(	Clause *	subsuming,
		Clause *	subsumed )

inline

Definition at line 129 of file cadical_subsume.cpp.

                                                                         {
  stats.subsumed++;
  CADICAL_assert (subsuming->size <= subsumed->size);
  LOG (subsumed, "subsumed");
  if (subsumed->redundant)
    stats.subred++;
  else
    stats.subirr++;
  if (subsumed->redundant || !subsuming->redundant) {
    mark_garbage (subsumed);
    return;
  }
  LOG ("turning redundant subsuming clause into irredundant clause");
  subsuming->redundant = false;
  if (proof)
    proof->strengthen (subsuming->id);
  mark_garbage (subsumed);
  stats.current.irredundant++;
  stats.added.irredundant++;
  stats.irrlits += subsuming->size;
  CADICAL_assert (stats.current.redundant > 0);
  stats.current.redundant--;
  CADICAL_assert (stats.added.redundant > 0);
  stats.added.redundant--;
  // ... and keep 'stats.added.total'.
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ subsume_round()

bool CaDiCaL::Internal::subsume_round ( )

Definition at line 340 of file cadical_subsume.cpp.

                              {
 
  if (!opts.subsume)
    return false;
  if (unsat)
    return false;
  if (terminated_asynchronously ())
    return false;
  if (!stats.current.redundant && !stats.current.irredundant)
    return false;
 
  START_SIMPLIFIER (subsume, SUBSUME);
  stats.subsumerounds++;
 
  int64_t check_limit;
  if (opts.subsumelimited) {
    int64_t delta = stats.propagations.search;
    delta *= 1e-3 * opts.subsumeeffort;
    if (delta < opts.subsumemineff)
      delta = opts.subsumemineff;
    if (delta > opts.subsumemaxeff)
      delta = opts.subsumemaxeff;
    delta = max (delta, (int64_t) 2l * active ());
 
    PHASE ("subsume-round", stats.subsumerounds,
           "limit of %" PRId64 " subsumption checks", delta);
 
    check_limit = stats.subchecks + delta;
  } else {
    PHASE ("subsume-round", stats.subsumerounds,
           "unlimited subsumption checks");
    check_limit = LONG_MAX;
  }
 
  int old_marked_candidate_variables_for_elimination = stats.mark.elim;
 
  CADICAL_assert (!level);
 
  // Allocate schedule and occurrence lists.
  //
  vector<ClauseSize> schedule;
  init_noccs ();
 
  // Determine candidate clauses and sort them by size.
  //
  int64_t left_over_from_last_subsumption_round = 0;
 
  for (auto c : clauses) {
 
    if (c->garbage)
      continue;
    if (c->size > opts.subsumeclslim)
      continue;
    if (!likely_to_be_kept_clause (c))
      continue;
 
    bool fixed = false;
    int subsume = 0;
    for (const auto &lit : *c)
      if (val (lit))
        fixed = true;
      else if (flags (lit).subsume)
        subsume++;
 
    // If the clause contains a root level assigned (fixed) literal we will
    // not work on it.  This simplifies the code substantially since we do
    // not have to care about assignments at all.  Strengthening becomes
    // much simpler too.
    //
    if (fixed) {
      LOG (c, "skipping (fixed literal)");
      continue;
    }
 
    // Further, if less than two variables in the clause were added since
    // the last subsumption round, the clause is ignored too.
    //
    if (subsume < 2) {
      LOG (c, "skipping (only %d added literals)", subsume);
      continue;
    }
 
    if (c->subsume)
      left_over_from_last_subsumption_round++;
    schedule.push_back (ClauseSize (c->size, c));
    for (const auto &lit : *c)
      noccs (lit)++;
  }
  shrink_vector (schedule);
 
  // Smaller clauses are checked and connected first.
  //
  rsort (schedule.begin (), schedule.end (), smaller_clause_size_rank ());
 
  if (!left_over_from_last_subsumption_round)
    for (auto cs : schedule)
      if (cs.clause->size > 2)
        cs.clause->subsume = true;
 
#ifndef CADICAL_QUIET
  int64_t scheduled = schedule.size ();
  int64_t total = stats.current.irredundant + stats.current.redundant;
  PHASE ("subsume-round", stats.subsumerounds,
         "scheduled %" PRId64 " clauses %.0f%% out of %" PRId64 " clauses",
         scheduled, percent (scheduled, total), total);
#endif
 
  // Now go over the scheduled clauses in the order of increasing size and
  // try to forward subsume and strengthen them. Forward subsumption tries
  // to find smaller or same size clauses which subsume or might strengthen
  // the candidate.  After the candidate has been processed connect one
  // of its literals (with smallest number of occurrences at this point) in
  // a one-watched scheme.
 
  int64_t subsumed = 0, strengthened = 0, checked = 0;
 
  vector<Clause *> shrunken;
  init_occs ();
  init_bins ();
 
  for (const auto &s : schedule) {
 
    if (terminated_asynchronously ())
      break;
    if (stats.subchecks >= check_limit)
      break;
 
    Clause *c = s.clause;
    CADICAL_assert (!c->garbage);
 
    checked++;
 
    // First try to subsume or strengthen this candidate clause.  For binary
    // clauses this could be done much faster by hashing and is costly due
    // to a usually large number of binary clauses.  There is further the
    // issue, that strengthening binary clauses (through double
    // self-subsuming resolution) would produce units, which needs much more
    // care. In the same (lazy) spirit we also ignore clauses with fixed
    // literals (false or true).
    //
    if (c->size > 2 && c->subsume) {
      c->subsume = false;
      const int tmp = try_to_subsume_clause (c, shrunken);
      if (tmp > 0) {
        subsumed++;
        continue;
      }
      if (tmp < 0)
        strengthened++;
    }
 
    // If not subsumed connect smallest occurring literal, where occurring
    // means the number of times it was used to connect (as a one-watch) a
    // previous smaller or equal sized clause.  This minimizes the length of
    // the occurrence lists traversed during 'try_to_subsume_clause'. Also
    // note that this number is usually way smaller than the number of
    // occurrences computed before and stored in 'noccs'.
    //
    int minlit = 0;
    int64_t minoccs = 0;
    size_t minsize = 0;
    bool subsume = true;
    bool binary = (c->size == 2 && !c->redundant);
 
    for (const auto &lit : *c) {
 
      if (!flags (lit).subsume)
        subsume = false;
      const size_t size = binary ? bins (lit).size () : occs (lit).size ();
      if (minlit && minsize <= size)
        continue;
      const int64_t tmp = noccs (lit);
      if (minlit && minsize == size && tmp <= minoccs)
        continue;
      minlit = lit, minsize = size, minoccs = tmp;
    }
 
    // If there is a variable in a clause different from is not 'subsume'
    // (has been added since the last subsumption round), then this clause
    // can not serve to strengthen or subsume another clause, since all
    // shrunken or added clauses mark all their variables as 'subsume'.
    //
    if (!subsume)
      continue;
 
    if (!binary) {
 
      // If smallest occurring literal occurs too often do not connect.
      //
      if (minsize > (size_t) opts.subsumeocclim)
        continue;
 
      LOG (c,
           "watching %d with %zd current and total %" PRId64 " occurrences",
           minlit, minsize, minoccs);
 
      occs (minlit).push_back (c);
 
      // This sorting should give faster failures for assumption checks
      // since the less occurring variables are put first in a clause and
      // thus will make it more likely to be found as witness for a clause
      // not to be subsuming.  One could in principle (see also the
      // discussion on 'subsumption' in our 'Splatz' solver) replace marking
      // by a kind of merge sort, as also suggested by Bayardo.  It would
      // avoid 'marked' calls and thus might be slightly faster but could
      // not take benefit of this sorting optimization.
      //
      sort (c->begin (), c->end (), subsume_less_noccs (this));
 
    } else {
 
      // If smallest occurring literal occurs too often do not connect.
      //
      if (minsize > (size_t) opts.subsumebinlim)
        continue;
 
      LOG (c,
           "watching %d with %zd current binary and total %" PRId64
           " occurrences",
           minlit, minsize, minoccs);
 
      const int minlit_pos = (c->literals[1] == minlit);
      const int other = c->literals[!minlit_pos];
      bins (minlit).push_back (Bin{other, c->id});
    }
  }
 
  PHASE ("subsume-round", stats.subsumerounds,
         "subsumed %" PRId64 " and strengthened %" PRId64 " out of %" PRId64
         " clauses %.0f%%",
         subsumed, strengthened, scheduled,
         percent (subsumed + strengthened, scheduled));
 
  const int64_t remain = schedule.size () - checked;
  const bool completed = !remain;
 
  if (completed)
    PHASE ("subsume-round", stats.subsumerounds,
           "checked all %" PRId64 " scheduled clauses", checked);
  else
    PHASE ("subsume-round", stats.subsumerounds,
           "checked %" PRId64 " clauses %.0f%% of scheduled (%" PRId64
           " remain)",
           checked, percent (checked, scheduled), remain);
 
  // Release occurrence lists and schedule.
  //
  erase_vector (schedule);
  reset_noccs ();
  reset_occs ();
  reset_bins ();
 
  // Reset all old 'added' flags and mark variables in shrunken
  // clauses as 'added' for the next subsumption round.
  //
  if (completed)
    reset_subsume_bits ();
 
  for (const auto &c : shrunken)
    mark_added (c);
  erase_vector (shrunken);
 
  report ('s', !opts.reportall && !(subsumed + strengthened));
 
  STOP_SIMPLIFIER (subsume, SUBSUME);
 
  return old_marked_candidate_variables_for_elimination < stats.mark.elim;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ swap_averages()

void CaDiCaL::Internal::swap_averages ( )

Definition at line 28 of file cadical_averages.cpp.

                              {
  LOG ("saving current averages");
  swap (averages.current, averages.saved);
  if (!averages.swapped)
    init_averages ();
  else
    LOG ("swapping in previously saved averages");
  averages.swapped++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep()

bool CaDiCaL::Internal::sweep ( )

Definition at line 1875 of file cadical_sweep.cpp.

                      {
  if (!opts.sweep)
    return false;
  if (unsat)
    return false;
  if (terminated_asynchronously ())
    return false;
  if (delaying_sweep.bumpreasons.delay ()) { // TODO need to fix Delay
    last.sweep.ticks = stats.ticks.search[0] + stats.ticks.search[1];
    return false;
  }
  delaying_sweep.bumpreasons.bypass_delay ();
  SET_EFFORT_LIMIT (tickslimit, sweep, !opts.sweepcomplete);
  delaying_sweep.bumpreasons.unbypass_delay ();
 
  CADICAL_assert (!level);
  START_SIMPLIFIER (sweep, SWEEP);
  stats.sweep++;
  uint64_t equivalences = stats.sweep_equivalences;
  uint64_t units = stats.sweep_units;
  Sweeper sweeper = Sweeper (this);
  if (opts.sweepcomplete)
    sweeper.limit.ticks = INT64_MAX;
  else
    sweeper.limit.ticks = tickslimit - stats.ticks.sweep;
  sweep_set_cadical_kitten_ticks_limit (sweeper);
  const unsigned scheduled = schedule_sweeping (sweeper);
  uint64_t swept = 0, limit = 10;
  for (;;) {
    if (unsat)
      break;
    if (terminated_asynchronously ())
      break;
    if (cadical_kitten_ticks_limit_hit (sweeper, "sweeping loop"))
      break;
    int idx = next_scheduled (sweeper);
    if (idx == 0)
      break;
    flags (idx).sweep = false;
#ifndef CADICAL_QUIET
    const char *res =
#endif
        sweep_variable (sweeper, idx);
    VERBOSE (2, "swept[%" PRIu64 "] external variable %d %s", swept,
             externalize (idx), res);
    if (++swept == limit) {
      VERBOSE (2,
               "found %" PRIu64 " equivalences and %" PRIu64
               " units after sweeping %" PRIu64 " variables ",
               stats.sweep_equivalences - equivalences,
               stats.sweep_units - units, swept);
      limit *= 10;
    }
  }
  VERBOSE (2, "swept %" PRIu64 " variables", swept);
  equivalences = stats.sweep_equivalences - equivalences,
  units = stats.sweep_units - units;
  PHASE ("sweep", stats.sweep,
         "found %" PRIu64 " equivalences and %" PRIu64 " units",
         equivalences, units);
  unschedule_sweeping (sweeper, swept, scheduled);
  release_sweeper (sweeper);
 
  if (!unsat) {
    propagated = 0;
    if (!propagate ()) {
      learn_empty_clause ();
    }
  }
 
  uint64_t eliminated = equivalences + units;
  report ('=', !eliminated);
 
  if (relative (eliminated, swept) < 0.001) {
    delaying_sweep.bumpreasons.bump_delay ();
  } else {
    delaying_sweep.bumpreasons.reduce_delay ();
  }
  STOP_SIMPLIFIER (sweep, SWEEP);
  return eliminated;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_add_clause()

void CaDiCaL::Internal::sweep_add_clause	(	Sweeper &	sweeper,
		unsigned	depth )

Definition at line 358 of file cadical_sweep.cpp.

                                                                 {
  // TODO: CADICAL_assertion fails, check if this an issue or can be avoided
  // CADICAL_assert (sweeper.clause.size () > 1);
  for (const auto &lit : sweeper.clause)
    add_literal_to_environment (sweeper, depth, lit);
  citten_clause_with_id (citten, sweeper.clauses.size (),
                         sweeper.clause.size (), sweeper.clause.data ());
  sweeper.clause.clear ();
  if (opts.sweepcountbinary || sweeper.clause.size () > 2)
    sweeper.encoded++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_backbone_candidate()

bool CaDiCaL::Internal::sweep_backbone_candidate	(	Sweeper &	sweeper,
		int	lit )

Definition at line 843 of file cadical_sweep.cpp.

                                                                  {
  LOG ("trying backbone candidate %d", lit);
  signed char value = cadical_kitten_fixed_signed (citten, lit);
  if (value) {
    stats.sweep_fixed_backbone++;
    CADICAL_assert (value > 0);
    if (val (lit) <= 0) {
      return sweep_extract_fixed (sweeper, lit);
    } else
      LOG ("literal %d already fixed", lit);
    return false;
  }
 
  int res = cadical_kitten_status (citten);
  if (res != 10) {
    LOG ("not flipping due to status %d != 10", res);
  }
  stats.sweep_flip_backbone++;
  if (res == 10 && sweep_flip (lit)) {
    stats.sweep_flipped_backbone++;
    LOG ("flipping %d succeeded", lit);
    // LOGBACKBONE ("refined backbone candidates");
    return false;
  }
 
  LOG ("flipping %d failed", lit);
  const int not_lit = -lit;
  stats.sweep_solved_backbone++;
  cadical_kitten_assume_signed (citten, not_lit);
  res = sweep_solve ();
  if (res == 10) {
    LOG ("sweeping backbone candidate %d failed", lit);
    sweep_refine (sweeper);
    stats.sweep_sat_backbone++;
    return false;
  }
 
  if (res == 20) {
    LOG ("sweep unit %d", lit);
    save_add_clear_core (sweeper);
    CADICAL_assert (val (lit));
    stats.sweep_unsat_backbone++;
    return true;
  }
 
  stats.sweep_unknown_backbone++;
 
  LOG ("sweeping backbone candidate %d failed", lit);
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_clause()

void CaDiCaL::Internal::sweep_clause	(	Sweeper &	sweeper,
		unsigned	depth,
		Clause *	c )

Definition at line 370 of file cadical_sweep.cpp.

                                                                        {
  if (c->swept)
    return;
  CADICAL_assert (can_sweep_clause (c));
  LOG (c, "sweeping[%u]", depth);
  CADICAL_assert (sweeper.clause.empty ());
  for (const auto &lit : *c) {
    const signed char tmp = val (lit);
    if (tmp > 0) {
      mark_garbage (c);
      sweep_update_noccs (c);
      sweeper.clause.clear ();
      return;
    }
    if (tmp < 0) {
      if (lrat)
        sweeper.prev_units[abs (lit)] = true;
      continue;
    }
    sweeper.clause.push_back (lit);
  }
  c->swept = true;
  sweep_add_clause (sweeper, depth);
  sweeper.clauses.push_back (c);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_dense_mode_and_watch_irredundant()

void CaDiCaL::Internal::sweep_dense_mode_and_watch_irredundant ( )

Definition at line 77 of file cadical_sweep.cpp.

                                                       {
  reset_watches ();
 
  init_noccs ();
 
  // mark satisfied irredundant clauses as garbage
  for (const auto &c : clauses) {
    if (!can_sweep_clause (c))
      continue;
    bool satisfied = false;
    for (const auto &lit : *c) {
      const signed char tmp = val (lit);
      if (tmp <= 0)
        continue;
      if (tmp > 0) {
        satisfied = true;
        break;
      }
    }
    if (satisfied)
      mark_garbage (c); // forces more precise counts
    else {
      for (const auto &lit : *c)
        noccs (lit)++;
    }
  }
 
  init_occs ();
 
  // Connect irredundant clauses.
  //
  for (const auto &c : clauses) {
    if (!c->garbage) {
      for (const auto &lit : *c)
        if (active (lit))
          occs (lit).push_back (c);
    } else if (c->size == 2) {
      if (!c->flushed) {
        if (proof) {
          c->flushed = true;
          proof->delete_clause (c);
        }
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_dense_propagate()

void CaDiCaL::Internal::sweep_dense_propagate ( Sweeper & sweeper )

Definition at line 133 of file cadical_sweep.cpp.

                                                      {
  vector<int> &work = sweeper.propagate;
  size_t i = 0;
  uint64_t &ticks = sweeper.current_ticks;
  while (i < work.size ()) {
    int lit = work[i++];
    LOG ("sweeping propagation of %d", lit);
    CADICAL_assert (val (lit) > 0);
    ticks += 1 + cache_lines (occs (-lit).size (), sizeof (Clause *));
    const Occs &ns = occs (-lit);
    for (const auto &c : ns) {
      ticks++;
      if (!can_sweep_clause (c))
        continue;
      int unit = 0, satisfied = 0;
      for (const auto &other : *c) {
        const signed char tmp = val (other);
        if (tmp < 0)
          continue;
        if (tmp > 0) {
          satisfied = other;
          break;
        }
        if (unit)
          unit = INT_MIN;
        else
          unit = other;
      }
      if (satisfied) {
        LOG (c, "sweeping propagation of %d finds %d satisfied", lit,
             satisfied);
        mark_garbage (c);
        sweep_update_noccs (c);
      } else if (!unit) {
        LOG ("empty clause during sweeping propagation of %d", lit);
        // need to set conflict = c for lrat
        conflict = c;
        learn_empty_clause ();
        conflict = 0;
        break;
      } else if (unit != INT_MIN) {
        LOG ("new unit %d during sweeping propagation of %d", unit, lit);
        build_chain_for_units (unit, c, 0);
        assign_unit (unit);
        work.push_back (unit);
        ticks++;
      }
    }
    if (unsat)
      break;
 
    // not necessary but should help
    ticks += 1 + cache_lines (occs (lit).size (), sizeof (Clause *));
    const Occs &ps = occs (lit);
    for (const auto &c : ps) {
      ticks++;
      if (c->garbage)
        continue;
      // if (c->redundant)  // TODO I assume it does not hurt to mark
      // everything here continue;
      LOG (c, "sweeping propagation of %d produces satisfied", lit);
      mark_garbage (c);
      sweep_update_noccs (c);
    }
  }
  work.clear ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_empty_clause()

void CaDiCaL::Internal::sweep_empty_clause ( Sweeper & sweeper )

Definition at line 654 of file cadical_sweep.cpp.

                                                   {
  CADICAL_assert (!unsat);
  save_add_clear_core (sweeper);
  CADICAL_assert (unsat);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_equivalence_candidates()

bool CaDiCaL::Internal::sweep_equivalence_candidates	(	Sweeper &	sweeper,
		int	lit,
		int	other )

Definition at line 1341 of file cadical_sweep.cpp.

                                                        {
  LOG ("trying equivalence candidates %d = %d", lit, other);
  const auto begin = sweeper.partition.begin ();
  auto const end = sweeper.partition.end ();
  CADICAL_assert (begin + 3 <= end);
  CADICAL_assert (end[-3] == lit);
  CADICAL_assert (end[-2] == other);
  const int third = (end - begin == 3) ? 0 : end[-4];
  int res = cadical_kitten_status (citten);
  if (res == 10) {
    stats.sweep_flip_equivalences++;
    if (sweep_flip (lit)) {
      stats.sweep_flipped_equivalences++;
      LOG ("flipping %d succeeded", lit);
      if (third == 0) {
        LOG ("squashing equivalence class of %d", lit);
        sweeper.partition.resize (sweeper.partition.size () - 3);
      } else {
        LOG ("removing %d from equivalence class of %d", lit, other);
        end[-3] = other;
        end[-2] = 0;
        sweeper.partition.resize (sweeper.partition.size () - 1);
      }
      return false;
    }
    stats.sweep_flip_equivalences++;
    if (sweep_flip (other)) {
      stats.sweep_flipped_equivalences++;
      LOG ("flipping %d succeeded", other);
      if (third == 0) {
        LOG ("squashing equivalence class of %d", lit);
        sweeper.partition.resize (sweeper.partition.size () - 3);
      } else {
        LOG ("removing %d from equivalence class of %d", other, lit);
        end[-2] = 0;
        sweeper.partition.resize (sweeper.partition.size () - 1);
      }
      return false;
    }
  }
  // frozen variables are not allowed to be eliminated.
  // It might still be beneficial to learn the binaries, if they
  // really are equivalent, but we avoid the issue by not trying
  // for equivalence at all if the non-representative is frozen.
  // i.e., the higher absolute value
  if (abs (lit) > abs (other) && frozen (lit)) {
    if (third == 0) {
      LOG ("squashing equivalence class of %d", lit);
      sweeper.partition.resize (sweeper.partition.size () - 3);
    } else {
      LOG ("removing %d from equivalence class of %d", lit, other);
      end[-3] = other;
      end[-2] = 0;
      sweeper.partition.resize (sweeper.partition.size () - 1);
    }
    return false;
  } else if (abs (other) > abs (lit) && frozen (other)) {
    if (third == 0) {
      LOG ("squashing equivalence class of %d", lit);
      sweeper.partition.resize (sweeper.partition.size () - 3);
    } else {
      LOG ("removing %d from equivalence class of %d", lit, other);
      end[-2] = 0;
      sweeper.partition.resize (sweeper.partition.size () - 1);
    }
    return false;
  }
 
  const int not_other = -other;
  const int not_lit = -lit;
  LOG ("flipping %d and %d both failed", lit, other);
  cadical_kitten_assume_signed (citten, not_lit);
  cadical_kitten_assume_signed (citten, other);
  stats.sweep_solved_equivalences++;
  res = sweep_solve ();
  if (res == 10) {
    stats.sweep_sat_equivalences++;
    LOG ("first sweeping implication %d -> %d failed", other, lit);
    sweep_refine (sweeper);
  } else if (!res) {
    stats.sweep_unknown_equivalences++;
    LOG ("first sweeping implication %d -> %d hit ticks limit", other, lit);
  }
 
  if (res != 20)
    return false;
 
  stats.sweep_unsat_equivalences++;
  LOG ("first sweeping implication %d -> %d succeeded", other, lit);
 
  save_core (sweeper, 0);
 
  cadical_kitten_assume_signed (citten, lit);
  cadical_kitten_assume_signed (citten, not_other);
  res = sweep_solve ();
  stats.sweep_solved_equivalences++;
  if (res == 10) {
    stats.sweep_sat_equivalences++;
    LOG ("second sweeping implication %d <- %d failed", other, lit);
    sweep_refine (sweeper);
  } else if (!res) {
    stats.sweep_unknown_equivalences++;
    LOG ("second sweeping implication %d <- %d hit ticks limit", other,
         lit);
  }
 
  if (res != 20) {
    sweeper.core[0].clear ();
    return false;
  }
 
  CADICAL_assert (res == 20);
 
  stats.sweep_unsat_equivalences++;
  LOG ("second sweeping implication %d <- %d succeeded too", other, lit);
 
  save_core (sweeper, 1);
 
  LOG ("sweep equivalence %d = %d", lit, other);
 
  // If cadical_kitten behaves as expected, the two binaries of the equivalence
  // should be stored at sweeper.core[i].back () for i in {0, 1}.
  // We pick the smaller absolute valued literal as representative and
  // store the equivalence .
  add_core (sweeper, 0);
  add_core (sweeper, 1);
  if (!val (lit) && !val (other)) {
    CADICAL_assert (sweeper.core[0].size ());
    CADICAL_assert (sweeper.core[1].size ());
    stats.sweep_equivalences++;
    sweep_binary bin1;
    sweep_binary bin2;
    if (abs (lit) > abs (other)) {
      bin1.lit = lit;
      bin1.other = not_other;
      bin2.lit = not_lit;
      bin2.other = other;
      bin1.id = add_sweep_binary (sweeper.core[0].back (), lit, not_other);
      bin2.id = add_sweep_binary (sweeper.core[1].back (), not_lit, other);
    } else {
      bin1.lit = not_other;
      bin1.other = lit;
      bin2.lit = other;
      bin2.other = not_lit;
      bin1.id = add_sweep_binary (sweeper.core[0].back (), not_other, lit);
      bin2.id = add_sweep_binary (sweeper.core[1].back (), other, not_lit);
    }
    if (bin1.id && bin2.id) {
      sweeper.binaries.push_back (bin1);
      sweeper.binaries.push_back (bin2);
    }
  }
 
  int repr;
  if (abs (lit) < abs (other)) {
    repr = sweeper.reprs[other] = lit;
    sweeper.reprs[not_other] = not_lit;
    sweep_remove (sweeper, other);
  } else {
    repr = sweeper.reprs[lit] = other;
    sweeper.reprs[not_lit] = not_other;
    sweep_remove (sweeper, lit);
  }
  clear_core (sweeper, 0);
  clear_core (sweeper, 1);
 
  const int repr_idx = abs (repr);
  schedule_inner (sweeper, repr_idx);
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_extract_fixed()

bool CaDiCaL::Internal::sweep_extract_fixed	(	Sweeper &	sweeper,
		int	lit )

Definition at line 827 of file cadical_sweep.cpp.

                                                             {
  const int not_lit = -lit;
  stats.sweep_solved_backbone++;
  cadical_kitten_assume_signed (citten, not_lit);
  int res = sweep_solve ();
  if (!res) {
    stats.sweep_unknown_backbone++;
    return false;
  }
  CADICAL_assert (res == 20);
  LOG ("sweep unit %d", lit);
  save_add_clear_core (sweeper);
  stats.sweep_unsat_backbone++;
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_flip()

bool CaDiCaL::Internal::sweep_flip ( int lit )

Definition at line 37 of file cadical_sweep.cpp.

                                  {
  START (sweepflip);
  bool res = cadical_kitten_flip_signed_literal (citten, lit);
  STOP (sweepflip);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_flip_and_implicant()

int CaDiCaL::Internal::sweep_flip_and_implicant ( int lit )

Definition at line 44 of file cadical_sweep.cpp.

                                               {
  START (sweepimplicant);
  int res = cadical_kitten_flip_and_implicant_for_signed_literal (citten, lit);
  STOP (sweepimplicant);
  return res;
}

Here is the call graph for this function:

◆ sweep_refine()

void CaDiCaL::Internal::sweep_refine ( Sweeper & sweeper )

Definition at line 762 of file cadical_sweep.cpp.

                                             {
  CADICAL_assert (cadical_kitten_status (citten) == 10);
  if (sweeper.backbone.empty ())
    LOG ("no need to refine empty backbone candidates");
  else
    sweep_refine_backbone (sweeper);
  if (sweeper.partition.empty ())
    LOG ("no need to refine empty partition candidates");
  else
    sweep_refine_partition (sweeper);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_refine_backbone()

void CaDiCaL::Internal::sweep_refine_backbone ( Sweeper & sweeper )

Definition at line 745 of file cadical_sweep.cpp.

                                                      {
  LOG ("refining backbone candidates");
  const auto end = sweeper.backbone.end ();
  auto q = sweeper.backbone.begin ();
  for (auto p = q; p != end; p++) {
    const int lit = *p;
    if (val (lit))
      continue;
    signed char value = cadical_kitten_signed_value (citten, lit);
    if (!value)
      LOG ("dropping sub-solver unassigned %d", lit);
    else if (value > 0)
      *q++ = lit;
  }
  sweeper.backbone.resize (q - sweeper.backbone.begin ());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_refine_partition()

void CaDiCaL::Internal::sweep_refine_partition ( Sweeper & sweeper )

Definition at line 660 of file cadical_sweep.cpp.

                                                       {
  LOG ("refining partition");
  vector<int> &old_partition = sweeper.partition;
  vector<int> new_partition;
  auto old_begin = old_partition.begin ();
  const auto old_end = old_partition.end ();
#ifdef LOGGING
  unsigned old_classes = 0;
  unsigned new_classes = 0;
#endif
  for (auto p = old_begin, q = p; p != old_end; p = q + 1) {
    unsigned assigned_true = 0;
    int other;
    for (q = p; (other = *q) != 0; q++) {
      if (sweep_repr (sweeper, other) != other)
        continue;
      if (val (other))
        continue;
      signed char value = cadical_kitten_signed_value (citten, other);
      if (!value)
        LOG ("dropping sub-solver unassigned %d", other);
      else if (value > 0) {
        new_partition.push_back (other);
        assigned_true++;
      }
    }
#ifdef LOGGING
    LOG ("refining class %u of size %zu", old_classes, (size_t) (q - p));
    old_classes++;
#endif
    if (assigned_true == 0)
      LOG ("no positive literal in class");
    else if (assigned_true == 1) {
#ifdef LOGGING
      other =
#else
      (void)
#endif
          new_partition.back ();
      new_partition.pop_back ();
      LOG ("dropping singleton class %d", other);
    } else {
      LOG ("%u positive literal in class", assigned_true);
      new_partition.push_back (0);
#ifdef LOGGING
      new_classes++;
#endif
    }
 
    unsigned assigned_false = 0;
    for (q = p; (other = *q) != 0; q++) {
      if (sweep_repr (sweeper, other) != other)
        continue;
      if (val (other))
        continue;
      signed char value = cadical_kitten_signed_value (citten, other);
      if (value < 0) {
        new_partition.push_back (other);
        assigned_false++;
      }
    }
 
    if (assigned_false == 0)
      LOG ("no negative literal in class");
    else if (assigned_false == 1) {
#ifdef LOGGING
      other =
#else
      (void)
#endif
          new_partition.back ();
      new_partition.pop_back ();
      LOG ("dropping singleton class %d", other);
    } else {
      LOG ("%u negative literal in class", assigned_false);
      new_partition.push_back (0);
#ifdef LOGGING
      new_classes++;
#endif
    }
  }
  old_partition.swap (new_partition);
  LOG ("refined %u classes into %u", old_classes, new_classes);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_remove()

void CaDiCaL::Internal::sweep_remove	(	Sweeper &	sweeper,
		int	lit )

Definition at line 1242 of file cadical_sweep.cpp.

                                                      {
  CADICAL_assert (sweeper.reprs[lit] != lit);
  vector<int> &partition = sweeper.partition;
  const auto begin_partition = partition.begin ();
  auto p = begin_partition;
  const auto end_partition = partition.end ();
  for (; *p != lit; p++)
    CADICAL_assert (p + 1 != end_partition);
  auto begin_class = p;
  while (begin_class != begin_partition && begin_class[-1] != 0)
    begin_class--;
  auto end_class = p;
  while (*end_class != 0)
    end_class++;
  const unsigned size = end_class - begin_class;
  LOG ("removing non-representative %d from equivalence class of size %u",
       lit, size);
  CADICAL_assert (size > 1);
  auto q = begin_class;
  if (size == 2) {
    LOG ("completely squashing equivalence class of %d", lit);
    for (auto r = end_class + 1; r != end_partition; r++)
      *q++ = *r;
  } else {
    for (auto r = begin_class; r != end_partition; r++)
      if (r != p)
        *q++ = *r;
  }
  partition.resize (q - partition.begin ());
}

Here is the caller graph for this function:

◆ sweep_repr()

int CaDiCaL::Internal::sweep_repr	(	Sweeper &	sweeper,
		int	lit )

Definition at line 319 of file cadical_sweep.cpp.

                                                   {
  int res;
  {
    int prev = lit;
    while ((res = sweeper.reprs[prev]) != prev)
      prev = res;
  }
  if (res == lit)
    return res;
  LOG ("sweeping repr[%d] = %d", lit, res);
  {
    const int not_res = -res;
    int next, prev = lit;
    while ((next = sweeper.reprs[prev]) != res) {
      const int not_prev = -prev;
      sweeper.reprs[not_prev] = not_res;
      sweeper.reprs[prev] = res;
      prev = next;
    }
    CADICAL_assert (sweeper.reprs[-prev] == not_res);
  }
  return res;
}

Here is the caller graph for this function:

◆ sweep_set_cadical_kitten_ticks_limit()

void CaDiCaL::Internal::sweep_set_cadical_kitten_ticks_limit ( Sweeper & sweeper )

Definition at line 51 of file cadical_sweep.cpp.

                                                                     {
  uint64_t remaining = 0;
  const uint64_t current = sweeper.current_ticks;
  if (current < sweeper.limit.ticks)
    remaining = sweeper.limit.ticks - current;
  LOG ("'cadical_kitten_ticks' remaining %" PRIu64, remaining);
  cadical_kitten_set_ticks_limit (citten, remaining);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_solve()

int CaDiCaL::Internal::sweep_solve ( )

Definition at line 24 of file cadical_sweep.cpp.

                           {
  START (sweepsolve);
  cadical_kitten_randomize_phases (citten);
  stats.sweep_solved++;
  int res = cadical_kitten_solve (citten);
  if (res == 10)
    stats.sweep_sat++;
  if (res == 20)
    stats.sweep_unsat++;
  STOP (sweepsolve);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_sparse_mode()

void CaDiCaL::Internal::sweep_sparse_mode ( )

Definition at line 125 of file cadical_sweep.cpp.

                                  {
  reset_occs ();
  reset_noccs ();
  init_watches ();
  connect_watches ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_substitute_lrat()

void CaDiCaL::Internal::sweep_substitute_lrat	(	Clause *	c,
		int64_t	id )

Definition at line 1030 of file cadical_sweep.cpp.

                                                           {
  if (!lrat)
    return;
  for (const auto &lit : *c) {
    CADICAL_assert (val (lit) <= 0);
    if (val (lit) < 0) {
      int64_t id = unit_id (-lit);
      lrat_chain.push_back (id);
    }
  }
  lrat_chain.push_back (id);
  lrat_chain.push_back (c->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_substitute_new_equivalences()

void CaDiCaL::Internal::sweep_substitute_new_equivalences ( Sweeper & sweeper )

Definition at line 1181 of file cadical_sweep.cpp.

                                                                  {
  if (unsat)
    return;
 
  unsigned count = 0;
  CADICAL_assert (lrat_chain.empty ());
 
  for (const auto &sb : sweeper.binaries) {
    count++;
    const auto lit = sb.lit;
    const auto other = sb.other;
    if (abs (lit) < abs (other)) {
      substitute_connected_clauses (sweeper, -other, lit, sb.id);
    } else {
      substitute_connected_clauses (sweeper, -lit, other, sb.id);
    }
    CADICAL_assert (lrat_chain.empty ());
    if (val (lit) < 0) {
      if (lrat) {
        const int64_t lid = unit_id (-lit);
        lrat_chain.push_back (lid);
      }
      if (!val (other)) {
        if (lrat)
          lrat_chain.push_back (sb.id);
        assign_unit (other);
      } else if (val (other) < 0) {
        if (lrat) {
          const int64_t oid = unit_id (-other);
          lrat_chain.push_back (oid);
          lrat_chain.push_back (sb.id);
        }
        learn_empty_clause ();
        return;
      }
    } else if (val (other) < 0) {
      if (!val (lit)) {
        if (lrat) {
          const int64_t oid = unit_id (-other);
          lrat_chain.push_back (oid);
          lrat_chain.push_back (sb.id);
        }
        assign_unit (lit);
      } else
        CADICAL_assert (val (lit) > 0);
    }
    lrat_chain.clear ();
    delete_sweep_binary (sb);
    if (count == 2) {
      if (!val (lit) && !val (other)) {
        const auto idx = abs (lit) < abs (other) ? abs (other) : abs (lit);
        if (!flags (idx).fixed ())
          mark_substituted (idx);
      }
      count = 0;
    }
    CADICAL_assert (lrat_chain.empty ());
  }
  sweeper.binaries.clear ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_update_noccs()

void CaDiCaL::Internal::sweep_update_noccs ( Clause * c )

Definition at line 60 of file cadical_sweep.cpp.

                                            {
  if (c->redundant)
    return;
  for (const auto &lit : *c) {
    noccs (lit)--;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_variable()

const char * CaDiCaL::Internal::sweep_variable	(	Sweeper &	sweeper,
		int	idx )

Definition at line 1514 of file cadical_sweep.cpp.

                                                               {
  CADICAL_assert (!unsat);
  if (!active (idx))
    return "inactive variable";
  const int start = idx;
  if (sweeper.reprs[start] != start)
    return "non-representative variable";
  CADICAL_assert (sweeper.vars.empty ());
  CADICAL_assert (sweeper.clauses.empty ());
  CADICAL_assert (sweeper.backbone.empty ());
  CADICAL_assert (sweeper.partition.empty ());
  CADICAL_assert (!sweeper.encoded);
 
  stats.sweep_variables++;
 
  LOG ("sweeping %d", idx);
  CADICAL_assert (!val (start));
  LOG ("starting sweeping[0]");
  add_literal_to_environment (sweeper, 0, start);
  LOG ("finished sweeping[0]");
  LOG ("starting sweeping[1]");
 
  bool limit_reached = false;
  size_t expand = 0, next = 1;
  bool success = false;
  unsigned depth = 1;
 
  uint64_t &ticks = sweeper.current_ticks;
  while (!limit_reached) {
    if (sweeper.encoded >= sweeper.limit.clauses) {
      LOG ("environment clause limit reached");
      limit_reached = true;
      break;
    }
    if (expand == next) {
      LOG ("finished sweeping[%u]", depth);
      if (depth >= sweeper.limit.depth) {
        LOG ("environment depth limit reached");
        break;
      }
      next = sweeper.vars.size ();
      if (expand == next) {
        LOG ("completely copied all clauses");
        break;
      }
      depth++;
      LOG ("starting sweeping[%u]", depth);
    }
    const unsigned choices = next - expand;
    if (opts.sweeprand && choices > 1) {
      const unsigned swaps = sweeper.random.pick_int (0, choices - 1);
      if (swaps) {
        CADICAL_assert (expand + swaps < sweeper.vars.size ());
        swap (sweeper.vars[expand], sweeper.vars[expand + swaps]);
      }
    }
    const int idx = sweeper.vars[expand];
    LOG ("traversing and adding clauses of %d", idx);
    for (unsigned sign = 0; sign < 2; sign++) {
      const int lit = sign ? -idx : idx;
      ticks += 1 + cache_lines (occs (lit).size (), sizeof (Clause *));
      Occs &ns = occs (lit);
      for (auto c : ns) {
        ticks++;
        if (!can_sweep_clause (c))
          continue;
        sweep_clause (sweeper, depth, c);
        if (sweeper.vars.size () >= sweeper.limit.vars) {
          LOG ("environment variable limit reached");
          limit_reached = true;
          break;
        }
      }
      if (limit_reached)
        break;
    }
    expand++;
  }
  stats.sweep_depth += depth;
  stats.sweep_clauses += sweeper.encoded;
  stats.sweep_environment += sweeper.vars.size ();
  VERBOSE (3,
           "sweeping variable %d environment of "
           "%zu variables %u clauses depth %u",
           externalize (idx), sweeper.vars.size (), sweeper.encoded, depth);
 
  int res;
  if (sweeper.vars.size () == 1) {
    LOG ("not sweeping literal %d with environment size 1", idx);
    goto DONE;
  }
  res = sweep_solve ();
  LOG ("sub-solver returns '%d'", res);
  if (res == 10) {
    init_backbone_and_partition (sweeper);
#ifndef CADICAL_QUIET
    uint64_t units = stats.sweep_units;
    uint64_t solved = stats.sweep_solved;
#endif
    START (sweepbackbone);
    while (sweeper.backbone.size ()) {
      if (unsat || terminated_asynchronously () ||
          cadical_kitten_ticks_limit_hit (sweeper, "backbone refinement")) {
        limit_reached = true;
      STOP_SWEEP_BACKBONE:
        STOP (sweepbackbone);
        goto DONE;
      }
      flip_backbone_literals (sweeper);
      if (terminated_asynchronously () ||
          cadical_kitten_ticks_limit_hit (sweeper, "backbone refinement")) {
        limit_reached = true;
        goto STOP_SWEEP_BACKBONE;
      }
      if (sweeper.backbone.empty ())
        break;
      const int lit = sweeper.backbone.back ();
      sweeper.backbone.pop_back ();
      if (!active (lit))
        continue;
      if (sweep_backbone_candidate (sweeper, lit))
        success = true;
    }
    STOP (sweepbackbone);
#ifndef CADICAL_QUIET
    units = stats.sweep_units - units;
    solved = stats.sweep_solved - solved;
#endif
    VERBOSE (3,
             "complete swept variable %d backbone with %" PRIu64
             " units in %" PRIu64 " solver calls",
             externalize (idx), units, solved);
    CADICAL_assert (sweeper.backbone.empty ());
#ifndef CADICAL_QUIET
    uint64_t equivalences = stats.sweep_equivalences;
    solved = stats.sweep_solved;
#endif
    START (sweepequivalences);
    while (sweeper.partition.size ()) {
      if (unsat || terminated_asynchronously () ||
          cadical_kitten_ticks_limit_hit (sweeper, "partition refinement")) {
        limit_reached = true;
      STOP_SWEEP_EQUIVALENCES:
        STOP (sweepequivalences);
        goto DONE;
      }
      flip_partition_literals (sweeper);
      if (terminated_asynchronously () ||
          cadical_kitten_ticks_limit_hit (sweeper, "backbone refinement")) {
        limit_reached = true;
        goto STOP_SWEEP_EQUIVALENCES;
      }
      if (sweeper.partition.empty ())
        break;
      if (sweeper.partition.size () > 2) {
        const auto end = sweeper.partition.end ();
        CADICAL_assert (end[-1] == 0);
        int lit = end[-3];
        int other = end[-2];
        if (sweep_equivalence_candidates (sweeper, lit, other))
          success = true;
      } else
        sweeper.partition.clear ();
    }
    STOP (sweepequivalences);
#ifndef CADICAL_QUIET
    equivalences = stats.sweep_equivalences - equivalences;
    solved = stats.sweep_solved - solved;
    if (equivalences)
      VERBOSE (3,
               "complete swept variable %d partition with %" PRIu64
               " equivalences in %" PRIu64 " solver calls",
               externalize (idx), equivalences, solved);
#endif
  } else if (res == 20)
    sweep_empty_clause (sweeper);
 
DONE:
  clear_sweeper (sweeper);
 
  if (!unsat)
    sweep_substitute_new_equivalences (sweeper);
  if (!unsat)
    sweep_dense_propagate (sweeper);
 
  if (success && limit_reached)
    return "successfully despite reaching limit";
  if (!success && !limit_reached)
    return "unsuccessfully without reaching limit";
  else if (success && !limit_reached)
    return "successfully without reaching limit";
  CADICAL_assert (!success && limit_reached);
  return "unsuccessfully and reached limit";
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ terminate()

void CaDiCaL::Internal::terminate ( )

inline

Definition at line 878 of file internal.hpp.

                    {
    LOG ("forcing asynchronous termination");
    termination_forced = true;
  }

◆ terminated_asynchronously()

bool CaDiCaL::Internal::terminated_asynchronously ( int factor = 1 )

inline

Definition at line 1789 of file internal.hpp.

                                                           {
  // First way of asynchronous termination is through 'terminate' which sets
  // the 'termination_forced' flag directly.  The second way is through a
  // call back to a 'terminator' if it is non-zero, which however is costly.
  //
  if (termination_forced) {
    LOG ("termination asynchronously forced");
    return true;
  }
 
  // This is only for testing and debugging asynchronous termination calls.
  // In production code this could be removed but then should not be costly
  // and keeping it will allow to test correctness of asynchronous
  // termination on the production platform too.  After this triggers we
  // have to set the 'termination_forced' flag, such that subsequent calls
  // to this function do not check this again.
  //
  if (lim.terminate.forced) {
    CADICAL_assert (lim.terminate.forced > 0);
    if (lim.terminate.forced-- == 1) {
      LOG ("internally forcing termination");
      termination_forced = true;
      return true;
    }
    LOG ("decremented internal forced termination limit to %d",
         lim.terminate.forced);
  }
 
  // The second way of asynchronous termination is through registering and
  // calling an external 'Terminator' object.  This is of course more costly
  // than just checking a (volatile though) boolean flag, particularly in
  // tight loops.  To avoid this cost we only call the terminator in
  // intervals of 'opts.terminateint', which in addition can be scaled up by
  // the argument 'factor'.  If the terminator returns 'true' we set the
  // 'termination_forced' flag to 'true' in order to remember the
  // termination status and to avoid the terminator again.  Setting this
  // flag leads to the first test above to succeed in subsequent calls.
  //
  if (external->terminator && !lim.terminate.check--) {
    CADICAL_assert (factor > 0);
    CADICAL_assert (INT_MAX / factor > opts.terminateint);
    lim.terminate.check = factor * opts.terminateint;
    if (external->terminator->terminate ()) {
      termination_forced = true; // Cache it.
      LOG ("connected terminator forces termination");
      return true;
    }
  }
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ terminating_asked()

bool CaDiCaL::Internal::terminating_asked ( )

Definition at line 267 of file cadical_lookahead.cpp.

                                  {
 
  if (external->terminator && external->terminator->terminate ()) {
    MSG ("connected terminator forces termination");
    return true;
  }
 
  if (termination_forced) {
    MSG ("termination forced");
    return true;
  }
  return false;
}

Here is the caller graph for this function:

◆ ternary()

bool CaDiCaL::Internal::ternary ( )

Definition at line 361 of file cadical_ternary.cpp.

                        {
 
  if (!opts.ternary)
    return false;
  if (unsat)
    return false;
  if (terminated_asynchronously ())
    return false;
 
  // No new ternary clauses added since last time?
  //
  if (last.ternary.marked == stats.mark.ternary)
    return false;
 
  SET_EFFORT_LIMIT (limit, ternary, true);
 
  START_SIMPLIFIER (ternary, TERNARY);
  stats.ternary++;
 
  CADICAL_assert (!level);
 
  CADICAL_assert (!unsat);
  if (watching ())
    reset_watches ();
 
  // The number of clauses derived through ternary resolution can grow
  // substantially, particularly for random formulas.  Thus we limit the
  // number of added clauses too (actually the number of 'htrs').
  //
  int64_t htrs_limit = stats.current.redundant + stats.current.irredundant;
  htrs_limit *= opts.ternarymaxadd;
  htrs_limit /= 100;
 
  // approximation of ternary ticks.
  // TODO: count with ternary.ticks directly.
  int64_t steps_limit = stats.ticks.ternary - limit;
  stats.ticks.ternary = limit;
 
  // With 'stats.ternary' we actually count the number of calls to
  // 'ternary_round' and not the number of calls to 'ternary'. But before
  // the first round we want to show the limit on the number of steps and
  // thus we increase counter for the first round here and skip increasing
  // it in the loop below.
  //
  PHASE ("ternary", stats.ternary,
         "will run a maximum of %d rounds "
         "limited to %" PRId64 " steps and %" PRId64 " clauses",
         opts.ternaryrounds, steps_limit, htrs_limit);
 
  bool resolved_binary_clause = false;
  bool completed = false;
 
  for (int round = 0;
       !terminated_asynchronously () && round < opts.ternaryrounds;
       round++) {
    if (htrs_limit < 0)
      break;
    if (steps_limit < 0)
      break;
    if (round)
      stats.ternary++;
    int old_htrs2 = stats.htrs2;
    int old_htrs3 = stats.htrs3;
    completed = ternary_round (steps_limit, htrs_limit);
    int delta_htrs2 = stats.htrs2 - old_htrs2;
    int delta_htrs3 = stats.htrs3 - old_htrs3;
    PHASE ("ternary", stats.ternary,
           "derived %d ternary and %d binary resolvents", delta_htrs3,
           delta_htrs2);
    report ('3', !opts.reportall && !(delta_htrs2 + delta_htrs2));
    if (delta_htrs2)
      resolved_binary_clause = true;
    if (!delta_htrs3)
      break;
  }
 
  CADICAL_assert (!occurring ());
  CADICAL_assert (!unsat);
  init_watches ();
  connect_watches ();
  if (!propagate ()) {
    LOG ("propagation after connecting watches results in inconsistency");
    learn_empty_clause ();
  }
 
  if (completed)
    last.ternary.marked = stats.mark.ternary;
 
  STOP_SIMPLIFIER (ternary, TERNARY);
 
  return resolved_binary_clause;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ternary_find_binary_clause()

bool CaDiCaL::Internal::ternary_find_binary_clause	(	int	a,
		int	b )

Definition at line 29 of file cadical_ternary.cpp.

                                                       {
  CADICAL_assert (occurring ());
  CADICAL_assert (active (a));
  CADICAL_assert (active (b));
  size_t s = occs (a).size ();
  size_t t = occs (b).size ();
  int lit = s < t ? a : b;
  if (opts.ternaryocclim < (int) occs (lit).size ())
    return true;
  for (const auto &c : occs (lit)) {
    if (c->size != 2)
      continue;
    const int *lits = c->literals;
    if (lits[0] == a && lits[1] == b)
      return true;
    if (lits[0] == b && lits[1] == a)
      return true;
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ternary_find_ternary_clause()

bool CaDiCaL::Internal::ternary_find_ternary_clause	(	int	a,
		int	b,
		int	c )

Definition at line 55 of file cadical_ternary.cpp.

                                                               {
  CADICAL_assert (occurring ());
  CADICAL_assert (active (a));
  CADICAL_assert (active (b));
  CADICAL_assert (active (c));
  size_t r = occs (a).size ();
  size_t s = occs (b).size ();
  size_t t = occs (c).size ();
  int lit;
  if (r < s)
    lit = (t < r) ? c : a;
  else
    lit = (t < s) ? c : b;
  if (opts.ternaryocclim < (int) occs (lit).size ())
    return true;
  for (const auto &d : occs (lit)) {
    const int *lits = d->literals;
    if (d->size == 2) {
      if (lits[0] == a && lits[1] == b)
        return true;
      if (lits[0] == b && lits[1] == a)
        return true;
      if (lits[0] == a && lits[1] == c)
        return true;
      if (lits[0] == c && lits[1] == a)
        return true;
      if (lits[0] == b && lits[1] == c)
        return true;
      if (lits[0] == c && lits[1] == b)
        return true;
    } else {
      CADICAL_assert (d->size == 3);
      if (lits[0] == a && lits[1] == b && lits[2] == c)
        return true;
      if (lits[0] == a && lits[1] == c && lits[2] == b)
        return true;
      if (lits[0] == b && lits[1] == a && lits[2] == c)
        return true;
      if (lits[0] == b && lits[1] == c && lits[2] == a)
        return true;
      if (lits[0] == c && lits[1] == a && lits[2] == b)
        return true;
      if (lits[0] == c && lits[1] == b && lits[2] == a)
        return true;
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ternary_idx()

void CaDiCaL::Internal::ternary_idx	(	int	idx,
		int64_t &	steps,
		int64_t &	htrs )

Definition at line 241 of file cadical_ternary.cpp.

                                                                  {
  CADICAL_assert (0 < idx);
  CADICAL_assert (idx <= max_var);
  steps -= 3;
  if (!active (idx))
    return;
  if (!flags (idx).ternary)
    return;
  int pos = occs (idx).size ();
  int neg = occs (-idx).size ();
  if (pos <= opts.ternaryocclim && neg <= opts.ternaryocclim) {
    LOG ("index %d has %zd positive and %zd negative occurrences", idx,
         occs (idx).size (), occs (-idx).size ());
    int pivot = (neg < pos ? -idx : idx);
    ternary_lit (pivot, steps, htrs);
  }
  flags (idx).ternary = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ternary_lit()

void CaDiCaL::Internal::ternary_lit	(	int	pivot,
		int64_t &	steps,
		int64_t &	htrs )

Definition at line 156 of file cadical_ternary.cpp.

                                                                    {
  LOG ("starting hyper ternary resolutions on pivot %d", pivot);
  steps -= 1 + cache_lines (occs (pivot).size (), sizeof (Clause *));
  for (const auto &c : occs (pivot)) {
    if (steps < 0)
      break;
    if (htrs < 0)
      break;
    if (c->garbage)
      continue;
    if (c->size != 3) {
      CADICAL_assert (c->size == 2);
      continue;
    }
    if (--steps < 0)
      break;
    bool assigned = false;
    for (const auto &lit : *c)
      if (val (lit)) {
        assigned = true;
        break;
      }
    if (assigned)
      continue;
    steps -= 1 + cache_lines (occs (-pivot).size (), sizeof (Clause *));
    for (const auto &d : occs (-pivot)) {
      if (htrs < 0)
        break;
      if (--steps < 0)
        break;
      if (d->garbage)
        continue;
      if (d->size != 3) {
        CADICAL_assert (d->size == 2);
        continue;
      }
      for (const auto &lit : *d)
        if (val (lit)) {
          assigned = true;
          break;
        }
      if (assigned)
        continue;
      CADICAL_assert (clause.empty ());
      htrs--;
      if (hyper_ternary_resolve (c, pivot, d)) {
        size_t size = clause.size ();
        bool red = (size == 3 || (c->redundant && d->redundant));
        if (lrat) {
          CADICAL_assert (lrat_chain.empty ());
          lrat_chain.push_back (c->id);
          lrat_chain.push_back (d->id);
        }
        Clause *r = new_hyper_ternary_resolved_clause (red);
        if (red)
          r->hyper = true;
        lrat_chain.clear ();
        clause.clear ();
        LOG (r, "hyper ternary resolved");
        stats.htrs++;
        for (const auto &lit : *r)
          occs (lit).push_back (r);
        if (size == 2) {
          LOG ("hyper ternary resolvent subsumes both antecedents");
          mark_garbage (c);
          mark_garbage (d);
          stats.htrs2++;
          break;
        } else {
          CADICAL_assert (r->size == 3);
          stats.htrs3++;
        }
      } else {
        LOG (clause, "ignoring size %zd resolvent", clause.size ());
        clause.clear ();
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ternary_round()

bool CaDiCaL::Internal::ternary_round	(	int64_t &	steps,
		int64_t &	htrs )

Definition at line 271 of file cadical_ternary.cpp.

                                                                       {
 
  CADICAL_assert (!unsat);
 
#ifndef CADICAL_QUIET
  int64_t bincon = 0;
  int64_t terncon = 0;
#endif
 
  init_occs ();
 
  steps_limit -= 1 + cache_lines (clauses.size (), sizeof (Clause *));
  for (const auto &c : clauses) {
    steps_limit--;
    if (c->garbage)
      continue;
    if (c->size > 3)
      continue;
    bool assigned = false, marked = false;
    for (const auto &lit : *c) {
      if (val (lit)) {
        assigned = true;
        break;
      }
      if (flags (lit).ternary)
        marked = true;
    }
    if (assigned)
      continue;
    if (c->size == 2) {
#ifndef CADICAL_QUIET
      bincon++;
#endif
    } else {
      CADICAL_assert (c->size == 3);
      if (!marked)
        continue;
#ifndef CADICAL_QUIET
      terncon++;
#endif
    }
 
    for (const auto &lit : *c)
      occs (lit).push_back (c);
  }
 
  PHASE ("ternary", stats.ternary,
         "connected %" PRId64 " ternary %.0f%% "
         "and %" PRId64 " binary clauses %.0f%%",
         terncon, percent (terncon, clauses.size ()), bincon,
         percent (bincon, clauses.size ()));
 
  // Try ternary resolution on all variables once.
  //
  for (auto idx : vars) {
    if (terminated_asynchronously ())
      break;
    if (steps_limit < 0)
      break;
    if (htrs_limit < 0)
      break;
    ternary_idx (idx, steps_limit, htrs_limit);
  }
 
  // Gather some statistics for the verbose messages below and also
  // determine whether new variables have been marked and it would make
  // sense to run another round of ternary resolution over those variables.
  //
  int remain = 0;
  for (auto idx : vars) {
    if (!active (idx))
      continue;
    if (!flags (idx).ternary)
      continue;
    remain++;
  }
  if (remain)
    PHASE ("ternary", stats.ternary, "%d variables remain %.0f%%", remain,
           percent (remain, max_var));
  else
    PHASE ("ternary", stats.ternary, "completed hyper ternary resolution");
 
  reset_occs ();
  CADICAL_assert (!unsat);
 
  return remain; // Are there variables that should be tried again?
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tied_next_factor_score()

double CaDiCaL::Internal::tied_next_factor_score ( int lit )

Definition at line 135 of file cadical_factor.cpp.

                                                {
  double res = occs (lit).size ();
  LOG ("watches score %g of %d", res, lit);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ time()

double CaDiCaL::Internal::time ( )

inline

Definition at line 1660 of file internal.hpp.

1660{ return opts.realtime ? real_time () : process_time (); }

CaDiCaL::Internal::real_time

double real_time() const

Definition cadical_resources.cpp:101

CaDiCaL::Internal::process_time

double process_time() const

Definition cadical_resources.cpp:105

Here is the call graph for this function:

Here is the caller graph for this function:

◆ trace()

void CaDiCaL::Internal::trace ( File * file )

Definition at line 126 of file cadical_proof.cpp.

                                {
  if (opts.veripb) {
    LOG ("PROOF connecting VeriPB tracer");
    bool antecedents = opts.veripb == 1 || opts.veripb == 2;
    bool deletions = opts.veripb == 2 || opts.veripb == 4;
    FileTracer *ft =
        new VeripbTracer (this, file, opts.binary, antecedents, deletions);
    connect_proof_tracer (ft, antecedents);
  } else if (opts.frat) {
    LOG ("PROOF connecting FRAT tracer");
    bool antecedents = opts.frat == 1;
    resize_unit_clauses_idx ();
    FileTracer *ft =
        new FratTracer (this, file, opts.binary, opts.frat == 1);
    connect_proof_tracer (ft, antecedents, true);
  } else if (opts.lrat) {
    LOG ("PROOF connecting LRAT tracer");
    FileTracer *ft = new LratTracer (this, file, opts.binary);
    connect_proof_tracer (ft, true);
  } else if (opts.idrup) {
    LOG ("PROOF connecting IDRUP tracer");
    FileTracer *ft = new IdrupTracer (this, file, opts.binary);
    connect_proof_tracer (ft, true);
  } else if (opts.lidrup) {
    LOG ("PROOF connecting LIDRUP tracer");
    FileTracer *ft = new LidrupTracer (this, file, opts.binary);
    connect_proof_tracer (ft, true);
  } else {
    LOG ("PROOF connecting DRAT tracer");
    FileTracer *ft = new DratTracer (this, file, opts.binary);
    connect_proof_tracer (ft, false);
  }
}

Here is the call graph for this function:

◆ transred()

void CaDiCaL::Internal::transred ( )

Definition at line 15 of file cadical_transred.cpp.

                         {
  if (!opts.transred)
    return;
  if (unsat)
    return;
  if (terminated_asynchronously ())
    return;
  if (!stats.current.redundant && !stats.current.irredundant)
    return;
 
  CADICAL_assert (opts.transred);
  CADICAL_assert (!level);
 
  START_SIMPLIFIER (transred, TRANSRED);
  stats.transreds++;
 
  // Transitive reduction can not be run to completion for larger formulas
  // with many binary clauses.  We bound it in the same way as 'probe_core'.
  //
  int64_t limit = stats.propagations.search;
  limit -= last.transred.propagations;
  limit *= 1e-3 * opts.transredeffort;
  if (limit < opts.transredmineff)
    limit = opts.transredmineff;
  if (limit > opts.transredmaxeff)
    limit = opts.transredmaxeff;
 
  PHASE ("transred", stats.transreds,
         "transitive reduction limit of %" PRId64 " propagations", limit);
 
  const auto end = clauses.end ();
  auto i = clauses.begin ();
 
  // Find first clause not checked for being transitive yet.
  //
  for (; i != end; i++) {
    Clause *c = *i;
    if (c->garbage)
      continue;
    if (c->size != 2)
      continue;
    if (c->redundant && c->hyper)
      continue;
    if (!c->transred)
      break;
  }
 
  // If all candidate clauses have been checked reschedule all.
  //
  if (i == end) {
 
    PHASE ("transred", stats.transreds,
           "rescheduling all clauses since no clauses to check left");
    for (i = clauses.begin (); i != end; i++) {
      Clause *c = *i;
      if (c->transred)
        c->transred = false;
    }
    i = clauses.begin ();
  }
 
  // Move watches of binary clauses to the front. Thus we can stop iterating
  // watches as soon a long clause is found during watch traversal.
  //
  sort_watches ();
 
  // This working stack plays the same role as the 'trail' during standard
  // propagation.
  //
  vector<int> work;
 
  int64_t propagations = 0, units = 0, removed = 0;
 
  while (!unsat && i != end && !terminated_asynchronously () &&
         propagations < limit) {
    Clause *c = *i++;
 
    // A clause is a candidate for being transitive if it is binary, and not
    // the result of hyper binary resolution.  The reason for excluding
    // those, is that they come in large numbers, most of them are reduced
    // away anyhow and further are non-transitive at the point they are
    // added (see the code in 'hyper_binary_resolve' in 'prope.cpp' and
    // also check out our CPAIOR paper on tree-based look ahead).
    //
    if (c->garbage)
      continue;
    if (c->size != 2)
      continue;
    if (c->redundant && c->hyper)
      continue;
    if (c->transred)
      continue;         // checked before?
    c->transred = true; // marked as checked
 
    LOG (c, "checking transitive reduction of");
 
    // Find a different path from 'src' to 'dst' in the binary implication
    // graph, not using 'c'.  Since this is the same as checking whether
    // there is a path from '-dst' to '-src', we can do the reverse search
    // if the number of watches of '-dst' is larger than those of 'src'.
    //
    int src = -c->literals[0];
    int dst = c->literals[1];
    if (val (src) || val (dst))
      continue;
    if (watches (-src).size () < watches (dst).size ()) {
      int tmp = dst;
      dst = -src;
      src = -tmp;
    }
 
    LOG ("searching path from %d to %d", src, dst);
 
    // If the candidate clause is irredundant then we can not use redundant
    // binary clauses in the implication graph.  See our inprocessing rules
    // paper, why this restriction is required.
    //
    const bool irredundant = !c->redundant;
 
    CADICAL_assert (work.empty ());
    mark (src);
    work.push_back (src);
    LOG ("transred assign %d", src);
 
    bool transitive = false; // found path from 'src' to 'dst'?
    bool failed = false;     // 'src' failed literal?
 
    size_t j = 0; // 'propagated' in BFS
 
    CADICAL_assert (lrat_chain.empty ());
    CADICAL_assert (mini_chain.empty ());
    vector<int> parents;
 
    while (!transitive && !failed && j < work.size ()) {
      const int lit = work[j++];
      CADICAL_assert (marked (lit) > 0);
      LOG ("transred propagating %d", lit);
      propagations++;
      const Watches &ws = watches (-lit);
      const const_watch_iterator eow = ws.end ();
      const_watch_iterator k;
      for (k = ws.begin (); !transitive && !failed && k != eow; k++) {
        const Watch &w = *k;
        if (!w.binary ())
          break; // since we sorted watches above
        Clause *d = w.clause;
        if (d == c)
          continue;
        if (irredundant && d->redundant)
          continue;
        if (d->garbage)
          continue;
        const int other = w.blit;
        if (other == dst)
          transitive = true; // 'dst' reached
        else {
          const int tmp = marked (other);
          if (tmp > 0)
            continue;
          else if (tmp < 0) {
            if (lrat) {
              parents.push_back (lit);
              mini_chain.push_back (d->id);
              work.push_back (other);
            }
            LOG ("found both %d and %d reachable", -other, other);
            failed = true;
          } else {
            if (lrat) {
              parents.push_back (lit);
              mini_chain.push_back (d->id);
            }
            mark (other);
            work.push_back (other);
            LOG ("transred assign %d", other);
          }
        }
      }
    }
 
    int failed_lit = work.back ();
    int next_pos = 0;
    int next_neg = 0;
 
    // Unassign all assigned literals (same as '[bp]acktrack').
    //
    while (!work.empty ()) {
      const int lit = work.back ();
      work.pop_back ();
      if (lrat && failed && !work.empty ()) {
        CADICAL_assert (!parents.empty () && !mini_chain.empty ());
        LOG ("transred LRAT current lit %d next pos %d next neg %d", lit,
             next_pos, next_neg);
        if (lit == failed_lit || lit == next_pos) {
          lrat_chain.push_back (mini_chain.back ());
          next_pos = parents.back ();
        } else if (lit == -failed_lit || lit == next_neg) {
          lrat_chain.push_back (mini_chain.back ());
          next_neg = parents.back ();
        }
        parents.pop_back ();
        mini_chain.pop_back ();
      }
      unmark (lit);
    }
    mini_chain.clear ();
    CADICAL_assert (mini_chain.empty ());
    if (lrat && failed) {
      reverse (lrat_chain.begin (), lrat_chain.end ());
    }
 
    if (transitive) {
      removed++;
      stats.transitive++;
      LOG (c, "transitive redundant");
      mark_garbage (c);
    } else if (failed) {
      units++;
      LOG ("found failed literal %d during transitive reduction", src);
      stats.failed++;
      stats.transredunits++;
      assign_unit (-src);
      if (!propagate ()) {
        VERBOSE (1, "propagating new unit results in conflict");
        learn_empty_clause ();
      }
    }
    lrat_chain.clear ();
  }
 
  last.transred.propagations = stats.propagations.search;
  stats.propagations.transred += propagations;
  erase_vector (work);
 
  PHASE ("transred", stats.transreds,
         "removed %" PRId64 " transitive clauses, found %" PRId64 " units",
         removed, units);
 
  STOP_SIMPLIFIER (transred, TRANSRED);
  report ('t', !opts.reportall && !(removed + units));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ traverse_clauses()

bool CaDiCaL::Internal::traverse_clauses ( ClauseIterator & it )

Definition at line 1166 of file cadical_internal.cpp.

                                                   {
  vector<int> eclause;
  if (unsat)
    return it.clause (eclause);
  for (const auto &c : clauses) {
    if (c->garbage)
      continue;
    if (c->redundant)
      continue;
    bool satisfied = false;
    for (const auto &ilit : *c) {
      const int tmp = fixed (ilit);
      if (tmp > 0) {
        satisfied = true;
        break;
      }
      if (tmp < 0)
        continue;
      const int elit = externalize (ilit);
      eclause.push_back (elit);
    }
    if (!satisfied && !it.clause (eclause))
      return false;
    eclause.clear ();
  }
  return true;
}

Here is the call graph for this function:

◆ traverse_constraint()

bool CaDiCaL::Internal::traverse_constraint ( ClauseIterator & it )

Definition at line 1138 of file cadical_internal.cpp.

                                                      {
  if (constraint.empty () && !unsat_constraint)
    return true;
 
  vector<int> eclause;
  if (unsat)
    return it.clause (eclause);
 
  LOG (constraint, "traversing constraint");
  bool satisfied = false;
  for (auto ilit : constraint) {
    const int tmp = fixed (ilit);
    if (tmp > 0) {
      satisfied = true;
      break;
    }
    if (tmp < 0)
      continue;
    const int elit = externalize (ilit);
    eclause.push_back (elit);
  }
  if (!satisfied && !it.clause (eclause))
    return false;
 
  return true;
}

Here is the call graph for this function:

◆ trivially_false_satisfiable()

int CaDiCaL::Internal::trivially_false_satisfiable ( )

Definition at line 34 of file cadical_lucky.cpp.

                                           {
  LOG ("checking that all clauses contain a negative literal");
  CADICAL_assert (!level);
  CADICAL_assert (assumptions.empty ());
  for (const auto &c : clauses) {
    if (terminated_asynchronously (100))
      return unlucky (-1);
    if (c->garbage)
      continue;
    if (c->redundant)
      continue;
    bool satisfied = false, found_negative_literal = false;
    for (const auto &lit : *c) {
      const signed char tmp = val (lit);
      if (tmp > 0) {
        satisfied = true;
        break;
      }
      if (tmp < 0)
        continue;
      if (lit > 0)
        continue;
      found_negative_literal = true;
      break;
    }
    if (satisfied || found_negative_literal)
      continue;
    LOG (c, "found purely positively");
    return unlucky (0);
  }
  VERBOSE (1, "all clauses contain a negative literal");
  for (auto idx : vars) {
    if (terminated_asynchronously (10))
      return unlucky (-1);
    if (val (idx))
      continue;
    search_assume_decision (-idx);
    if (propagate ())
      continue;
    CADICAL_assert (level > 0);
    LOG ("propagation failed including redundant clauses");
    return unlucky (0);
  }
  stats.lucky.constant.zero++;
  return 10;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ trivially_true_satisfiable()

int CaDiCaL::Internal::trivially_true_satisfiable ( )

Definition at line 81 of file cadical_lucky.cpp.

                                          {
  LOG ("checking that all clauses contain a positive literal");
  CADICAL_assert (!level);
  CADICAL_assert (assumptions.empty ());
  for (const auto &c : clauses) {
    if (terminated_asynchronously (100))
      return unlucky (-1);
    if (c->garbage)
      continue;
    if (c->redundant)
      continue;
    bool satisfied = false, found_positive_literal = false;
    for (const auto &lit : *c) {
      const signed char tmp = val (lit);
      if (tmp > 0) {
        satisfied = true;
        break;
      }
      if (tmp < 0)
        continue;
      if (lit < 0)
        continue;
      found_positive_literal = true;
      break;
    }
    if (satisfied || found_positive_literal)
      continue;
    LOG (c, "found purely negatively");
    return unlucky (0);
  }
  VERBOSE (1, "all clauses contain a positive literal");
  for (auto idx : vars) {
    if (terminated_asynchronously (10))
      return unlucky (-1);
    if (val (idx))
      continue;
    search_assume_decision (idx);
    if (propagate ())
      continue;
    CADICAL_assert (level > 0);
    LOG ("propagation failed including redundant clauses");
    return unlucky (0);
  }
  stats.lucky.constant.one++;
  return 10;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ try_to_eliminate_variable()

void CaDiCaL::Internal::try_to_eliminate_variable	(	Eliminator &	eliminator,
		int	pivot,
		bool &	deleted_binary_clause )

Definition at line 681 of file cadical_elim.cpp.

                                                                       {
 
  if (!active (pivot))
    return;
  CADICAL_assert (!frozen (pivot));
 
  // First flush garbage clauses.
  //
  int64_t pos = flush_occs (pivot);
  int64_t neg = flush_occs (-pivot);
 
  if (pos > neg) {
    pivot = -pivot;
    swap (pos, neg);
  }
  LOG ("pivot %d occurs positively %" PRId64
       " times and negatively %" PRId64 " times",
       pivot, pos, neg);
  CADICAL_assert (!eliminator.schedule.contains (abs (pivot)));
  CADICAL_assert (pos <= neg);
 
  if (pos && neg > opts.elimocclim) {
    LOG ("too many occurrences thus not eliminated %d", pivot);
    CADICAL_assert (!eliminator.schedule.contains (abs (pivot)));
    return;
  }
 
  LOG ("trying to eliminate %d", pivot);
  CADICAL_assert (!flags (pivot).eliminated ());
 
  // Sort occurrence lists, such that shorter clauses come first.
  Occs &ps = occs (pivot);
  stable_sort (ps.begin (), ps.end (), clause_smaller_size ());
  Occs &ns = occs (-pivot);
  stable_sort (ns.begin (), ns.end (), clause_smaller_size ());
 
  if (pos)
    find_gate_clauses (eliminator, pivot);
 
  if (!unsat && !val (pivot)) {
    if (elim_resolvents_are_bounded (eliminator, pivot)) {
      LOG ("number of resolvents on %d are bounded", pivot);
      elim_add_resolvents (eliminator, pivot);
      if (!unsat)
        mark_eliminated_clauses_as_garbage (eliminator, pivot,
                                            deleted_binary_clause);
      if (active (pivot))
        mark_eliminated (pivot);
    } else {
      LOG ("too many resolvents on %d so not eliminated", pivot);
    }
  }
 
  unmark_gate_clauses (eliminator);
  elim_backward_clauses (eliminator);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ try_to_fasteliminate_variable()

void CaDiCaL::Internal::try_to_fasteliminate_variable	(	Eliminator &	eliminator,
		int	pivot,
		bool &	deleted_binary_clause )

Definition at line 189 of file cadical_elimfast.cpp.

                                                                           {
 
  if (!active (pivot))
    return;
  CADICAL_assert (!frozen (pivot));
 
  // First flush garbage clauses and check limits.
 
  int64_t bound = opts.fastelimbound;
 
  int64_t pos = flush_elimfast_occs (pivot);
  if (pos > bound) {
    LOG ("too many occurrences thus not eliminated %d", pivot);
    CADICAL_assert (!eliminator.schedule.contains (abs (pivot)));
    return;
  }
 
  int64_t neg = flush_elimfast_occs (-pivot);
  if (neg > bound) {
    LOG ("too many occurrences thus not eliminated %d", -pivot);
    CADICAL_assert (!eliminator.schedule.contains (abs (pivot)));
    return;
  }
 
  const int64_t product = pos * neg;
  const int64_t sum = pos + neg;
  if (bound > sum)
    bound = sum;
 
  if (pos > neg) {
    pivot = -pivot;
    swap (pos, neg);
  }
 
  LOG ("pivot %d occurs positively %" PRId64
       " times and negatively %" PRId64 " times",
       pivot, pos, neg);
 
  CADICAL_assert (!eliminator.schedule.contains (abs (pivot)));
  CADICAL_assert (pos <= neg);
 
  LOG ("trying to eliminate %d", pivot);
  CADICAL_assert (!flags (pivot).eliminated ());
 
  // Sort occurrence lists, such that shorter clauses come first.
  Occs &ps = occs (pivot);
  stable_sort (ps.begin (), ps.end (), clause_smaller_size ());
  Occs &ns = occs (-pivot);
  stable_sort (ns.begin (), ns.end (), clause_smaller_size ());
 
  if (!unsat && !val (pivot)) {
    if (product <= bound ||
        elimfast_resolvents_are_bounded (eliminator, pivot)) {
      LOG ("number of resolvents on %d are bounded", pivot);
      elimfast_add_resolvents (eliminator, pivot);
      if (!unsat)
        mark_eliminated_clauses_as_garbage (eliminator, pivot,
                                            deleted_binary_clause);
      if (active (pivot))
        mark_eliminated (pivot);
    } else {
      LOG ("too many resolvents on %d so not eliminated", pivot);
    }
  }
 
  unmark_gate_clauses (eliminator);
  elim_backward_clauses (eliminator);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ try_to_satisfy_formula_by_saved_phases()

int CaDiCaL::Internal::try_to_satisfy_formula_by_saved_phases ( )

Definition at line 752 of file cadical_internal.cpp.

                                                      {
  LOG ("satisfying formula by saved phases");
  CADICAL_assert (!level);
  CADICAL_assert (!force_saved_phase);
  CADICAL_assert (propagated == trail.size ());
  force_saved_phase = true;
  if (external_prop) {
    CADICAL_assert (!level);
    LOG ("external notifications are turned off during preprocessing.");
    private_steps = true;
  }
  int res = 0;
  while (!res) {
    if (satisfied ()) {
      LOG ("formula indeed satisfied by saved phases");
      res = 10;
    } else if (decide ()) {
      LOG ("inconsistent assumptions with redundant clauses and phases");
      res = 20;
    } else if (!propagate ()) {
      LOG ("saved phases do not satisfy redundant clauses");
      CADICAL_assert (level > 0);
      backtrack ();
      conflict = 0; // ignore conflict
      CADICAL_assert (!res);
      break;
    }
  }
  CADICAL_assert (force_saved_phase);
  force_saved_phase = false;
  if (external_prop) {
    private_steps = false;
    LOG ("external notifications are turned back on.");
    if (!level)
      notify_assignments (); // In case fixed assignments were found.
    else {
      renotify_trail_after_local_search ();
    }
  }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ try_to_subsume_clause()

int CaDiCaL::Internal::try_to_subsume_clause	(	Clause *	c,
		vector< Clause * > &	shrunken )

inline

Definition at line 188 of file cadical_subsume.cpp.

                                                                        {
 
  stats.subtried++;
  CADICAL_assert (!level);
  LOG (c, "trying to subsume");
 
  mark (c); // signed!
 
  Clause *d = 0;
  int flipped = 0;
 
  for (const auto &lit : *c) {
 
    // Only clauses which have a variable which has recently been added are
    // checked for being subsumed.  The idea is that all these newly added
    // clauses are candidates for subsuming the clause.  Then we also only
    // need to check occurrences of these variables.  The occurrence lists
    // of other literal do not have to be checked.
    //
    if (!flags (lit).subsume)
      continue;
 
    for (int sign = -1; !d && sign <= 1; sign += 2) {
 
      // First we check against all binary clauses.  The other literals of
      // all binary clauses of 'sign*lit' are stored in one consecutive
      // array, which is way faster than storing clause pointers and
      // dereferencing them.  Since this binary clause array is also not
      // shrunken, we also can bail out earlier if subsumption or
      // strengthening is determined.
 
      // In both cases the (self-)subsuming clause is stored in 'd', which
      // makes it nonzero and forces aborting both the outer and inner loop.
      // If the binary clause can strengthen the candidate clause 'c'
      // (through self-subsuming resolution), then 'filled' is set to the
      // literal which can be removed in 'c', otherwise to 'INT_MIN' which
      // is a non-valid literal.
 
      for (const auto &bin : bins (sign * lit)) {
        const auto &other = bin.lit;
        const int tmp = marked (other);
        if (!tmp)
          continue;
        if (tmp < 0 && sign < 0)
          continue;
        if (tmp < 0) {
          if (sign < 0)
            continue; // tautological resolvent
          dummy_binary->literals[0] = lit;
          dummy_binary->literals[1] = other;
          flipped = other;
        } else {
          dummy_binary->literals[0] = sign * lit;
          dummy_binary->literals[1] = other;
          flipped = (sign < 0) ? -lit : INT_MIN;
        }
 
        // This dummy binary clauses is initialized in 'Internal::Internal'
        // and only changes it literals in the lines above.   By using such
        // a faked binary clause we can simply reuse 'subsume_clause' as
        // well as the code around 'strengthen_clause' uniform for both real
        // clauses and this special case for binary clauses
 
        dummy_binary->id = bin.id;
        d = dummy_binary;
 
        break;
      }
 
      if (d)
        break;
 
      // In this second loop we check for larger than binary clauses to
      // subsume or strengthen the candidate clause.   This is more costly,
      // and needs a call to 'subsume_check'.  Otherwise the same contract
      // as above for communicating 'subsumption' or 'strengthening' to the
      // code after the loop is used.
      //
      const Occs &os = occs (sign * lit);
      for (const auto &e : os) {
        CADICAL_assert (!e->garbage); // sanity check
        if (e->garbage)
          continue; // defensive: not needed
        flipped = subsume_check (e, c);
        if (!flipped)
          continue;
        d = e; // leave also outer loop
        break;
      }
    }
 
    if (d)
      break;
  }
 
  unmark (c);
 
  if (flipped == INT_MIN) {
    LOG (d, "subsuming");
    subsume_clause (d, c);
    return 1;
  }
 
  if (flipped) {
    LOG (d, "strengthening");
    if (lrat) {
      CADICAL_assert (lrat_chain.empty ());
      lrat_chain.push_back (c->id);
      lrat_chain.push_back (d->id);
    }
    if (d->used > c->used)
      c->used = d->used;
    strengthen_clause (c, -flipped);
    lrat_chain.clear ();
    CADICAL_assert (likely_to_be_kept_clause (c));
    shrunken.push_back (c);
    return -1;
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ u2i()

int CaDiCaL::Internal::u2i ( unsigned u )

inline

Definition at line 412 of file internal.hpp.

                       {
    CADICAL_assert (u > 1);
    int res = u / 2;
    CADICAL_assert (res <= max_var);
    if (u & 1)
      res = -res;
    return res;
  }

Here is the caller graph for this function:

◆ unassign()

void CaDiCaL::Internal::unassign ( int lit )

inline

Definition at line 14 of file cadical_backtrack.cpp.

                                       {
  CADICAL_assert (val (lit) > 0);
  set_val (lit, 0);
 
  int idx = vidx (lit);
  LOG ("unassign %d @ %d", lit, var (idx).level);
  num_assigned--;
 
  // In the standard EVSIDS variable decision heuristic of MiniSAT, we need
  // to push variables which become unassigned back to the heap.
  //
  if (!scores.contains (idx))
    scores.push_back (idx);
 
  // For VMTF we need to update the 'queue.unassigned' pointer in case this
  // variable sits after the variable to which 'queue.unassigned' currently
  // points.  See our SAT'15 paper for more details on this aspect.
  //
  if (queue.bumped < btab[idx])
    update_queue_unassigned (idx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unit_clauses()

int64_t & CaDiCaL::Internal::unit_clauses ( int uidx )

inline

Definition at line 443 of file internal.hpp.

                                          {
    CADICAL_assert (lrat || frat);
    CADICAL_assert (uidx > 0);
    CADICAL_assert ((size_t) uidx < unit_clauses_idx.size ());
    return unit_clauses_idx[uidx];
  }

Here is the caller graph for this function:

◆ unit_id()

int64_t CaDiCaL::Internal::unit_id ( int lit ) const

inline

Definition at line 434 of file internal.hpp.

                                  {
    CADICAL_assert (lrat || frat);
    CADICAL_assert (val (lit) > 0);
    const unsigned uidx = vlit (lit);
    int64_t id = unit_clauses_idx[uidx];
    CADICAL_assert (id);
    return id;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unlucky()

int CaDiCaL::Internal::unlucky ( int res )

Definition at line 26 of file cadical_lucky.cpp.

                              {
  if (level > 0)
    backtrack ();
  if (conflict)
    conflict = 0;
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unmark() [1/3]

void CaDiCaL::Internal::unmark ( Clause * c )

Definition at line 23 of file cadical_clause.cpp.

                                {
  for (const auto &lit : *c)
    unmark (lit);
}

Here is the call graph for this function:

◆ unmark() [2/3]

void CaDiCaL::Internal::unmark ( int lit )

inline

Definition at line 490 of file internal.hpp.

                        {
    marks[vidx (lit)] = 0;
    CADICAL_assert (!marked (lit));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unmark() [3/3]

void CaDiCaL::Internal::unmark ( vector< int > & lits )

inline

Definition at line 527 of file internal.hpp.

                                  {
    for (const auto &lit : lits)
      unmark (lit);
  }

Here is the call graph for this function:

◆ unmark67()

void CaDiCaL::Internal::unmark67 ( int lit )

inline

Definition at line 517 of file internal.hpp.

                          {
    signed char &m = marks[vidx (lit)];
    const signed char mask = 0x3f;
#ifndef CADICAL_NDEBUG
    const signed bits = m & mask;
#endif
    m &= mask;
    CADICAL_assert ((m & mask) == bits);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unmark_as_conditional_literal()

void CaDiCaL::Internal::unmark_as_conditional_literal ( int lit )

inline

Definition at line 117 of file cadical_condition.cpp.

                                                            {
  LOG ("unmarking %d as conditional literal", lit);
  CADICAL_assert (is_conditional_literal (lit));
  unsetbit (lit, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unmark_binary_literals()

void CaDiCaL::Internal::unmark_binary_literals ( Eliminator & eliminator )

Definition at line 192 of file cadical_gates.cpp.

                                                             {
  LOG ("unmarking %zd literals", eliminator.marked.size ());
  for (const auto &lit : eliminator.marked)
    unmark (lit);
  eliminator.marked.clear ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unmark_block()

void CaDiCaL::Internal::unmark_block ( int lit )

inline

Definition at line 1094 of file internal.hpp.

                              {
    Flags &f = flags (lit);
    const unsigned bit = bign (lit);
    f.block &= ~bit;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unmark_clause()

void CaDiCaL::Internal::unmark_clause ( )

Definition at line 33 of file cadical_clause.cpp.

                              {
  for (const auto &lit : clause)
    unmark (lit);
}

Here is the call graph for this function:

◆ unmark_decomposed()

void CaDiCaL::Internal::unmark_decomposed ( int lit )

inline

Definition at line 1126 of file internal.hpp.

                                   {
    Flags &f = flags (lit);
    const unsigned bit = bign (lit);
    f.marked_signed &= ~bit;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unmark_gate_clauses()

void CaDiCaL::Internal::unmark_gate_clauses ( Eliminator & eliminator )

Definition at line 758 of file cadical_gates.cpp.

                                                          {
  LOG ("unmarking %zd gate clauses", eliminator.gates.size ());
  for (const auto &c : eliminator.gates) {
    CADICAL_assert (c->gate);
    c->gate = false;
  }
  eliminator.gates.clear ();
  eliminator.definition_unit = 0;
}

Here is the caller graph for this function:

◆ unmark_in_candidate_clause()

void CaDiCaL::Internal::unmark_in_candidate_clause ( int lit )

inline

Definition at line 141 of file cadical_condition.cpp.

                                                         {
  LOG ("unmarking %d as literal of the candidate clause", lit);
  CADICAL_assert (is_in_candidate_clause (lit));
  unmark67 (lit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unmarkfact()

void CaDiCaL::Internal::unmarkfact	(	int	lit,
		int	fact )

inline

Definition at line 599 of file internal.hpp.

                                      {
    CADICAL_assert (fact == 1 || fact == 2 || fact == 4);
    CADICAL_assert (getfact (lit, fact));
    int res = marks[vidx (lit)];
    if (lit < 0) {
      res &= ~(fact << 3);
    } else {
      res &= ~fact;
    }
    marks[vidx (lit)] = res;
    CADICAL_assert (!getfact (lit, fact));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unphase()

void CaDiCaL::Internal::unphase ( int lit )

Definition at line 37 of file cadical_phases.cpp.

                               {
  const int idx = vidx (lit);
  signed char old_forced_phase = phases.forced[idx];
  if (!old_forced_phase) {
    LOG ("forced phase of %d already reset", lit);
    return;
  }
  LOG ("clearing old forced phase %d", old_forced_phase * idx);
  phases.forced[idx] = 0;
}

Here is the call graph for this function:

◆ unprotect_reasons()

void CaDiCaL::Internal::unprotect_reasons ( )

Definition at line 140 of file cadical_collect.cpp.

                                  {
  LOG ("unprotecting reasons clauses of all assigned variables on trail");
  CADICAL_assert (protected_reasons);
#ifdef LOGGING
  size_t count = 0;
#endif
  for (const auto &lit : trail) {
    if (!active (lit))
      continue;
    CADICAL_assert (val (lit));
    Var &v = var (lit);
    CADICAL_assert (v.level > 0);
    Clause *reason = v.reason;
    if (!reason)
      continue;
    if (reason == external_reason)
      continue;
    LOG (reason, "unprotecting assigned %d reason %p", lit,
         (void *) reason);
    CADICAL_assert (reason->reason);
    reason->reason = false;
#ifdef LOGGING
    count++;
#endif
  }
  LOG ("unprotected %zd reason clauses referenced on trail", count);
  protected_reasons = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unschedule_sweeping()

void CaDiCaL::Internal::unschedule_sweeping	(	Sweeper &	sweeper,
		unsigned	swept,
		unsigned	scheduled )

Definition at line 1845 of file cadical_sweep.cpp.

                                                        {
#ifdef CADICAL_QUIET
  (void) scheduled, (void) swept;
#endif
  CADICAL_assert (sweep_schedule.empty ());
  CADICAL_assert (sweep_incomplete);
  for (all_scheduled (idx))
    if (active (idx)) {
      sweep_schedule.push_back (idx);
      LOG ("untried scheduled %d", idx);
    }
#ifndef CADICAL_QUIET
  const unsigned retained = sweep_schedule.size ();
#endif
  VERBOSE (3, "retained %u variables %.0f%% to be swept next time",
           retained, percent (retained, active ()));
  const unsigned incomplete = incomplete_variables ();
  if (incomplete)
    VERBOSE (3, "need to sweep %u more variables %.0f%% for completion",
             incomplete, percent (incomplete, active ()));
  else {
    VERBOSE (3, "no more variables needed to complete sweep");
    sweep_incomplete = false;
    stats.sweep_completed++;
  }
  PHASE ("sweep", stats.sweep, "swept %u variables (%u remain %.0f%%)",
         swept, incomplete, percent (incomplete, scheduled));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unsetbit()

void CaDiCaL::Internal::unsetbit	(	int	lit,
		int	bit )

inline

Definition at line 546 of file internal.hpp.

                                   {
    CADICAL_assert (0 <= bit), CADICAL_assert (bit < 6);
    CADICAL_assert (getbit (lit, bit));
    marks[vidx (lit)] &= ~(1 << bit);
    CADICAL_assert (!getbit (lit, bit));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unwatch_clause()

void CaDiCaL::Internal::unwatch_clause ( Clause * c )

inline

Definition at line 640 of file internal.hpp.

                                         {
    const int l0 = c->literals[0];
    const int l1 = c->literals[1];
    remove_watch (watches (l0), c);
    remove_watch (watches (l1), c);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_decision_rate_average()

void CaDiCaL::Internal::update_decision_rate_average ( )

Definition at line 927 of file cadical_analyze.cpp.

                                             {
  int64_t current = stats.decisions;
  int64_t decisions = current - saved_decisions;
  UPDATE_AVERAGE (averages.current.decisions, decisions);
  saved_decisions = current;
}

Here is the caller graph for this function:

◆ update_factor_candidate()

void CaDiCaL::Internal::update_factor_candidate	(	Factoring &	factoring,
		int	lit )

Definition at line 742 of file cadical_factor.cpp.

                                                                     {
  FactorSchedule &schedule = factoring.schedule;
  const size_t size = occs (lit).size ();
  const unsigned idx = vlit (lit);
  if (schedule.contains (idx))
    schedule.update (idx);
  else if (size > 1) {
    schedule.push_back (idx);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_factored()

void CaDiCaL::Internal::update_factored	(	Factoring &	factoring,
		Quotient *	q )

Definition at line 701 of file cadical_factor.cpp.

                                                                 {
  const int factor = q->factor;
  update_factor_candidate (factoring, factor);
  update_factor_candidate (factoring, -factor);
  for (auto c : q->qlauses) {
    LOG (c, "deleting unfactored");
    for (const auto &lit : *c)
      if (lit != factor)
        update_factor_candidate (factoring, lit);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_queue_unassigned()

void CaDiCaL::Internal::update_queue_unassigned ( int idx )

inline

Definition at line 652 of file internal.hpp.

                                                {
    CADICAL_assert (0 < idx);
    CADICAL_assert (idx <= max_var);
    queue.unassigned = idx;
    queue.bumped = btab[idx];
    LOG ("queue unassigned now %d bumped %" PRId64 "", idx, btab[idx]);
  }

Here is the caller graph for this function:

◆ update_reason_references()

void CaDiCaL::Internal::update_reason_references ( )

Definition at line 246 of file cadical_collect.cpp.

                                         {
  LOG ("update assigned reason references");
#ifdef LOGGING
  size_t count = 0;
#endif
  for (auto &lit : trail) {
    if (!active (lit))
      continue;
    Var &v = var (lit);
    Clause *c = v.reason;
    if (!c)
      continue;
    if (c == external_reason)
      continue;
    LOG (c, "updating assigned %d reason", lit);
    CADICAL_assert (c->reason);
    CADICAL_assert (c->moved);
    Clause *d = c->copy;
    v.reason = d;
#ifdef LOGGING
    count++;
#endif
  }
  LOG ("updated %zd assigned reason references", count);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_target_and_best()

void CaDiCaL::Internal::update_target_and_best ( )

Definition at line 50 of file cadical_backtrack.cpp.

                                       {
 
  bool reset = (rephased && stats.conflicts > last.rephase.conflicts);
 
  if (reset) {
    target_assigned = 0;
    if (rephased == 'B')
      best_assigned = 0; // update it again
  }
 
  if (no_conflict_until > target_assigned) {
    copy_phases (phases.target);
    target_assigned = no_conflict_until;
    LOG ("new target trail level %zu", target_assigned);
  }
 
  if (no_conflict_until > best_assigned) {
    copy_phases (phases.best);
    best_assigned = no_conflict_until;
    LOG ("new best trail level %zu", best_assigned);
  }
 
  if (reset) {
    report (rephased);
    rephased = 0;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ use_scores()

bool CaDiCaL::Internal::use_scores ( ) const

inline

Definition at line 471 of file internal.hpp.

471{ return opts.score && stable; }

Here is the caller graph for this function:

◆ val()

signed char CaDiCaL::Internal::val ( int lit ) const

inline

Definition at line 1518 of file internal.hpp.

                                  {
    CADICAL_assert (-max_var <= lit);
    CADICAL_assert (lit);
    CADICAL_assert (lit <= max_var);
    return vals[lit];
  }

◆ var()

Var & CaDiCaL::Internal::var ( int lit )

inline

Definition at line 452 of file internal.hpp.

452{ return vtab[vidx (lit)]; }

Here is the call graph for this function:

◆ verror()

void CaDiCaL::Internal::verror	(	const char *	fmt,
		va_list &	ap )

Definition at line 175 of file cadical_message.cpp.

                                                   {
  error_message_start ();
  vfprintf (stderr, fmt, ap);
  error_message_end ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vidx()

int CaDiCaL::Internal::vidx ( int lit ) const

inline

Definition at line 395 of file internal.hpp.

                           {
    int idx;
    CADICAL_assert (lit);
    CADICAL_assert (lit != INT_MIN);
    idx = abs (lit);
    CADICAL_assert (idx <= max_var);
    return idx;
  }

Here is the caller graph for this function:

◆ vivify()

bool CaDiCaL::Internal::vivify ( )

Definition at line 1804 of file cadical_vivify.cpp.

                       {
 
  if (unsat)
    return false;
  if (terminated_asynchronously ())
    return false;
  if (!opts.vivify)
    return false;
  if (!stats.current.irredundant)
    return false;
  if (level)
    backtrack ();
  CADICAL_assert (opts.vivify);
  CADICAL_assert (!level);
 
  SET_EFFORT_LIMIT (totallimit, vivify, true);
 
  private_steps = true;
 
  START_SIMPLIFIER (vivify, VIVIFY);
  stats.vivifications++;
 
  // the effort is normalized by dividing by sumeffort below, hence no need
  // to multiply by 1e-3 (also making the precision better)
  double tier1effort = !opts.vivifytier1 ? 0 : (double) opts.vivifytier1eff;
  double tier2effort = !opts.vivifytier2 ? 0 : (double) opts.vivifytier2eff;
  double tier3effort = !opts.vivifytier3 ? 0 : (double) opts.vivifytier3eff;
  double irreffort =
      delaying_vivify_irredundant.bumpreasons.delay () || !opts.vivifyirred
          ? 0
          : (double) opts.vivifyirredeff;
  double sumeffort = tier1effort + tier2effort + tier3effort + irreffort;
  if (!stats.current.redundant)
    tier1effort = tier2effort = tier3effort = 0;
  if (!sumeffort)
    sumeffort = irreffort = 1;
  int64_t total = totallimit - stats.ticks.vivify;
 
  PHASE ("vivify", stats.vivifications,
         "vivification limit of %" PRId64 " ticks", total);
  Vivifier vivifier (Vivify_Mode::TIER1);
  compute_tier_limits (vivifier);
 
  if (vivifier.tier1_limit == vivifier.tier2_limit) {
    tier1effort += tier2effort;
    tier2effort = 0;
    LOG ("vivification tier1 matches tier2 "
         "thus using tier2 budget for tier1");
  }
  int64_t init_ticks = 0;
 
  // Refill the schedule every time.  Unchecked clauses are 'saved' by
  // setting their 'vivify' bit, such that they can be tried next time.
  //
  // TODO: count against ticks.vivify directly instead of this unholy
  // shifting.
  vivify_initialize (vivifier, init_ticks);
  stats.ticks.vivify += init_ticks;
  int64_t limit = stats.ticks.vivify;
  const double shared_effort = (double) init_ticks / 4.0;
  if (opts.vivifytier1) {
    set_vivifier_mode (vivifier, Vivify_Mode::TIER1);
    if (limit < stats.ticks.vivify)
      limit = stats.ticks.vivify;
    const double effort = (total * tier1effort) / sumeffort;
    CADICAL_assert (std::numeric_limits<int64_t>::max () - (int64_t) effort >=
            limit);
    limit += effort;
    if (limit - shared_effort > stats.ticks.vivify) {
      limit -= shared_effort;
      CADICAL_assert (limit >= 0);
      vivify_round (vivifier, limit);
    } else {
      LOG ("building the schedule already used our entire ticks budget for "
           "tier1");
    }
  }
 
  if (!unsat && tier2effort) {
    erase_vector (
        vivifier.schedule_tier1); // save memory (well, not really as we
                                  // already reached the peak memory)
    if (limit < stats.ticks.vivify)
      limit = stats.ticks.vivify;
    const double effort = (total * tier2effort) / sumeffort;
    CADICAL_assert (std::numeric_limits<int64_t>::max () - (int64_t) effort >=
            limit);
    limit += effort;
    if (limit - shared_effort > stats.ticks.vivify) {
      limit -= shared_effort;
      CADICAL_assert (limit >= 0);
      set_vivifier_mode (vivifier, Vivify_Mode::TIER2);
      vivify_round (vivifier, limit);
    } else {
      LOG ("building the schedule already used our entire ticks budget for "
           "tier2");
    }
  }
 
  if (!unsat && tier3effort) {
    erase_vector (vivifier.schedule_tier2);
    if (limit < stats.ticks.vivify)
      limit = stats.ticks.vivify;
    const double effort = (total * tier3effort) / sumeffort;
    CADICAL_assert (std::numeric_limits<int64_t>::max () - (int64_t) effort >=
            limit);
    limit += effort;
    if (limit - shared_effort > stats.ticks.vivify) {
      limit -= shared_effort;
      CADICAL_assert (limit >= 0);
      set_vivifier_mode (vivifier, Vivify_Mode::TIER3);
      vivify_round (vivifier, limit);
    } else {
      LOG ("building the schedule already used our entire ticks budget for "
           "tier3");
    }
  }
 
  if (!unsat && irreffort) {
    erase_vector (vivifier.schedule_tier3);
    if (limit < stats.ticks.vivify)
      limit = stats.ticks.vivify;
    const double effort = (total * irreffort) / sumeffort;
    CADICAL_assert (std::numeric_limits<int64_t>::max () - (int64_t) effort >=
            limit);
    limit += effort;
    if (limit - shared_effort > stats.ticks.vivify) {
      limit -= shared_effort;
      CADICAL_assert (limit >= 0);
      set_vivifier_mode (vivifier, Vivify_Mode::IRREDUNDANT);
      const int old = stats.vivifystrirr;
      const int old_tried = stats.vivifychecks;
      vivify_round (vivifier, limit);
      if (stats.vivifychecks - old_tried == 0 ||
          (float) (stats.vivifystrirr - old) /
                  (float) (stats.vivifychecks - old_tried) <
              0.01) {
        delaying_vivify_irredundant.bumpreasons.bump_delay ();
      } else {
        delaying_vivify_irredundant.bumpreasons.reduce_delay ();
      }
    } else {
      delaying_vivify_irredundant.bumpreasons.bump_delay ();
      LOG ("building the schedule already used our entire ticks budget for "
           "irredundant");
    }
  }
 
  reset_noccs ();
  STOP_SIMPLIFIER (vivify, VIVIFY);
 
  private_steps = false;
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_analyze()

void CaDiCaL::Internal::vivify_analyze	(	Clause *	start,
		bool &	subsumes,
		Clause **	subsuming,
		const Clause * const	candidate,
		int	implied,
		bool &	redundant )

Definition at line 652 of file cadical_vivify.cpp.

                                                {
  const auto &t = &trail; // normal trail, so next_trail is wrong
  int i = t->size ();     // Start at end-of-trail.
  Clause *reason = start;
  CADICAL_assert (reason);
  CADICAL_assert (!trail.empty ());
  int uip = trail.back ();
  bool mark_implied = (implied);
 
  while (i >= 0) {
    if (reason) {
      redundant = (redundant || reason->redundant);
      subsumes = (start != reason && reason->size <= start->size);
      LOG (reason, "resolving on %d with", uip);
      for (auto other : *reason) {
        const Var v = var (other);
        Flags &f = flags (other);
        if (!marked2 (other) && v.level) {
          LOG ("not subsuming due to lit %d", other);
          subsumes = false;
        }
        if (!val (other)) {
          LOG ("skipping unset lit %d", other);
          continue;
        }
        if (other == uip) {
          continue;
        }
        if (!v.level) {
          if (f.seen || !lrat || reason == start)
            continue;
          LOG ("unit reason for %d", other);
          int64_t id = unit_id (-other);
          LOG ("adding unit reason %zd for %d", id, other);
          unit_chain.push_back (id);
          f.seen = true;
          analyzed.push_back (other);
          continue;
        }
        if (mark_implied && other != implied) {
          LOG ("skipping non-implied literal %d on current level", other);
          continue;
        }
 
        CADICAL_assert (val (other));
        if (f.seen)
          continue;
        LOG ("pushing lit %d", other);
        analyzed.push_back (other);
        f.seen = true;
      }
      if (start->redundant) {
        const int new_glue = recompute_glue (start);
        promote_clause (start, new_glue);
      }
      if (subsumes) {
        CADICAL_assert (reason);
        LOG (reason, "clause found subsuming");
        LOG (candidate, "clause found subsumed");
        *subsuming = reason;
        return;
      }
    } else {
      LOG ("vivify analyzed decision %d", uip);
      clause.push_back (-uip);
    }
    mark_implied = false;
 
    uip = 0;
    while (!uip && i > 0) {
      CADICAL_assert (i > 0);
      const int lit = (*t)[--i];
      if (!var (lit).level)
        continue;
      if (flags (lit).seen)
        uip = lit;
    }
    if (!uip)
      break;
    LOG ("uip is %d", uip);
    Var &w = var (uip);
    reason = w.reason;
    if (lrat && reason)
      lrat_chain.push_back (reason->id);
  }
  (void) candidate;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_analyze_redundant()

void CaDiCaL::Internal::vivify_analyze_redundant	(	Vivifier &	,
		Clause *	start,
		bool &	)

Here is the call graph for this function:

◆ vivify_assign()

void CaDiCaL::Internal::vivify_assign	(	int	lit,
		Clause *	reason )

inline

Definition at line 146 of file cadical_vivify.cpp.

                                                            {
  require_mode (VIVIFY);
  const int idx = vidx (lit);
  CADICAL_assert (!vals[idx]);
  CADICAL_assert (!flags (idx).eliminated () || !reason);
  Var &v = var (idx);
  v.level = level;               // required to reuse decisions
  v.trail = (int) trail.size (); // used in 'vivify_better_watch'
  CADICAL_assert ((int) num_assigned < max_var);
  num_assigned++;
  v.reason = level ? reason : 0; // for conflict analysis
  if (!level)
    learn_unit_clause (lit);
  const signed char tmp = sign (lit);
  vals[idx] = tmp;
  vals[-idx] = -tmp;
  CADICAL_assert (val (lit) > 0);
  CADICAL_assert (val (-lit) < 0);
  trail.push_back (lit);
  LOG (reason, "vivify assign %d", lit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_assume()

void CaDiCaL::Internal::vivify_assume ( int lit )

Definition at line 170 of file cadical_vivify.cpp.

                                     {
  require_mode (VIVIFY);
  level++;
  control.push_back (Level (lit, trail.size ()));
  LOG ("vivify decide %d", lit);
  CADICAL_assert (level > 0);
  CADICAL_assert (propagated == trail.size ());
  vivify_assign (lit, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_build_lrat()

void CaDiCaL::Internal::vivify_build_lrat	(	int	lit,
		Clause *	reason,
		std::vector< std::tuple< int, Clause *, bool > > &	stack )

Definition at line 1257 of file cadical_vivify.cpp.

                                                     {
  CADICAL_assert (stack.empty ());
  stack.push_back ({lit, reason, false});
  while (!stack.empty ()) {
    int lit;
    Clause *reason;
    bool finished;
    std::tie (lit, reason, finished) = stack.back ();
    LOG ("VIVIFY LRAT justifying %d", lit);
    stack.pop_back ();
    if (lit && flags (lit).seen) {
      LOG ("skipping already justified");
      continue;
    }
    if (finished) {
      lrat_chain.push_back (reason->id);
      if (lit && reason) {
        Flags &f = flags (lit);
        f.seen = true;
        analyzed.push_back (lit); // CADICAL_assert (val (other) < 0);
        CADICAL_assert (flags (lit).seen);
      }
      continue;
    } else
      stack.push_back ({lit, reason, true});
    for (const auto &other : *reason) {
      if (other == lit)
        continue;
      Var &v = var (other);
      Flags &f = flags (other);
      if (f.seen)
        continue;
      if (!v.level) {
        const int64_t id = unit_id (-other);
        lrat_chain.push_back (id);
        f.seen = true;
        analyzed.push_back (other);
        continue;
      }
      if (v.reason) { // recursive justification
        LOG ("VIVIFY LRAT pushing %d", other);
        stack.push_back ({other, v.reason, false});
      }
    }
  }
  stack.clear ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_chain_for_units()

void CaDiCaL::Internal::vivify_chain_for_units	(	int	lit,
		Clause *	reason )

inline

Definition at line 1309 of file cadical_vivify.cpp.

                                                                     {
  if (!lrat)
    return;
  // LOG ("building chain for units");        bad line for debugging
  // equivalence if (opts.chrono && assignment_level (lit, reason)) return;
  if (level)
    return; // not decision level 0
  CADICAL_assert (lrat_chain.empty ());
  for (auto &reason_lit : *reason) {
    if (lit == reason_lit)
      continue;
    CADICAL_assert (val (reason_lit));
    const int signed_reason_lit = val (reason_lit) * reason_lit;
    int64_t id = unit_id (signed_reason_lit);
    lrat_chain.push_back (id);
  }
  lrat_chain.push_back (reason->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_clause()

bool CaDiCaL::Internal::vivify_clause	(	Vivifier &	vivifier,
		Clause *	candidate )

Definition at line 947 of file cadical_vivify.cpp.

                                                           {
 
  CADICAL_assert (c->size > 2); // see (NO-BINARY) below
  CADICAL_assert (analyzed.empty ());
 
  c->vivify = false;  // mark as checked / tried
  c->vivified = true; // and globally remember
 
  CADICAL_assert (!c->garbage);
 
  auto &lrat_stack = vivifier.lrat_stack;
  auto &ticks = vivifier.ticks;
  ticks++;
 
  // First check whether the candidate clause is already satisfied and at
  // the same time copy its non fixed literals to 'sorted'.  The literals
  // in the candidate clause might not be sorted anymore due to replacing
  // watches during propagation, even though we sorted them initially
  // while pushing the clause onto the schedule and sorting the schedule.
  //
  auto &sorted = vivifier.sorted;
  sorted.clear ();
 
  for (const auto &lit : *c) {
    const int tmp = fixed (lit);
    if (tmp > 0) {
      LOG (c, "satisfied by propagated unit %d", lit);
      mark_garbage (c);
      return false;
    } else if (!tmp)
      sorted.push_back (lit);
  }
 
  CADICAL_assert (sorted.size () > 1);
  if (sorted.size () == 2) {
    LOG ("skipping actual binary");
    return false;
  }
 
  sort (sorted.begin (), sorted.end (), vivify_more_noccs_kissat (this));
 
  // The actual vivification checking is performed here, by assuming the
  // negation of each of the remaining literals of the clause in turn and
  // propagating it.  If a conflict occurs or another literal in the
  // clause becomes assigned during propagation, we can stop.
  //
  LOG (c, "vivification checking");
  stats.vivifychecks++;
 
  // If the decision 'level' is non-zero, then we can reuse decisions for
  // the previous candidate, and avoid re-propagating them.  In preliminary
  // experiments this saved between 30%-50% decisions (and thus
  // propagations), which in turn lets us also vivify more clauses within
  // the same propagation bounds, or terminate earlier if vivify runs to
  // completion.
  //
  if (level) {
#ifdef LOGGING
    int orig_level = level;
#endif
    // First check whether this clause is actually a reason for forcing
    // one of its literals to true and then backtrack one level before
    // that happened.  Otherwise this clause might be incorrectly
    // considered to be redundant or if this situation is checked then
    // redundancy by other clauses using this forced literal becomes
    // impossible.
    //
    int forced = 0;
 
    // This search could be avoided if we would eagerly set the 'reason'
    // boolean flag of clauses, which however we do not want to do for
    // binary clauses (during propagation) and thus would still require
    // a version of 'protect_reason' for binary clauses during 'reduce'
    // (well binary clauses are not collected during 'reduce', but again
    // this exception from the exception is pretty complex and thus a
    // simply search here is probably easier to understand).
 
    for (const auto &lit : *c) {
      const signed char tmp = val (lit);
      if (tmp < 0)
        continue;
      if (tmp > 0 && var (lit).reason == c)
        forced = lit;
      break;
    }
    if (forced) {
      LOG ("clause is reason forcing %d", forced);
      CADICAL_assert (var (forced).level);
      backtrack_without_updating_phases (var (forced).level - 1);
    }
 
    // As long the (remaining) literals of the sorted clause match
    // decisions on the trail we just reuse them.
    //
    if (level) {
 
      int l = 1; // This is the decision level we want to reuse.
 
      for (const auto &lit : sorted) {
        CADICAL_assert (!fixed (lit));
        const int decision = control[l].decision;
        if (-lit == decision) {
          LOG ("reusing decision %d at decision level %d", decision, l);
          stats.vivifyreused++;
          if (++l > level)
            break;
        } else {
          LOG ("literal %d does not match decision %d at decision level %d",
               lit, decision, l);
          backtrack_without_updating_phases (l - 1);
          break;
        }
      }
    }
 
    LOG ("reused %d decision levels from %d", level, orig_level);
  }
 
  LOG (sorted, "sorted size %zd probing schedule", sorted.size ());
 
  // Make sure to ignore this clause during propagation.  This is not that
  // easy for binary clauses (NO-BINARY), e.g., ignoring binary clauses,
  // without changing 'propagate'. Actually, we do not want to remove binary
  // clauses which are subsumed.  Those are hyper binary resolvents and
  // should be kept as learned clauses instead, unless they are transitive
  // in the binary implication graph, which in turn is detected during
  // transitive reduction in 'transred'.
  //
  ignore = c;
 
  int subsume = 0; // determined to be redundant / subsumed
 
  // If the candidate is redundant, i.e., we are in redundant mode, the
  // clause is subsumed (in one of the two cases below where 'subsume' is
  // assigned) and further all reasons involved are only binary clauses,
  // then this redundant clause is what we once called a hidden tautology,
  // and even for redundant clauses it makes sense to remove the candidate.
  // It does not add anything to propagation power of the formula.  This is
  // the same argument as removing transitive clauses in the binary
  // implication graph during transitive reduction.
  //
 
  // Go over the literals in the candidate clause in sorted order.
  //
  for (const auto &lit : sorted) {
 
    // Exit loop as soon a literal is positively implied (case '@5' below)
    // or propagation of the negation of a literal fails ('@6').
    //
    if (subsume)
      break;
 
    // We keep on assigning literals, even though we know already that we
    // can remove one (was negatively implied), since we either might run
    // into the 'subsume' case above or more false literals become implied.
    // In any case this might result in stronger vivified clauses.  As a
    // consequence continue with this loop even if 'remove' is non-zero.
 
    const signed char tmp = val (lit);
 
    if (tmp) { // literal already assigned
 
      const Var &v = var (lit);
      CADICAL_assert (v.level);
      if (!v.reason) {
        LOG ("skipping decision %d", lit);
        continue;
      }
 
      if (tmp < 0) {
        CADICAL_assert (v.level);
        LOG ("literal %d is already false and can be removed", lit);
        continue;
      }
 
      CADICAL_assert (tmp > 0);
      LOG ("subsumed since literal %d already true", lit);
      subsume = lit; // will be able to subsume candidate '@5'
      break;
    }
 
    CADICAL_assert (!tmp);
 
    stats.vivifydecs++;
    vivify_assume (-lit);
    LOG ("negated decision %d score %" PRId64 "", lit, noccs (lit));
 
    if (!vivify_propagate (ticks)) {
      break; // hot-spot
    }
  }
 
  if (subsume) {
    int better_subsume_trail = var (subsume).trail;
    for (auto lit : sorted) {
      if (val (lit) <= 0)
        continue;
      const Var v = var (lit);
      if (v.trail < better_subsume_trail) {
        LOG ("improving subsume from %d at %d to %d at %d", subsume,
             better_subsume_trail, lit, v.trail);
        better_subsume_trail = v.trail;
        subsume = lit;
      }
    }
  }
 
  Clause *subsuming = nullptr;
  bool redundant = false;
  const int level_after_assumptions = level;
  CADICAL_assert (level_after_assumptions);
  vivify_deduce (c, conflict, subsume, &subsuming, redundant);
 
  bool res;
 
  // reverse lrat_chain. We could probably work with reversed iterators
  // (views) to be more efficient but we would have to distinguish in proof
  //
  if (lrat) {
    for (auto id : unit_chain)
      lrat_chain.push_back (id);
    unit_chain.clear ();
    reverse (lrat_chain.begin (), lrat_chain.end ());
  }
 
  if (subsuming) {
    CADICAL_assert (c != subsuming);
    LOG (c, "deleting subsumed clause");
    if (c->redundant && subsuming->redundant && c->glue < subsuming->glue) {
      promote_clause (c, c->glue);
    }
    vivify_subsume_clause (subsuming, c);
    res = false;
    // stats.vivifysubs++;  // already done in vivify_subsume_clause
  } else if (vivify_shrinkable (sorted, conflict)) {
    vivify_increment_stats (vivifier);
    LOG ("vivify succeeded, learning new clause");
    clear_analyzed_literals ();
    LOG (lrat_chain, "lrat");
    LOG (clause, "learning clause");
    conflict = nullptr; // TODO dup from below
    vivify_strengthen (c);
    res = true;
  } else if (subsume && c->redundant) {
    LOG (c, "vivification implied");
    mark_garbage (c);
    ++stats.vivifyimplied;
    res = true;
  } else if ((conflict || subsume) && !c->redundant && !redundant) {
    LOG ("demote clause from irredundant to redundant");
    if (opts.vivifydemote) {
      demote_clause (c);
      const int new_glue = recompute_glue (c);
      promote_clause (c, new_glue);
      res = false;
    } else {
      mark_garbage (c);
      ++stats.vivifyimplied;
      res = true;
    }
  } else if (subsume) {
    LOG (c, "no vivification instantiation with implied literal %d",
         subsume);
    CADICAL_assert (!c->redundant);
    CADICAL_assert (redundant);
    res = false;
    ++stats.vivifyimplied;
  } else {
    CADICAL_assert (level > 2);
    CADICAL_assert ((size_t) level == sorted.size ());
    LOG (c, "vivification failed on");
    lrat_chain.clear ();
    CADICAL_assert (!subsume);
    if (!subsume && opts.vivifyinst) {
      res = vivify_instantiate (sorted, c, lrat_stack, ticks);
      CADICAL_assert (!conflict);
    } else {
      LOG ("cannot apply instantiation");
      res = false;
    }
  }
 
  if (conflict && level == level_after_assumptions) {
    LOG ("forcing backtracking at least one level after conflict");
    backtrack_without_updating_phases (level - 1);
  }
 
  clause.clear ();
  clear_analyzed_literals (); // TODO why needed?
  lrat_chain.clear ();
  conflict = nullptr;
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_deduce()

void CaDiCaL::Internal::vivify_deduce	(	Clause *	candidate,
		Clause *	conflct,
		int	implied,
		Clause **	subsuming,
		bool &	redundant )

Definition at line 743 of file cadical_vivify.cpp.

                                               {
  CADICAL_assert (lrat_chain.empty ());
  bool subsumes;
  Clause *reason;
 
  CADICAL_assert (clause.empty ());
  if (implied) {
    reason = candidate;
    mark2 (candidate);
    const int not_implied = -implied;
    CADICAL_assert (var (not_implied).level);
    Flags &f = flags (not_implied);
    f.seen = true;
    LOG ("pushing implied lit %d", not_implied);
    analyzed.push_back (not_implied);
    clause.push_back (implied);
  } else {
    reason = (conflict ? conflict : candidate);
    CADICAL_assert (reason);
    CADICAL_assert (!reason->garbage);
    mark2 (candidate);
    subsumes = (candidate != reason);
    redundant = reason->redundant;
    LOG (reason, "resolving with");
    if (lrat)
      lrat_chain.push_back (reason->id);
    for (auto lit : *reason) {
      const Var &v = var (lit);
      Flags &f = flags (lit);
      CADICAL_assert (val (lit) < 0);
      if (!v.level) {
        if (!lrat)
          continue;
        LOG ("adding unit %d", lit);
        if (!f.seen) {
          // nevertheless we can use var (l) as if l was still assigned
          // because var is updated lazily
          int64_t id = unit_id (-lit);
          LOG ("adding unit reason %zd for %d", id, lit);
          unit_chain.push_back (id);
        }
        f.seen = true;
        analyzed.push_back (lit);
        continue;
      }
      CADICAL_assert (v.level);
      if (!marked2 (lit)) {
        LOG ("lit %d is not marked", lit);
        subsumes = false;
      }
      LOG ("analyzing lit %d", lit);
      LOG ("pushing lit %d", lit);
      analyzed.push_back (lit);
      f.seen = true;
    }
    if (reason != candidate && reason->redundant) {
      const int new_glue = recompute_glue (reason);
      promote_clause (reason, new_glue);
    }
    if (subsumes) {
      CADICAL_assert (candidate != reason);
#ifndef CADICAL_NDEBUG
      int nonfalse_reason = 0;
      for (auto lit : *reason)
        if (!fixed (lit))
          ++nonfalse_reason;
 
      int nonfalse_candidate = 0;
      for (auto lit : *candidate)
        if (!fixed (lit))
          ++nonfalse_candidate;
 
      CADICAL_assert (nonfalse_reason <= nonfalse_candidate);
#endif
      LOG (candidate, "vivify subsumed 0");
      LOG (reason, "vivify subsuming 0");
      *subsuming = reason;
      unmark (candidate);
      if (lrat)
        lrat_chain.clear ();
      return;
    }
  }
 
  vivify_analyze (reason, subsumes, subsuming, candidate, implied,
                  redundant);
  unmark (candidate);
  if (subsumes) {
    CADICAL_assert (*subsuming);
    LOG (candidate, "vivify subsumed");
    LOG (*subsuming, "vivify subsuming");
    if (lrat)
      lrat_chain.clear ();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_increment_stats()

void CaDiCaL::Internal::vivify_increment_stats ( const Vivifier & vivifier )

inline

Definition at line 880 of file cadical_vivify.cpp.

                                                                      {
  switch (vivifier.tier) {
  case Vivify_Mode::TIER1:
    ++stats.vivifystred1;
    break;
  case Vivify_Mode::TIER2:
    ++stats.vivifystred2;
    break;
  case Vivify_Mode::TIER3:
    ++stats.vivifystred3;
    break;
  default:
    CADICAL_assert (vivifier.tier == Vivify_Mode::IRREDUNDANT);
    ++stats.vivifystrirr;
    break;
  }
}

Here is the caller graph for this function:

◆ vivify_initialize()

void CaDiCaL::Internal::vivify_initialize	(	Vivifier &	vivifier,
		int64_t &	ticks )

Definition at line 1397 of file cadical_vivify.cpp.

                                                                    {
 
  const int tier1 = vivifier.tier1_limit;
  const int tier2 = vivifier.tier2_limit;
  // Count the number of occurrences of literals in all clauses,
  // particularly binary clauses, which are usually responsible
  // for most of the propagations.
  //
  init_noccs ();
 
  // Disconnect all watches since we sort literals within clauses.
  //
  CADICAL_assert (watching ());
#if 0
  clear_watches ();
#endif
 
  size_t prioritized_irred = 0, prioritized_tier1 = 0,
         prioritized_tier2 = 0, prioritized_tier3 = 0;
  for (const auto &c : clauses) {
    ++ticks;
    if (c->size == 2)
      continue; // see also (NO-BINARY) above
    if (!consider_to_vivify_clause (c))
      continue;
 
    // This computes an approximation of the Jeroslow Wang heuristic
    // score
    //
    //       nocc (L) =     sum       2^(12-|C|)
    //                   L in C in F
    //
    // but we cap the size at 12, that is all clauses of size 12 and
    // larger contribute '1' to the score, which allows us to use 'long'
    // numbers. See the example above (search for '@1').
    //
    const int shift = 12 - c->size;
    const int64_t score = shift < 1 ? 1 : (1l << shift); // @4
    for (const auto lit : *c) {
      noccs (lit) += score;
    }
    LOG (c, "putting clause in candidates");
    if (!c->redundant)
      vivifier.schedule_irred.push_back (c),
          prioritized_irred += (c->vivify);
    else if (c->glue <= tier1)
      vivifier.schedule_tier1.push_back (c),
          prioritized_tier1 += (c->vivify);
    else if (c->glue <= tier2)
      vivifier.schedule_tier2.push_back (c),
          prioritized_tier2 += (c->vivify);
    else
      vivifier.schedule_tier3.push_back (c),
          prioritized_tier3 += (c->vivify);
    ++ticks;
  }
 
  vivify_prioritize_leftovers ('x', prioritized_irred,
                               vivifier.schedule_irred);
  vivify_prioritize_leftovers ('u', prioritized_tier1,
                               vivifier.schedule_tier1);
  vivify_prioritize_leftovers ('v', prioritized_tier2,
                               vivifier.schedule_tier2);
  vivify_prioritize_leftovers ('w', prioritized_tier3,
                               vivifier.schedule_tier3);
 
  if (opts.vivifyflush) {
    clear_watches ();
    for (auto &sched : vivifier.schedules) {
      for (const auto &c : sched) {
        // Literals in scheduled clauses are sorted with their highest score
        // literals first (as explained above in the example at '@2').  This
        // is also needed in the prefix subsumption checking below. We do an
        // approximation below that is done only in the vivify_ref structure
        // below.
        //
        sort (c->begin (), c->end (), vivify_more_noccs (this));
      }
      // Flush clauses subsumed by another clause with the same prefix,
      // which also includes flushing syntactically identical clauses.
      //
      flush_vivification_schedule (sched, ticks);
    }
    connect_watches (); // watch all relevant clauses
  }
#if 0
  connect_watches (); // watch all relevant clauses
  vivify_propagate (ticks);
#endif
  vivify_propagate (ticks);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_instantiate()

bool CaDiCaL::Internal::vivify_instantiate	(	const std::vector< int > &	sorted,
		Clause *	c,
		std::vector< std::tuple< int, Clause *, bool > > &	lrat_stack,
		int64_t &	ticks )

Definition at line 901 of file cadical_vivify.cpp.

                    {
  LOG ("now trying instantiation");
  conflict = nullptr;
  const int lit = sorted.back ();
  LOG ("vivify instantiation");
  CADICAL_assert (!var (lit).reason);
  CADICAL_assert (var (lit).level);
  CADICAL_assert (val (lit));
  backtrack (level - 1);
  CADICAL_assert (val (lit) == 0);
  stats.vivifydecs++;
  vivify_assume (lit);
  bool ok = vivify_propagate (ticks);
  if (!ok) {
    LOG (c, "instantiate success with literal %d in", lit);
    stats.vivifyinst++;
    // strengthen clause
    if (lrat) {
      clear_analyzed_literals ();
      CADICAL_assert (lrat_chain.empty ());
      vivify_build_lrat (0, c, lrat_stack);
      vivify_build_lrat (0, conflict, lrat_stack);
      clear_analyzed_literals ();
    }
    int remove = lit;
    conflict = nullptr;
    unwatch_clause (c);
    backtrack_without_updating_phases (level - 2);
    strengthen_clause (c, remove);
    vivify_sort_watched (c);
    watch_clause (c);
    CADICAL_assert (!conflict);
    return true;
  } else {
    LOG ("vivify instantiation failed");
    return false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_prioritize_leftovers()

void CaDiCaL::Internal::vivify_prioritize_leftovers	(	char	tag,
		size_t	prioritized,
		std::vector< Clause * > &	schedule )

inline

Definition at line 1373 of file cadical_vivify.cpp.

                                                                      {
  if (prioritized) {
    PHASE ("vivify", stats.vivifications,
           "[phase %c] leftovers of %" PRId64 " clause", tag, prioritized);
  } else {
    PHASE ("vivify", stats.vivifications,
           "[phase %c] prioritizing all clause", tag);
    for (auto c : schedule)
      c->vivify = true;
  }
  const size_t max = opts.vivifyschedmax;
  if (schedule.size () > max) {
    if (prioritized) {
      std::partition (begin (schedule), end (schedule),
                      [] (Clause *c) { return c->vivify; });
    }
    schedule.resize (max);
  }
  // let's try to save a bit of memory
  shrink_vector (schedule);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_propagate()

bool CaDiCaL::Internal::vivify_propagate ( int64_t & ticks )

Definition at line 184 of file cadical_vivify.cpp.

                                               {
  require_mode (VIVIFY);
  CADICAL_assert (!unsat);
  START (propagate);
  int64_t before = propagated2 = propagated;
  for (;;) {
    if (propagated2 != trail.size ()) {
      const int lit = -trail[propagated2++];
      LOG ("vivify propagating %d over binary clauses", -lit);
      Watches &ws = watches (lit);
      ticks +=
          1 + cache_lines (ws.size (), sizeof (const_watch_iterator *));
      for (const auto &w : ws) {
        if (!w.binary ())
          continue;
        const signed char b = val (w.blit);
        if (b > 0)
          continue;
        if (b < 0)
          conflict = w.clause; // but continue
        else {
          ticks++;
          build_chain_for_units (w.blit, w.clause, 0);
          vivify_assign (w.blit, w.clause);
          lrat_chain.clear ();
        }
      }
    } else if (!conflict && propagated != trail.size ()) {
      const int lit = -trail[propagated++];
      LOG ("vivify propagating %d over large clauses", -lit);
      Watches &ws = watches (lit);
      const const_watch_iterator eow = ws.end ();
      const_watch_iterator i = ws.begin ();
      ticks += 1 + cache_lines (ws.size (), sizeof (*i));
      watch_iterator j = ws.begin ();
      while (i != eow) {
        const Watch w = *j++ = *i++;
        if (w.binary ())
          continue;
        if (val (w.blit) > 0)
          continue;
        ticks++;
        if (w.clause->garbage) {
          j--;
          continue;
        }
        literal_iterator lits = w.clause->begin ();
        const int other = lits[0] ^ lits[1] ^ lit;
        const signed char u = val (other);
        if (u > 0)
          j[-1].blit = other;
        else {
          const int size = w.clause->size;
          const const_literal_iterator end = lits + size;
          const literal_iterator middle = lits + w.clause->pos;
          literal_iterator k = middle;
          signed char v = -1;
          int r = 0;
          while (k != end && (v = val (r = *k)) < 0)
            k++;
          if (v < 0) {
            k = lits + 2;
            CADICAL_assert (w.clause->pos <= size);
            while (k != middle && (v = val (r = *k)) < 0)
              k++;
          }
          w.clause->pos = k - lits;
          CADICAL_assert (lits + 2 <= k), CADICAL_assert (k <= w.clause->end ());
          if (v > 0)
            j[-1].blit = r;
          else if (!v) {
            LOG (w.clause, "unwatch %d in", r);
            lits[0] = other;
            lits[1] = r;
            *k = lit;
            ticks++;
            watch_literal (r, lit, w.clause);
            j--;
          } else if (!u) {
            if (w.clause == ignore) {
              LOG ("ignoring propagation due to clause to vivify");
              continue;
            }
            ticks++;
            CADICAL_assert (v < 0);
            vivify_chain_for_units (other, w.clause);
            vivify_assign (other, w.clause);
            lrat_chain.clear ();
          } else {
            if (w.clause == ignore) {
              LOG ("ignoring conflict due to clause to vivify");
              continue;
            }
            CADICAL_assert (u < 0);
            CADICAL_assert (v < 0);
            conflict = w.clause;
            break;
          }
        }
      }
      if (j != i) {
        while (i != eow)
          *j++ = *i++;
        ws.resize (j - ws.begin ());
      }
    } else
      break;
  }
  int64_t delta = propagated2 - before;
  stats.propagations.vivify += delta;
  if (conflict)
    LOG (conflict, "conflict");
  STOP (propagate);
  return !conflict;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_round()

void CaDiCaL::Internal::vivify_round	(	Vivifier &	vivifier,
		int64_t	delta )

Definition at line 1576 of file cadical_vivify.cpp.

                                                                    {
 
  if (unsat)
    return;
  if (terminated_asynchronously ())
    return;
 
  PHASE ("vivify", stats.vivifications,
         "starting %c vivification round ticks limit %" PRId64 "",
         vivifier.tag, ticks_limit);
 
  PHASE ("vivify", stats.vivifications,
         "starting %c vivification round ticks limit %" PRId64 "",
         vivifier.tag, ticks_limit);
 
  CADICAL_assert (watching ());
 
  auto &refs_schedule = current_refs_schedule (vivifier);
  auto &schedule = current_schedule (vivifier);
 
  int64_t ticks = 1 + schedule.size ();
 
  // Sort candidates, with first to be tried candidate clause last, i.e.,
  // many occurrences and high score literals) as in the example explained
  // above (search for '@3').
  //
  if (vivifier.tier != Vivify_Mode::IRREDUNDANT ||
      irredundant () / 10 < redundant ()) {
    // Literals in scheduled clauses are sorted with their highest score
    // literals first (as explained above in the example at '@2').  This is
    // also needed in the prefix subsumption checking below. We do an
    // approximation below that is done only in the vivify_ref structure
    // below.
    //
 
    // first build the schedule with vivifier_refs
    auto end_schedule = end (schedule);
    refs_schedule.resize (schedule.size ());
    std::transform (begin (schedule), end_schedule, begin (refs_schedule),
                    [&] (Clause *c) { return create_ref (this, c); });
    // now sort by size
    MSORT (opts.radixsortlim, refs_schedule.begin (), refs_schedule.end (),
           vivify_inversesize_rank (), vivify_inversesize_smaller ());
    // now (stable) sort by number of occurrences
    for (int i = 0; i < COUNTREF_COUNTS; ++i) {
      const int offset = COUNTREF_COUNTS - 1 - i;
      MSORT (opts.radixsortlim, refs_schedule.begin (),
             refs_schedule.end (), vivify_refcount_rank (offset),
             vivify_refcount_smaller (offset));
    }
    // force left-overs at the end
    std::stable_partition (begin (refs_schedule), end (refs_schedule),
                           [] (vivify_ref c) { return !c.vivify; });
    std::transform (begin (refs_schedule), end (refs_schedule),
                    begin (schedule),
                    [] (vivify_ref c) { return c.clause; });
    erase_vector (refs_schedule);
    LOG ("clause after sorting final:");
  } else {
    // skip sorting but still put clauses with the vivify tag at the end to
    // be done first Kissat does this implicitely by going twice over all
    // clauses
    std::stable_partition (begin (schedule), end (schedule),
                           [] (Clause *c) { return !c->vivify; });
  }
 
  // Remember old values of counters to summarize after each round with
  // verbose messages what happened in that round.
  //
  int64_t checked = stats.vivifychecks;
  int64_t subsumed = stats.vivifysubs;
  int64_t strengthened = stats.vivifystrs;
  int64_t units = stats.vivifyunits;
 
  int64_t scheduled = schedule.size ();
  stats.vivifysched += scheduled;
 
  PHASE ("vivify", stats.vivifications,
         "scheduled %" PRId64 " clauses to be vivified %.0f%%", scheduled,
         percent (scheduled, stats.current.irredundant));
 
  // Limit the number of propagations during vivification as in 'probe'.
  //
  const int64_t limit = ticks_limit - stats.ticks.vivify;
  CADICAL_assert (limit >= 0);
 
  // the clauses might still contain set literals, so propagation since the
  // beginning
  propagated2 = propagated = 0;
 
  if (!unsat && !propagate ()) {
    LOG ("propagation after connecting watches in inconsistency");
    learn_empty_clause ();
  }
 
  vivifier.ticks = ticks;
  int retry = 0;
  while (!unsat && !terminated_asynchronously () && !schedule.empty () &&
         vivifier.ticks < limit) {
    Clause *c = schedule.back (); // Next candidate.
    schedule.pop_back ();
    if (vivify_clause (vivifier, c) && !c->garbage && c->size > 2 &&
        retry < opts.vivifyretry) {
      ++retry;
      schedule.push_back (c);
    } else
      retry = 0;
  }
 
  if (level)
    backtrack_without_updating_phases ();
 
  if (!unsat) {
    int64_t still_need_to_be_vivified = schedule.size ();
#if 0
    // in the current round we have new_clauses_to_vivify @ leftovers from previous round There are
    // now two possibilities: (i) we consider all clauses as leftovers, or (ii) only the leftovers
    // from previous round are considered leftovers.
    //
    // CaDiCaL had the first version before. If
    // commented out we go to the second version.
    for (auto c : schedule)
      c->vivify = true;
#elif 1
    // if we have gone through all the leftovers, the current clauses are
    // leftovers for the next round
    if (!schedule.empty () && !schedule.front ()->vivify &&
        schedule.back ()->vivify)
      for (auto c : schedule)
        c->vivify = true;
#else
    // do nothing like in kissat and use the candidates for next time.
#endif
    // Preference clauses scheduled but not vivified yet next time.
    //
    if (still_need_to_be_vivified)
      PHASE ("vivify", stats.vivifications,
             "still need to vivify %" PRId64 " clauses %.02f%% of %" PRId64
             " scheduled",
             still_need_to_be_vivified,
             percent (still_need_to_be_vivified, scheduled), scheduled);
    else {
      PHASE ("vivify", stats.vivifications,
             "no previously not yet vivified clause left");
    }
 
    erase_vector (schedule); // Reclaim  memory early.
  }
 
  if (!unsat) {
 
    // Since redundant clause were disconnected during propagating vivified
    // units in redundant mode, and further irredundant clauses are
    // arbitrarily sorted, we have to propagate all literals again after
    // connecting the first two literals in the clauses, in order to
    // reestablish the watching invariant.
    //
    propagated2 = propagated = 0;
 
    if (!propagate ()) {
      LOG ("propagating vivified units leads to conflict");
      learn_empty_clause ();
    }
  }
 
  checked = stats.vivifychecks - checked;
  subsumed = stats.vivifysubs - subsumed;
  strengthened = stats.vivifystrs - strengthened;
  units = stats.vivifyunits - units;
 
  PHASE ("vivify", stats.vivifications,
         "checked %" PRId64 " clauses %.02f%% of %" PRId64
         " scheduled using %" PRIu64 " ticks",
         checked, percent (checked, scheduled), scheduled, vivifier.ticks);
  if (units)
    PHASE ("vivify", stats.vivifications,
           "found %" PRId64 " units %.02f%% of %" PRId64 " checked", units,
           percent (units, checked), checked);
  if (subsumed)
    PHASE ("vivify", stats.vivifications,
           "subsumed %" PRId64 " clauses %.02f%% of %" PRId64 " checked",
           subsumed, percent (subsumed, checked), checked);
  if (strengthened)
    PHASE ("vivify", stats.vivifications,
           "strengthened %" PRId64 " clauses %.02f%% of %" PRId64
           " checked",
           strengthened, percent (strengthened, checked), checked);
 
  stats.subsumed += subsumed;
  stats.strengthened += strengthened;
  stats.ticks.vivify += vivifier.ticks;
 
  bool unsuccessful = !(subsumed + strengthened + units);
  report (vivifier.tag, unsuccessful);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_shrinkable()

bool CaDiCaL::Internal::vivify_shrinkable	(	const std::vector< int > &	sorted,
		Clause *	c )

Definition at line 842 of file cadical_vivify.cpp.

                                                    {
 
  unsigned count_implied = 0;
  for (auto lit : sorted) {
    const signed char value = val (lit);
    if (!value) {
      LOG ("vivification unassigned %d", lit);
      return true;
    }
    if (value > 0) {
      LOG ("vivification implied satisfied %d", lit);
      if (conflict)
        return true;
      if (count_implied++) {
        LOG ("at least one implied literal with conflict thus shrinking");
        return true;
      }
    } else {
      CADICAL_assert (value < 0);
      const Var &v = var (lit);
      const Flags &f = flags (lit);
      if (!v.level)
        continue;
      if (!f.seen) {
        LOG ("vivification non-analyzed %d", lit);
        return true;
      }
      if (v.reason) {
        LOG ("vivification implied falsified %d", lit);
        return true;
      }
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_sort_watched()

void CaDiCaL::Internal::vivify_sort_watched ( Clause * c )

Definition at line 616 of file cadical_vivify.cpp.

                                             {
 
  sort (c->begin (), c->end (), vivify_better_watch (this));
 
  int new_level = level;
 
  const int lit0 = c->literals[0];
  signed char val0 = val (lit0);
  if (val0 < 0) {
    const int level0 = var (lit0).level;
    LOG ("1st watch %d negative at level %d", lit0, level0);
    new_level = level0 - 1;
  }
 
  const int lit1 = c->literals[1];
  const signed char val1 = val (lit1);
  if (val1 < 0 && !(val0 > 0 && var (lit0).level <= var (lit1).level)) {
    const int level1 = var (lit1).level;
    LOG ("2nd watch %d negative at level %d", lit1, level1);
    new_level = level1 - 1;
  }
 
  CADICAL_assert (new_level >= 0);
  if (new_level < level)
    backtrack (new_level);
 
  CADICAL_assert (val (lit0) >= 0);
  CADICAL_assert (val (lit1) >= 0 || (val (lit0) > 0 && val (lit1) < 0 &&
                              var (lit0).level <= var (lit1).level));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_strengthen()

void CaDiCaL::Internal::vivify_strengthen ( Clause * candidate )

Definition at line 555 of file cadical_vivify.cpp.

                                           {
 
  CADICAL_assert (!clause.empty ());
 
  if (clause.size () == 1) {
 
    backtrack_without_updating_phases ();
    const int unit = clause[0];
    LOG (c, "vivification shrunken to unit %d", unit);
    CADICAL_assert (!val (unit));
    assign_unit (unit);
    // lrat_chain.clear ();   done in search_assign
    stats.vivifyunits++;
 
    bool ok = propagate ();
    if (!ok)
      learn_empty_clause ();
 
  } else {
 
    // See explanation before 'vivify_better_watch' above.
    //
    sort (clause.begin (), clause.end (), vivify_better_watch (this));
 
    int new_level = level;
 
    const int lit0 = clause[0];
    signed char val0 = val (lit0);
    if (val0 < 0) {
      const int level0 = var (lit0).level;
      LOG ("1st watch %d negative at level %d", lit0, level0);
      new_level = level0 - 1;
    }
 
    const int lit1 = clause[1];
    const signed char val1 = val (lit1);
    if (val1 < 0 && !(val0 > 0 && var (lit0).level <= var (lit1).level)) {
      const int level1 = var (lit1).level;
      LOG ("2nd watch %d negative at level %d", lit1, level1);
      new_level = level1 - 1;
    }
 
    CADICAL_assert (new_level >= 0);
    if (new_level < level)
      backtrack (new_level);
 
    CADICAL_assert (val (lit0) >= 0);
    CADICAL_assert (val (lit1) >= 0 || (val (lit0) > 0 && val (lit1) < 0 &&
                                var (lit0).level <= var (lit1).level));
 
    Clause *d = new_clause_as (c);
    LOG (c, "before vivification");
    LOG (d, "after vivification");
    (void) d;
  }
  clause.clear ();
  mark_garbage (c);
  lrat_chain.clear ();
  ++stats.vivifystrs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vivify_subsume_clause()

void CaDiCaL::Internal::vivify_subsume_clause	(	Clause *	subsuming,
		Clause *	subsumed )

inline

Definition at line 53 of file cadical_vivify.cpp.

                                                               {
  stats.subsumed++;
  stats.vivifysubs++;
#ifndef CADICAL_NDEBUG
  CADICAL_assert (subsuming);
  CADICAL_assert (subsumed);
  CADICAL_assert (subsuming != subsumed);
  CADICAL_assert (!subsumed->garbage);
  // size after removeing units;
  int real_size_subsuming = 0, real_size_subsumed = 0;
  for (auto lit : *subsuming) {
    if (!val (lit) || var (lit).level)
      ++real_size_subsuming;
    else
      CADICAL_assert (val (lit) < 0);
  }
  for (auto lit : *subsumed) {
    if (!val (lit) || var (lit).level)
      ++real_size_subsumed;
    else
      CADICAL_assert (val (lit) < 0);
  }
  CADICAL_assert (real_size_subsuming <= real_size_subsumed);
#endif
  LOG (subsumed, "subsumed");
  if (subsumed->redundant) {
    stats.subred++;
    ++stats.vivifysubred;
  } else {
    stats.subirr++;
    ++stats.vivifysubirr;
  }
  if (subsuming->garbage) {
    CADICAL_assert (subsuming->size == 2);
    LOG (subsuming,
         "binary subsuming clause was already deleted, so undeleting");
    subsuming->garbage = false;
    subsuming->glue = 1;
    ++stats.current.total;
    if (subsuming->redundant)
      stats.current.redundant++;
    else
      stats.current.irredundant++, stats.irrlits += subsuming->size;
  }
  if (subsumed->redundant || !subsuming->redundant) {
    mark_garbage (subsumed);
    return;
  }
  LOG ("turning redundant subsuming clause into irredundant clause");
  subsuming->redundant = false;
  if (proof)
    proof->strengthen (subsuming->id);
  mark_garbage (subsumed);
  mark_added (subsuming);
  stats.current.irredundant++;
  stats.added.irredundant++;
  stats.irrlits += subsuming->size;
  CADICAL_assert (stats.current.redundant > 0);
  stats.current.redundant--;
  CADICAL_assert (stats.added.redundant > 0);
  stats.added.redundant--;
  // ... and keep 'stats.added.total'.
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vlit()

unsigned CaDiCaL::Internal::vlit ( int lit ) const

inline

Definition at line 408 of file internal.hpp.

                                {
    return (lit < 0) + 2u * (unsigned) vidx (lit);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ walk()

void CaDiCaL::Internal::walk ( )

Definition at line 696 of file cadical_walk.cpp.

                     {
  START_INNER_WALK ();
  int64_t limit = stats.propagations.search;
  limit *= 1e-3 * opts.walkeffort;
  if (limit < opts.walkmineff)
    limit = opts.walkmineff;
  if (limit > opts.walkmaxeff)
    limit = opts.walkmaxeff;
  (void) walk_round (limit, false);
  STOP_INNER_WALK ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ walk_break_value()

unsigned CaDiCaL::Internal::walk_break_value ( int lit )

Definition at line 117 of file cadical_walk.cpp.

                                            {
 
  require_mode (WALK);
  CADICAL_assert (val (lit) > 0);
 
  unsigned res = 0; // The computed break-count of 'lit'.
 
  for (auto &w : watches (lit)) {
    CADICAL_assert (w.blit != lit);
    if (val (w.blit) > 0)
      continue;
    if (w.binary ()) {
      res++;
      continue;
    }
 
    Clause *c = w.clause;
    CADICAL_assert (lit == c->literals[0]);
 
    // Now try to find a second satisfied literal starting at 'literals[1]'
    // shifting all the traversed literals to right by one position in order
    // to move such a second satisfying literal to 'literals[1]'.  This move
    // to front strategy improves the chances to find the second satisfying
    // literal earlier in subsequent break-count computations.
    //
    auto begin = c->begin () + 1;
    const auto end = c->end ();
    auto i = begin;
    int prev = 0;
    while (i != end) {
      const int other = *i;
      *i++ = prev;
      prev = other;
      if (val (other) < 0)
        continue;
 
      // Found 'other' as second satisfying literal.
 
      w.blit = other; // Update 'blit'
      *begin = other; // and move to front.
 
      break;
    }
 
    if (i != end)
      continue; // Double satisfied!
 
    // Otherwise restore literals (undo shift to the right).
    //
    while (i != begin) {
      const int other = *--i;
      *i = prev;
      prev = other;
    }
 
    res++; // Literal 'lit' single satisfies clause 'c'.
  }
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ walk_flip_lit()

void CaDiCaL::Internal::walk_flip_lit	(	Walker &	walker,
		int	lit )

Definition at line 244 of file cadical_walk.cpp.

                                                     {
 
  require_mode (WALK);
  LOG ("flipping assign %d", lit);
  CADICAL_assert (val (lit) < 0);
 
  // First flip the literal value.
  //
  const int tmp = sign (lit);
  const int idx = abs (lit);
  set_val (idx, tmp);
  CADICAL_assert (val (lit) > 0);
 
  // Then remove 'c' and all other now satisfied (made) clauses.
  {
    // Simply go over all unsatisfied (broken) clauses.
 
    LOG ("trying to make %zd broken clauses", walker.broken.size ());
 
    // We need to measure (and bound) the memory accesses during traversing
    // broken clauses in terms of 'propagations'. This is tricky since we
    // are not actually propagating literals.  Instead we use the clause
    // variable 'ratio' as an approximation to the number of clauses used
    // during propagating a literal.  Note that we use a one-watch scheme.
    // Accordingly the number of broken clauses traversed divided by that
    // ratio is an approximation of the number of propagation this would
    // correspond to (in terms of memory access).  To eagerly update these
    // statistics we simply increment the propagation counter after every
    // 'ratio' traversed clause.  These propagations are particularly
    // expensive if the number of broken clauses is large which usually
    // happens initially.
    //
    const double ratio = clause_variable_ratio ();
    const auto eou = walker.broken.end ();
    auto j = walker.broken.begin (), i = j;
#ifdef LOGGING
    int64_t made = 0;
#endif
    int64_t count = 0;
 
    while (i != eou) {
 
      Clause *d = *j++ = *i++;
 
      int *literals = d->literals, prev = 0;
 
      // Find 'lit' in 'd'.
      //
      const int size = d->size;
      for (int i = 0; i < size; i++) {
        const int other = literals[i];
        CADICAL_assert (active (other));
        literals[i] = prev;
        prev = other;
        if (other == lit)
          break;
        CADICAL_assert (val (other) < 0);
      }
 
      // If 'lit' is in 'd' then move it to the front to watch it.
      //
      if (prev == lit) {
        literals[0] = lit;
        LOG (d, "made");
        watch_literal (literals[0], literals[1], d);
#ifdef LOGGING
        made++;
#endif
        j--;
 
      } else { // Otherwise the clause is not satisfied, undo shift.
 
        for (int i = size - 1; i >= 0; i--) {
          int other = literals[i];
          literals[i] = prev;
          prev = other;
        }
      }
 
      if (count--)
        continue;
 
      // Update these counters eagerly.  Otherwise if we delay the update
      // until all clauses are traversed, interrupting the solver has a high
      // chance of giving bogus statistics on the number of 'propagations'
      // in 'walk', if it is interrupted in this loop.
 
      count = ratio; // Starting counting down again.
      walker.propagations++;
      stats.propagations.walk++;
    }
    LOG ("made %" PRId64 " clauses by flipping %d", made, lit);
    walker.broken.resize (j - walker.broken.begin ());
  }
 
  // Finally add all new unsatisfied (broken) clauses.
  {
    walker.propagations++;     // This really corresponds now to one
    stats.propagations.walk++; // propagation (in a one-watch scheme).
 
#ifdef LOGGING
    int64_t broken = 0;
#endif
    Watches &ws = watches (-lit);
 
    LOG ("trying to break %zd watched clauses", ws.size ());
 
    for (const auto &w : ws) {
      Clause *d = w.clause;
      LOG (d, "unwatch %d in", -lit);
      int *literals = d->literals, replacement = 0, prev = -lit;
      CADICAL_assert (literals[0] == -lit);
      const int size = d->size;
      for (int i = 1; i < size; i++) {
        const int other = literals[i];
        CADICAL_assert (active (other));
        literals[i] = prev; // shift all to right
        prev = other;
        const signed char tmp = val (other);
        if (tmp < 0)
          continue;
        replacement = other; // satisfying literal
        break;
      }
      if (replacement) {
        literals[1] = -lit;
        literals[0] = replacement;
        CADICAL_assert (-lit != replacement);
        watch_literal (replacement, -lit, d);
      } else {
        for (int i = size - 1; i > 0; i--) { // undo shift
          const int other = literals[i];
          literals[i] = prev;
          prev = other;
        }
        CADICAL_assert (literals[0] == -lit);
        LOG (d, "broken");
        walker.broken.push_back (d);
#ifdef LOGGING
        broken++;
#endif
      }
    }
    LOG ("broken %" PRId64 " clauses by flipping %d", broken, lit);
    ws.clear ();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ walk_pick_clause()

Clause * CaDiCaL::Internal::walk_pick_clause ( Walker & walker )

Definition at line 100 of file cadical_walk.cpp.

                                                  {
  require_mode (WALK);
  CADICAL_assert (!walker.broken.empty ());
  int64_t size = walker.broken.size ();
  if (size > INT_MAX)
    size = INT_MAX;
  int pos = walker.random.pick_int (0, size - 1);
  Clause *res = walker.broken[pos];
  LOG (res, "picking random position %d", pos);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ walk_pick_lit()

int CaDiCaL::Internal::walk_pick_lit	(	Walker &	walker,
		Clause *	c )

Definition at line 191 of file cadical_walk.cpp.

                                                      {
  LOG ("picking literal by break-count");
  CADICAL_assert (walker.scores.empty ());
  double sum = 0;
  int64_t propagations = 0;
  for (const auto lit : *c) {
    CADICAL_assert (active (lit));
    if (var (lit).level == 1) {
      LOG ("skipping assumption %d for scoring", -lit);
      continue;
    }
    CADICAL_assert (active (lit));
    propagations++;
    unsigned tmp = walk_break_value (-lit);
    double score = walker.score (tmp);
    LOG ("literal %d break-count %u score %g", lit, tmp, score);
    walker.scores.push_back (score);
    sum += score;
  }
  LOG ("scored %zd literals", walker.scores.size ());
  CADICAL_assert (!walker.scores.empty ());
  walker.propagations += propagations;
  stats.propagations.walk += propagations;
  CADICAL_assert (walker.scores.size () <= (size_t) c->size);
  const double lim = sum * walker.random.generate_double ();
  LOG ("score sum %g limit %g", sum, lim);
  const auto end = c->end ();
  auto i = c->begin ();
  auto j = walker.scores.begin ();
  int res;
  for (;;) {
    CADICAL_assert (i != end);
    res = *i++;
    if (var (res).level > 1)
      break;
    LOG ("skipping assumption %d without score", -res);
  }
  sum = *j++;
  while (sum <= lim && i != end) {
    res = *i++;
    if (var (res).level == 1) {
      LOG ("skipping assumption %d without score", -res);
      continue;
    }
    sum += *j++;
  }
  walker.scores.clear ();
  LOG ("picking literal %d by break-count", res);
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ walk_round()

int CaDiCaL::Internal::walk_round	(	int64_t	limit,
		bool	prev )

Definition at line 411 of file cadical_walk.cpp.

                                                  {
 
  backtrack ();
  if (propagated < trail.size () && !propagate ()) {
    LOG ("empty clause after root level propagation");
    learn_empty_clause ();
    return 20;
  }
 
  stats.walk.count++;
 
  clear_watches ();
 
  // Remove all fixed variables first (assigned at decision level zero).
  //
  if (last.collect.fixed < stats.all.fixed)
    garbage_collection ();
 
#ifndef CADICAL_QUIET
  // We want to see more messages during initial local search.
  //
  if (localsearching) {
    CADICAL_assert (!force_phase_messages);
    force_phase_messages = true;
  }
#endif
 
  PHASE ("walk", stats.walk.count,
         "random walk limit of %" PRId64 " propagations", limit);
 
  // First compute the average clause size for picking the CB constant.
  //
  double size = 0;
  int64_t n = 0;
  for (const auto c : clauses) {
    if (c->garbage)
      continue;
    if (c->redundant) {
      if (!opts.walkredundant)
        continue;
      if (!likely_to_be_kept_clause (c))
        continue;
    }
    size += c->size;
    n++;
  }
  double average_size = relative (size, n);
 
  PHASE ("walk", stats.walk.count,
         "%" PRId64 " clauses average size %.2f over %d variables", n,
         average_size, active ());
 
  // Instantiate data structures for this local search round.
  //
  Walker walker (internal, average_size, limit);
 
  bool failed = false; // Inconsistent assumptions?
 
  level = 1; // Assumed variables assigned at level 1.
 
  if (assumptions.empty ()) {
    LOG ("no assumptions so assigning all variables to decision phase");
  } else {
    LOG ("assigning assumptions to their forced phase first");
    for (const auto lit : assumptions) {
      signed char tmp = val (lit);
      if (tmp > 0)
        continue;
      if (tmp < 0) {
        LOG ("inconsistent assumption %d", lit);
        failed = true;
        break;
      }
      if (!active (lit))
        continue;
      tmp = sign (lit);
      const int idx = abs (lit);
      LOG ("initial assign %d to assumption phase", tmp < 0 ? -idx : idx);
      set_val (idx, tmp);
      CADICAL_assert (level == 1);
      var (idx).level = 1;
    }
    if (!failed)
      LOG ("now assigning remaining variables to their decision phase");
  }
 
  level = 2; // All other non assumed variables assigned at level 2.
 
  if (!failed) {
 
    for (auto idx : vars) {
      if (!active (idx)) {
        LOG ("skipping inactive variable %d", idx);
        continue;
      }
      if (vals[idx]) {
        CADICAL_assert (var (idx).level == 1);
        LOG ("skipping assumed variable %d", idx);
        continue;
      }
      int tmp = 0;
      if (prev)
        tmp = phases.prev[idx];
      if (!tmp)
        tmp = sign (decide_phase (idx, true));
      CADICAL_assert (tmp == 1 || tmp == -1);
      set_val (idx, tmp);
      CADICAL_assert (level == 2);
      var (idx).level = 2;
      LOG ("initial assign %d to decision phase", tmp < 0 ? -idx : idx);
    }
 
    LOG ("watching satisfied and registering broken clauses");
#ifdef LOGGING
    int64_t watched = 0;
#endif
    for (const auto c : clauses) {
 
      if (c->garbage)
        continue;
      if (c->redundant) {
        if (!opts.walkredundant)
          continue;
        if (!likely_to_be_kept_clause (c))
          continue;
      }
 
      bool satisfiable = false; // contains not only assumptions
      int satisfied = 0;        // clause satisfied?
 
      int *lits = c->literals;
      const int size = c->size;
 
      // Move to front satisfied literals and determine whether there
      // is at least one (non-assumed) literal that can be flipped.
      //
      for (int i = 0; satisfied < 2 && i < size; i++) {
        const int lit = lits[i];
        CADICAL_assert (active (lit)); // Due to garbage collection.
        if (val (lit) > 0) {
          swap (lits[satisfied], lits[i]);
          if (!satisfied++)
            LOG ("first satisfying literal %d", lit);
        } else if (!satisfiable && var (lit).level > 1) {
          LOG ("non-assumption potentially satisfying literal %d", lit);
          satisfiable = true;
        }
      }
 
      if (!satisfied && !satisfiable) {
        LOG (c, "due to assumptions unsatisfiable");
        LOG ("stopping local search since assumptions falsify a clause");
        failed = true;
        break;
      }
 
      if (satisfied) {
        watch_literal (lits[0], lits[1], c);
#ifdef LOGGING
        watched++;
#endif
      } else {
        CADICAL_assert (satisfiable); // at least one non-assumed variable ...
        LOG (c, "broken");
        walker.broken.push_back (c);
      }
    }
#ifdef LOGGING
    if (!failed) {
      int64_t broken = walker.broken.size ();
      int64_t total = watched + broken;
      LOG ("watching %" PRId64 " clauses %.0f%% "
           "out of %" PRId64 " (watched and broken)",
           watched, percent (watched, total), total);
    }
#endif
  }
 
  int64_t old_global_minimum = stats.walk.minimum;
 
  int res; // Tells caller to continue with local search.
 
  if (!failed) {
 
    int64_t broken = walker.broken.size ();
 
    PHASE ("walk", stats.walk.count,
           "starting with %" PRId64 " unsatisfied clauses "
           "(%.0f%% out of %" PRId64 ")",
           broken, percent (broken, stats.current.irredundant),
           stats.current.irredundant);
 
    walk_save_minimum (walker);
 
    int64_t minimum = broken;
#ifndef CADICAL_QUIET
    int64_t flips = 0;
#endif
    while (!terminated_asynchronously () && !walker.broken.empty () &&
           walker.propagations < walker.limit) {
#ifndef CADICAL_QUIET
      flips++;
#endif
      stats.walk.flips++;
      stats.walk.broken += broken;
      Clause *c = walk_pick_clause (walker);
      const int lit = walk_pick_lit (walker, c);
      walk_flip_lit (walker, lit);
      broken = walker.broken.size ();
      LOG ("now have %" PRId64 " broken clauses in total", broken);
      if (broken >= minimum)
        continue;
      minimum = broken;
      VERBOSE (3, "new phase minimum %" PRId64 " after %" PRId64 " flips",
               minimum, flips);
      walk_save_minimum (walker);
    }
 
    if (minimum < old_global_minimum)
      PHASE ("walk", stats.walk.count,
             "%snew global minimum %" PRId64 "%s in %" PRId64 " flips and "
             "%" PRId64 " propagations",
             tout.bright_yellow_code (), minimum, tout.normal_code (),
             flips, walker.propagations);
    else
      PHASE ("walk", stats.walk.count,
             "best phase minimum %" PRId64 " in %" PRId64 " flips and "
             "%" PRId64 " propagations",
             minimum, flips, walker.propagations);
 
    if (opts.profile >= 2) {
      PHASE ("walk", stats.walk.count,
             "%.2f million propagations per second",
             relative (1e-6 * walker.propagations,
                       time () - profiles.walk.started));
 
      PHASE ("walk", stats.walk.count, "%.2f thousand flips per second",
             relative (1e-3 * flips, time () - profiles.walk.started));
 
    } else {
      PHASE ("walk", stats.walk.count, "%.2f million propagations",
             1e-6 * walker.propagations);
 
      PHASE ("walk", stats.walk.count, "%.2f thousand flips", 1e-3 * flips);
    }
 
    if (minimum > 0) {
      LOG ("minimum %" PRId64 " non-zero thus potentially continue",
           minimum);
      res = 0;
    } else {
      LOG ("minimum is zero thus stop local search");
      res = 10;
    }
 
  } else {
 
    res = 20;
 
    PHASE ("walk", stats.walk.count,
           "aborted due to inconsistent assumptions");
  }
 
  copy_phases (phases.prev);
 
  for (auto idx : vars)
    if (active (idx))
      set_val (idx, 0);
 
  CADICAL_assert (level == 2);
  level = 0;
 
  clear_watches ();
  connect_watches ();
 
#ifndef CADICAL_QUIET
  if (localsearching) {
    CADICAL_assert (force_phase_messages);
    force_phase_messages = false;
  }
#endif
 
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ walk_save_minimum()

void CaDiCaL::Internal::walk_save_minimum ( Walker & walker )

inline

Definition at line 396 of file cadical_walk.cpp.

                                                       {
  int64_t broken = walker.broken.size ();
  if (broken >= stats.walk.minimum)
    return;
  VERBOSE (3, "new global minimum %" PRId64 "", broken);
  stats.walk.minimum = broken;
  for (auto i : vars) {
    const signed char tmp = vals[i];
    if (tmp)
      phases.min[i] = phases.saved[i] = tmp;
  }
}

Here is the caller graph for this function:

◆ warning()

void CaDiCaL::Internal::warning	(	const char *	fmt,
			... )

Definition at line 140 of file cadical_message.cpp.

                                            {
  fflush (stdout);
  terr.bold ();
  fputs ("cadical: ", stderr);
  terr.red (1);
  fputs ("warning:", stderr);
  terr.normal ();
  fputc (' ', stderr);
  va_list ap;
  va_start (ap, fmt);
  vfprintf (stderr, fmt, ap);
  va_end (ap);
  fputc ('\n', stderr);
  fflush (stderr);
}

◆ watch_clause()

void CaDiCaL::Internal::watch_clause ( Clause * c )

inline

Definition at line 633 of file internal.hpp.

                                       {
    const int l0 = c->literals[0];
    const int l1 = c->literals[1];
    watch_literal (l0, l1, c);
    watch_literal (l1, l0, c);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ watch_literal()

void CaDiCaL::Internal::watch_literal	(	int	lit,
		int	blit,
		Clause *	c )

inline

Definition at line 623 of file internal.hpp.

                                                           {
    CADICAL_assert (lit != blit);
    Watches &ws = watches (lit);
    ws.push_back (Watch (blit, c));
    LOG (c, "watch %d blit %d in", lit, blit);
  }

Here is the caller graph for this function:

◆ watches()

Watches & CaDiCaL::Internal::watches ( int lit )

inline

Definition at line 467 of file internal.hpp.

467{ return wtab[vlit (lit)]; }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ watching()

bool CaDiCaL::Internal::watching ( ) const

inline

Definition at line 462 of file internal.hpp.

462{ return !wtab.empty (); }

Here is the caller graph for this function:

◆ wrapped_learn_external_reason_clause()

Clause * CaDiCaL::Internal::wrapped_learn_external_reason_clause ( int lit )

Definition at line 715 of file cadical_external_propagate.cpp.

                                                                {
  Clause *res;
  std::vector<int64_t> chain_tmp{std::move (lrat_chain)};
  lrat_chain.clear ();
  if (clause.empty ()) {
    res = learn_external_reason_clause (ilit, 0, true);
  } else {
    std::vector<int> clause_tmp{std::move (clause)};
    clause.clear ();
    res = learn_external_reason_clause (ilit, 0, true);
    // The learn_external_reason clause can leave a literal in clause when
    // there is a falsified elit arg. Here it is not allowed to
    // happen.
    CADICAL_assert (clause.empty ());
 
    clause = std::move (clause_tmp);
    clause_tmp.clear ();
  }
  CADICAL_assert (lrat_chain.empty ());
  lrat_chain = std::move (chain_tmp);
  chain_tmp.clear ();
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ analyzed

vector<int> CaDiCaL::Internal::analyzed

Definition at line 267 of file internal.hpp.

◆ arena

Arena CaDiCaL::Internal::arena

Definition at line 307 of file internal.hpp.

◆ assumptions

vector<int> CaDiCaL::Internal::assumptions

Definition at line 261 of file internal.hpp.

◆ averages

Averages CaDiCaL::Internal::averages

Definition at line 284 of file internal.hpp.

◆ best_assigned

size_t CaDiCaL::Internal::best_assigned

Definition at line 256 of file internal.hpp.

◆ big

vector<Bins> CaDiCaL::Internal::big

Definition at line 240 of file internal.hpp.

◆ btab

vector<int64_t> CaDiCaL::Internal::btab

Definition at line 234 of file internal.hpp.

◆ citten

cadical_kitten* CaDiCaL::Internal::citten

Definition at line 277 of file internal.hpp.

◆ clause

vector<int> CaDiCaL::Internal::clause

Definition at line 260 of file internal.hpp.

◆ clause_id

int64_t CaDiCaL::Internal::clause_id

Definition at line 201 of file internal.hpp.

◆ clauses

vector<Clause *> CaDiCaL::Internal::clauses

Definition at line 283 of file internal.hpp.

◆ concluded

bool CaDiCaL::Internal::concluded

Definition at line 206 of file internal.hpp.

◆ conclusion

vector<int64_t> CaDiCaL::Internal::conclusion

Definition at line 207 of file internal.hpp.

◆ conflict

Clause* CaDiCaL::Internal::conflict

Definition at line 242 of file internal.hpp.

◆ conflict_id

int64_t CaDiCaL::Internal::conflict_id

Definition at line 204 of file internal.hpp.

◆ congruence_delay

Delay CaDiCaL::Internal::congruence_delay

Definition at line 286 of file internal.hpp.

◆ constraint

vector<int> CaDiCaL::Internal::constraint

Definition at line 262 of file internal.hpp.

◆ control

vector<Level> CaDiCaL::Internal::control

Definition at line 282 of file internal.hpp.

◆ delay

Delay CaDiCaL::Internal::delay[2]

Definition at line 285 of file internal.hpp.

◆ delaying_sweep

Delay CaDiCaL::Internal::delaying_sweep

Definition at line 292 of file internal.hpp.

◆ delaying_vivify_irredundant

Delay CaDiCaL::Internal::delaying_vivify_irredundant

Definition at line 291 of file internal.hpp.

◆ did_external_prop

bool CaDiCaL::Internal::did_external_prop

Definition at line 193 of file internal.hpp.

◆ dummy_binary

Clause* CaDiCaL::Internal::dummy_binary

Definition at line 244 of file internal.hpp.

◆ error_message

Format CaDiCaL::Internal::error_message

Definition at line 308 of file internal.hpp.

◆ ext_clause_forgettable

bool CaDiCaL::Internal::ext_clause_forgettable

Definition at line 249 of file internal.hpp.

◆ external

External* CaDiCaL::Internal::external

Definition at line 312 of file internal.hpp.

◆ external_prop

bool CaDiCaL::Internal::external_prop

Definition at line 192 of file internal.hpp.

◆ external_prop_is_lazy

bool CaDiCaL::Internal::external_prop_is_lazy

Definition at line 194 of file internal.hpp.

◆ external_reason

Clause* CaDiCaL::Internal::external_reason

Definition at line 245 of file internal.hpp.

◆ file_tracers

vector<FileTracer *> CaDiCaL::Internal::file_tracers

Definition at line 298 of file internal.hpp.

◆ force_no_backtrack

bool CaDiCaL::Internal::force_no_backtrack

Definition at line 247 of file internal.hpp.

◆ force_saved_phase

bool CaDiCaL::Internal::force_saved_phase

Definition at line 188 of file internal.hpp.

◆ forced_backt_allowed

bool CaDiCaL::Internal::forced_backt_allowed

Definition at line 195 of file internal.hpp.

◆ frat

bool CaDiCaL::Internal::frat

Definition at line 218 of file internal.hpp.

◆ from_propagator

bool CaDiCaL::Internal::from_propagator

Definition at line 248 of file internal.hpp.

◆ frozentab

vector<unsigned> CaDiCaL::Internal::frozentab

Definition at line 223 of file internal.hpp.

◆ ftab

vector<Flags> CaDiCaL::Internal::ftab

Definition at line 233 of file internal.hpp.

◆ gtab

vector<int64_t> CaDiCaL::Internal::gtab

Definition at line 235 of file internal.hpp.

◆ i2e

vector<int> CaDiCaL::Internal::i2e

Definition at line 224 of file internal.hpp.

◆ ignore

Clause* CaDiCaL::Internal::ignore

Definition at line 243 of file internal.hpp.

◆ inc

Inc CaDiCaL::Internal::inc

Definition at line 289 of file internal.hpp.

◆ inst_chain

vector<Clause *> CaDiCaL::Internal::inst_chain

Definition at line 214 of file internal.hpp.

◆ internal

Internal* CaDiCaL::Internal::internal

Definition at line 311 of file internal.hpp.

◆ iterating

bool CaDiCaL::Internal::iterating

Definition at line 183 of file internal.hpp.

◆ last

Last CaDiCaL::Internal::last

Definition at line 288 of file internal.hpp.

◆ level

int CaDiCaL::Internal::level

Definition at line 219 of file internal.hpp.

◆ levels

vector<int> CaDiCaL::Internal::levels

Definition at line 266 of file internal.hpp.

◆ lim

Limit CaDiCaL::Internal::lim

Definition at line 287 of file internal.hpp.

◆ links

Links CaDiCaL::Internal::links

Definition at line 227 of file internal.hpp.

◆ lits

const Sange CaDiCaL::Internal::lits

Definition at line 325 of file internal.hpp.

◆ localsearching

bool CaDiCaL::Internal::localsearching

Definition at line 184 of file internal.hpp.

◆ lookingahead

bool CaDiCaL::Internal::lookingahead

Definition at line 185 of file internal.hpp.

◆ lrat

bool CaDiCaL::Internal::lrat

Definition at line 217 of file internal.hpp.

◆ lrat_chain

vector<int64_t> CaDiCaL::Internal::lrat_chain

Definition at line 210 of file internal.hpp.

◆ marked_failed

bool CaDiCaL::Internal::marked_failed

Definition at line 264 of file internal.hpp.

◆ marks

vector<signed char> CaDiCaL::Internal::marks

Definition at line 222 of file internal.hpp.

◆ max_used

const unsigned CaDiCaL::Internal::max_used = 255

Definition at line 314 of file internal.hpp.

◆ max_var

int CaDiCaL::Internal::max_var

Definition at line 200 of file internal.hpp.

◆ mini_chain

vector<int64_t> CaDiCaL::Internal::mini_chain

Definition at line 211 of file internal.hpp.

◆ minimize_chain

vector<int64_t> CaDiCaL::Internal::minimize_chain

Definition at line 212 of file internal.hpp.

◆ minimized

vector<int> CaDiCaL::Internal::minimized

Definition at line 270 of file internal.hpp.

◆ mode

int CaDiCaL::Internal::mode

Definition at line 177 of file internal.hpp.

◆ newest_clause

Clause* CaDiCaL::Internal::newest_clause

Definition at line 246 of file internal.hpp.

◆ no_conflict_until

size_t CaDiCaL::Internal::no_conflict_until

Definition at line 258 of file internal.hpp.

◆ notified

size_t CaDiCaL::Internal::notified

Definition at line 251 of file internal.hpp.

◆ ntab

vector<int64_t> CaDiCaL::Internal::ntab

Definition at line 239 of file internal.hpp.

◆ num_assigned

size_t CaDiCaL::Internal::num_assigned

Definition at line 279 of file internal.hpp.

◆ opts

Options CaDiCaL::Internal::opts

Definition at line 301 of file internal.hpp.

◆ original

vector<int> CaDiCaL::Internal::original

Definition at line 265 of file internal.hpp.

◆ original_id

int64_t CaDiCaL::Internal::original_id

Definition at line 202 of file internal.hpp.

◆ otab

vector<Occs> CaDiCaL::Internal::otab

Definition at line 236 of file internal.hpp.

◆ parents

vector<int> CaDiCaL::Internal::parents

Definition at line 232 of file internal.hpp.

◆ phases

Phases CaDiCaL::Internal::phases

Definition at line 220 of file internal.hpp.

◆ prefix

string CaDiCaL::Internal::prefix

Definition at line 309 of file internal.hpp.

◆ preprocessing

bool CaDiCaL::Internal::preprocessing

Definition at line 186 of file internal.hpp.

◆ private_steps

bool CaDiCaL::Internal::private_steps

Definition at line 196 of file internal.hpp.

◆ probe_reason

Clause* CaDiCaL::Internal::probe_reason

Definition at line 252 of file internal.hpp.

◆ probehbr_chains

vector<vector<vector<int64_t> > > CaDiCaL::Internal::probehbr_chains

Definition at line 216 of file internal.hpp.

◆ probes

vector<int> CaDiCaL::Internal::probes

Definition at line 281 of file internal.hpp.

◆ proof

Proof* CaDiCaL::Internal::proof

Definition at line 294 of file internal.hpp.

◆ propagated

size_t CaDiCaL::Internal::propagated

Definition at line 253 of file internal.hpp.

◆ propagated2

size_t CaDiCaL::Internal::propagated2

Definition at line 254 of file internal.hpp.

◆ propergated

size_t CaDiCaL::Internal::propergated

Definition at line 255 of file internal.hpp.

◆ protected_reasons

bool CaDiCaL::Internal::protected_reasons

Definition at line 187 of file internal.hpp.

◆ ptab

vector<int> CaDiCaL::Internal::ptab

Definition at line 238 of file internal.hpp.

◆ queue

Queue CaDiCaL::Internal::queue

Definition at line 226 of file internal.hpp.

◆ reap

Reap CaDiCaL::Internal::reap

Definition at line 272 of file internal.hpp.

◆ relevanttab

vector<unsigned> CaDiCaL::Internal::relevanttab

Definition at line 225 of file internal.hpp.

◆ reluctant

Reluctant CaDiCaL::Internal::reluctant

Definition at line 198 of file internal.hpp.

◆ rephased

char CaDiCaL::Internal::rephased

Definition at line 197 of file internal.hpp.

◆ reported

bool CaDiCaL::Internal::reported

Definition at line 191 of file internal.hpp.

◆ reserved_ids

int64_t CaDiCaL::Internal::reserved_ids

Definition at line 203 of file internal.hpp.

◆ rtab

vector<Occs> CaDiCaL::Internal::rtab

Definition at line 237 of file internal.hpp.

◆ saved_decisions

int64_t CaDiCaL::Internal::saved_decisions

Definition at line 205 of file internal.hpp.

◆ score_inc

double CaDiCaL::Internal::score_inc

Definition at line 228 of file internal.hpp.

◆ scores

ScoreSchedule CaDiCaL::Internal::scores

Definition at line 229 of file internal.hpp.

◆ searching_lucky_phases

bool CaDiCaL::Internal::searching_lucky_phases

Definition at line 189 of file internal.hpp.

◆ shrinkable

vector<int> CaDiCaL::Internal::shrinkable

Definition at line 271 of file internal.hpp.

◆ sign_marked

vector<int> CaDiCaL::Internal::sign_marked

Definition at line 269 of file internal.hpp.

◆ stab

vector<double> CaDiCaL::Internal::stab

Definition at line 230 of file internal.hpp.

◆ stable

bool CaDiCaL::Internal::stable

Definition at line 190 of file internal.hpp.

◆ stat_tracers

vector<StatTracer *> CaDiCaL::Internal::stat_tracers

Definition at line 299 of file internal.hpp.

◆ stats

Stats CaDiCaL::Internal::stats

Definition at line 302 of file internal.hpp.

◆ sweep_incomplete

bool CaDiCaL::Internal::sweep_incomplete

Definition at line 275 of file internal.hpp.

◆ sweep_schedule

vector<int> CaDiCaL::Internal::sweep_schedule

Definition at line 274 of file internal.hpp.

◆ tainted_literal

int CaDiCaL::Internal::tainted_literal

Definition at line 250 of file internal.hpp.

◆ target_assigned

size_t CaDiCaL::Internal::target_assigned

Definition at line 257 of file internal.hpp.

◆ termination_forced

volatile bool CaDiCaL::Internal::termination_forced

Definition at line 320 of file internal.hpp.

◆ tier1

int CaDiCaL::Internal::tier1[2]

Initial value:

= {

2, 2}

Definition at line 178 of file internal.hpp.

178 {

179 2, 2}; // tier1 limit for 0=focused, 1=stable; aka tier1[stable]

◆ tier2

int CaDiCaL::Internal::tier2[2]

Initial value:

= {

6, 6}

Definition at line 180 of file internal.hpp.

180 {

181 6, 6}; // tier2 limit for 0=focused, 1=stable; aka tier1[stable]

◆ tracers

vector<Tracer *> CaDiCaL::Internal::tracers

Definition at line 296 of file internal.hpp.

◆ trail

vector<int> CaDiCaL::Internal::trail

Definition at line 259 of file internal.hpp.

◆ unit_analyzed

vector<int> CaDiCaL::Internal::unit_analyzed

Definition at line 268 of file internal.hpp.

◆ unit_chain

vector<int64_t> CaDiCaL::Internal::unit_chain

Definition at line 213 of file internal.hpp.

◆ unit_clauses_idx

vector<int64_t> CaDiCaL::Internal::unit_clauses_idx

Definition at line 209 of file internal.hpp.

◆ unsat

bool CaDiCaL::Internal::unsat

Definition at line 182 of file internal.hpp.

◆ unsat_constraint

bool CaDiCaL::Internal::unsat_constraint

Definition at line 263 of file internal.hpp.

◆ vals

signed char* CaDiCaL::Internal::vals

Definition at line 221 of file internal.hpp.

◆ vars

const Range CaDiCaL::Internal::vars

Definition at line 324 of file internal.hpp.

◆ vsize

size_t CaDiCaL::Internal::vsize

Definition at line 199 of file internal.hpp.

◆ vtab

vector<Var> CaDiCaL::Internal::vtab

Definition at line 231 of file internal.hpp.

◆ wtab

vector<Watches> CaDiCaL::Internal::wtab

Definition at line 241 of file internal.hpp.

The documentation for this struct was generated from the following files:

src/sat/cadical/internal.hpp
src/sat/cadical/cadical_analyze.cpp
src/sat/cadical/cadical_assume.cpp
src/sat/cadical/cadical_averages.cpp
src/sat/cadical/cadical_backtrack.cpp
src/sat/cadical/cadical_backward.cpp
src/sat/cadical/cadical_bins.cpp
src/sat/cadical/cadical_block.cpp
src/sat/cadical/cadical_clause.cpp
src/sat/cadical/cadical_collect.cpp
src/sat/cadical/cadical_compact.cpp
src/sat/cadical/cadical_condition.cpp
src/sat/cadical/cadical_congruence.cpp
src/sat/cadical/cadical_constrain.cpp
src/sat/cadical/cadical_cover.cpp
src/sat/cadical/cadical_decide.cpp
src/sat/cadical/cadical_decompose.cpp
src/sat/cadical/cadical_deduplicate.cpp
src/sat/cadical/cadical_definition.cpp
src/sat/cadical/cadical_elim.cpp
src/sat/cadical/cadical_elimfast.cpp
src/sat/cadical/cadical_external_propagate.cpp
src/sat/cadical/cadical_factor.cpp
src/sat/cadical/cadical_flags.cpp
src/sat/cadical/cadical_flip.cpp
src/sat/cadical/cadical_gates.cpp
src/sat/cadical/cadical_instantiate.cpp
src/sat/cadical/cadical_internal.cpp
src/sat/cadical/cadical_limit.cpp
src/sat/cadical/cadical_lookahead.cpp
src/sat/cadical/cadical_lucky.cpp
src/sat/cadical/cadical_message.cpp
src/sat/cadical/cadical_minimize.cpp
src/sat/cadical/cadical_occs.cpp
src/sat/cadical/cadical_phases.cpp
src/sat/cadical/cadical_probe.cpp
src/sat/cadical/cadical_proof.cpp
src/sat/cadical/cadical_propagate.cpp
src/sat/cadical/cadical_queue.cpp
src/sat/cadical/cadical_reduce.cpp
src/sat/cadical/cadical_rephase.cpp
src/sat/cadical/cadical_report.cpp
src/sat/cadical/cadical_resources.cpp
src/sat/cadical/cadical_restart.cpp
src/sat/cadical/cadical_score.cpp
src/sat/cadical/cadical_shrink.cpp
src/sat/cadical/cadical_stats.cpp
src/sat/cadical/cadical_subsume.cpp
src/sat/cadical/cadical_sweep.cpp
src/sat/cadical/cadical_ternary.cpp
src/sat/cadical/cadical_tier.cpp
src/sat/cadical/cadical_transred.cpp
src/sat/cadical/cadical_var.cpp
src/sat/cadical/cadical_vivify.cpp
src/sat/cadical/cadical_walk.cpp
src/sat/cadical/cadical_watch.cpp

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Enumeration Documentation

◆ Mode

Constructor & Destructor Documentation

◆ Internal()

◆ ~Internal()

Member Function Documentation

◆ active() [1/2]

◆ active() [2/2]

◆ add_core()

◆ add_external_clause()

◆ add_factored_divider()

◆ add_factored_quotient()

◆ add_literal_to_environment()

◆ add_new_original_clause()

◆ add_observed_var()

◆ add_original_lit()

◆ add_self_subsuming_factor()

◆ add_sweep_binary()

◆ already_solved()

◆ analyze()

◆ analyze_literal()

◆ analyze_reason()

◆ apply_factoring()

◆ arenaing()

◆ ask_decision()

◆ ask_external_clause()

◆ assign_original_unit()

◆ assign_unit()

◆ assignment_level()

◆ assume()

◆ assume_analyze_literal()

◆ assume_analyze_reason()

◆ assumed()

◆ asymmetric_literal_addition()

◆ backtrack()

◆ backtrack_without_updating_phases()

◆ backward_false_satisfiable()

◆ backward_true_satisfiable()

◆ best_quotient()

◆ better_decision()

◆ bins()

◆ block()

◆ block_candidates()

◆ block_impossible()

◆ block_literal()

◆ block_literal_with_at_least_two_negative_occs()

◆ block_literal_with_one_negative_occ()

◆ block_pure_literal()

◆ block_reschedule()

◆ block_reschedule_clause()

◆ block_schedule()

◆ blocked_clause()

◆ build_chain_for_empty()

◆ build_chain_for_units()

◆ build_lrat_for_clause()

◆ bump_also_all_reason_literals()

◆ bump_also_reason_literal()

◆ bump_also_reason_literals()

◆ bump_clause()

◆ bump_clause2()

◆ bump_queue()

◆ bump_variable()

◆ bump_variable_score()

◆ bump_variable_score_inc()

◆ bump_variables()

◆ bumped()

◆ cache_lines() [1/2]

◆ cache_lines() [2/2]

◆ cadical_kitten_ticks_limit_hit()

◆ calculate_minimize_chain()

◆ can_sweep_clause()

◆ cdcl_loop_with_inprocessing()

◆ check()

◆ check_clause_stats()

◆ check_var_stats()