def sample(self, bqm, chain_strength=1.0, chain_break_fraction=True, **parameters):
        """Sample from the provided binary quadratic model.

        Also set parameters for handling a chain, the set of vertices in a target graph that
        represents a source-graph vertex; when a D-Wave system is the sampler, it is a set
        of qubits that together represent a variable of the binary quadratic model being
        minor-embedded.

        Args:
            bqm (:obj:`dimod.BinaryQuadraticModel`):
                Binary quadratic model to be sampled from.

            chain_strength (float, optional, default=1.0):
                Magnitude of the quadratic bias (in SPIN-space) applied between variables to create
                chains. The energy penalty of chain breaks is 2 * `chain_strength`.

            chain_break_fraction (bool, optional, default=True):
                If True, the unembedded response contains a ‘chain_break_fraction’ field that
                reports the fraction of chains broken before unembedding.

            **parameters:
                Parameters for the sampling method, specified by the child sampler.

        Returns:
            :class:`dimod.SampleSet`: A `dimod` :obj:`~dimod.SampleSet` object.

        Examples:
            This example submits an triangle-structured Ising problem to a D-Wave solver, selected
            by the user's default
            :std:doc:`D-Wave Cloud Client configuration file <cloud-client:intro>`,
            by minor-embedding the problem's variables to physical qubits.

            >>> from dwave.system.samplers import DWaveSampler
            >>> from dwave.system.composites import EmbeddingComposite
            >>> import dimod
            ...
            >>> sampler = EmbeddingComposite(DWaveSampler())
            >>> bqm = dimod.BinaryQuadraticModel.from_ising({}, {'ab': 0.5, 'bc': 0.5, 'ca': 0.5})
            >>> response = sampler.sample(bqm, chain_strength=2)
            >>> response.first:    # doctest: +SKIP
            Sample(sample={'a': -1, 'b': 1, 'c': 1}, energy=-0.5,
                   num_occurrences=1, chain_break_fraction=0.0)

        See `Ocean Glossary <https://docs.ocean.dwavesys.com/en/latest/glossary.html>`_
        for explanations of technical terms in descriptions of Ocean tools.
        """

        # solve the problem on the child system
        child = self.child

        # apply the embedding to the given problem to map it to the child sampler
        __, target_edgelist, target_adjacency = child.structure

        # add self-loops to edgelist to handle singleton variables
        source_edgelist = list(bqm.quadratic) + [(v, v) for v in bqm.linear]

        # get the embedding
        embedding = minorminer.find_embedding(source_edgelist, target_edgelist)

        if bqm and not embedding:
            raise ValueError("no embedding found")

        bqm_embedded = embed_bqm(bqm, embedding, target_adjacency,
                                 chain_strength=chain_strength,
                                 smear_vartype=dimod.SPIN)

        if 'initial_state' in parameters:
            parameters['initial_state'] = _embed_state(embedding, parameters['initial_state'])

        response = child.sample(bqm_embedded, **parameters)

        return unembed_sampleset(response, embedding, source_bqm=bqm,
                                 chain_break_fraction=chain_break_fraction)