cwi:oSrSSKJr SSKJrJrJrJr SSKJ r J r J r J r J r Jr SSKJrJr SSKJr /SQr"S S \5r"S S \5r"S S\S9r\ R0"\ "S5SS9S5r\ R0"\ "S5SS9S5r\ R0"\ "S5SS9S5r\ R0"\ "S5SS9S5r\ R0"\ "S5SS9S5r\ R0"\ "S5SS9S5r\ R0"\ "S5SS9S5r\ R0"\ "S5S S9S!5r \ R0"\ "S5S"S9S#5r!\ R0"\ "S5S$S9S%5r"\ R0"\ "S5S&S9S'5r#\ R0"\ "S5S(S9S)5r$\ R0"\ "S5S*S9S+5r%\ R0"\ "S5S,S9S-5r&\ R0"\ "S5S.S9S/5r'\ R0"\ "S5S0S9S15r(\ R0"\ "S5S2S9S35r)\ R0"\ "S5S4S9S55r*\ R0"\ "S5S6S9S75r+"S8S9\S95r,g:);a( Functions and classes to observe or add ground statements. Examples -------- The following example shows how to add a fact to a program via the backend and observe the corresponding rule passed to the backend: >>> from clingo.symbol import Function >>> from clingo.control import Control >>> >>> class Observer: ... def rule(self, choice, head, body): ... print("rule:", choice, head, body) ... >>> ctl = Control() >>> ctl.register_observer(Observer()) >>> >>> sym_a = Function("a") >>> with ctl.backend() as backend: ... atm_a = backend.add_atom(sym_a) ... backend.add_rule([atm_a]) ... rule: False [1] [] >>> ctl.symbolic_atoms[sym_a].is_fact True >>> >>> print(ctl.solve(on_model=print)) a SAT )ABCMeta)ContextManagerOptionalSequenceTuple)_c_call_cb_error_handler_ffi _handle_error_lib_to_str) OrderedEnum TruthValue)Symbol)Backend HeuristicTypeObserverTheorySequenceTypecd\rSrSrSr\R r\Rr \Rr Sr g)r+/ Enumeration of the different heuristic types. N) __name__ __module__ __qualname____firstlineno____doc__r !clingo_theory_sequence_type_tupler clingo_theory_sequence_type_listListclingo_theory_sequence_type_setSet__static_attributes__rH/home/james-whalen/.local/lib/python3.13/site-packages/clingo/backend.pyrr+s=  2 2E  0 0D  . .Cr%rc\rSrSrSr\R r\Rr \Rr \Rr \Rr\R rSrg)r>rrN)rrrrrr clingo_heuristic_type_factorFactorclingo_heuristic_type_falseFalse_clingo_heuristic_type_initInitclingo_heuristic_type_levelLevelclingo_heuristic_type_signSignclingo_heuristic_type_trueTrue_r$rr%r&rr>ss . .F - -F  * *D  , ,E  * *D  + +Er%rc 8\rSrSrSrS\SS4SjrS4SjrS\S \\ S \\ SS4S jr S\S \\ S \ S \\ \ \ 4SS4 S jr S\ S\\ \ \ 4SS4Sjr S\\ SS4SjrS\S\ SS4SjrS\S\\ SS4SjrS\ S\SS4SjrS\\ SS4SjrS\ S\S\ S\ S\\ SS4 SjrS\ S\ S\\ SS4S jrS!\ S"\ SS4S#jrS!\ S$\SS4S%jrS!\ S&\ S'\\ SS4S(jrS)\ S*\\ S\\ SS4S+jrS,\ S!\ S-\\ SS4S.jrS,\ S!\ S-\\ S/\ S0\ SS4 S1jrS4S2jrS3r g)5r]z Interface that has to be implemented to inspect rules produced during grounding. See Also -------- clingo.control.Control.register_observer Notes ----- Not all functions the `Observer` interface have to be implemented and can be omitted if not needed. incrementalreturnNcg)z Called once in the beginning. Parameters ---------- incremental Whether the program is incremental. If the incremental flag is true, there can be multiple calls to `clingo.control.Control.solve`. Nr)selfr7s r& init_programObserver.init_programlr%cg)zD Marks the beginning of a block of directives passed to the solver. Nrr:s r& begin_stepObserver.begin_stepwr=r%choiceheadbodycg)z Observe rules passed to the solver. Parameters ---------- choice Determines if the head is a choice or a disjunction. head List of program atoms forming the rule head. body List of program literals forming the rule body. Nr)r:rBrCrDs r&rule Observer.rule|r=r% lower_boundcg)a Observe rules with one weight constraint in the body passed to the solver. Parameters ---------- choice Determines if the head is a choice or a disjunction. head List of program atoms forming the head of the rule. lower_bound The lower bound of the weight constraint in the rule body. body List of weighted literals (pairs of literal and weight) forming the elements of the weight constraint. Nr)r:rBrCrHrDs r& weight_ruleObserver.weight_ruler=r%priorityliteralscg)z Observe minimize directives (or weak constraints) passed to the solver. Parameters ---------- priority The priority of the directive. literals List of weighted literals whose sum to minimize (pairs of literal and weight). Nrr:rLrMs r&minimizeObserver.minimizer=r%atomscg)zw Observe projection directives passed to the solver. Parameters ---------- atoms The program atoms to project on. Nrr:rRs r&projectObserver.projectr=r%symbolatomcg)a Observe shown atoms passed to the solver. Facts do not have an associated program atom. The value of the atom is set to zero. Parameters ---------- symbol The symbolic representation of the atom. atom The associated program atom (`0` for facts). Nr)r:rWrXs r& output_atomObserver.output_atomr=r% conditioncg)z Observe shown terms passed to the solver. Parameters ---------- symbol The symbolic representation of the term. condition List of program literals forming the condition when to show the term. Nr)r:rWr\s r& output_termObserver.output_termr=r%valuecg)z Observe external statements passed to the solver. Parameters ---------- atom The external atom in form of a program literal. value The truth value of the external statement. Nrr:rXr`s r&externalObserver.externalr=r%cg)z Observe assumption directives passed to the solver. Parameters ---------- literals The program literals to assume (positive literals are true and negative literals false for the next solve call). Nrr:rMs r&assumeObserver.assumer=r%type_biascg)a  Observe heuristic directives passed to the solver. Parameters ---------- atom The program atom heuristically modified. type_ The type of the modification. bias A signed integer. priority An unsigned integer. condition List of program literals. Nrr:rXrirjrLr\s r& heuristicObserver.heuristicr=r%node_unode_vcg)u( Observe edge directives passed to the solver. Parameters ---------- node_u The start vertex of the edge (in form of an integer). node_v Тhe end vertex of the edge (in form of an integer). condition The list of program literals forming th condition under which to add the edge. Nrr:rorpr\s r& acyc_edgeObserver.acyc_edger=r%term_idnumbercg)zx Observe numeric theory terms. Parameters ---------- term_id The id of the term. number The value of the term. Nr)r:rurvs r&theory_term_numberObserver.theory_term_numberr=r%namecg)z| Observe string theory terms. Parameters ---------- term_id The id of the term. name The string value of the term. Nr)r:rurzs r&theory_term_stringObserver.theory_term_stringr=r%name_id_or_type argumentscg)aa Observe compound theory terms. Parameters ---------- term_id The id of the term. name_id_or_type The name id or type of the term where the value `-1` stands for tuples, `-2` for sets, `-3` for lists, or otherwise for the id of the name (in form of a string term). arguments The arguments of the term in form of a list of term ids. Nr)r:rur~rs r&theory_term_compoundObserver.theory_term_compound+r=r% element_idtermscg)z Observe theory elements. Parameters ---------- element_id The id of the element. terms The term tuple of the element in form of a list of term ids. condition The list of program literals forming the condition. Nr)r:rrr\s r&theory_elementObserver.theory_element=r=r%atom_id_or_zeroelementscg)z Observe theory atoms without guard. Parameters ---------- atom_id_or_zero The id of the atom or zero for directives. term_id The term associated with the atom. elements The elements of the atom in form of a list of element ids. Nr)r:rrurs r& theory_atomObserver.theory_atomMr=r% operator_idright_hand_side_idcg)a{ Observe theory atoms with guard. Parameters ---------- atom_id_or_zero The id of the atom or zero for directives. term_id : int The term associated with the atom. elements The elements of the atom in form of a list of element ids. operator_id The id of the operator (a string term). right_hand_side_id The id of the term on the right hand side of the atom. Nr)r:rrurrrs r&theory_atom_with_guardObserver.theory_atom_with_guard]r=r%cg)zt Marks the end of a block of directives passed to the solver. This function is called right before solving starts. Nrr?s r&end_stepObserver.end_stepvr=r%r)r8N)!rrrrrboolr;r@rintrFrrJrPrUrrZr^rrcrgrrmrsrxstrr|rrrrrr$rr%r&rr]s         4  x}  HSM  d    sm   uS#X'    0    sCx0I  d   Xc] t   &        &  Xc]  t    S        x}           C=    2    S  Xc]  t    #  s  t    #  S  T    -0 =Ec]  $  &.sm @H    " -0 > *4DE   ,Es B &B pyclingo_observer_minimizec [R"U5RnURU[ U5Vs/sHoQUR XR 4PM! sn5 gs snfr)r rrrPrrr)rLrMsizerrrs r&_pyclingo_observer_minimizers^))$/44H eDkRkQK''););IIEHH/=E    ( ( II KK   r%rXr`cl[[R"URXR55 g)a Mark a program atom as external optionally fixing its truth value. Parameters ---------- atom The program atom to mark as external. value Optional truth value. Notes ----- Can also be used to release an external atom using `TruthValue.Release`. N)r r clingo_backend_externalrr`rbs r& add_externalBackend.add_externals! d22499dKKPQr%rirjrLc [[R"URXRX4U[ U555 g)z Add a heuristic directive to the program. Parameters ---------- atom Program atom to heuristically modify. type_ The type of modification. bias A signed integer. priority An unsigned integer. condition List of program literals. N)r r clingo_backend_heuristicrr`rrls r& add_heuristicBackend.add_heuristics10   ) ) 4diY  r%c l[[R"URX[ U555 g)z Add a minimize constraint to the program. Parameters ---------- priority Integer for the priority. literals List of pairs of program literals and weights. N)r r clingo_backend_minimizerrrOs r& add_minimizeBackend.add_minimizes&   ( (HH V r%rRc l[[R"URU[ U555 g)zo Add a project statement to the program. Parameters ---------- atoms List of program atoms to project on. N)r r clingo_backend_projectrrrTs r& add_projectBackend.add_projects# d11$))UCJOPr%FrCrDrBc [[R"URX1[ U5U[ U555 g)a` Add a disjuntive or choice rule to the program. Parameters ---------- head The program atoms forming the rule head. body The program literals forming the rule body. choice Whether to add a disjunctive or choice rule. Notes ----- Integrity constraints and normal rules can be added by using an empty or singleton head list, respectively. N)r r clingo_backend_rulerr)r:rCrDrBs r&add_ruleBackend.add_rules1*   $ $ 6TD#d)  r%lowerc [[R"URXA[ U5X#[ U555 g)am Add a disjuntive or choice rule with one weight constraint with a lower bound in the body to the program. Parameters ---------- head The program atoms forming the rule head. lower The lower bound. body The pairs of program literals and weights forming the elements of the weight constraint. choice Whether to add a disjunctive or choice rule. N)r r clingo_backend_weight_rulerr)r:rCr rDrBs r&add_weight_ruleBackend.add_weight_rules1.   + + 6TET  r%rvc`[S[RURUURS9$)z Add a numeric theory term. Parameters ---------- number The value of the term. Returns ------- The id of the added term. clingo_id_tr)r r !clingo_backend_theory_term_numberrr)r:rvs r&add_theory_term_numberBackend.add_theory_term_numbers.   2 2 II KK   r%stringc|[S[RURUR 5UR S9$)z Add a theory term representing a string. Parameters ---------- string The value of the term. Returns ------- The id of the added term. r&r)r r !clingo_backend_theory_term_stringrencoder)r:r*s r&add_theory_term_stringBackend.add_theory_term_string&s4   2 2 II MMOKK   r%rzrc [S[RURUR 5U[ U5UR S9$)z Add a theory term representing a function. Parameters ---------- name The name of the function. arguments Sequence of term ids for the function arguments. Returns ------- The id of the added term. r&r)r r #clingo_backend_theory_term_functionrr-rr)r:rzrs r&add_theory_term_function Backend.add_theory_term_function;s>   4 4 II KKM   NKK  r% sequence_typec [S[RURURU[ U5UR S9$)z Add a theory term representing a sequence of theory terms. Parameters ---------- sequence_type The type of the sequence arguments Sequence of term ids for the function arguments. Returns ------- The id of the added term. r&r)r r #clingo_backend_theory_term_sequencerr`rr)r:r4rs r&add_theory_term_sequence Backend.add_theory_term_sequenceTs>"   4 4 II      NKK  r%ct[S[RURURURS9$)z Create a theory term from a symbol. Parameters ---------- symbol The symbol to convert. Returns ------- The id of the added term. r&r)r r !clingo_backend_theory_term_symbolrr)r:rWs r&add_theory_term_symbolBackend.add_theory_term_symbolos2   2 2 II KKKK   r%rc [S[RURU[ U5U[ U5UR S9$)z Create a theory atom element. Parameters ---------- terms A sequence of term ids. condition A sequence of program literals. Returns ------- The id of the added element. r&r)r r clingo_backend_theory_elementrrr)r:rr\s r&add_theory_elementBackend.add_theory_elements?   . . II  J   NKK  r%rurrc UcSn[S[RURUUU[ U5UR S9$)a9 Add a theory atom without a guard. If no atom_id is given, a fresh atom id is assigned. In case an atom id is given and an equivalent theory atom already exists, the given atom id is ignored. To declare a defined theory atom, a rule defining the program atom should be added. Otherwise, the theory atom is considered an external body occurrence. Parameters ---------- term_id The id of the term associated with the theory atom. elements A sequence of ids of theory atom elements. atom_id_or_zero An optional program atom or zero for theory directives. rr)r r clingo_backend_theory_atomrrr)r:rurrs r&add_theory_atomBackend.add_theory_atomsF6  "(O   + + II    MKK  r%operatorrc UcSn[S[RURUUU[ U5UR 5UUR S9 $)a Add a theory atom with a guard. Parameters ---------- term_id The id of the term associated with the theory atom. elements A sequence of ids of theory atom elements. operator String representing a theory operator. right_hand_side_id Term id for the term on the right hand side. atom_id_or_zero A optional program atom or zero for theory directives. See Also -------- Backend.add_theory_atom rBrr)r r %clingo_backend_theory_atom_with_guardrrr-r)r:rurrFrrs r&add_theory_atom_with_guard"Backend.add_theory_atom_with_guardsS8  "(O   6 6 II    M OO  KK  r%)rrr)F)%rrrrrrrrrrrrrrr rr,rrrrrrrrr#r(rr.r2rr7r;r?rDrIr$rr%r&rr6s    C  # SW & V8C= VT V x/ 3 <;E:K:KRRZRPTR"       C=    <  S  HU38_4M  RV   Q# Q4 Q:rQsP@<<UU) H&K>^ ^ B  f %,L *629WXY *629UVW *629QRS f %,K  *629UVW*629TUV  f %,K  f %,K *629UVW *629STU *629VWX*629VWX  f %,R  f %,R  f %,T f %,N   f %,K  f %,V  y nY'y r%