  Lattice-linearity was introduced as modelling problems using predicates that
induce a lattice among the global states (Garg, SPAA 2020). Such modelling
enables permitting asynchronous execution in multiprocessor systems. A key
property of \textit{the predicate} representing such problems is that it
induces \textit{one} lattice in the state space. Such representation guarantees
the execution to be correct even if nodes execute asynchronously. However, many
interesting problems do not exhibit lattice-linearity. This issue was
alleviated with the introduction of eventually lattice-linear algorithms (Gupta
and Kulkarni, SSS 2021). They induce \textit{single or multiple} lattices in a
subset of the state space even when the problem cannot be defined by a
predicate under which the states form a lattice.
  In this paper, we focus on analyzing and differentiating between
lattice-linear problems and algorithms. We introduce a new class of algorithms
called \textit{fully lattice-linear algorithms}. These algorithms partition the
\textit{entire} reachable state space into \textit{one or more lattices}. For
illustration, we present lattice-linear self-stabilizing algorithms for minimal
dominating set (MDS) and graph colouring (GC) problems, and a parallel
processing lattice-linear 2-approximation algorithm for vertex cover (VC).
  The algorithms for MDS and GC converge in {\boldmath $n$} moves and
{\boldmath $n+2m$} moves respectively. These algorithms preserve this time
complexity while allowing the nodes to execute asynchronously, where these
nodes may execute based on old or inconsistent information about their
neighbours. The algorithm for VC is the first lattice-linear approximation
algorithm for an NP-Hard problem; it converges in {\boldmath $n$} moves.
