Since it looks like no one else has tried programmatic search I thought I'd give it a try.
I wrote the following Haskell program which generates polyplets of size n and checks them for vanishing cases. Currently it ignores the symmetries of possible solutions.
data Polyplet = Polyplet {
members :: [(Int,Int)]
}
instance Eq Polyplet where
(Polyplet a) == (Polyplet b) = filter(`notElem`a)b ++ filter(`notElem`b)a == []
(Polyplet a) ! (Polyplet b) = filter(`notElem`a)b ++ filter(`notElem`b)a == []
instance Show Polyplet where
show (Polyplet p) = unlines [[if elem (x,y) p then '*' else ' '|x<-rangify[x|(x,_)<-p]]|y<-rangify[y|(_,y)<-p]]
children :: Polyplet -> [Polyplet]
children polyplet@(Polyplet p) = [zero $ Polyplet $ c : p | c <- uniquify $ allDeads polyplet]
zero :: Polyplet -> Polyplet
zero (Polyplet p) = do
let mx = minimum [x|(x,_)<-p];
let my = minimum [y|(_,y)<-p];
Polyplet[(x-mx,y-my)|(x,y)<-p];
rangify l = [minimum l..maximum l]
deadsAt :: Polyplet -> (Int,Int) -> [(Int,Int)]
deadsAt (Polyplet p) x = filter(`notElem`p) $ adjacents x
allDeads :: Polyplet -> [(Int,Int)]
allDeads polyplet@(Polyplet p) = uniquify $ p >>= deadsAt polyplet
uniquify :: (Eq a) => [a] -> [a]
uniquify u = [a|(a,b) <- zip u [0..],notElem a $ take b u]
adjacents :: (Int,Int) -> [(Int,Int)]
adjacents (a,b) = [(a+x,b+y)|x<-[-1..1],y<-[-1..1],(x,y)/=(0,0)]
sizeNpolyplets :: Int -> [Polyplet]
sizeNpolyplets 1 = [Polyplet [(0,0)]]
sizeNpolyplets n = uniquify $ sizeNpolyplets (n-1) >>= children
vanishing :: Polyplet -> Bool
vanishing polyplet@(Polyplet p) = all ((`notElem`[5,6]).length.deadsAt polyplet) p && all ((/=5).length.deadsAt polyplet) (allDeads polyplet)
You can envoke it like so in ghci
mapM_ print $ filter vanishing $ sizeNpolyplets 7
This will make a nice little ascii diagram of the found polyplets. If you want the raw data you can use
mapM_ (print.members) $ filter vanishing $ sizeNpolyplets 7
instead.
The program is not very fast but I have been able to confirm that there are no solutions of size $n=5$ or $n=6$ using my laptop. Perhaps better techniques/more powerful computers can exhaust larger cases.