Python 2, 30 bytes

lambda a,b:a in(b,5-b,b-5,b+5)

Try it online!

_{One byte saved by Arnauld}

_{Three bytes saved by alephalpha}

JavaScript (ES6), 28 bytes

Takes input as (a)(b). Returns $0$ or $1$.

a=>b=>a+b==5|!(a-=b)|a*a==25

Try it online!

x86 machine code, 39 bytes

00000000: 6a01 5e6a 055f 5251 31c0 39d1 0f44 c601  j.^j._RQ1.9..D..

00000010: d139 cf0f 44c6 595a 29d1 83f9 050f 44c6  .9..D.YZ).....D.

00000020: 83f9 fb0f 44c6 c3                        ....D..

Assembly

section .text

	global func

func:					;inputs int32_t ecx and edx

	push 0x1

	pop esi

	push 0x5

	pop edi

	push edx

	push ecx

	xor eax, eax



	;ecx==edx?

	cmp ecx, edx

	cmove eax, esi



	;ecx+edx==5?

	add ecx, edx

	cmp edi, ecx

	cmove eax, esi

	

	;ecx-edx==5?

	pop ecx

	pop edx

	sub ecx, edx

	cmp ecx, 5

	

	;ecx-edx==-5?

	cmove eax, esi

	cmp ecx, -5

	cmove eax, esi



	ret

Try it online!

Dyalog APL, 9 bytes

=∨5∊+,∘|-

Try it online!

Spelled out:

  =   ∨  5      ∊                +   , ∘    |            -

equal or 5 found in an array of sum and absolute of difference.

R, 40 bytes (or 34)

function(x,y)any((-1:1*5)%in%c(x+y,x-y))

Try it online!

For non-R users:

• 
  -1:1*5 expands to [-5, 0, 5]
  


• the %in% operator takes elements from the left and checks (element-wise) if they exist in the vector on the right

A direct port of @ArBo's solution has 35 34 bytes, so go upvote that answer if you like it:

function(x,y)x%in%c(y--1:1*5,5-y)

J, 12 11 bytes

1 byte saved thanks to Adám

1#.=+5=|@-,+

Try it online!

Explanation

This is equivalent to:

1 #. = + 5 = |@- , +

This can be divided into the following fork chain:

(= + (5 e. (|@- , +)))

Or, visualized using 5!:4<'f':

  ┌─ =               

  ├─ +               

──┤   ┌─ 5           

  │   ├─ e.          

  └───┤          ┌─ |

      │    ┌─ @ ─┴─ -

      └────┼─ ,      

           └─ +      

Annotated:

  ┌─ =                                     equality

  ├─ +                                     added to (boolean or)

──┤   ┌─ 5                                   noun 5

  │   ├─ e.                                  is an element of

  └───┤          ┌─ |  absolute value         |

      │    ┌─ @ ─┴─ -  (of) subtraction       |

      └────┼─ ,        paired with            |

           └─ +        addition               | any of these?

Jelly, 7 bytes

+,ạ5eo=

Try it online!

How it works

+,ạ5eo=  Main link. Arguments: x, y (integers)



+        Yield x+y.

  ạ      Yield |x-y|.

 ,       Pair; yield (x+y, |x-y|).

   5e    Test fi 5 exists in the pair.

      =  Test x and y for equality.

     o   Logical OR.

PowerShell, 48 44 bytes

param($a,$b)5-in($x=$b-$a),-$x,($a+$b)-or!$x

Try it online!

Takes input $a and $b. Checks if 5 is -in the group $b-$a, -$x ($a-$b), or $a+$b, stores the first into $x, and -ors the -in check with !$x to check equality.

-4 bytes thanks to mazzy.

Python 2, 38 bytes

-2 bytes thanks to @DjMcMayhem

lambda a,b:a+b==5or abs(a-b)==5or a==b

Try it online!

C# (.NET Core), 43, 48, 47, 33 bytes

EDIT: Tried to use % and apparently forgot how to %. Thanks to Arnauld for pointing that out!

EDIT2: AdmBorkBork with a -1 byte golf rearranging the parentheses to sit next to the return so no additional space is needed!

EDIT3: Thanks to dana for -14 byte golf for the one-line return shortcut and currying the function (Ty Embodiment of Ignorance for linking to TIO).

C# (.NET Core), 33 bytes

a=>b=>a==b|a+b==5|(a-b)*(a-b)==25

Try it online!

C (gcc), 41 34 bytes

f(a,b){a=5==abs(a-b)|a+b==5|a==b;}

Try it online!

Wolfram Language (Mathematica), 22 bytes

Takes input as [a][b].

MatchQ[#|5-#|#-5|#+5]&

Try it online!

Scala, 45 bytes

def f(a:Int,b:Int)=a+b==5||(a-b).abs==5||a==b

Try it online!

Tcl, 53 bytes

proc P a b {expr abs($a-$b)==5|$a==$b|abs($a+$b)==5}

Try it online!

Japt, 13 12 bytes

x ¥5|50ìøUra

Try it or run all test cases

x ¥5|50ìøUra

                 :Implicit input of array U

x                :Reduce by addition

  ¥5             :Equal to 5?

    |            :Bitwise OR

     50ì         :Split 50 to an array of digits

        ø        :Contains?

         Ur      :  Reduce U

           a     :    By absolute difference

Alternative

50ìø[Ux Ura]

Japt, 14 13 bytes

¥VªaU ¥5ª5¥Nx

Try it online!

05AB1E, 13 12 bytes

ÐO5Qs`α5QrËO

Try it online!

Takes input as a list of integers, saving one byte. Thanks @Wisław!

Alternate 12 byte answer

Q¹²α5Q¹²+5QO

Try it online!

This one takes input on separate lines.

Batch, 81 bytes

@set/as=%1+%2,d=%1-%2

@if %d% neq 0 if %d:-=% neq 5 if %s% neq 5 exit/b

@echo 1

Takes input as command-line arguments and outputs 1 on success, nothing on failure. Batch can't easily do disjunctions so I use De Morgan's laws to turn it into a conjunction.

05AB1E, 10 bytes

OIÆ‚Ä50SåZ

Try it online!

O           # Sum the input.

 IÆ         # Reduced subtraction of the input.

   ‚        # Wrap [sum,reduced_subtraction]

    Ä       # abs[sum,red_sub]

     50S    # [5,0]

        å   # [5,0] in abs[sum,red_sub]?

         Z  # Max of result, 0 is false, 1 is true.

Tried to do it using stack-only operations, but it was longer.

Charcoal, 18 bytes

Ｎθ¿№⟦θ⁺⁵θ⁻⁵θ⁻θ⁵⟧Ｎ1

Try it online! Link is to verbose version of code. Port of @ArBo's Python 2 solution.

Java (JDK), 30 bytes

a->b->a+b==5|a==b|(b-=a)*b==25

Try it online!

Perl 6, 25 bytes

{$^a==$^b|5-$b|$b-5|$b+5}

Try it online!

Port of @Arbo's solution. This uses the Any Junction rather than checking if a is a the list. Technically, ^ could work as well.

Explanation:

{                        }  # Anonymous code block

 $^a==                      # Is the first input equal to

         |    |    |        # Any of

      $^b                       # The second input

          5-$b                  # 5 - b

               $b-5             # b - 5

                     $b+5       # b + 5

Runic Enchantments, 30 bytes

i::i::}3s=?!@-'|A"5"n:}=?!@+=@

Try it online!

With a pending update, 4 bytes can be saved, as presently integer inputs are treated as doubles and don't equal integers of the same value. Hence "5"n instead of just 5. This was an oversight and several factors are being adjusted to account for it (such as using Approximately(a, b) instead of a.Equals(b)).

Outputs 0 (exactly one zero) for false and any other output (literally whatever is left on the stack) for true.

Retina 0.8.2, 82 bytes

d+

$*

^(-?1*) 1$|^(-?1*)1{5} -?2$|^-?(-?1*) (3)1{5}$|^-?(1 ?){5}$|^(1 ?-?){5}$

Try it online! Link includes test cases. Explanation: The first two lines convert the inputs into unary. The final line then checks for any of the permitted matches:

^(-?1*) 1$                              x==y

^(-?1*)1{5} -?2$   x>=0 y>=0 x=5+y i.e. x-y=5

                    x>=0 y<=0 x=5-y i.e. x+y=5

                    x<=0 y<=0 x=y-5 i.e. y-x=5

^-?(-?1*) (3)1{5}$ x<=0 y<=0 y=x-5 i.e. x-y=5

                    x<=0 y>=0 y=5-x i.e. x+y=5

                    x>=0 y>=0 y=5+x i.e. y-x=5

^-?(1 ?){5}$        x>=0 y>=0 y=5-x i.e. x+y=5

                    x<=0 y>=0 y=5+x i.e. y-x=5

^(1 ?-?){5}$        x>=0 y>=0 x=5-y i.e. x+y=5

                    x>=0 y<=0 x=5+y i.e. x-y=5

Pivoted by the last column we get:

x==y            ^(-?1*) 1$

x+y=5 x>=0 y>=0 ^-?(1 ?){5}$

      x>=0 y>=0 ^(1 ?-?){5}$

      x>=0 y<=0 ^(-?1*)1{5} -?2$

      x<=0 y>=0 ^-?(-?1*) (3)1{5}$

      x<=0 y<=0 (impossible)       

x-y=5 x>=0 y>=0 ^(-?1*)1{5} -?2$

      x>=0 y<=0 ^(1 ?-?){5}$

      x<=0 y>=0 (impossible)

      x<=0 y<=0 ^-?(-?1*) (3)1{5}$

y-x=5 x>=0 y>=0 ^-?(-?1*) (3)1{5}$

      x>=0 y<=0 (impossible)

      x<=0 y>=0 ^-?(1 ?){5}$

      x<=0 y<=0 ^(-?1*)1{5} -?2$

Perl 5, 51 bytes

Pretty simple really, uses the an flags for input. Outputs 0 for false, 1 for true. Not gonna lie, I don't know if bitwise OR is appropriate here, but is does work for all the test cases, so that's nice.

($a,$b)=@F;print($a==$b|$a+$b==5|$a-$b==5|$b-$a==5)

Try it online!

8086 machine code, 22 20 bytes

8bd0 2bc3 740e 7902 f7d8 3d05 0074 0503 d383 fa05

Ungolfed:

ESD  MACRO

    LOCAL SUB_POS, DONE

    MOV  DX, AX     ; Save AX to DX

    SUB  AX, BX     ; AX = AX - BX

    JZ   DONE       ; if 0, then they are equal, ZF=1

    JNS  SUB_POS    ; if positive, go to SUB_POS

    NEG  AX         ; otherwise negate the result

SUB_POS:

    CMP  AX, 5      ; if result is 5, ZF=1

    JZ   DONE

    ADD  DX, BX     ; DX = DX + BX

    CMP  DX, 5      ; if 5, ZF=1

DONE:

    ENDM

Input numbers in AX and BX and returns Zero Flag (ZF=1) if result is true.

If the difference between the numbers is 0, we know they are equal. Otherwise if result is negative, then first negate it and then check for 5. If still not true, then add and check for 5.

Example use:

    MOV  AX, 4

    MOV  BX, 1

    ESD

    JZ   TRUE   ; jump if true

    JNZ  FALSE  ; or jump false

Or:

    MOV  AX, 4

    MOV  BX, 1

    ESD

    PUSHF 

    POP AX      ; examine the flag directly

C (gcc), 33 bytes

f(a,b){a=!(a+b-5&&(a-=b)/6|a%5);}

Try it online!

Tried an approach I didn't see anyone else try using. The return expression is equivalent to a+b==5||((-6<a-b||a-b<6)&&(a-b)%5==0).