Is it a lobster number? Introduction
A &quot;lobster number&quot;, by my own designation, is a number that contains within itself all of its prime factors.  The &quot;lobster&quot; description was inspired by the recent question &quot;Speed of Lobsters&quot;.  The basic idea is that each prime factor can be made by lobsters munching away digits of the number until you are left with just the factor.
Example: 51375 is a lobster number, since its prime factors are [3,5,137], which can be made by lobsters thusly: [***3*, 5**** / ****5, *137*].   Another lobster number is 62379, as the factors [3,29,239] can be formed as [**3**,*2**9,*23*9].
Challenge
Given a number as input, return whether it is a lobster number or not.  Preferentially this is a boolean output, such as 1 or 0, or True or False.
Astute readers may realize that prime numbers are a trivial solution to this requirement, but since they don't allow the lobsters to eat any digits, they are out. Your program must not identify prime numbers as lobster numbers.
This is similar to OEIS A035140, but has the additional requirement that each digit of the factor must appear at least the same number of times in the number, and in the correct order. In other words, 132 is not a lobster number, since its factors are [2,3,11], and the 11 cannot be made by munching away at just 132.  312 is also not a lobster number, because its factors are [2,3,13], and 13 is out of order.
I believe the &quot;mathematical&quot; definition would be: &quot;Determine if the number n is a composite number such that all prime factors of n are a subsequence of n&quot;.
Test Cases
59177  -&gt; True
62379  -&gt; True
7      -&gt; False
121    -&gt; True
187    -&gt; False
312    -&gt; False

As always, Standard Loopholes are forbidden.
Note:
It has come to my attention that the original reasoning I gave for not needing to handle 0 or 1 as input is faulty.  However, requiring the proper output at this point would invalidate a number of answers.  Therefore, let it hereby be known that neither 0 nor 1 are lobster numbers, but you also do not need to handle them as input (they are not valid test cases). If your code does handle them correctly, you may give yourself the Lobster Advocate Badge™.
Python 3, 155, 126, 124, 123, 120 116, 113 bytes

Yes! First python answer!
Saved 21 bytes due to a suggestion by Dominic van Essen to remove the for loop!
Saved 8 bytes because I realized I could use t*=True/False instead of t+=[True/False].
Saved another 2 bytes right after I finished editing because I realized t could simply be set to the same value as i and l!
Saved 1 byte based off Danis's python 2 comment.
Saved another 3 bytes based off Tipping Octopus's comment.
Saved another 4 bytes due to Tipping Octopus again!
Saved another 3 bytes thanks to Dominic's suggestion to remove the t variable.
New Answer
x=input()
n=int(x)
i=l=2
while~-n:
 if n%i:i+=1
 else:n//=i;l+=1;j=iter(x);l*=2*all(c in j for c in str(i))
print(l&gt;4)

How it works
The while loop computes the prime factors of the input. If a prime factor is found, it checks if it is a subsequence of the input. l is multiplied by whether or not this is True. This takes advantage of the fact that python's True and False values act like 1s and 0s when you multiply by them. This means that instead of appending True/False to t and checking whether all(t) is True like in my old answer, I can just multiply l by 2*True/False and check its value in the print statement. The print statement prints True if l&gt;4.
Try it online!
Old Answer
x=n=int(input())
l=[]
i=2
while i&lt;=n:
 if n%i:i+=1
 else:n/=i;l+=[i]
t=[]
for p in l:i=iter(str(x));t+=[all(c in i for c in str(p))]
print(all(t)*len(l)&gt;1)

Try it online!