docs: def map_query(self, init_iter=1000, later_iter=20, dual_threshold=0.0002, integrality_gap_threshold=0.0002,
                    tighten_triplet=True, max_triplets=5, max_iterations=100, prolong=False):
          """
          MAP query method using Max Product LP method.
          This returns the best assignment of the nodes in the form of a dictionary.
  
          Parameters
          ----------
          init_iter: integer
                     Number of maximum iterations that we want MPLP to run for the first time.
  
          later_iter: integer
                      Number of maximum iterations that we want MPLP to run for later iterations
  
          dual_threshold: double
                          This sets the minimum width between the dual objective decrements. If the decrement is lesser
                          than the threshold, then that means we have stuck on a local minima.
  
          integrality_gap_threshold: double
                                     This sets the threshold for the integrality gap below which we say that the solution
                                     is satisfactory.
  
          tighten_triplet: bool
                           set whether to use triplets as clusters or not.
  
          max_triplets: integer
                        Set the maximum number of triplets that can be added at once.
  
          max_iterations: integer
                          Maximum number of times we tighten the relaxation. Used only when tighten_triplet is set True.
  
          prolong: bool
                   If set False: The moment we exhaust of all the triplets the tightening stops.
                   If set True: The tightening will be performed max_iterations number of times irrespective of the
                                triplets.
  
          Reference:
          Section 3.3: The Dual Algorithm; Tightening LP Relaxation for MAP using Message Passing (2008)
          By Sontag Et al.
  
          Examples
          --------
          >>> from pgmpy.models import MarkovModel
          >>> from pgmpy.factors.discrete import DiscreteFactor
          >>> from pgmpy.inference import Mplp
          >>> import numpy as np
          >>> student = MarkovModel()
          >>> student.add_edges_from([('A', 'B'), ('B', 'C'), ('C', 'D'), ('E', 'F')])
          >>> factor_a = DiscreteFactor(['A'], cardinality=[2], values=np.array([0.54577, 1.8323]))
          >>> factor_b = DiscreteFactor(['B'], cardinality=[2], values=np.array([0.93894, 1.065]))
          >>> factor_c = DiscreteFactor(['C'], cardinality=[2], values=np.array([0.89205, 1.121]))
          >>> factor_d = DiscreteFactor(['D'], cardinality=[2], values=np.array([0.56292, 1.7765]))
          >>> factor_e = DiscreteFactor(['E'], cardinality=[2], values=np.array([0.47117, 2.1224]))
          >>> factor_f = DiscreteFactor(['F'], cardinality=[2], values=np.array([1.5093, 0.66257]))
          >>> factor_a_b = DiscreteFactor(['A', 'B'], cardinality=[2, 2],
          ...                             values=np.array([1.3207, 0.75717, 0.75717, 1.3207]))
          >>> factor_b_c = DiscreteFactor(['B', 'C'], cardinality=[2, 2],
          ...                             values=np.array([0.00024189, 4134.2, 4134.2, 0.0002418]))
          >>> factor_c_d = DiscreteFactor(['C', 'D'], cardinality=[2, 2],
          ...                             values=np.array([0.0043227, 231.34, 231.34, 0.0043227]))
          >>> factor_d_e = DiscreteFactor(['E', 'F'], cardinality=[2, 2],
          ...                             values=np.array([31.228, 0.032023, 0.032023, 31.228]))
          >>> student.add_factors(factor_a, factor_b, factor_c, factor_d, factor_e, factor_f,
          ...                     factor_a_b, factor_b_c, factor_c_d, factor_d_e)
          >>> mplp = Mplp(student)
          >>> result = mplp.map_query()
          >>> result
          {'B': 0.93894, 'C': 1.121, 'A': 1.8323, 'F': 1.5093, 'D': 1.7765, 'E': 2.12239}
          """
  
          self.dual_threshold = dual_threshold
          self.integrality_gap_threshold = integrality_gap_threshold
          # Run MPLP initially for a maximum of init_iter times.
          self._run_mplp(init_iter)
          # If triplets are to be used for the tightening, we proceed as follows
          if tighten_triplet:
              self._tighten_triplet(max_iterations, later_iter, max_triplets, prolong)
          # Get the best result from the best assignment
          self.best_decoded_result = {factor.scope()[0]: factor.values[self.best_assignment[frozenset(factor.scope())]]
                                      for factor in self.model.factors if len(factor.scope()) == 1}
          return self.best_decoded_result