[Question]
  [
*Redivosite is a portmanteau word invented for the sole purpose of this challenge. It's a mix of Reduction, Division and Composite.*
## Definition
Given an integer **N > 6**:
* If **N** is prime, **N** is not a Redivosite Number.
* If **N** is composite:
	+ repeatedly compute **N' = N / d + d + 1** until **N'** is prime, where **d** is the smallest divisor of **N** greater than 1
	+ **N** is a Redivosite Number if and only if the final value of **N'** is a divisor of **N**
Below are the 100 first Redivosite Numbers (no OEIS entry at the time of posting):
```
14,42,44,49,66,70,143,153,168,169,176,195,204,260,287,294,322,350,414,462,518,553,572,575,592,629,651,702,726,735,775,806,850,869,889,891,913,950,1014,1023,1027,1071,1118,1173,1177,1197,1221,1235,1254,1260,1302,1364,1403,1430,1441,1554,1598,1610,1615,1628,1650,1673,1683,1687,1690,1703,1710,1736,1771,1840,1957,1974,2046,2067,2139,2196,2231,2254,2257,2288,2310,2318,2353,2392,2409,2432,2480,2522,2544,2635,2640,2650,2652,2684,2717,2758,2760,2784,2822,2835
```
## Examples
* **N = 13**: 13 is prime, so 13 is not a Redivosite Number
* **N = 32**: 32 / 2 + 3 = 19; 19 is not a divisor or 32, so 32 is not a Redivosite Number
* **N = 260**: 260 / 2 + 3 = 133, 133 / 7 + 8 = 27, 27 / 3 + 4 = 13; 13 is a divisor or 260, so 260 is a Redivosite Number
## Your task
* Given an integer **N**, return a truthy value if it's a Redivosite Number or a falsy value otherwise. (You may also output any two distinct values, as long as they're consistent.)
* The input is guaranteed to be larger than **6**.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in bytes wins!
  
[Answer]
## Haskell, ~~91~~ ~~85~~ ~~83~~ ~~80~~ ~~75~~ 74 bytes
```
n#m=([n#(div m d+d+1)|d<-[2..m-1],mod m d<1]++[mod n m<1&&m<n])!!0
f x=x#x
```
[Try it online!](https://tio.run/##FcmxCsMgEADQvV9xwRISTMTr0kW/RBwCF6nUu4Y0FIf@uyHj472W73stpTVR7IcgaqD8AwbSpHH8k5vDwxieMU78oSscRq3DBQF22PfsJI5dZ28Jqq@qNl6ygIdtz3LAHVIux7pDgvA0Bq21sZ0 "Haskell – Try It Online")
```
f x=x#x                           -- call # with x for both parameters
n#m               
         |d<-[2..m-1],mod m d<1   -- for all divisors d of m
    [n#(div m d+d+1)           ]  -- make a list of recursive calls to #,
                                  -- but with m set to m/d+d+1
   ++ [mod n m<1&&m<n]            -- append the Redivosite-ness of n (m divides n,
                                  -- but is not equal to n)
                           !!0    -- pick the last element of the list
                                  -- -> if there's no d, i.e. m is prime, the
                                  --    Redivosite value is picked, else the
                                  --    result of the call to # with the smallest d
```
Edit: -2 bytes thanks to @BMO, -3 bytes thanks to @H.PWiz and ~~-5~~ -6 bytes thanks to @Ørjan Johansen
[Answer]
# [Husk](https://github.com/barbuz/Husk), 14 bytes
```
?¬Ṡ¦ΩṗoΓ~+→Πpṗ
```
[Try it online!](https://tio.run/##yygtzv7/3/7Qmoc7Fxxadm7lw53T889NrtN@1Dbp3IICIO////9GFsamAA "Husk – Try It Online")
-3 thanks to [H.PWiz](https://codegolf.stackexchange.com/users/71256/h-pwiz).
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~94~~ 89 bytes
```
m,n;o(k){for(m=1;m++<k;)if(k%m<1)return m;}
F(N){for(n=N;m=o(n),m-n;n=n/m-~m);N=m<N>N%n;}
```
[Try it online!](https://tio.run/##NcxNCsIwEEDhvacohUCGJEgWupnEpcu5g8RGQpiphHYl9erxD/fve8ndUuqdreCsKzzy3DRHj2xMqAgl66o4eGjTsjYZGLfdWdOvk0jIcdYClp2gRNmzezIgRQ50IiW4db4U@QOKRzSGgp8O3/XnBPdWZMl6VFc7jJbgbV4 "C (gcc) – Try It Online")
# Explanation
```
m,n;                  // two global integers
o(k){                 // determine k's smallest divisor
 for(m=1;m++<k;)      // loop through integers 2 to n (inclusive)
  if(k%m<1)return m;} // return found divisor
F(N){                 // determine N's redivosity
 for(n=N;             // save N's initial value
  m=o(n),             // calculate n's smallest divisor (no name clash regarding m)
  m-n;                // loop while o(n)!=n, meaning n is not prime
                      //  (if N was prime, the loop will never be entered)
  n=n/m-~m);          // redivosite procedure, empty loop body
 N=m<N>N%n;}          // m<N evaluates to 0 or 1 depending on N being prime,
                      //  N%n==0 determines whether or not N is divisible by n,
                      //  meaning N could be redivosite => m<N&&N%n==0
                      //  <=> m<N&&N%n<1 <=> m<N&&1>N%n <=> (m<N)>N%n <=> m<N>N%n
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 14 bytes
```
ÆḌḊ
Ç.ịS‘µÇ¿eÇ
```
[Try it online!](https://tio.run/##ASwA0/9qZWxsef//w4bhuIzhuIoKw4cu4buLU@KAmMK1w4fCv2XDh/83w4cxMDAj/w "Jelly – Try It Online")
### How it works
```
ÆḌḊ         Helper link. Argument: k
ÆḌ          Yield k's proper (including 1, but not k) divisors.
  Ḋ         Dequeue; remove the first element (1).
Ç.ịS‘µÇ¿eÇ  Main link. Argument: n
     µ      Combine the links to the left into a chain.
      Ç¿    While the helper link, called with argument n, returns a truthy result,
            i.e., while n is composite, call the chain to the left and update n.
Ç             Call the helper link.
 .ị           At-index 0.5; return the elements at indices 0 (last) and 1 (first).
              This yields [n/d, d].
   S          Take the sum.
    ‘         Increment.
        Ç   Call the helper link on the original value of n.
       e    Test if the result of the while loop belongs to the proper divisors.
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~97~~ 91 bytes
```
r=0;e=d=i=input()
while r-e:e=i;r=[j for j in range(2,i+1)if i%j<1][0];i=i/r-~r
d%e<1<d/e<q
```
[Try it online!](https://tio.run/##TY5ND8FQEEX38ysmTSQE4fF8tX1LlmzsxKLawRSvNZ5g469XKxLd3MlNzpzc/OWOmR0UcZYQGvQ8rxDTD8gkhg3b/O6aLXgc@UwoXfLJcCBmk@I@E0yRLUpkD9QcdLitWrxHbqSh2m7626B870n3LZA0KFRh0qPwWpT@n20td/IB0cmrOoj0pBirGd@WC1uHi@h8qzo9Y8odLqMLzUUy8WtMJfoj89WiRuyEolOhhqA0qBFoDbrMMegJ6Cno2Qc "Python 2 – Try It Online")
Outputs via exit code.
### Ungolfed:
```
r = 0                             # r is the lowest divisor of the current number,
                                  # initialized to 0 for the while loop condition.
e = d = i = input()               # d remains unchanged, e is the current number
                                  # and i is the next number.
while r != e:                     # If the number is equal to its lowest divisor,
                                  # it is prime and we need to end the loop.
    e = i                         # current number := next number
    r = [j for j in range(2, i+1) # List all divisors of the number in the range [2; number + 1)
         if i%j < 1][0]           # and take the first (lowest) one.
    i = i/r+r+1                   # Calculate the next number.
                                  # We now arrived at a prime number.
print d%e == 0 and d != e         # Print True if our current number divides the input
                                  # and is distinct from the input.
                                  # If our current number is equal to the input,
                                  # the input is prime.
```
[Try it online!](https://tio.run/##jVNLc9owEL7rV2zJZAYGpo2p0wcpx/TaS29MDoq1FBEjOSs5JP3zdFeyUyBPz/ip9ffaVfMQV95Nd5U3CHMYDAY74vsZvHacAIENEFcItd9iiGDsnQ2ewC/T16olQhfBtZtrpAlYZ6PVtf2LBqJn9CXXSuF2ZWsB8Q1U3hmu8k6JEMOnldM1bRyOnggwQLjR1gVoXbXS7g@aCWCv6pAftDMM1q05vO8XVKYn@DAHnL1g1WZLHRSD4G2ra7FhYzjyz06jlDRkN5hot0KYXYfoGyWYmLy9HO6R@tn8QLPUSIsW65TimiMCkgCGU6YfFyNGqC1r0nXd6wp9Y3oXLr2l32Axvei/j6EYqUcl7NyeruEHFFeLs6sDiWIt6htMMEtLTDfMUYzAO0wYqX2faEzj4nmbuq7aWkd80hZ48zhJwfotaCJ7x/lq9tvF3oHwC2doTjltmWdRbFKj90ByzW9qUcz6lo6zl/wM5sFJo5hnKfBCiNZVEZbkN/@XP75L@/Nc@6P1CDjZo@4Ha8e7tBtdkT5jzkgPszxb91iBbGYlzxU2ES5//bwk8pQLrgn1za74rIpSFeeqLFXJ1y@q/KrKb6r8/g8 "Python 2 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~17~~ 16 bytes
```
[Dp#Òć©sP+>]Ö®p*
```
[Try it online!](https://tio.run/##MzBNTDJM/f8/2qVA@fCkI@2HVhYHaNvFHp52aF2B1v//RmYGAA "05AB1E – Try It Online")
**Explanation**
```
[                  # start loop
 Dp#               # break if current value is prime
    Ò              # get prime factors of current value
     ć©            # extract the smallest (d) and store a copy in register
       sP          # take the product of the rest of the factors
         +>        # add the smallest (d) and increment
           ]       # end loop
            Ö      # check if the input is divisible by the resulting prime
             ®p    # check if the last (d) is prime (true for all composite input)
               *   # multiply
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 20 bytes
```
<P_QiI.WtPHh+/ZKhPZK
```
**[Try it here!](https://pyth.herokuapp.com/?code=%3CP_QiI.WtPHh%2B%2FZKhPZK&input=42&debug=0)**
## How it works
```
iI.WtPHh+/ZKhPZK || Full program.
  .W             || Functional while. It takes two functions as arguments, A and B.
                 || While A(value) is truthy, turn the value into B(value). The 
                 || starting value is the input.
    tPH          || First function, A. Takes a single argument, H.
     PH          || .. The prime factors factors of H.
    t            || .. Tail (remove first element). While truthy (H is composite):
       h+/ZKhPZK || The second function, B. Takes a single argument, Z:
         /Z      || .. Divide Z, by:
           KhP   || .. Its lowest prime factor, and assign that to K.   
       h         || .. Increment. 
        +      K || And add K.
iI               || Check if the result (last value) divides the input.
```
And the first 4 bytes (`<P_Q`) just check if the input is not prime.
With help from [Emigna](https://codegolf.stackexchange.com/users/47066/emigna), I managed to save 3 bytes.
[Answer]
# [Python 3](https://docs.python.org/3/), 149 bytes
```
def f(N):
	n=N;s=[0]*-~N
	for p in range(2,N):
		if s[p]<1:
			for q in range(p*p,N+1,p):s[q]=s[q]or p
	while s[n]:n=n//s[n]-~s[n]
	return s[N]>1>N%n
```
[Try it online!](https://tio.run/##RU9BboMwEDzbr9hLFZwCiRMKgRae4A8gDkiYxhJZHNtViaLk69TOpZfR7s7szqy@ufOMx3Ud5AhjJFhFCdbi09btvtsmT0HJOBvQoBBMj98yOsQvEVEj2FZ3Xzw0L9H1X6S3OhbvPNassu21qwOEM5T8ntUk/SZ2Fda424UqeQakxEj3Y9CTomt4I95wVRc9Gwf2ZmlwWIKDb1LrBoWpkf0wKZQRS62elItCMG0Uumhzf0DSwP2xSf3ipXeRT7nEAP7JwC@MUcLYyjPIDpB5LCHPodgD/wCeAy@An4CXUMAJSuB@zv8A "Python 3 – Try It Online")
Using a sieve approach. Should be fast (`O(N log log N)` = time complexity of the sieve of Eratosthenes) even with large `N` (but stores `O(N)` integers in memory)
Note:
* It can be proven that all intermediate values of `n` does not exceed `N`, and for `N > 7` `p` can be in `range(2,N)` instead of `range(2,N+1)` for sieving.
* `/` doesn't work, `//` must be used, because of list index.
* Storing `range` into another variable doesn't help, unfortunately.
Explanation:
* `-~N` == `N+1`.
* At first, the array `s` is initialized with `N+1` zeroes (Python is 0-indexing, so the indices are `0..N`)
* After initialization, `s[n]` is expected to be `0` if `n` is a prime, and `p` for `p` the minimum prime which divides `n` if `n` is a composite. `s[0]` and `s[1]` values are not important.
* For each `p` in range `[2 .. N-1]`:
	+ If `s[p] < 1` (that is, `s[p] == 0`), then `p` is a prime, and for each `q` being a multiple of `p` and `s[q] == 0`, assign `s[q] = p`.
* The last 2 lines are straightforward, except that `n//s[n]-~s[n]` == `(n // s[n]) + s[n] + 1`.
---
# [Python 3](https://docs.python.org/3/), 118 bytes
```
def f(N):
	n=N;s=[0]*-~N
	for p in range(N,1,-1):s[2*p::p]=(N-p)//p*[p]
	while s[n]:n=n//s[n]-~s[n]
	return s[N]>1>N%n
```
[Try it online!](https://tio.run/##FY9NboMwEIXX9ilmU8VG/MQphUAFR/AFEAskTGOJDJbtqkRRcnVqb57evE@jN2Me/rbh53HMaoGFSd5Sgp38dt1wHpPsLSlZNgsGNIKd8EcxmYo0E7x1wyUxbWvGjsnM8KIwyWBGSv5uelXgBhxb7LAoosveUSmxyv9aDFCOvejlBx76bjbrwT0cjT177AlD7vysMbdqmleNivHcmVV7Fs8zVqNnp@cLsh6er1MeFu@TZ5SQPQUIX0S@c04J54coobxAGbSBqoL6DOILRAWiBnEF0UANV2hAhFz8Aw "Python 3 – Try It Online")
At the cost of slightly worse performance. (This one runs in `O(N log N)` time complexity, assume reasonable implementation of Python slices)
---
The equivalent full program is [117 bytes](https://tio.run/##NU7LbsIwELzvV6xcVYqjpMGU8ggyF@75gSiKUnDAUlhbttOWC7@emkIvo53RzM7Yazgbep9e0Hwp5/RRoSY7hoRjP9IhaEOYkHGXbhiueFIBOxw0KeyduTysHL3BcO4CBuWDphNqj6rzWjk4qv7/X@ll236OeogW37ZvT3lrnaaQ@IzlO2SZoqNkjG@dCqMj9AD7yNlEspJ33zPFwct61qT5rYLeOLSxBV1HJ5VUmchyEevqeWrL0jYyqXLLi8KmtW3g@6wHhb6mpiRJRXG/8tsd4bmkrpqd2FWvxKfYvAVQP@qQsEdwX/6xPWd8EgtYzGERcQPLJaxmID5ALEGsQKxBbGAFa9iAiLr4BQ).
[Answer]
# [Haskell](https://www.haskell.org/), 110 bytes
```
f n|mod(product[1..n-1]^2)n>0=1<0|1>0=n`mod`u n<1
u n|d<-[i|i<-[2..],n`mod`i<1]!!0=last$n:[u$n`div`d+d+1|d/=n]
```
[Try it online!](https://tio.run/##JYpBDoIwEADvvmJJOGiQ2uViQlo/0tSUWIgby0KgeOrfaxMvM4eZ97B/xhBynoDTvPjzui3@eEWDQnCL9tld@CE1KpmwmF153AGs8FSYvGoNJSrshLDXfyaFtqqkDsMea@7NUbPz9HW@8Q0mf9Ns8zwQg4Z1I45Qw0QhjhtMYO5CoJTS5h8 "Haskell – Try It Online")
Not very happy...
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 92 bytes
```
function r=f(n)k=n;while~isprime(k)l=2:k;d=l(~mod(k,l))(1);k=k/d+d+1;end;r=~mod(n,k)&k<n;end
```
[Try it online!](https://tio.run/##HU3LDsIgELz3K/ZkIG0i1YNJcT/GdCGSpYvBqrf@OgJzmMwjmUnr/vi6UvxH1j0kgYxeiWYU@3uG6I7wfuWwOcU64mVhSxjVsSVSPEWt1awtI59ppHG2Tshm7K1MrE98l5YVnzIIINyWqzFmgIrgof103UD1p3rbg7YzNCp/)
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 50 bytes
```
{(0=n|⍵)∧⍵>n←{⍬≢k←o/⍨0=⍵|⍨o←2↓⍳⍵:∇1+d+⍵÷d←⌊/k⋄⍵}⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/9OAZLWGgW1ezaPerZqPOpYDKbs8kOCj3jWPOhdlA5n5@o96VxjYAmWAilbkA0WMHrVNftS7GShi9aij3VA7RRvIPLw9BSj1qKdLP/tRdwtQoBaE///XMAfKbjY0MNAEmZN2aAWMz5WmYGhgaAKhTAE "APL (Dyalog Unicode) – Try It Online")
[Answer]
# Japt, ~~25~~ 24 bytes
I fear I may have gone in the wrong direction with this but I've run out of time to try a different approach.
Outputs `0` for false or `1` for true.
```
j ?V©vU :ßU/(U=k g)+°UNg
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=aiA/Vql2VSA631UvKFU9ayBnKSuwVU5n&input=MjgzNQ==)
[Answer]
# [Perl 5](https://www.perl.org/), 291+1(-a) = 292 bytes
Darn Perl for not having a native prime checker.
```
use POSIX;&r($_,$_);
sub p{$n=shift;if($n<=1){return;}if($n==2||$n==3){return 1;}if($n%2==0||$n%3==0){return;}for(5..ceil($n/2)){if($n%$_==0){return;}}return 1;}
sub r{$n=shift;$o=shift;if(&p($n)){print $o%$n==0&&$n!=$o?1:0;last;}for(2..ceil($n/2)){if($n%$_==0){&r(($n/$_)+$_+1, $o);last;}}}
```
Ungolfed version,
```
use POSIX;
&r($_,$_);
sub p{
    my $n=shift;
    if($n<=1){
        return;
    }
    if($n==2||$n==3){
        return 1;
    }
    if($n%2==0||$n%3==0){
        return;
    }
    for(5..ceil($n/2)){
        if($n%$_==0){
            return;
        }
    }
    return 1;
}
sub r{
    my $n=shift;
    my $o=shift;
    if(&p($n)){
        print $o%$n==0&&$n!=$o ? 1 : 0;
        last;
    }
    for(2..ceil($n/2)){
        if($n%$_==0){
            &r(($n/$_)+$_+1, $o);
            last;
        }
    }
}
```
[Try it online!](https://tio.run/##fVHLjtpAELz3VxBpQKB9ZLrn0TMhVs45JVIuuaFNBFpLyEbGnFh@PU41uxHKZQ9Tnunqqn74sB32aZpOx@3s@7cfX3@uF8PSbe7dZrWm4@nX7HB2XXN8bnfjut0tXfe54dV52I6noVtfrpGmkZcX@4R/xIzfqLk0jTdyHnC56Xb9sEyPj7@37R5ZH2W1Or/mu81/eZeb37WZ4daM629dLQ7QwuMwtN04c/3cuvGLhes@NK7/wp/8ev90HF/ryjt1MbvFMfyd29zxPbxWb9LLZZo4UhSKwEo5k3riGIgTTi44lVgzcU0kPpJkT1KUpEYKIhSSp2gWWShxoQRdUtw1UapCWeCaGLZCKrAPiRRc8ZkKtAX@peBUpsqBKmLsYchegoEClIkZ5swaDBDjChABIXBkSVBYbxxQiEPGM/pgo9g8EXnJUlK1kdgbQJbFnlYy63XeK6hNjZiagVqyBmxArY0Sve0CKVWjbSQDMvbBoQIqnhIYgGoAEFIKIeQN7IYFScBmJHooYrBbAZuwTahsxZhIMgqJtQYAkQsIZfhpgovab1CLFZOVkP70h7Htu@P08PQX "Perl 5 – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 64 bytes
Straightforward implementation using recursive pattern replacement
(replacing "\[Divides]" with the ﻿"∣" symbol saves 7 bytes)
```
(g=!PrimeQ@#&)@#&&(#//.x_/;g@x:>x/(c=Divisors[x][[2]])+c+1)\[Divides]#&
```
[Try it online!](https://tio.run/##FczNCgIhFEDhV7khiMNITkEEheGiZYt@ljcJMceEnGCUEKJnt2lxNt/iRJMfLpocrKm9rMzL2XEM0Z0Uoc0UZUSIebmJrVdlsyuCWbkP75BeY8KiEZdaN61tF80V/353SRNap8eQ1cU9nc34IRx6Rb5AQSg4m8E7XHNYdZ3mcDAp6/oD "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Clean](https://clean.cs.ru.nl), ~~128~~ ~~117~~ 114 bytes
```
import StdEnv
@n#v=hd[p\\p<-[2..]|and[gcd p i<2\\i<-[2..p-1]]&&n rem p<1]
|v<n= @(n/v+v+1)=n
?n= @n<n&&n rem(@n)<1
```
[Try it online!](https://tio.run/##Lc1BC4IwGIDhu7/ig0AU0VCILht6qEPQzaPbYbhpI/c5dA0Cf3urqOvDC28/KYHBzPIxKTBCY9DGzouD1skz@qjBnac32VnGLMm7qij4JlB2Yy/BgiYVY/rnNi85j2OERRmwpOTR5glSaBLc@8xnZUoxqr@ABP9d0mBKytA6sbiIghN3BdUBkkFPTi1QQ3f8DNPw6odJjGvIL9dweqIwul/f "Clean – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 35 bytes
```
(~:*0=|~)(1+d+]%d=.0{q:)^:(0&p:)^:_
```
[Try it online!](https://tio.run/##y/r/P81WT6POSsvAtqZOU8NQO0U7VjXFVs@gutBKM85Kw0CtAETH//dz0lNwS8wpTq3kSk3OyFdIUzA0hrGMjbi4QPIhRaUlGQh5ExjLxAjGMjIz@A8A "J – Try It Online")
The minimum divisor being the first prime factor was stolen from @Dennis's Jelly solution (previously I was using `<./@q:`).
There should be a better way to do the iteration, but I can't seem to find it. I thought of avoiding doing the primality test (`^:(0&p:)`) and instead using adverse but it seems like that will be a bit longer since you'll need a `_2{` and some changes which might not give a net reduction.
I really feel like there must be a way to avoid having parens around the primality check, too.
# Explanation (expanded)
```
(~: * 0 = |~)(1 + d + ] % d =. 0 { q:) ^: (0&p:) ^:_ Input: N
             (1 + d + ] % d =. 0 { q:) ^: (0&p:) ^:_ Find the final N'
                                       ^:        ^:_  Do while
                                           0&p:       N is not prime
                                   q:                 Get prime factors (in order)
                               0 {                    Take first (smallest divisor)
                          d =.                        Assign this value to d
             1 + d + ] %  d                           Compute (N/d) + 1 + d
(~: * 0 = |~)                                        Is it redivosite?
      0 = |~                                          N = 0 (mod N'), i.e. N'|N
    *                                                 And
 ~:                                                   N =/= N', i.e. N is not prime
```
[Answer]
# APL NARS, 43 chars, 85 bytes
```
{(⍵≤6)∨0π⍵:0⋄⍵{1=⍴t←π⍵:0=⍵|⍺⋄⍺∇1+↑t+⍵÷↑t}⍵}
```
(hoping that it converge for all number>6) test:
```
h←{(⍵≤6)∨0π⍵:0⋄⍵{1=⍴t←π⍵:0=⍵|⍺⋄⍺∇1+↑t+⍵÷↑t}⍵}
v←⍳100     
v,¨h¨v
   1 0  2 0  3 0  4 0  5 0  6 0  7 0  8 0  9 0  10 0  11 0
   12 0  13 0  14 1  15 0  16 0  17 0  18 0  19 0  20 0  
   21 0  22 0  23 0  24 0  25 0  26 0  27 0  28 0  29 0  
   30 0  31 0  32 0  33 0  34 0  35 0  36 0  37 0  38 0  
   39 0  40 0  41 0  42 1  43 0  44 1  45 0  46 0  47 0  
   48 0  49 1  50 0  51 0  52 0  53 0  54 0  55 0  56 0  
   57 0  58 0  59 0  60 0  61 0  62 0  63 0  64 0  65 0  
   66 1  67 0  68 0  69 0  70 1  71 0  72 0  73 0  74 0  
   75 0  76 0  77 0  78 0  79 0  80 0  81 0  82 0  83 0  
   84 0  85 0  86 0  87 0  88 0  89 0  90 0  91 0  92 0  
   93 0  94 0  95 0  96 0  97 0  98 0  99 0  100 0  
```
The idea of using 2 anonymous functions I get to other Apl solution.
```
 {(⍵≤60)∨π⍵:0⋄ -- if arg ⍵ is prime or <=6 return 0
  ⍵{1=⍴t←π⍵:0=⍵|⍺⋄ -- if list of factors ⍵ has length 1 (it is prime)
                    -- then return ⍺mod⍵==0
  ⍺∇1+↑t+⍵÷↑t}⍵}   -- else recall this function with args ⍺ and 1+↑t+⍵÷↑t
   
```
[Answer]
# [Pyt](https://github.com/mudkip201/pyt), 44 [bytes](https://github.com/mudkip201/pyt/wiki/Codepage)
```
←⁻0`ŕ⁺ĐĐϼ↓Đ3Ș⇹÷+⁺Đṗ¬⇹⁻⇹łŕáĐ0⦋Đ↔ĐŁ⁻⦋⁺|¬⇹ṗ⇹3Ș⊽
```
See the code below for an explanation - the only differences are (1) that N is decremented before to account for the incrementation at the beginning of the loop, and (2) it uses NOR instead of OR.
  
[Try it online!](https://tio.run/##K6gs@f//UduER427DRKOTn3UuOvIhCMTzu951Db5yATjEzMete88vF0bLPxw5/RDa4B8oFIgebTp6NTDC49MMHi0rPvIhEdtU45MONoIklrWDVRdA1YJ1AEkQaZ07f3/38QYAA)
---
  
I made this before I re-read the question and noticed that it only wanted a true/false.
# Pyt, 52 bytes
```
60`ŕ⁺ĐĐϼ↓Đ3Ș⇹÷+⁺Đṗ¬⇹⁻⇹łŕáĐ0⦋Đ↔ĐŁ⁻⦋⁺|¬⇹Đṗ⇹3Ș∨ł⇹Đƥ⇹ŕ1ł
```
Prints an infinite list of Redivosite numbers.
Explanation:
```
6                                                            Push 6
 0                                                           Push unused character
  `                   ł                     ł      ł         Return point for all three loops
   ŕ                                                         Remove top of stack
    ⁺                                                        Increment top of stack (n)
     ĐĐ                                                      Triplicate top of stack (n)
       ϼ↓                                                    Get smallest prime factor of n (returns 1 if n is prime) 
         Đ                                                   Duplicate top of stack
          3Ș⇹                                                Manipulate stack so that the top is (in descending order): [d,(N,N'),d]
             ÷+⁺                                             Calculates N'=(N,N')/d+d+1
                Đṗ¬                                          Is N' not prime?
                   ⇹⁻⇹                                       Decrement N' (so the increment at the beginning doesn't change the value), and keep the boolean on top - end of innermost loop (it loops if top of stack is true)
                       ŕ                                     Remove top of stack
                        á                                    Convert stack to array
                         Đ                                   Duplicate array
                          0⦋Đ                                Get the first element (N)
                             ↔ĐŁ⁻⦋                           Get the last element ((final N')-1)
                                  ⁺                          Increment to get (final N')
                                   |¬                        Does N' not divide N?
                                     ⇹Đṗ                     Is N prime?
                                        ⇹3Ș∨                 Is N prime or does N' not divide N? - end of second loop (loops if top of stack is true)
                                             ⇹Đƥ⇹ŕ           Print N, and reduce stack to [N]
                                                  1          Push garbage (pushes 1 so that the outermost loop does not terminate)
```
  
[Try it online!](https://tio.run/##K6gs@f//UdsEg4SjUx817joy4ciE83setU0@MsH4xIxH7TsPb9cGCz/cOf3QGiD/UeNuIHm06ejUwwuPTDB4tKz7yIRHbVOOTDjaCJJa1g1UXQNWCdYDpEHmdKw42gQWOrYUpHuq4dGm///NAA)
]