[Question]
  [
A family of sets is called [laminar](https://en.wikipedia.org/wiki/Laminar_set_family) if for any two sets \$A\$ and \$B\$ in the family one of the following is true:
* \$ A \subseteq B \$
* \$ A \supseteq B \$
* \$ A \cap B = \emptyset \$
Or less mathematical:
A laminar set is a list of lists that satisfies the following condition: If two elements of the top level list have at least one element in common, one of them has to be completely contained in the other one.
Examples:
```
laminar:
{} 
{{1,2,3},{1,2},{1},{}}
{{1,2,3,4},{1,2,3},{1,2},{3},{4}}
{{1,2,3,4},{1,2},{3,4},{1},{3}}
{{1,2,3,4},{1,3},{2,4},{1},{2},{3},{4},{}}
{{1,2,3},{4,5},{7,8},{3},{5},{7}}
not laminar:
{{1,2},{2,3}}
{{1,2,3,4},{1,2,3},{1,2},{3,4}}
{{1,2,3,4},{1,2},{3,4},{2,3},{1},{2},{3},{4}}
{{1,2,3,4,5},{1,2,3},{4,5,6}}
```
Your goal is to write a program of function that takes a set of set as input and returns truthy if the set is laminar and falsey if is it not laminar.
Rules:
* You can take lists instead of sets as Input
* If you use lists as input you can assume that the lists (top-level and/or sub-lists) are sorted (in any convenient order) and each element appear only once
* Your solution should be able to handle Inputs lists with at least 250 distinct element values
* You are allowed to use any type to represent the elements of the list (as long as it has enough distinct values)
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") the shortest solution (per language) wins.
  
[Answer]
# [Python](https://www.python.org), 50 bytes
```
lambda c:all(a&b in(a,b,a-a)for a in c for b in c)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vweI025ilpSVpuhY3jXISc5NSEhWSrRJzcjQS1ZIUMvM0EnWSdBJ1EzXT8osUEoECCskKIGYSmKkJ0XmLsaukqLQko9I2OjpWR4ErutpQx0jHuFYHRIPIWp3i1BINzVgdmJSOCUQSSRGIZVKLqQQkBWGDFWEoAOkzgitAmIRuJUhQxxRImutYQBWBeSATY7m40hJziisVbBWiIerBhmKxDcXFOnjdC1WK4ihk5WDHIDlNxwzmFGD4ZoLCFxKoVlycBUWZeSUaaRqZmppI0mAnW3EpAAGSAkiULFgAoQE)
[Answer]
# Rust, 63 bytes
Port of [mousetail](https://codegolf.stackexchange.com/users/91213/mousetail)'s [python answer](https://codegolf.stackexchange.com/a/263630).
```
|s|s.iter().all(|a|s.iter().all(|b|a&b==*a||a&b==*b||a&b==a-a))
```
[Rust explorer](https://www.rustexplorer.com/b#%2F*%0A%5Bdependencies%5D%0Amaplit%20%3D%20%221.0.2%22%0A*%2F%0A%0Ause%20maplit%3A%3Ahashset%3B%0Ause%20std%3A%3Acollections%3A%3AHashSet%3B%0A%0Afn%20main()%20%7B%0A%20%20%20%20let%20f%3A%20for%3C%27a%3E%20fn(%26%5BHashSet%3Ci32%3E%5D)%20-%3E%20bool%20%3D%20%7Cs%7C%20%7B%0A%20%20%20%20%20%20%20%20s.iter().all(%7Ca%7C%20%7B%0A%20%20%20%20%20%20%20%20%20%20%20%20s.iter()%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20.all(%7Cb%7C%20a%20%26%20b%20%3D%3D%20*a%20%7C%7C%20a%20%26%20b%20%3D%3D%20*b%20%7C%7C%20a%20%26%20b%20%3D%3D%20a%20-%20a)%0A%20%20%20%20%20%20%20%20%7D)%0A%20%20%20%20%7D%3B%0A%0A%20%20%20%20assert!(f(%26%5B%5D))%3B%0A%20%20%20%20assert!(f(%26%5B%0A%20%20%20%20%20%20%20%20hashset!%5B1%2C%202%2C%203%5D%2C%0A%20%20%20%20%20%20%20%20hashset!%5B1%2C%202%5D%2C%0A%20%20%20%20%20%20%20%20hashset!%5B1%5D%2C%0A%20%20%20%20%20%20%20%20hashset!%5B%5D%0A%20%20%20%20%5D))%3B%0A%20%20%20%20assert!(f(%26%5B%0A%20%20%20%20%20%20%20%20hashset!%20%7B1%2C2%2C3%2C4%7D%2C%0A%20%20%20%20%20%20%20%20hashset!%20%7B1%2C3%7D%2C%0A%20%20%20%20%20%20%20%20hashset!%20%7B2%2C4%7D%2C%0A%20%20%20%20%20%20%20%20hashset!%20%7B1%7D%2C%0A%20%20%20%20%20%20%20%20hashset!%20%7B2%7D%2C%0A%20%20%20%20%20%20%20%20hashset!%20%7B3%7D%2C%0A%20%20%20%20%20%20%20%20hashset!%20%7B4%7D%2C%0A%20%20%20%20%20%20%20%20hashset!%20%7B%7D%0A%20%20%20%20%5D))%3B%0A%0A%20%20%20%20assert!(!f(%26%5Bhashset!%20%7B1%2C2%7D%2C%20hashset!%20%7B2%2C3%7D%5D))%3B%0A%7D%0A)
[Answer]
# [Nekomata](https://github.com/AlephAlpha/Nekomata) + `-e`, 8 bytes
```
ᵒ{ᵋ∩?Ø?=
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70iLzU7PzexJHFNtJJurpKOgpJuqlLsgqWlJWm6Fusfbp1U_XBr96OOlfaHZ9jbLilOSi6Gyi24xagcHavAFR1tqGOkYxyrA6JBJBDHxsKEdUwgEkgKQCwTTBUgGQgbrAZdHqTLCC6PMAfZMpCAjimQNNexgCoA82AqwEZgGo3iOB18ToOqRHEAkmqw3Ugu0TGLjYUEFgA)
```
ᵒ{ᵋ∩?Ø?=
ᵒ{          For each pair of elements A, B in the input, check that:
  ᵋ∩        Intersection of A and B
    ?Ø?     Any of A, B, or the empty set
       =    Are they equal?
```
[Answer]
# JavaScript (ES6), 69 bytes
Expects a list of lists. Returns *false* for laminar, or *true* for not laminar.
Not the right tool for the job.
```
a=>a.some(x=>a.some(y=>(b=x.filter(v=>y.includes(v))+'')&&b!=x&b!=y))
```
[Try it online!](https://tio.run/##jY9NboMwEIX3PoWTRWKrU0tN0h81MruegnoxIaalcuwKCILTU4agFNpIycLPz543Hn9fWGGR5Nl3ee/D3rapblFHqIpwsKI@u0ZHYqdrlWautLmodNSozCfuuLeFqKS8Wy7lYrGb6ZqkkbJNgi@Cs8qFDzF3eMg85q9zuWUx4zw2QBo/wArWBmgn7ZYZV2Bzqo0y5DYXQ1Q8@T52IUK9q3Pk97U/U@kOHjt9hpch05@MYYapNORvmHwK5DriY8hUoJQdH5uQv3sfSv6Pf/gwTbsGDFdwh/CEaNrQw4zQ4Ok2lPYH "JavaScript (Node.js) – Try It Online")
### 41 bytes (ES11)
As one would expect, converting each sub-list to a BigInt bit-mask and applying bitwise logic is longer.
```
a=>(a=a.map(b=>b.map(v=>m|=1n<<v,m=0n)&&m)).some(x=>a.some(y=>y^(y&=x)&&x^y&&y))
```
[Try it online!](https://tio.run/##pVDRSsMwFH3PV4Q9lASy4ubU4XbzIPjgN9QM7mo7K00y2lIa8N9r0xZtdbAHA7k5yTk3yTkfWGMZF9m5Whr7lrQptAiSIWCo8cyOII89qEHqT1iZ/b4WGm4MDwLNeVhanbAGJA7IgXQH5gJoOr45uCBwnLexNaXNkzC3J7bIUWcGi8cF35GIUBop4Wu0Emtxq4Rffe2mmjJiM3ATjUebiyJPDriXXZD43vW35Oe2X6/6M3HX1QexHTX9TimiSJja4hnjd4YUJJ2aTNmYnieG/J6y04upuB87QmaJvBpjK/onl9GI/8W1IMSVGEbxzOm8oTc5sSzu/2ex/QI "JavaScript (Node.js) – Try It Online") (80 bytes)
But if we can take the list of sets directly as a list of bit-masks (as suggested by [@Cubic](https://codegolf.stackexchange.com/users/32454/cubic)), then we can just do:
```
a=>a.some(x=>a.some(y=>y^(y&=x)&&x^y&&y))
```
[Try it online!](https://tio.run/##tZDfaoMwFMbv8xSHXkgCp2Htuq2sjReDXewZXAqp1c6hSVEnCnt312Ol067QqwVycnK@7@TP79NUpgjz5FBOrdtFbaxao3wjC5dFvD5njfKbDW88VQvPqzeN5zVCtKGzhUsjmbo9n6QmS6zJnydixQIGEGikGMxwjvcaaaV4nHqo4OKkDTyULa6aSDzlne2KhXrnZ8vvaRe3Ug0fjvEJl72n22nNNJOxy19N@MENKB@Gn4y5kZk58C0JW5lHu68w4jxDqASVMviGmYX1Gl6S/ZsteSUQ7qygsWJsxOvdWlfCH2r9N@mNtzDhDUi9ecRh3NAhGADBx/8E0P4A "JavaScript (Node.js) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 11 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ãε¯ªy`Ã.å}P
```
[Try it online](https://tio.run/##yy9OTMpM/f//8OJzWw@tP7SqMuFws97hpbUB//9HRxvqGOkY65jE6kBYEBpIglgmsbEA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeX/w4vPbT20/tCqyoTDzXqHl9YG/Nf5Hx0dq6MQHW2oY6RjHKsDokEkEMcixHVMIDJIKkAsEyxKQFIQNlgRhgKQPiO4AoRJKPaBRHRMgaS5jgVUBZgHVwI2xJiAC3Xwug@qFMURyMrB9iO5RscsNjYWAA).
**Explanation:**
```
ã        # Cartesian product to get all pairs of the (implicit) input-list
 ε       # Map over each pair of lists:
  ¯ª     #  Append an empty list to the pair
  y`     #  Push the lists of the pair separately to the stack
    Ã    #  Pop both, and push a list with values that occurred in both lists
     .å  #  Non-vectorized check if this list is in the earlier triplet of lists
 }P      # After the map: check if all are truthy
         # (after which the result is output implicitly)
```
[Answer]
# [Raku](https://raku.org/), 47 bytes
```
{all cross @^a,@a,:with{$^x∩$^y≡∅|$x|$y}}
```
[Try it online!](https://tio.run/##hY5hCoJAEIWvMsgSuzEIuWohRN6h/8YSSoGiqZSi/gy8StfyIqYbpoXUn7fMvm/evMiNfbMNclh4sG0L4ftwjMMkAdsRaAu0buf0VBAna@oHcXJwL9emvpckK0leVW0iclCKnQdqICILlureTSsLyEGNumDKFPDCGChDoHSFGnKG/Su1EzYaqL@sCcJ7RMcZSJr6kMJnkD5FGxENJ3kfd@WX0ekaNwNjoJzflAzg/8rqv4oO6HeX6YqsMSmFJmPtEw "Perl 6 – Try It Online")
(The ageing version of Perl 6 on TIO does not understand the `≡` operator, added in 2020. I replaced it there with  `eqv` for one additional byte.)
This anonymous function takes as input a list of sets in the variable `@^a`/`@a`. It computes the cross product of all of those sets with each other using the anonymous function in braces following `:with`. For each pair, that function returns a truthy value if the intersection (`∩`) of the two sets is identical to (`≡`) one of those sets or to the empty set (`∅`). The final result is a truthy value indicating whether `all` of those pairwise values are truthy.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 88 bytes
```
x=>x.some(a=>x.some(b=>g(a,b)&g(b,a)))
g=(a,b)=>/0,1|1,0/.test(a.map(i=>+b.includes(i)))
```
[Try it online!](https://tio.run/##fU7LboMwELznK3oqa3VjIEmbXMyxP9BjUykGDHLlAMUQUVF/O8XOoySVcvB6d2Z2Zz75geukllUzL8pUDBkbOhZ1VJd7AfzSxSzKgWNMHnOIkRNCZjlzAIv8AMOfEAOfNkI3wOmeVyBZ9BRTWSSqTYUGOW4MtfhqZS3Ay7RHaC14@iqVePsuEgjQa5ts4@BK8USAv@39HL33K8hY6GOEdKVks9sWO2c2Jk7KQpdKUFXmkIE4cAUdsaa9eZj1fYgLXBq0v63jM@YM4@pITAS2W/1XWObYO80tb7cWF/7vztTMAvg81jVuTgI3nRXuxPJ@OLwX7aS8CjBRO@9JEnwx5hc "JavaScript (Node.js) – Try It Online")
Return inversed
[Answer]
# [Factor](https://factorcode.org) + `math.unicode sets.extras`, 52 bytes
```
[ dup '[ _ [ diffs f like and and ] with ∃ ] ∃ ]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70sLTG5JL9owS0mttBgTz93K4Xi1JJivdSKkqLEYoXs1KK81BygUGFpal5yarFCbmJJhl5ZKkgLlFOal5mcn5KqUFCUWlJSWVCUmVeiYM3FVc2lAATVCrVQulrBUMFIwVihFsqC0CCyFkONCVwVqnoIzwSvDog6EyTzjfGoh5hohKIe3S5sLoTImYJpcwULJB0wMXQ9EJPxuQXTt8T7FKEXmw8wzTBFsxMkYgZWWbu0tCRN1-KmSbRCSmmBgnq0QrwCkJmZllaskKaQk5mdqpCYlwLGsQrlmSUZCo86moFMMAnRuzQ3sUBBD8JesABCAwA)
Output is inverted: outputs `f` for laminar and `t` for not laminar.
* `∃` alias for `any?` that is 1 byte shorter
* `dup '[ _ [ ... ] with ∃ ] ∃` Is there any pair of sets in the input that is true when `[ ... ]` is applied to them?
* `diffs` A lovely word that takes two sets as inputs and returns three outputs: the set difference between input 1 and input 2, the set difference between input 2 and input 1, and the intersection between input 1 and input 2. This word converts empty sets to `f` except for the intersection.
* `f like` Convert the intersection to `f` if it is empty; leave alone otherwise.
* `and and` Take the logical and of the three results.
[Answer]
# [Haskell](https://www.haskell.org/), ~~68~~ 63 bytes
Unfortunately `\\` is not in `Prelude`, and I couldn't figure out how to write it shorter without the `Data.List` functions (without the import it's ~~51~~ bytes).
(Shaved off 5 bytes by switching to list comprehension from nested `all`)
```
import Data.List
l s=and[a\\b==[]||b\\a==[]||a\\b==a|a<-s,b<-s]
```
[Try it online!](https://tio.run/##dY9Na8MwDIbv/hUitJCAW2iafVCWnXYphG2w3WwfHJrSsMQJscd6yH/PZDsbS5sdbEuvHr@STlJ/FFU1lHXbdAbei7NZv3alMscf6Ukauc5KbUgFOpXqwCTneZoy0fc559JHXpO9fFhpmuMlhuIMux0wtldGCFg9wv4FwoigrCGF1jWBoJJ1qWQXLnWE6lJzFUCoT80XoOCDBWDniBBSy1JZT2/kshQODQFoP82b6TIFQeb9AhSxExPjyzY0pltBwQaCsg0eMS3SZCwjB9RzwNyf5D/UETZzhtsZDCO0YPEvFDuQsuR6AqvSG7zv6P1IuQyxyY5cPTcGqumm42LWZnYK7@8hq81DY9H7XA58@cXN@mdyeovI8A0 "Haskell – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
iƇⱮFf\€Ƒ
```
[Try it online!](https://tio.run/##y0rNyan8/z/zWPujjevc0mIeNa05NvH/4XbNyP//o7miY3W4oqsNdYx0jGt1QDSIBOJahLiOCUQGSQWIZYJFCUgKwgYrwlAA0mcEV4AwCcU@kIiOKZA017GAqgDz4ErAhhgTcKEOXvdBlaI4Alk52H4k1@iY1cZyxQIA "Jelly – Try It Online")
Relies on the whole family being sorted *descending by length*, incidentally coinciding with how the testcases are displayed.
```
  ⱮF        For each element of any of the sets,
iƇ          filter the family to only sets containing it.
      €Ƒ    Is every one of those sub-families unchanged by
    f\      cumulative intersection?
```
# [Jelly](https://github.com/DennisMitchell/jelly), ~~10~~ 9 bytes
```
fpḟpḟ@ðþF
```
[Try it online!](https://tio.run/##y0rNyan8/z@t4OGO@SDscHjD4X1u/w@3a0b@/x/NFR2rwxVdbahjpGNcqwOiQSQQ1yLEdUwgMkgqQCwTLEpAUhA2WBGGApA@I7gChEko9oFEdEyBpLmOBVQFmAdXAjbEmIALdfC6D6oUxRHIysH2I7lGx6w2lisWAA "Jelly – Try It Online")
*-1 remembering that I already made the link dyadic*
Outputs an empty list iff laminar. If output can't have reversed truthiness, slap a `Ṇ` on the end.
```
      ðþ     For every pair (dyadically) of sets:
 p           Take the Cartesian product of
f            the intersection and 
  ḟ          the difference one way
   p         and
    ḟ@       the difference the other way.
        F    Flatten.
```
# [Jelly](https://github.com/DennisMitchell/jelly), 10 bytes
```
Œcµḟṭif/)P
```
[Try it online!](https://tio.run/##y0rNyan8///opORDWx/umP9w59rMNH3NgP@H2zUj//@P5oqO1eGKrjbUMdIxrtUB0SASiGsR4jomEBkkFSCWCRYlICkIG6wIQwFInxFcAcIkFPtAIjqmQNJcxwKqAsyDKwEbYkzAhTp43QdViuIIZOVg@5Fco2NWG8sVCwA "Jelly – Try It Online")
Direct approach everyone else is using.
```
Œcµ     )P    For every pair (as a list) of sets:
    ṭ         Append
   ḟ          the empty list;
     i        does that contain
      f/      the intersection?
```
[Answer]
# [Scala](http://www.scala-lang.org/), 79 bytes
Port of [@corvus\_192's Rust answer](https://codegolf.stackexchange.com/a/263644/110802) in Scala.
---
Golfed version. [Try it online!](https://tio.run/##jY/NTgMhFIX3PMV1B8mExLYrDU10pQtXXTZdXKYQMQyMgI3259lH0EnsUBMNyU3O4XC/Q2zR4mC63ocEsQjeemtVm4x33HTdW0JpFX/A@LxSiRAvX/IlPKFxoN6TctsId30PB0LIDi3oG7pSr@sxv350abMRy3vvrULHQAxRLA@Rax/QWornQmaxwwB7gWBcUiEWkrzdC4HHY57yayLfGq0pslM5AwDGqEKiuoC56vr0McUzRqYhmjXAmKHXDcwamLPmwq2tqR5RBZFt9j9KA4tLUM2e/ZKqI5WuVyz@6vpT9uq77fTj513mrDw4keET)
```
s=>{s.forall(a=>{s.forall(b=>{var z=a intersect b;z==a||z==b||z==a.diff(a)})})}
```
Ungollfed version. [Try it online!](https://tio.run/##jY/NasMwEITvforpTQIjaJJTwIXm1B56yjHksLYlqiJLrqVCS@Nnd/0HdRRDCwJpP83uzPqCDHWdrmrXBPihEoUzRhZBOyt0VX0Eyo0UT@RfjzIkicvf@k@8kLaQn0Ha0uOxrvGdAP0ppYJifo@jfD/NTadnG85nvsfBOSPJIhvVgBfKNWQMI2QPM1vQfEkBEtoG2fjenuUcWQbC5bKC83VMotRKMeLzxHZ6jFc7pSfvZROYYn16Ias6fEU78EjExhGzht2n2KTY8vSGxui6nq0Gix7z/7mk2N0axd6bFVUsiep4xO6vrL9h76a014svs2z50NAmXfcD)
```
import scala.collection.immutable.HashSet
object Main extends App {
  
  def f(s: Seq[HashSet[Int]]): Boolean = {
    s.forall(a => {
      s.forall(b => {
        a.intersect(b) == a || a.intersect(b) == b || a.intersect(b) == a.diff(a)
      })
    })
  }
  
  assert(f(Seq.empty[HashSet[Int]]))
  assert(f(Seq(
    HashSet(1, 2, 3),
    HashSet(1, 2),
    HashSet(1),
    HashSet.empty[Int]
  )))
  assert(f(Seq(
    HashSet(1, 2, 3, 4),
    HashSet(1, 3),
    HashSet(2, 4),
    HashSet(1),
    HashSet(2),
    HashSet(3),
    HashSet(4),
    HashSet.empty[Int]
  )))
  assert(!f(Seq(HashSet(1, 2), HashSet(2, 3))))
}
```
[Answer]
# [R](https://www.r-project.org), 64 bytes
```
\(x,`?`=all)?Map(\(A)?Map(\(B)any(?(p=A%in%B),?B%in%A,?!p),x),x)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMGiNNulpSVpuhY3HWI0KnQS7BNsE3NyNO19Ews0YjQcYQwnzcS8Sg17jQJbR9XMPFUnTR17JxDDUcdesUBTpwKEIObcYpJL08jJLC7R0NRU4IIywYShjpGOsaYOjA1jQWlNTU1M1TomCPVY9MJETAhqhmlAiMGNIKAVZocRhlZMV-DxCUyNjimUZa5jgaYfLgMyAN0EuCsIOhhrQOmQEURIBuH0MXZD4Z5E87qOGVADJJksWAChAQ)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 15 bytes
```
⬤θ⬤θ№⟦ιλυ⟧⁻ι⁻ιλ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMxJ0ejUEcBSjnnlwLFojN1FHJ0FEpjdRR8M/NKizUykRg5mmBg/f9/dHS0oY6RjrGOSawOkGUMJI0gbBALiEEiIH5sbOx/3bIcAA "Charcoal – Try It Online") Link is to verbose version of code. Outputs a Charcoal boolean, i.e. `-` for laminar, nothing if not. Explanation: Charcoal has no set intersection function, otherwise this would be a direct port of @mousetail's latest Python answer, but emulating list intersection using list difference does mean I get to use the predefined variable for an empty list.
```
 θ              Input list
⬤               All elements satisfy
   θ            Input list
  ⬤             All elements satisfy
      ι         Outer element
       λ        Inner element
        υ       Empty list
    №⟦   ⟧      Includes
           ι    Outer element
          ⁻     List difference
             ι  Outer element
            ⁻   List difference
              λ Inner element
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 13 bytes
```
.Am}@Fd+d.{Y*
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72koLIkY8GCpaUlaboWa_Ucc2sd3FK0U_SqI7UgYlCpBTd1o6sNdYx0jHVManWALGMgaQRhg1hADBIB8otTSzQ0YyG6AA)
### Explanation
```
.Am}@Fd+d.{Y*QQ    # implicitly add QQ
                   # implicitly assign Q = eval(input())
            *QQ    # cartesian product of Q and Q
  m                # map over lambda d
    @Fd            #   intersection of the elements of d
   }               #   is in
       +d.{Y       #   d plus the empty set
.A                 # return whether all elements are true
```
[Answer]
# [Arturo](https://arturo-lang.io), 56 bytes
```
$->x[some? x'a->some? x'b->¬∨∨a=a--b[]=a--b[]=b--a]
```
[Try it!](http://arturo-lang.io/playground?bAgc1W)
Inverts the output; `false` for laminar and `true` for not laminar.
```
$->x[               ; a function taking a set of sets x
    some? x'a->     ; is there some set a in x that
        some? x'b-> ; is there some set b in x that
            []=b--a ; the empty set equals b diff a
            ∨       ; or
            []=a--b ; the empty set equals a diff b
            ∨       ; or
            a=a--b  ; a diff b is unchanged
            ¬       ; logical not (we have to do it this way to accommodate empty input)
]                   ; end function
```
[Answer]
# [C (GCC)](https://gcc.gnu.org), ~~199~~ 197 bytes
* *-1 bytes thanks to [@Unrelated String](https://codegolf.stackexchange.com/users/85334/unrelated-string)*
* *-1 bytes thanks to [@ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)*
```
#define T int
#define A(p,z)*v){T b=0,i=0;for(;y;++i)b|=p;return b?z:!z;}
#define y v[i]
C(T x,T A(x==y,1)P(T z,T*s,T A(z-C(y,s),1)X(T*a,T*A(P(1,a,y)&P(1,y,a)&(P(0,a,y)|P(0,y,a)),0)f(T*A(!X(y,v),1)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=fVNdTttAEFbVp_gUQxDRrnGQQ6FFOEmFuAAPfkCKUORs1rDUsS3v2uSHXKEX6AsvfazUS_QQ5TSdsR0nAoose3e__ebb-WbWP36JNMo1veNbIX6P2t0wldlMaa0K2b55-pmbsHv298_-VIYqluCDio21WV2w1Flyu-ArHyYD11ED1wuTjHkL7_BQ8cnjIPUyafIshsnX5fne0ls3sQsoRurGumQ-zB0fpeaDwcLp8SsElo5v6xJcdi_ZwtEcN66Zbwe4ccGuWM8JnAXv0GThBLyDkFtCjzQhiDsuDxmx965RoSCFyszzx-_7KhZRPpXQL6QwSTa0tojQZqqSXUQl2mQymA0taz-PMX3wLSvXKr6FOJhJnQZCAkZ5lmXkLI0Cg0FmkUraBX9o1fHQSbC2AZ7X77MtlhsHRBJrA1UyfX8InYLDymrhHvT70F61PauFhQUW5CYBZWAAxdFE3qqYcY_WewTIeIrLMnITaiuDoS0VAsOO7PI4ws0BDtAJ6-2Ja1rXrUPMs9ZoDi2Re7wBYMgs2HaV8tgk4zRBXGasNlEPZtiYIXqKicfyAYw9Ko60WkrG4RB6N5U9Rsp0h0D1N9se0E0iRylel034iO7OC4FG4Z4U7vs7FBK5L0VKldE9CRXVjCLXpffablqaJaFZQPWtcp8jT9wFGQh03nptUksqdAOAHQXa1Ok2KIU-3KlIAtMiiEPWPpgeCKx-Z46v4NSebq9qILVsDoMtUBZQ4DmU-6uyI87JSkvULQwZcXnZTXxwoFAazPT8HK9AVNIRPBKRDDLG60q0ZKQlNMe7Vd2Il-b6bjwJxDdWuqvOe9vnjtJqw-oOtwJz3tR9Xf2WT88feLdn9eAYPoELNNLXxaeBT-qNLYFmJ29R3GZekV4QCDpuCLtKO1QCTvH7Bc5qQrVqKG5NezfBd9PbUN3_uTndUaTV53K7Ktk_)
Takes input as a double pointer to int (`int **`) which is zero terminated on both levels (hence `0` cannot be used as an element).
Note that the solution is in C, while the full snippet is in C++ because I used vectors to store the data after parsing.
---
[ungolfed solution](https://ato.pxeger.com/run?1=nVK7asMwFIVu1ldcJxAkcCDpVOwk0D1j6FJKkW25CGzZWJJJXPwlXbJ0LHTo1_RrKsWPOhQayCB0X5xzro7ePqIi1dKe55co-nyczJOClRmXklds8nR81yqZ333ffE25iFIdM1hVLFJ5uUHTmCVcMHjAOwJSxb7fdla7DRqa99strjzYe1B4UBNI8hIw1SqHvQ8VgVfgCeCCQMmULgXUATR97NYBQoplRUqV4VWHggmaMTD4YZ6nEOVCUS4kNoFUsIOZoWnjk6aZxUdOJ-FgVMB6be8lQc2_yFKHkik8xpLLc2x5O4DblmF2Bz0mMW0PFpd4qFD8Kq4rqPR-4LCo9nnOWeiJ5NegsDUIOdYht5NJPQjN7Az6QugBbQt4tM0wNqqdJglBjtP5uwiQ06A-WwYXNkj-6B_baxhdu6MN-_doP2_3h4_d_QM) (in C++)
[Answer]
# [Julia 1.0](http://julialang.org/), 43 bytes
```
~x=all(A⊆B||B⊆A||A∩B==[] for A=x,B=x)
```
[Try it online!](https://tio.run/##hZHNagMhEMfP9SkmBEKEYSFp2uQi7C7kCdrb4sGDISmWhNVQD8seS8ib5LXyIlt17X7Q0oLOh/Nz/KtvZ3UQC9s0tWVCqXl2v37mVZU7l1VVdr/ccsYKDrtjCRmzmDNLmylsrXg/KUlSvT9@QP0izbwgD8EtcImPnGKfDpI@5JS4QabwKrXRxJRnsz9IDQxco4IjOBt7YWjirJucY1fAVVsaID5a/cb4WhsH6ifhdy47ou81PtIv4ZOza9xEJGSe4WQnlO7vEI/1u/4RjX9LjuxI1ogPigb68LnVkwqtZWnAfywkdffGFGazuDhJ6m/VtPkC "Julia 1.0 – Try It Online")
-2 bytes thanks to MarcMush: square brackets aren't needed for an array comprehension that is passed to a function
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~45~~ 43 bytes
```
->a{a.all?{|x|a.all?{|y|[[],x,y].any?x&y}}}
```
[Try it online!](https://tio.run/##KypNqvyfpmD7X9cusTpRLzEnx766pqIGxqqsiY6O1anQqYzVS8yrtK9Qq6ytrf2vrJCTmJuZl1hkxVVQWlKskKanER2riWBHG@oY6RjH6oBoEAnEsZjyOiYQFUgqQSwTPEpBSiBssGKcCkHmGMEVIkzG6g6QjI4pkDTXsYCqBPNASrmUFfLySxDeRdULtsWYSK/pEOUxqBYUV2PTBnYwkvN1zIDK/gMA "Ruby – Try It Online")
]