[Question]
  [
A set is sum-free if no two (not necessarily distinct) elements when added together are part of the set itself.
For example, `{1, 5, 7}` is sum-free, because all members are odd, and two odd numbers when added together are always even. On the other hand, `{2, 4, 9, 13}` is not sum-free, as either `2 + 2 = 4` or `4 + 9 = 13` add together to a member of the set.
Write a program or function that takes a set as input, and outputs a Truthy value if the set is sum-free, and Falsy otherwise.
Examples:
```
Sum-free:
{}
{4}
{1, 5, 7}
{16, 1, 4, 9}
Not sum-free:
{0}
{1, 4, 5, 7}
{3, 0}
{16, 1, 4, 8}
```
  
[Answer]
# Python 2, 41 bytes
```
lambda s:s==s-{a+b for a in s for b in s}
```
`s` should be a Python set.
Fun fact: `sum-free` is an anagram of my name.
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), 5 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ṗ3ḅ-P
```
[Try it online!](http://jelly.tryitonline.net/#code=4bmXM-G4hS1Q&input=&args=WzIsIDQsIDksIDEzXQ&debug=on)
### How it works
```
ṗ3ḅ-P  Main link. Argument: A (array)
ṗ3     Take the third Cartesian power of A, i.e., generate all triplets that
       consist of elements of A.
  ḅ-   Convert each triplet from base -1 to integer.
       This maps [a, b, c] to a - b + c = (a + c) - b.
       If (a + c) belong to A, this will yield 0 for some b.
    P  Take the product of all resulting integers. 
```
[Answer]
# Pyth - ~~8~~ 5 bytes
*Thanks to @FryAmTheEggman for saving me 3 bytes.*
```
!@sM*
```
[Test Suite](http://pyth.herokuapp.com/?code=%21%40sM%2a&test_suite=1&test_suite_input=1%2C+5%2C+7%0A2%2C+4%2C+9%2C+13&debug=0).
```
!             Logical not. This makes the empty intersection true and vice versa.
 @    Q       Setwise intersection with input (implictly).
  sM          Map sum to all the pairs.
   *QQ        Get all pairs by doing cartesian product with input*input (implicit).
```
[Answer]
# JavaScript, ~~86~~ ~~42~~ 41 bytes
```
n=>!n.some(m=>n.some(o=>n.includes(m+o)))
```
Thanks Cᴏɴᴏʀ O'Bʀɪᴇɴ for saving me a ton of bytes off parentheses/curly brackets. Also thanks Neil for pointing out that the function was returning the opposite boolean value than it should have.
I tried to cut down on bytes by redefining `n.some` but that doesn't work because it's a prototype function unfortunately. There might be a better solution with `Array.prototype.map` in JS but the some function is really fun.
I'm now wondering if there's a shorter way than `.includes` using something such as .indexOf and adding 1 (which would give it a truthy value if it contains the number).
---
Testing:
```
> (n=>!n.some(m=>n.some(o=>n.includes(m+o))))([1,5,7]);
true
> (n=>!n.some(m=>n.some(o=>n.includes(m+o))))([1,5,7,12]);
false
```
[Answer]
# MATL, 5 bytes
```
t&+m~
```
This outputs an array which is truthy if all entries are `1` and falsey otherwise. [Here is a demo to show various truthy/falsey values in MATL](http://matl.tryitonline.net/#code=YGkgICAgICAgJSBGb3IgYWxsIGlucHV0cwo_ICAgICAgICAlIElmIHRydWUKJ3RydWUnCn0gICAgICAgICUgZWxzZSBmYWxzZQonZmFsc2UnCl1EVA&input=MQowClsxIDEgMV0KWzAgMCAwXQpbMSAwIDFd).
[**Try it Online**](http://matl.tryitonline.net/#code=dCYrbX4&input=WzEgNSA3XQ)
**Explanation**
```
        % Implicitly grab input
t       % Duplicate
&+      % Compute sum of each element with every other element (2D Matrix)
m       % Check which members of the input are present in this matrix of sums
~       % Negate the result to yield a truthy value for sum-free sets
        % Implicitly display truthy/falsey value
```
[Answer]
# Mathematica, 23 Bytes
```
{}==#⋂Tr/@#~Tuples~2&
```
[Answer]
# Haskell, ~~32~~, 30 bytes
Simple solution:
```
f x=and[a+b/=c|a<-x,b<-x,c<-x]
```
Two bytes saved by @Lynn
[Answer]
# J, ~~18~~ ~~10~~ 8 bytes
8 bytes saved thanks to miles, and 2 thanks to FrownyFrog!
```
-:]-.+/~
```
Matches the original list with the set difference of tabulated sums. This is equivalent to:
```
(-: (] -. +/~)) y
```
for input `y`. This translates to:
```
y -: (] -. +/~) y
y -: (y -. +/~ y)
```
`+/~` returns a table of sums using `y`. For `y =: 16 1 4 9`, this gives:
```
   +/~ 16 1 4 9
32 17 20 25
17  2  5 10
20  5  8 13
25 10 13 18
```
Then, we use `-.`, which produces a list consisting of all elements in `y` not in this table. If the list is sum-free, this will produce the same list. Then, `-:` checks for equality of lists, which produces the desired output.
## Old, 18 bytes
```
[:-.[:>./^:_+/~e.]
```
`+/~` creates a table of the values of the set added to itself, and `e.` checks if those members are in the original set. The rest of that is negating the maximal element.
[Answer]
# Julia, 18 bytes
```
!x=x∩(x'.+x)==[]
```
[Try it online!](http://julia.tryitonline.net/#code=IXg9eOKIqSh4Jy4reCk9PVtdCgohWzEsIDUsIDddICAgICB8PiBwcmludGxuCiFbMiwgNCwgOSwgMTNdIHw-IHByaW50bG4&input=)
[Answer]
## [Retina](https://github.com/m-ender/retina), ~~45~~ 44 bytes
```
\d+
<$&$*1>
$
$`$`
M`(<1*)>.*<(1*>).*\1\2
^0
```
Input is a decimal list of comma-separated numbers. Output is `0` (falsy) or `1` (truthy).
[Try it online!](http://retina.tryitonline.net/#code=JShHYApcZCsKJCoxPgokCiRgJGAKTWBcYigxKj4pLipcYigxKik-LipcYlwyXDEKXjA&input=MSw1LDcKCjEKMiw0CjQsOSwxMwoyLDQsOSwxMwow) (The first line enables a linefeed-separated test suite.)
### Explanation
**Stage 1: Substitution**
```
\d+
<$&$*1>
```
This converts all elements of the input to unary and wraps them in `<...>`. The purpose of the angle brackets is to distinguish a list containing only `0` from an empty list (since the unary representation of `0` is empty itself).
**Stage 2: Substitution**
```
$
$`$`
```
We repeat the string 3 times by append it twice at the end.
**Stage 3: Match**
```
M`(<1*)>.*<(1*>).*\1\2
```
We now try to find three numbers in the result such that the first two add up to the third. Those matches are counted (this doesn't actually count all such tuples, because matches cannot overlap, but if such a tuple exists it will be found). Hence, we get `0` for sum-free sets and something positive otherwise.
**Stage 4: Match**
```
^0
```
Since the previous stage gave the opposite of what we want, we negate the result by counting the matches of `^0` which is `1` for input `0` and `0` for everything else.
[Answer]
# Octave, ~~29~~ ~~21~~ 25 bytes
```
@(s)~[ismember(s,s+s') 0]
```
Thanks to [Suever](https://codegolf.stackexchange.com/users/51939/suever)! It returns an array. I added `0` at the end to make `[]` become sum-free. To verify truthy and falsey in Octave, you can do this:
```
> f=@(s)~[ismember(s,s+s') 0]
> if f([]) "sum-free" else "not sum-free" end
ans = sum-free
> if f([0]) "sum-free" else "not sum-free" end
ans = not sum-free
> if f([4]) "sum-free" else "not sum-free" end
ans = sum-free
> if f([1 3]) "sum-free" else "not sum-free" end
ans = sum-free
> if f([2 4]) "sum-free" else "not sum-free" end
ans = not sum-free
```
An alternative that returns 0 or 1 is:
```
@(s)~numel(intersect(s+s',s))
```
[Answer]
# Clojure, ~~47~~ 37 bytes
```
#(=(for[a % b % :when(%(+ a b))]a)[])
```
quite plain solution. uses list comprehension to find all elements which sum is equal to another element.
38 bytes variant:
```
#(every? nil?(for[a % b %](%(+ a b))))
```
[Answer]
# Ruby, 36 bytes
Constructs a cartesian product of the set against itself and finds the sum of all elements, then checks for intersection with the original set. Input is arrays, but in Ruby they have enough set operations to make it work out nicely anyways.
-1 byte over my original solution (used `&` instead of `-` and compared with `[]`) because of inspiration from @feersum
[Try it here!](https://repl.it/C94f/1)
```
->s{s-s.product(s).map{|x,y|x+y}==s}
```
[Answer]
# [Perl 6](http://perl6.org), ~~24 21 20~~ 19 bytes
```
~~{not any (@\_ X+@\_)X==@\_}
{so all (@\_ X+@\_)X!==@\_}
{not @\_ (&)(@\_ X+@\_)}
{not @\_∩(@\_ X+@\_)}~~
{!(@_∩(@_ X+@_))}
```
Input is any [Positional](https://docs.perl6.org/type/Positional) value like a [List](https://docs.perl6.org/type/).  
( a [Set](https://docs.perl6.org/type/Set) is an [Associative](https://docs.perl6.org/type/Associative) so you would have to call [`.keys`](https://docs.perl6.org/routine/keys) on it. )
### Test:
```
#! /usr/bin/env perl6
use v6.c;
use Test;
my @sum-free = (
  (),
  (4,),
  (1, 5, 7),
  (16, 1, 4, 9),
);
my @not-sum-free = (
  (0,),
  (1, 4, 5, 7),
  (3, 0),
  (16, 1, 4, 8),
);
my @tests = ( |(@sum-free X=> True), |(@not-sum-free X=> False) );
plan +@tests;
# store the lambda in lexical namespace for clarity
my &sum-free-set = {!(@_∩(@_ X+@_))}
for @tests -> $_ ( :key(@list), :value($expected) ) {
  is sum-free-set(@list), $expected, .gist
}
```
```
1..8
ok 1 - () => True
ok 2 - (4) => True
ok 3 - (1 5 7) => True
ok 4 - (16 1 4 9) => True
ok 5 - (0) => False
ok 6 - (1 4 5 7) => False
ok 7 - (3 0) => False
ok 8 - (16 1 4 8) => False
```
[Answer]
# Mathematica ~~63 62~~ 42 bytes
This shorter version benefitted from A Simmons' submission. No element needs to be removed from the list before `IntegerPartitions` is applied.
If an element cannot be partitioned into two integers (each from the list), then `IntegerPartitions[#,{2},#]=={}` holds. `And` checks whether this holds for every element in the list. If so, the list is sum-free.
```
And@@(IntegerPartitions[#,{2},#]=={}&/@#)&
```
---
## Examples
```
 And@@(IntegerPartitions[#,{2},#]=={}&/@ #)&@{2, 4, 9, 13}
```
False
---
```
 And@@(IntegerPartitions[#,{2},#]=={}&/@ #)&@{1, 5, 7}
```
True
---
There is a 2, but no odd numbers that differ by 2.
```
 And@@(IntegerPartitions[#,{2},#]=={}&/@#)&@{2, 3, 7, 11, 17, 23, 29, 37, 41, 47, 53, 59, 67, 71}
```
True
[Answer]
# R, ~~39~~ 36 bytes
```
w<-function(s)!any(outer(s,s,'+')%in%s)
```
Call as `w(s)`, where `s` is the set (actually vector) of values. Here is the output for some test cases:
```
> w(numeric(0)) # The empty set
[1] TRUE
> w(0)
[1] FALSE
> w(1)
[1] TRUE
> w(c(1, 5, 7))
[1] TRUE
> w(c(2, 4, 9, 13))
[1] FALSE
```
Where `c()` is the concatenation function that takes a bunch of values and makes it a vector.
EDIT: Making it an anonymous function to save 3 bytes, thanks to @MickyT.
```
function(s)!any(outer(s,s,'+')%in%s)
```
[Answer]
# Python, 40 bytes
```
lambda s:s^{a+b for a in s for b in s}>s
```
`^` = symmetric difference, new set with elements in either sets but not both
`>` True if the left set is a superset of the right set.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 13 bytes
```
'(p:?+L:?x'L)
```
### Explanation
```
'(          )  True if what's in the parentheses is impossible, false otherwise
  p            Get a permutation of Input
   :?+L        L is the list of element-wise sums of the permutation with Input
       :?x'L   There is at least one element of Input in L
```
[Answer]
# Racket, 58 bytes
```
(λ(l)(andmap(λ(m)(andmap(λ(n)(not(memq(+ n m)l)))l))l))
```
Explanation:
```
(λ(l)(andmap(λ(m)(andmap(λ(n)(not(memq(+ n m)l)))l))l))
(λ(l)                                                 ) # Define a lambda function that takes in one parameter
     (andmap(λ(m)                                  )l)  # If for all m in l
                 (andmap(λ(n)                   )l)     # If for all n in l
                             (not(memq(+ n m)l))        # n + m is not in l
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~9~~ 5 bytes
Saved 4 bytes thanks to *Magic Octopus Urn*
```
ãOå_P
```
[Try it online!](https://tio.run/##MzBNTDJM/f//8GL/w0vjA/7/jzbUMdUxjwUA "05AB1E – Try It Online")
**Explanation**
```
ã       # cartesian product
 O      # sum
  å     # check each if it exists in input
   _    # logical negation
    P   # product
```
[Answer]
# APL, 8 bytes
```
⊢≡⊢~∘.+⍨
```
Explanation:
```
⊢         argument
 ≡        equals
  ⊢       argument
   ~      without 
    ∘.+⍨  sums of its elements
```
Test:
```
      ( ⊢≡⊢~∘.+⍨ ) ¨ (1 5 7)(2 4 9 13)
1 0
```
[Answer]
## Haskell, 30 bytes
```
f s=and[x+y/=z|x<-s,y<-s,z<-s]
```
I think there exists a shorter solution that's more interesting, but I haven't found it.
These are 33 and 34 bytes:
```
f s=and$((/=)<$>s<*>)$(+)<$>s<*>s
f s|q<-((-)<$>s<*>)=all(/=0)$q$q$s
```
[Answer]
# [Actually](https://github.com/Mego/Seriously), 7 bytes
```
;;∙♂Σ∩Y
```
[Try it online!](http://actually.tryitonline.net/#code=OzviiJnimYLOo-KIqVk&input=WzEsNSw3XQ)
```
;;∙♂Σ∩Y              Stack: [1,5,7]
;         duplicate         [1,5,7] [1,5,7]
 ;        duplicate         [1,5,7] [1,5,7] [1,5,7]
  ∙       cartesian product [1,5,7] [[1,1],[1,5],[1,7],[5,1],[5,5],[5,7],[7,1],[7,5],[7,7]]
   ♂Σ     sum each          [1,5,7] [2,6,8,6,10,12,8,12,14]
     ∩    intersect         []
      Y   negate            1
```
[Answer]
## Java, 67 bytes
```
s->!s.stream().anyMatch(p->s.stream().anyMatch(q->s.contains(p+q)))
```
Input is a `Set<Integer>`. Tests:
```
import java.util.Arrays;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
public class SumFree {
    public static void main(String[] args) {
        sumFree(s->!s.stream()
            .anyMatch(p->s.stream()
                .anyMatch(q->s.contains(p+q)))); // formatted to avoid wrapping
    }
    public static void sumFree(Function<Set<Integer>, Boolean> func) {
        test(func);
        test(func, 4);
        test(func, 1, 5, 7);
        test(func, 16, 1, 4, 9);
        test(func, 1, 4, 5, 7);
        test(func, 0);
        test(func, 3, 0);
        test(func, 16, 1, 4, 8);
    }
    public static void test(Function<Set<Integer>, Boolean> func, Integer... vals) {
        Set<Integer> set = Arrays.stream(vals).collect(Collectors.toSet());
        System.out.format("%b %s%n", func.apply(set), set);
    }
}
```
Output:
```
true []
true [4]
true [1, 5, 7]
true [16, 1, 4, 9]
false [0]
false [1, 4, 5, 7]
false [0, 3]
false [16, 1, 4, 8]
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 30 bits1, 3.75 [bytes](https://github.com/Vyxal/Vyncode/blob/main/README.md)
```
ẊṠ↔¬
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=1#WyJBPSIsIiIsIuG6iuG5oOKGlMKsIiwiIiwiW11cbls0XVxuWzEsIDUsIDddXG5bMTYsIDEsIDQsIDldXG5bMF1cblsxLCA0LCA1LCA3XVxuWzMsIDBdXG5bMTYsIDEsIDQsIDhdIl0=)
```
Ẋ    # cartesian product with itself
 Ṡ   # vectorized sums
  ↔  # intersection of this with the input
   ¬ # logical NOT
```
If inverted truthiness is allowed, the `¬` can be removed for [2.875 bytes](https://vyxal.pythonanywhere.com/?v=1#WyJBPSIsIiIsIuG6iuG5oOKGlCIsIiIsIltdXG5bNF1cblsxLCA1LCA3XVxuWzE2LCAxLCA0LCA5XVxuWzBdXG5bMSwgNCwgNSwgN11cblszLCAwXVxuWzE2LCAxLCA0LCA4XSJd), but the challenge specifically states "*outputs a Truthy value if the set is sum-free, and Falsy otherwise.*"
[Answer]
# TSQL, 47 bytes
```
CREATE table T(a int)
INSERT T values(1),(5),(7),(12)
SELECT min(iif(a.a+b.a<>T.a,1,0))FROM T a,T b,T
```
Note: This will only run once, then the table needs to be deleted or dropped to run again. The fiddle editor doesn't allow creation of tables. Therefore the fiddle included in my answer uses 2 extra bytes to compensate for this - the fiddle version doesn't require cleanup.
**[Fiddle](https://data.stackexchange.com/stackoverflow/query/508914/is-it-a-sum-free-set)**
[Answer]
# Perl, 46 bytes
45 bytes code + 1 byte command line (-p)
```
$_="$_ $_ $_"!~/(\b\d++.*)((?1))(??{$1+$2})/
```
Uses a single regex match with Perl's support for 'code expressions' inside the regex to allow for evaluation within a match.
To get around the requirement that the input is unsorted, we repeat the input string three times. This guarantees that the result is after the two operands, and allows the same digit to be matched again (e.g. in the case of input `2 4`).
Usage example:
```
echo "3 5 6 8" | perl -p entry.pl
```
[Answer]
# Factor, 47 bytes
```
[ dup dup 2array [ Σ ] product-map ∩ { } = ]
```
* `∩ { } =` is equivalent to but shorter than `intersects?`.
* `Σ` is shorter than but equivalent to `sum`.
Thanks, [math.unicode](https://codegolf.stackexchange.com/questions/75610/tips-for-golfing-in-factor)!
testing code:
```
USING: arrays kernel math.unicode sequences sequences.product ;
IN: sum-free
: sum-free? ( seq -- ? )
  dup dup 2array [ Σ ] product-map ∩ { } = ;
USING: tools.test sum-free ;
IN: sum-free.tests
{ t } [ { 5 7 9 } sum-free? ] unit-test
{ f } [ { 2 4 9 13 } sum-free? ] unit-test
{ t } [ { } sum-free? ] unit-test
{ f } [ { 0 } sum-free? ] unit-test
{ t } [ { 1 } sum-free? ] unit-test
{ f } [ { 0 1 } sum-free? ] unit-test
```
I'm only confident the first two are correct. It's unclear from the question what the rest should be, so I think it's fine for now.
[Answer]
# PHP, 73 bytes
+8 to turn the snippet into a program, -8 on obsolete variables thanks to insertusernamehere
```
<?foreach($argv as$p)foreach($argv as$q)if(in_array($p+$q,$argv))die;echo 1;
```
prints `1` for `true`, empty output for `false`  
usage: `php <filename> <value1> <value2> ...`
qualified function for testing (~~94~~ 86): returns `1` or nothing
```
function f($a){foreach($a as$p)foreach($a as$q)if(in_array($p+$q,$a))return;return 1;}
```
**tests**
```
function out($a){if(!is_array($a))return$a;$r=[];foreach($a as$v)$r[]=out($v);return'['.join(',',$r).']';}
function cmp($a,$b){if(is_numeric($a)&&is_numeric($b))return 1e-2<abs($a-$b);if(is_array($a)&&is_array($b)&&count($a)==count($b)){foreach($a as $v){$w = array_shift($b);if(cmp($v,$w))return true;}return false;}return strcmp($a,$b);}
function test($x,$e,$y){static $h='<table border=1><tr><th>input</th><th>output</th><th>expected</th><th>ok?</th></tr>';echo"$h<tr><td>",out($x),'</td><td>',out($y),'</td><td>',out($e),'</td><td>',cmp($e,$y)?'N':'Y',"</td></tr>";$h='';}
$samples = [
    [], 1,
    [0], false,
    [1], 1,
    [0,1], false,
    [2, 4, 9, 13], false,
    [1,5,7], 1
];
while($samples)
{
    $a=array_shift($samples);
    $e=array_shift($samples);
    test($a,$e,f($a));
}
```
[Answer]
## Clojure, 34 bytes
```
#(not-any? %(for[i % j %](+ i j)))
```
I wrote this before noticing the earlier Clojure solution. Anyway, this one is more compact as it uses the input set as a `pred` function for `not-any?`.
]