Abstraction of threads that may run in parallel with the current thread. NoThread < AnyThreadExceptSelf < AnyThread

`type astate````=`

`|` `NoThread` | (** No threads can run in parallel with the current thread (concretization: empty set). We assume this by default unless we see evidence to the contrary (annotations, use of locks, etc.) *)
`|` `AnyThreadButSelf` | (** Current thread can run in parallel with other threads, but not with a copy of itself. (concretization : { t | t \in TIDs ^ t != t_cur } ) *)
`|` `AnyThread` | (** Current thread can run in parallel with any thread, including itself (concretization: set of all TIDs ) *)

``
`include InferModules.AbstractDomain.WithBottom with type astate := astate`
`include InferModules.AbstractDomain.S`
`type astate`````
`val (<=) : lhs:astate ‑> rhs:astate ‑> bool`

the partial order induced by join

`val join : astate ‑> astate ‑> astate`
`val widen : prev:astate ‑> next:astate ‑> num_iters:int ‑> astate`
`val pp : InferModules.AbstractDomain.F.formatter ‑> astate ‑> unit`
`val empty : astate`

The bottom value of the domain. Naming it empty instead of bottom helps to bind the empty value for sets and maps to the natural definition for bottom

`val is_empty : astate ‑> bool`

Return true if this is the bottom value

`val can_conflict : astate ‑> astate ‑> bool`

return true if two accesses with these thread values can run concurrently

`val is_any : astate ‑> bool`
`val integrate_summary : caller_astate:astate ‑> callee_astate:astate ‑> astate`

integrate current state with a callee summary