[Question]
  [
### Task
Given the situation with this global pandemic, you've been enlisted to help maintain social distancing. Your challenge, should you choose to accept it, is to write a program that takes in the positions of a group of people and checks whether the group is following social distancing rules. Your program must output a truthy value if social distancing guidelines are being met else output a falsy value.
People must always be six spaces apart:
```
[[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]] -> True
[[1, 0, 0, 0, 0, 0, 0, 1]] -> True
[[1, 0, 0, 0, 0, 0, 1]] -> False
[[1, 0, 0, 1]] -> False
[[1],
 [0],
 [0],
 [0],
 [0],
 [1]] -> False
[[1],
 [0],
 [0],
 [0],
 [0],
 [0],
 [0],
 [1]] -> True
```
For the purpose of this challenge, instead of measuring distance with Pythagoras's theorem, we measure the distance as the length of the shortest path between two people, so this example outputs true:
```
[[1, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 1,]] -> True
```
Since the shortest path passes through at least six squares.
```
[[1, █, █, █, █,],
 [0, 0, 0, 0, █,],
 [0, 0, 0, 0, █,],
 [0, 0, 0, 0, 1,],]
```
Your algorithm must be deterministic (i.e., always produce the same output).
Your program should also, at least in theory, work for inputs containing more than five people and needs to work for a two dimensional input.
### Input and Output
Your input can be the a nested array in STDIN or any other input format that doesn't break the [standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default).
Output has to be written to STDOUT or closest alternative. Output should consist of a [truthy or falsy value](http://meta.codegolf.stackexchange.com/a/2194) (or a string representation thereof).
### Additional Rules and Examples
```
[[1, 0, 0, 0, 0, 0, 1, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 1, 0, 0, 0, 0, 0, 1,]] -> False
[[1, 0, 0, 0, 0, 0, 0, 1, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 1, 0, 0, 0, 0,]] -> True
[[1, 0, 0, 0, 0, 0, 0, 1, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 1, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [1, 0, 0, 0, 0, 0, 0, 0, 1,]] -> True
[[1, 0, 0, 0, 0, 0, 0, 1, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 1, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 1, 0,],
 [0, 1, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 1, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 1, 0,],
 [0, 0, 0, 1, 0, 0, 0, 0, 0,],
 [0, 0, 0, 0, 0, 0, 0, 0, 0,],
 [1, 0, 0, 0, 0, 0, 0, 0, 1,]] -> False
```
* Submissions in most languages will be scored in *bytes* in an appropriate preexisting encoding, usually (but not necessarily) UTF-8.
The language [Piet](http://www.dangermouse.net/esoteric/piet.html), for example, will be scored in codels, which is the natural choice for this language.
Some languages, like [Folders](http://esolangs.org/wiki/Folders), are a bit tricky to score. If in doubt, please ask on [Meta](http://meta.codegolf.stackexchange.com/).
* If your language of choice is a trivial variant of another (potentially more popular) language which already has an answer (think BASIC or SQL dialects, Unix shells or trivial Brainfuck derivatives like Headsecks or Unary), consider adding a note to the existing answer that the same or a very similar solution is also the shortest in the other language.
* Unless they have been overruled earlier, all standard [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") rules apply.
  
[Answer]
# [Python 2](https://docs.python.org/2/) with `SciPy`, ~~105 101~~ 99 bytes
*-1 byte thanks to @vroomfondel !*
```
lambda l:N.all(S.convolve2d(l,N.outer(*[N.r_[:7]-3]*2)**2<9)<2)
import numpy as N,scipy.signal as S
```
[Try it online!](https://tio.run/##1VTRbpswFH33VxyxF0gIKuxhGmr6srVSX9hD@sZQ5ILTWjO2ZZtkfH1mmmhb1tCsWqduEkLce8895/gaW/fuXslsu5p/3gra3jYUIi8SKkS4SGol10qsWdaEIi4S1TlmwklZJGZZ5u@q2dtqkkWTSXb@PjrPIsJbrYyD7Frdg1oUsa257hPL7yQVQ2axbdgKd8wtBZcsjHICZ/ochrnOSBi6WXKpOxdGBOxrzbTD5aerS2OU@Q4qlGSEbO65YEg9wRtfoA0oHLMONbUMK6NaLG4@XhcEFvOfBAn4yqe4faDJcet7vxDs2ILZRQCpHLiEzS2mh50/vr0ma7XrMYQEIgaVdsOMl2qpDtma@pRNrBbchQNrFJHB6OCQeLu2E85jV6HwtNpw6fbJGEEZTMNdMJ/vWalsEHxQxrDaBVAGwbWs92E0DapgW5ZpjLMnn7SqMLvAjen89EbwJzF7wBUV9hDxqFDFBOXZyPt56COdxx3ucM9OpfHJZT9JiJOSf4g4ZmhsIx7ZPiH2T5V/2c7f@GH/8xW@trWxWyP9a8N/oQEcaKevqD1yQl9i@A@H@xs "Python 2 – Try It Online")
A function that takes in a 2D list, and returns a boolean representing whether social distancing guidelines are met.
### Big idea
For each position in the array, there can only be at most 1 person within a 3 unit radius around that position. (If there are 2 people near that position, then they are at most 5 units apart.)
We can use convolution to count how many people are within a 3 unit radius of any point. The kernel specifies all positions at most 3-unit away from the current point:
```
[[0 0 0 1 0 0 0]
 [0 0 1 1 1 0 0]
 [0 1 1 1 1 1 0]
 [1 1 1 1 1 1 1]
 [0 1 1 1 1 1 0]
 [0 0 1 1 1 0 0]
 [0 0 0 1 0 0 0]]
```
After convolution, we just need to check if all positions are less than 2.
The following examples show the results of the convolution (`0` is replaced with `.` for visual clarity):
```
                   ...1......1....
                   ..111....111...
                   .11111..11111..
1......1.          11111111111111.
.........          .11111..11111..
.........          ..111....111...
.........     -->  ...1...1..1....
.........          ......111......
.........          .....11111.....
....1....          ....1111111....
                   .....11111.....
                   ......111......
                   .......1.......
                   ...1......1....
                   ..111....111...
                   .11111.111111..
1......1.          11111122211111.
.........          .111121122211..
....1....          ..1131111332...
.........          ...2121222211..
.......1.          ..111133311111.
.1.......     -->  .111122322211..
....1....          ..1122311332...
.........          ...1132222211..
.......1.          ...12123311211.
...1.....          ..12211222222..
.........          .1112211122211.
1.......1          111112211121111
                   .111111..11111.
                   ..111.....111..
                   ...1.......1...
```
### Code explanation
The only tricky part is to create the kernel. First, we use `numpy.outer` to find the outer product of 2 arrays:
```
>> numpy.r_[:7]
[0 1 2 3 4 5 6]
>> numpy.r_[:7] - 3
[-3 -2 -1 0 1 2 3]
>> numpy.outer([-3,-2,-1,0,1,2,3], [-3,-2,-1,0,1,2,3])
[[ 9  6  3  0 -3 -6 -9]
 [ 6  4  2  0 -2 -4 -6]
 [ 3  2  1  0 -1 -2 -3]
 [ 0  0  0  0  0  0  0]
 [-3 -2 -1  0  1  2  3]
 [-6 -4 -2  0  2  4  6]
 [-9 -6 -3  0  3  6  9]]
```
Then, we only keep the elements whose absolute value is less than 3.
```
>> numpy.outer(...)**2 < 9
[[0 0 0 1 0 0 0]
 [0 0 1 1 1 0 0]
 [0 1 1 1 1 1 0]
 [1 1 1 1 1 1 1]
 [0 1 1 1 1 1 0]
 [0 0 1 1 1 0 0]
 [0 0 0 1 0 0 0]]
```
[Answer]
# [R](https://www.r-project.org/), 42 bytes
```
function(m)all(dist(which(m>0,T),"man")>6)
```
[Try it online!](https://tio.run/##K/qfZqP7P600L7kkMz9PI1czMSdHIyWzuESjPCMzOUMj185AJ0RTRyk3MU9J085M83@aRlFqYopecnGZRoatm05xaoGtkoKSTklqRYmtkqGCARZoqKSpyUWCPtLUE1TNhVDOZYCHZahAgklg9WgmKWAxnSgxcr0D08xFhGUUisDtHOTOo5rJhqQmYtI8TryDIeYYUskctORGpMf/AwA "R – Try It Online")
Pretty self-explanatory - anonymous function that checks whether Manhattan distances between the coordinates of each non-zero entry of the input is greater than 6.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~18~~ 17 bytes
-1 thanks to Bubbler.
Full program. Input: Expression for Boolean (0/1) matrix via STDIN. Output: 0 or 1 to STDOUT.
```
(×≡6∘<)+/¨|∘.-⍨⍸⎕
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKO94L/G4emPOheaPeqYYaOprX9oRQ2Qpaf7qHfFo94dj/qmghT9VwCDAq5HbROBQl7B/n7q0dGGOgoGeJFhbKw6F/FaSVFOhFo8SmJ1FKINsBBkaCFKM7LbwepJEiApXHAbi4aoKm9IcdwTsnEwSKLG43D33wA5yJBKhckAeB7JTsMBsBN7VqQowAE "APL (Dyalog Unicode) – Try It Online")
`⎕` prompt for matrix
`⍸` **ɩ**ndices of trues
`∘.-⍨` (y,x) distances between all combinations of coordinate pairs
`|` absolute value
`+/¨` sum each (this gives a matrix of Manhattan distances)
`(`…`)` apply the following tacit function to that:
 `6∘<` the matrix mask indicating (0/1) where greater than six
 `×≡` does it match the matrix of signums (0/1)?
In effect, this checks if all non-zero distances are greater than six.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 [bytes](https://github.com/DennisMitchell/jelly)
```
ŒṪŒcạ/€§>6Ạ
```
A monadic Link accepting a multi-dimensional list which yields an integer: `1` if distancing has been maintained; `0` if not.
**[Try it online!](https://tio.run/##y0rNyan8///opIc7Vx2dlPxw10L9R01rDi23M3u4a8H///@jow11FAxQEZJIrA6XQrQBhgoDWqrA5qDYWAA "Jelly – Try It Online")** Or see the [test-suite](https://tio.run/##y0rNyan8///opIc7Vx2dlPxw10L9R01rDi23M3u4a8H/w@1Azv//0dHRhjoKBniRYWwslw4OdTjl0CVg/FgdLgWFaAM8FPEqsetDcQdUBRlihjo4vYbfKAXCtlGsBJuj8MUSMbYMPnm0qBzu/hsU7sNVGtAifVHN/6j2Gw6w/TiyKBXCPxYA "Jelly – Try It Online").
### How?
```
ŒṪŒcạ/€§>6Ạ - Link: list
ŒṪ          - multi-dimensional truthy indices
  Œc        - pairs
      €     - for each:
     /      -   reduce by:
    ạ       -     absoulute difference (vectorises)
       §    - sums
        >6  - greater than six? (vectorises)
          Ạ - all truthy?
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~59~~ 48 bytes
*Saved 11 bytes and removed the imperfections thanks to user202729's great comment!*
```
Min[Tr@Abs[#-#2]&@@@#~Position~1~Subsets~{2}]>5&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b73zczLzqkyMExqThaWVfZKFbNwcFBuS4gvzizJDM/r86wLrg0qTi1pLiu2qg21s5U7X9AUWZeSXSaQ3W1oY6CASoyrK2N5cKpACT7HwA "Wolfram Language (Mathematica) – Try It Online")
Unnamed function taking an array of `0`s and `1`s as input and returning `True` or `False`.
* `#~Position~1` finds the coordinates of the people in the input array.
* `~Subsets~{2}` collects all unordered pairs of such coordinates.
* `Tr@Abs[#-#2]&@@@` sums the absolute values of coordinatewise differences inside each such pair.
* `Min[...]>5&` tests whether the differences comprise sufficient social distancing.
In addition to being shorter than the other Mathematica answer, this implementation has the property that *it works on inputs of any dimensions* (even uneven arrays). Social distancing in spacetime, anyone...?
[Answer]
# JavaScript (ES6), ~~93 84 82~~ 80 bytes
Takes a binary matrix as input and returns a Boolean value.
```
f=(m,X,Y)=>m.every((r,y)=>r.every((v,x)=>v?1/X?x<X|x-X+y-Y>6:f(m,x,y,r[x]--):1))
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zVYjVydCJ1LT1i5XL7UstahSQ6NIpxLILYJxy3QqgNwye0P9CPsKm4iaCt0I7UrdSDszqzSg3gqdSp2i6IpYXV1NK0NNzf/J@XnF@Tmpejn56RppGtFcCtGGOgoGqAhJJFYHqMIAQ4UBLVVgc1AsV6ympoK@voJbYk5xKhcXMd6AGUXA/kEljeoLuK9DikpHjqcH2mmGOKQN6RkfVAoTFLsNB9BuHFmbSvEBLhX@AwA "JavaScript (Node.js) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 20 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
˜ƶ0K<Iнg‰2.Æε`αO7@}P
```
[Try it online](https://tio.run/##yy9OTMpM/f//9Jxj2wy8bTwv7E1/1LDBSO9w27mtCec2@ps71Ab8/x8dbahjAIGxOtEGBNiGsbEA) or [verify all test cases](https://tio.run/##yy9OTMpM/V@m5JlXUFpipaCkU3lot46Sf2kJhGtf@f/0nGPbDLxtKi/sTX/UsMFI73Dbua0J5zb6mzvUBvzXObTN/n90dLShjgEWaBgbq4MuhymGLAJlAwkDNIxbBk0FzFyQKAE2FrdgqtfBagrRooaEwgO7CTQUQ4TQ4HIN9e0wJCY9UtmFMPMMqWweWloi3sexAA).
**Explanation:**
```
˜                     # Flatten the (implicit) input-matrix
 ƶ                    # Multiply each value by its 1-based index
  0K                  # Remove all 0s
    <                 # Decrease each by 1 to make it 0-based indexing
     I                # Push the input-matrix again
      нg              # Pop and get the width of the matrix (length of the first row)
        ‰             # Divmod each integer by this row-length to get all coordinates
         2.Æ          # Get all possible pairs of coordinates
            ε         # Map each pair of coordinates to:
             `        #  Pop and push the coordinates separated to the stack
              α       #  Take the absolute differences of both the x and y coordinates
               O      #  Sum those two together
                7@    #  And check whether it's >= 7
                  }P  # After the map: check if all were truthy
                      # (after which the result is output implicitly)
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 63 bytes
```
2>Max@ListConvolve[Table[Boole[i<j],{i,8},{j,8}],#~ArrayPad~9]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2Yb89/IzjexwsEns7jEOT@vLD@nLDU6JDEpJzXaKT8fSGbaZMXqVGfqWNTqVGcByVgd5TrHoqLEyoDElDrLWLX//nkOjsXFqUUlXFwBRZl5JQ5pDtXVhjoKBniRYW0tIeWoSgxQeEAOXu04jEcVNgLy/gMA "Wolfram Language (Mathematica) – Try It Online")
The list convolution kernel `Table[Boole[i<j],{i,8},{j,8}]` can be generated as `UpperTriangularize@ConstantArray[1,{7, 7}]` too (using more built-in), but that's longer.
Unlike most (all?) other solutions posted, this solution only have time complexity O(n) in terms of the input size (with a possibly large constant factor)
[Answer]
# [Python 3](https://docs.python.org/3/), 99 bytes
Takes as input a list of lists \$ l \$, and outputs `True` if social distancing is *not* followed, and `False` otherwise. 
```
eval(f"lambda l:any(s&q>0<abs(a-c)+abs(b-d)<7{'for %s,%s in enumerate(%s)'*4%(*'aplbqpcrldsr',)})")
```
[Try it online!](https://tio.run/##1VRRa4MwEH73V9wKLrlOh2GDQal93C/Ym/MhaqRCam1ON8rYb3dVBttq1Y5udIMQwt139313yaXYlst1flOn/mOtnqTm6UTLVZRI0DOZbzldbhbeXEbEpRvjVXOI3ATndy8sXRuwybEJshxUXq2UkaXiNiGb3tp8ymSho00RG52QYQ6@4gTr52WmFYiZBbEkBf4utqhKjtdU6KzkDNwFMLRAEilTQspbUQ028EJEuPDhwyJCrINAOOANLhGGTdoHUymrBz4GefffS01fAPv20IGdzu52LK4TcVBRC/qmRThjJQ5lgzG6kwCHxPQ0vKN4mOmvePfub/w9/tvSzqiq7yMQv9PwHyn8M684E2/PEJ7e8HZ63wA "Python 3 – Try It Online")
## Explanation
We can reduce the following code to 99 bytes by using the fact that the expression `for a,b in enumerate(c)` is used a total of four times, which can be condensed.
### [Python 3](https://docs.python.org/3/), 111 bytes
```
lambda l,E=enumerate:any(s&q>0<abs(a-c)+abs(b-d)<7for a,p in E(l)for b,q in E(p)for c,r in E(l)for d,s in E(r))
```
[Try it online!](https://tio.run/##1VRNb4MwDL3zK7zLGmthItphUlV6637BboyDgaAipTRNwqb@elbopHWlwKpu6iZFUez3Yj87H3rrluvyoc7Dl1rRKskIFF@EsqxW0pCTUyq3zN5u5sGMEsvIT/GuWSR@hrPHfG2AuIaihAVT2JgJ3@xN3ZopN4doxu3eNIj127JQEsTUg5SshHCH6MoxvLdaFY5NwJ/DBD0ga6VxkDP5Soo13CiIEeEmhE@PiLGOIsEhGBwijpuwz6aSXg99jPKBP5GyXwjH/pjDTmd3@i6vs@OkopZ0pkfwsRKHosFYuosIp8T0NLyjeDjTX0GPzm/8Pv7b0q6oqu8jEL/T8B8p/DCvuFLenkd4ecPb1/sO "Python 3 – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~18~~ 17 bytes
```
1Ya&fht1&ZP7<zGz=
```
Outputs `1` if the input satisfies the distance rule, and `0` otherwise.
[Try it online!](https://tio.run/##y00syfn/3zAyUS0to8RQLSrA3KbKvcr2//9oQx0FA1SEELFGl0JBVJLF4oBYAA) Or [verify all test cases](https://tio.run/##y00syfmf8N8wMlEtLaPEUC0qwNymyr3K9r9LVEXI/2hDHQUDvMgwlgu7IuwSKKJgjrWCARLCIoQkgWkcnG2N151UkjUkwfv4zR04KRTXDm3X09cZhiTnADp6DG6XIR3twp4pyAxEAA).
### Explanation
Consider the following input as an example:
```
[1 0 0 0 0 0 1 0 0 0;
 0 0 0 0 0 0 0 0 0 0;
 0 0 0 0 0 0 0 0 0 0;
 0 0 0 0 0 0 0 0 0 0;
 0 0 0 1 0 0 0 0 0 1]
```
```
      % Implicit input
1Ya   % Padarray with size 1 along the first dimension. This extends the
      % input with two rows of zeros. The purpose if this is to ensure that
      % the modified input will never be a row vector
      % STACK: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0;
                1, 0, 0, 0, 0, 0, 1, 0, 0, 0;
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0;
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0;
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0;
                0, 0, 0, 1, 0, 0, 0, 0, 0, 1;
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
&f    % Two-output find: row and column indices of nonzeros. This gives the
      % result as column vectors (it would give row vectors if the input
      % argument were a row vector, but the previou steps ensures that will
      % not happen) 
      % STACK: [1; 5; 1; 5], [1; 4; 7; 10]
h     % Concatenate horizontally
      % STACK: [1 1; 5 4; 1 7; 5 10]
t     % Duplicate
      % STACK: [1 1; 5 4; 1 7; 5 10], [1 1; 5 4; 1 7; 5 10]
1&ZP  % Cityblock distance between rows of the two matrices. Gives a matrix
      % with the distances. The diagonal contains 0
      % STACK: [0  7  6 13;
                7  0  7  6;
                6  7  0  7;
               13  6  7  0]
7<    % Less than 7? Element-wise. The diagonal contains 1. An off-diagonal
      % entry is 1 if and only the distance condition is not satisfied for
      % that pair of people
      % STACK: [1 0 1 0;
                0 1 0 1;
                1 0 1 0;
                0 1 0 1]
z     % Number of nonzeros
      % STACK: 8
Gz    % Push input again. Number of nonzeros
      % STACK: 8, 4
=     % Equal?
      % STACK: 0
      % Implicit display
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 87 bytes
```
M`10{0,5}1|(?<=(.)*)(?=(1)){6}(?<-2>.*\n)+(?>(?<-1>.)*)((?<-2>0)*1|0(?<=1(?<-2>0)*))
^0
```
[Try it online!](https://tio.run/##K0otycxL/P/fN8HQoNpAx7TWsEbD3sZWQ09TS1PD3lbDUFOz2qwWKKRrZKenFZOnqa1hbwfiGtqBlUBkDDS1DGsMQBoN4QKamlxxBv//G0CAoQGXIZRpwGWAg2WIVxasgssAZgwA "Retina 0.8.2 – Try It Online") Takes input as a linefeed-separated character array and outputs `1` or `0` (outputting `0` or `1` would save 3 bytes; outputting `0` or non-`0` would save 5 bytes). Explanation:
```
10{0,5}1|
```
Are two `1`s on the same row fewer than 6 `0`s apart? Otherwise,
```
(?<=(.)*)
```
Count the current column in `$#1`.
```
(?=(1)){6}
```
Store 6 in `$#2`, plus ensure that we're matching a `1`.
```
(?<-2>.*\n)+
```
Move down rows, decrementing `$#2` each time. (If `$#2` runs out, this match fails, so the regex engine has to try fewer rows or starting at a different `1`.)
```
(?>(?<-1>.)*)
```
Move across to column `$#1`.
```
((?<-2>0)*1|0(?<=1(?<-2>0)*))
```
Try looking either right or left for a `1` that is no more than `$#2` `0`s away, meaning that it is not sufficiently distant.
```
M`
^0
```
The above regex looks for insufficiently distant pairs, so check whether none were found to give the desired result.
[Answer]
# [JavaScript (V8)](https://v8.dev/), 126 bytes
```
e=>(e.map((w,x)=>w.map((t,y)=>t?p.push({x,y}):''),p=[],d=Math.abs),p.every(r=>p.filter(t=>d(r.x-t.x)+d(r.y-t.y)<7).length==1))
```
[Try it online!](https://tio.run/##zVLBSsRADL33K/bWBGdD56SIqV/gF5Qext3pdmXcDjPZbgfx22vXgiAqyuKhIYeX8HgJeXkyvYmbsPey7m/GhkfLJVh6Nh7gpAbk8jQXotJUyL0nf4wtvAwqveJtnqPyXNVqyw9GWjKPcWqQ7W1IELj01Oyd2ADC5RYCDWuhAa/OME0w4d01krOHnbTMGnHcdIfYOUuu20HeGBct5ypbTdFAVel6xlXxB6DrGjPMPilKOF4ueOEItSq@5HvzQ@47RrF0hl70pvoHhlazZdkvj/Zvpuklm3Y@xfgG "JavaScript (V8) – Try It Online")
[Answer]
# perl -E, 157 bytes
```
@b=map{[/\d/g]}<>;for$x(@a=keys@b){for$z(@a){for$y(@c=keys@{$b[0]}){for$w(@c){$t||=$b[$x][$y]&&$b[$z][$w]&&abs($x-$z)+abs($y-$w)<7&&($x!=$z||$y!=$w)}}}}say$t
```
[Try it online!](https://tio.run/##zY69DoIwEIB3n6ImF0IjSDsQB4HwAm5utQMoGuMPhGKgBV7dWmBUdy6X3JfvW67IyruvdZyGj6RomXc4eRfeB9H2nJfQ2HES3jIp4hS3g1BGTCTt@DilFlJGeD/p2mjcQtV1odHQcAaSW9bAynBtOEmFDY0LCq9GlC7UONhYlrHLEFTXgTS3xr0ZkUiotGaMOoh87Si5s0CM/MpkdpnO6zX6J1OHc@RGaF@@sndeVNf8KbS789eEkg8 "Perl 5 – Try It Online")
Prints a false value (0, or empty string) if all people are at least distance 6 away, and prints 1 if there is at least one pair of people with less distance.
[Answer]
# [Python 3.8 or newer](https://docs.python.org/3.8/), ~~137~~ 135 bytes
```
lambda m:(p:=[(r,c)for r in range(len(m))for c in range(len(m[0]))if m[r][c]])and all(abs(a-c)+abs(b-d)>6for(a,b),(c,d)in zip(p,p[1:]))
```
[Try it online!](https://tio.run/##3VRNT4QwEL33V0z2wkwsCbhGDQl79Bd46/ZQoCgJsE0piUr47Qj4EdHdeHDNGpummb55nY@mfebR3e/q9bWxQx5vh1JVSaagitBEsUDLU8p3FiwUNVhV32ksdY0VzWj6CRWBJCpyqISVIpWSVJ2BKktUSYPKT@lsMhI/o83leB4VT4hjyjMa4zwVBg03IozGIIPTjWsgBmRChByC5fyASM5ABF8YwW8y9hUkR8q@Ut/o3@T4U@5lF/@4s1OXFh5wH/85HanxRe7whLkPfMSfXzox/WAm4blRZaM53Nr2fZ0hYjbG1tu251cXqcfhxQzXHrFJEx3X8Kpms4bxMRxFDMYx6VmOjuaNsUXtMF91rgd/A13TQ2dFE8da9isangE "Python 3.8 (pre-release) – Try It Online")
]