[Question]
  [
# Goal:
Given two natural numbers (integers from 0 to infinity), output a number that is not the sum of those numbers, but is a natural number.
# Example solutions (TI-Basic):
* `A+B+1`
* `not(A+B)`
# Invalid solutions:
* `A+B-1` (for inputs `0,0`, it returns `-1`, which is not natural)
* `"ABC"` (`ABC` is not a number)
# Notes:
* The output must always be a sum of two natural numbers (which is actually just a natural number)
* `-1`, `undefined`, `infinity`, `NaN` and Error messages are not natural numbers. For our purposes, `0` is natural (although not all mathematicians agree).
  
[Answer]
# [RProgN](https://github.com/TehFlaminTaco/Reverse-Programmer-Notation), ~~4~~ ~~3~~ 1 Byte
[Crossed out 4 is still 4 ;(](https://codegolf.stackexchange.com/a/82343/58375)
```
E
```
The most simple of solutions, compares if A and B are equal. Pushes true, which RProgN sees as 1, if they are the same, or false aka 0 otherwise.
## Test Cases
```
0+0 = 1
1+0 = 0
0+1 = 0
1+1 = 1
```
[Try it online!](https://tio.run/nexus/rprogn#@@/6//9/w/8GAA "RProgN – TIO Nexus")
[Answer]
# [Python](https://docs.python.org/2/), 13 bytes
```
[(0,0)].count
```
[Try it online!](https://tio.run/nexus/python2#S7ON@R@tYaBjoBmrl5xfmlfyv6AoM69EIVojUSdJUyEtv0ghUSEzT6EoMS89VcMUIpKEIpKZppCmAVauqWBrq5ConRT7HwA "Python 2 – TIO Nexus") Takes input as a tuple.
Using an [object method](https://codegolf.stackexchange.com/a/95156/20260) for the function avoids the boilerplate of a `lambda`.
```
lambda a,b:a-~b   # 15 bytes
```
Here, the idea is to map `(0,0)` to `1` and everything else to `0`. Since only `0+0` gives a sum of `0` among natural numbers, that always avoids matching the sum.
If one could output a Boolean here, which I find shady, a byte could be saved as 
```
(0,0).__ge__
```
This checks if the input tuple is at most `(0,0)`, which is only true for `(0,0)`. In Python, `True==1` and `False==0`. Even more shadily, outputting via exit code and treating that as a Python Boolen would save two bytes:
```
[(0,0)].pop
```
If string I/O is allowed and leading zeroes are OK, there's the 8-byte solution
```
'1'.join
```
This concatenates `a1b`, which is always bigger than `a+b`.
[Answer]
# [Retina](https://github.com/m-ender/retina), 3 bytes
```
 
1
```
[Try it online!](https://tio.run/nexus/retina#@6/AZfj/v6GRgrEJAA "Retina – TIO Nexus")
(The first line has a space before the newline. Stack Exchange isn't very good at showing trailing whitespace.)
Input is the numbers in decimal, separated by a space (e.g. `12 34`). This program just changes the space to a `1`, creating a number too large to be the sum of the input numbers (it necessarily has at least 2 more digits than either, and adding two numbers produces an output with no more than 1 digit more than the larger input).
[Answer]
# MATL, et al. 1 byte
```
=
```
Accepts two natural numbers as inputs and compares them. If they are equal, the output is `1` and if they not equal the output is `0`. This is the same approach as @ATaco's solution.
* [**MATL**](https://matl.suever.net/?code=%3D&inputs=0%0A1&version=19.7.4)
* [**Jelly**](https://tio.run/nexus/jelly#@2/7//9/g/8GAA) (by @ais523)
* [**Stacked**](https://tio.run/nexus/stacked#SyxKL9bT0/tv@z@/tOT/f5P/xgA) (by @Conor O'Brien)
* [**APL (Dyalog APL)**](https://tio.run/nexus/apl-dyalog#@///f9qjtgm2XCYKaQrGAA) (by @Adám)
* [**J**](https://tio.run/nexus/j#@///f5qCrZ6CLZeJQpqCMQA) (by @Adám)
* [**Actually**](https://tio.run/nexus/actually#@2/7/78hlyEA) (by @Mego)
* [**Implicit**](https://tio.run/##K87MLchJLS5JTM7@/9/2/39DBWMA) (by @MD XF)
* [**W**](https://github.com/a-ee/w) (by @a'\_')
* [**Keg**](https://github.com/JonoCode9374/Keg) (by @a'\_')
* [**GolfScript**](https://tio.run/##S8/PSStOLsosKPlvqGD43/b/fwA) (by @Pseudo Nym)
* [**Vyxal**](https://github.com/lyxal/vyxal) (by @emanresu A)
[Answer]
# Javascript, 10 bytes
```
x=>y=>!x+y
```
Takes 2 numbers using currying syntax like so:
```
(x=>y=>!x+y)(0)(0) // 1
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 8 bytes
```
({}{}())
```
[Try it online!](https://tio.run/nexus/brain-flak#@69RXVtdq6Gp@f@/MZcJAA "Brain-Flak – TIO Nexus")
This is the most readable brain-flak answer I have ever written. :)
Explanation:
```
(      )    # Push the sum of all the following:
 {}         #   The first input
   {}       #   The second input
     ()     #   and one
```
Alternate solutions (also 8 bytes):
```
({}[]{})    # Sum + 1
([]{}{})    # Sum + 2
```
There's a bunch of other solutions that only work with positive numbers:
```
(<{}>{})
({}<{}>)
({{}}())
({{}()})
({{}}[])
({{}[]})
```
[Answer]
# Vim, 3 bytes/keystrokes
```
<C-a>gJ
```
[Try it online!](https://tio.run/nexus/v#@2/jrJtol@71/78ll@F/3TIA "V – TIO Nexus")
Note that `<C-a>` is actually *ctrl-a*, which represents byte `0x01`.
I love it when vim (which isn't even a programming language) can compete with golfing languages. :) Input comes in this format:
```
a
b
```
This simply increments the first number by one (This is the `<C-a>` part) and then joins the string representations of the two numbers together. As far as I can tell, this should never result in the sum.
[Answer]
# TI-Basic, 3 bytes
```
not(max(Ans
```
Alternative solutions:
```
10^(sum(Ans         3 bytes @DestructibleWatermelon
not(sum(Ans         3 bytes
1+sum(Ans           4 bytes
Input :X=Y          5 bytes @ATaco
Input :X+not(Y      6 bytes
Input :not(X+Y      6 bytes
Input :10^(X+Y      6 bytes
Input :X+Y+1        7 bytes
Input :not(max(X,Y  7 bytes
Ans(1)=Ans(2        8 bytes
Ans(1)+not(Ans(2    9 bytes
not(Ans(1)+Ans(2    9 bytes
```
It's interesting that you made the question's examples in TI-Basic, but you forgot the shorter `A=B` (or maybe it was up to us to find out?)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 2 bytes
```
+‘
```
The + adds the two inputs together then the ' increments the answer by one
[Try it online!](https://tio.run/nexus/jelly#@6/9qGHG////Df4bAAA "Jelly – TIO Nexus")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 2 bytes
```
+<
```
[Try it online!](https://tio.run/nexus/brachylog2#@69t8/9/tLGOSez/qK95@brJickZqQA "Brachylog – TIO Nexus")
### Explanation
```
+     The sum of the elements in the Input...
 <    ...is strictly less than the Output
      (implicitely label the output with an integer respecting this constraint)
```
This will always result in `A+B+1`, if `Input = [A, B]`.
[Answer]
# Mathematica, 5 bytes
```
1+##&
```
Outputs the sum of the two arguments plus 1. For example, `1+##&[2,5]` yields `8`.
(Side note: `Binomial` almost works, although `Binomial[1,0]=1` and `Binomial[4,2]=6` are counterexamples; I think they're the only counterexamples, though.)
[Answer]
# PHP, 17 bytes
```
<?=1-join($argv);
```
Run like this:
```
echo '<?=1-join($argv);' | php -- 0 0
> 1
```
# Explanation
This just concatenates the arguments. The first argument (script name) contains `-`. So that results in a negative number, which I negate with the minus sign. Then I add 1, just in case the first input number is a `0` (0123 = 123).
[Answer]
# [Perl 6](http://perl6.org/), 4 bytes
```
!*+*
```
A lambda (formed by [Whatever-currying](https://docs.perl6.org/type/Whatever)), that adds the boolean inverse (1 or 0) of the first argument to the second argument.
[Try it online!](https://tio.run/nexus/perl6#y61UUEtTsP2vqKWt9d@ai6s4sVIhTcFAR8HAGso2RGIDxQ1hbFMdBUtL6/8A "Perl 6 – TIO Nexus")
[Answer]
# [Java (OpenJDK 9)](http://openjdk.java.net/projects/jdk9/), 10 bytes
```
a->b->a-~b
```
[Try it online!](https://tio.run/nexus/java-openjdk9#ZY8xT8MwEIXn5Ffc6Ayx2iJgiNqFCYmyZEQMZ9dpjZJLZDstVRX@ejhTgyqhG9757tN7Z9sNvQvwgUeUY7CtrDUSGVflw6haq0G36D1s0RJc8sxSMK5BbeAFO7VDuACPwI0koqqigumWehqdO/@hqfml8UqnIB8wsBx7u4OO40QdnKX92zug2/sipme3ds16xnKjyg2WX2rOsor36Xjwek3mBOkp6rMPppOWigidDrY1wmt5QP9qPoMoruZZwvoxyIGjQ0uikfFYZonBZ4rs/8mPK39kyqd5AQtYcS3hHh5YH@GO@@U3 "Java (OpenJDK 9) – TIO Nexus")
[Answer]
# [Turtlèd](https://github.com/Destructible-Watermelon/turtl-d/), 12 bytes
makes very large numbers
```
'1?:?:[1'0l]
```
### [Try it online!](https://tio.run/nexus/turtled#@69uaG9lbxVtqG6QE/v/vyGXAQA "Turtlèd – TIO Nexus")
## Explanation:
```
'1                write one on the starting grid square
  ?:?:            take a number, move right that many (repeat)
      [1   ]      while not on a grid square with a one on it
        '0l       put a zero on that square, move left
[implicit output of grid]
```
It thus outputs 10\*\*(x+y).
[Answer]
# PHP, 19 bytes
```
1<?=max([0]+$argv);
```
[Answer]
# SmileBASIC, 4 bytes
```
!A+B
```
not(A)+B  
`1+1=2 -> !1+1 -> 0+1=1`  
`0+1=1 -> !0+1 -> 1+1=2`
[Answer]
## R, 13 bytes
```
sum(scan()+1)
```
Thanks to Jonathan Allan for his inputs !
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 1 byte
```
Q
```
Works the same as the `RProgN` answer.
Checks if `a` and `b` are the same. If so, print `1`. Otherwise, print `0`
[Try it online!](https://tio.run/nexus/05ab1e#@x/4/78hl8HXvHzd5MTkjFQA "05AB1E – TIO Nexus")
[Answer]
## C ~~26~~ ~~24~~ 19 bytes
```
f(c,d){return!c+d;}
```
Ungolfed version:
```
int f(int c,int d)
{
   return !c+d; 
}
```
I hope I got the specification right. Can definitely be shortened!?
@Pavel Thanks for saving 2 bytes
@Neil Thanks for your input.
[Answer]
# MATLAB / Octave, 3 bytes
```
@eq
```
Accepts two inputs and checks for equality and yields `1` if they are equal and `0` otherwise.
[Online Demo](http://ideone.com/Ddaya4)
[Answer]
# brainfuck, 12 bytes
Simple solution that outputs `A+B+1`.
```
,>,[-<+>]<+.
```
[**Try it online**](https://tio.run/nexus/brainfuck#@69jpxOta6NtF2ujrff/v4IiAA)
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 5 bytes
```
?1n+n
```
[Try it online!](https://tio.run/nexus/dc#@29vmKed9/@/kZGRgrGxMQA "dc – TIO Nexus")
Input: Two natural numbers separated by a space on stdin.
Output: The digit 1 immediately followed by the sum of the two numbers, which is a number larger than the sum of the two numbers.
Example:
Input: `222 333`
Output: `1555`
[Answer]
# PHP, 13 bytes; (17 REPL-less)
```
!max($argv)+0
```
Examples
```
[0,0] -> 1
[0,1] -> 0
[1,0] -> 0
```
For those without REPL use
```
<?=!max($argv)+0;
```
and run using
```
echo '<?=!max($argv)+0;' | php -- 0 0
```
[Answer]
# Cubix, ~~9~~ 8 bytes
```
u-~OII/@
```
## Explanation
Expanded, this answer looks like this:
```
    u -
    ~ O
I I / @ . . . .
. . . . . . . .
    . .
    . .
```
The order of the instructions that are executed is `II~-O@`
```
II~-O@
I      # First input
   -   # Minus
 I~    # NOT(second input)
    O  # Output as integer
     @ # End program
```
Tested for all combinations of inputs where both are in the range `0-100`.
Try it [here](https://ethproductions.github.io/cubix/?code=dS1+T0lJL0A=&input=MCwwCg==&speed=20).
[Answer]
# APL - 4 Bytes
```
1++/
```
Takes array, sums its elements and adds one.
Test:
```
 1++/1 2  
4
 1++/1 0
2
```
[Answer]
# [///](https://esolangs.org/wiki////), 10 bytes + input
```
/0/1//+//[input A]+[input B]
```
*Obviously `[input A]` and `[input B]` are supposed to be replaced with the appropriate inputs*
[Try it online!](https://tio.run/nexus/slashes#@69voG@or6@tr2@sbWjw/z8A)
Changes 0's to 1's, then concatenates the strings.
This works because: 
* For A,B>0, join(A,B)>A+B
* join(A,B)>join(C,D) if A>C or B>D
* The function f(x)='change 0's to 1's in the digits of x' is always at least x
So we have join(f(A),f(B))>f(A)+f(B)>=A+B.
And if one or both of the inputs are 0, we have join(1,B)>1+B>0+B, join(A,1)>A+1>A+0 and join(1,1)=11>0+0.
*Note 1: This type of input has been [approved by the community](http://meta.codegolf.stackexchange.com/a/10553/60483)*  
*Note 2: This output doesn't give leading 0's either*  
*Note 3: Less bytes than Python, PHP, C#, C, Powershell and more!*
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), 7 bytes
```
?<.!?)@
```
[Try it online!](https://tio.run/##y0itSEzPz6v8/9/eRk/RXtPh/38DBQMA "Hexagony – Try It Online")
Or in more readable format,
```
 ? <
. ! ?
 ) @
```
This beats the current Hexagony solution of 11 bytes.
## Explanation:
### If the first number is not 0, the program takes the following path:
[![Not 0](https://i.stack.imgur.com/9f85z.png)](https://i.stack.imgur.com/9f85z.png)
This reads the first number and branches right. Then it reads the second number, followed by wrapping and trying to read a third, but that doesn't exist so it reads 0. This is printed and the program terminated (note that if a>0, since b is non-negative a+b>0).
### If the first number is 0, the program takes the following path to start with:
[![Is 0](https://i.stack.imgur.com/gU0m6.png)](https://i.stack.imgur.com/gU0m6.png)
This reads the first number and branches left. It hits the corner, taking the route from along the north-west edge because the number is 0, and reads the second number. It wraps, then increments the second number and prints.
[![Is still 0](https://i.stack.imgur.com/qzpXk.png)](https://i.stack.imgur.com/qzpXk.png)
It bounces against the `<`, printing the incremented second input again. It increments the value and takes the north-east edge again, but this time because the current edge a twice-incremented non-negative value which is definitely positive. It then tries to get a third input, but receives 0 instead.
[![Is still 0 some more](https://i.stack.imgur.com/0BOyR.png)](https://i.stack.imgur.com/0BOyR.png)
Finally it wraps and gets diverted by the arrow, then tries to read a fourth input and gets 0 again. It wraps and tries to read a fifth input and receives 0 for the last time. This it prints, and wraps to the `@` and exits.
Note that b\*(10^k+1)\*10>0+b=b where k is the length of b in digits, so this works.
[Answer]
# [√ å ı ¥ ® Ï Ø ¿](https://github.com/cairdcoinheringaahing/UnprintableName), 4 bytes
```
II1_
II   Take 2 inputs and push to the stack
  1  Push 1 to the stack
   _ Push the sum of the stack
```
To output, add `o` to the end.
[Answer]
# [Billiards](https://github.com/alexander-liao/java-public/tree/master/programs/ball-simulator), 11 characters = 17 bytes
```
⇲
⇲
+
1
+
↥
```
Implements `x + y + 1`. Pretty elementary. It takes the inputs on two separate lines. (By the way, the language was modified slightly after the challenge, but only to suppress the prompt from inputting, not sure if this answer is still valid).
# 7 characters = 11 bytes, non-competing
This one is shorter but only possible after a new update of the language:
```
⇲
⇲
=
$
```
This uses `x == y`, which was shamelessly stolen from @ATaco's RProgN solution [ hope you don't mind (: ]. The `$`, on exit, outputs how many balls passed over it.
]