Here's a solution that represents the balls of each lottery draw in
separate table rows as opposed to separate columns. So all draws of N
lottery balls are represented by a (ball, draw_number) table, as
opposed to a (ball_1, ..., ball_N) table, with all balls in a given
draw having the same unique draw_number value. This makes for a more
scalable normalized solution, e.g., it's straightforward to represent
all 6-ball combinations with no schema change. The key, however, with
this approach is to generate the unique draw_number values. The
solution is implemented by a UDF which takes as an argument the number
of balls to find combinations of, that is, finding all N-ball
combinations from the set of all balls not already drawn is
accomplished by specifying N as the argument to the function.

Let me motivate with an example and follow with the code.

/*
Create the set of lottery balls. Note that this is not hardwired.
In your case, to insert 56 lottery balls, call
EXEC InsertLotteryBalls 56
*/
-- Insert 6 lottery balls labelled 1 through 6
EXEC InsertLotteryBalls 6

-- Insert lottery balls already drawn
-- So the set of lottery balls to find combinations of is {2, 4, 5, 6}
INSERT INTO LotteryBallsDrawn (ball)
VALUES ('1')
INSERT INTO LotteryBallsDrawn (ball)
VALUES ('3')

-- All combinations of 2 lottery balls from those not drawn
-- All balls in the same sequence, or draw, have the same draw number
SELECT number_balls_drawn, ball, draw_number
FROM LotteryBallCombinations(2)
ORDER BY draw_number, ball

number_balls_drawn ball draw_number
2 2 0
2 4 0
2 2 1
2 5 1
2 4 2
2 5 2
2 2 3
2 6 3
2 4 4
2 6 4
2 5 5
2 6 5

/*
Here are some interesting uses of a combinations table
*/
-- Total number of N-ball combinations
DECLARE @n INT
SET @n = 2
SELECT COALESCE(MAX(draw_number) + 1, 0) AS total
FROM LotteryBallCombinations(@n)

total
6

-- All N-ball combinations that include a specific ball
DECLARE @ball CHAR(2), @n INT
SET @ball = '4' -- combos that include this ball
SET @n = 2
SELECT C.number_balls_drawn, C.ball, C.draw_number
FROM (SELECT draw_number
FROM LotteryBallCombinations(@n)
GROUP BY draw_number
HAVING SUM(CASE WHEN ball = @ball THEN 1 ELSE 0 END) = 1) AS Draws
INNER JOIN
LotteryBallCombinations(@n) AS C
ON C.draw_number = Draws.draw_number
ORDER BY C.draw_number, C.ball

number_balls_drawn ball draw_number
2 2 0
2 4 0
2 4 2
2 5 2
2 4 4
2 6 4

-- Code

-- All lottery balls
CREATE TABLE LotteryBalls
(
ball CHAR(2) NOT NULL PRIMARY KEY
)

-- Insert N lottery balls labelled from 1 to N
CREATE PROCEDURE InsertLotteryBalls @number_of_balls INT = 56
AS
DELETE FROM LotteryBalls
DECLARE @ball INT
SET @ball = 1
WHILE @ball <= @number_of_balls
BEGIN
INSERT INTO LotteryBalls (ball)
VALUES (CAST(@ball AS CHAR(2)))
SET @ball = @ball + 1
END

-- Lottery balls that have been drawn
CREATE TABLE LotteryBallsDrawn
(
ball CHAR(2) NOT NULL PRIMARY KEY REFERENCES LotteryBalls (ball)
)

/*
Candidate balls are balls that can be drawn, i.e., balls that haven't
been drawn.
Candidate balls in ascending order are mapped to consecutive natural
numbers.
*/
CREATE VIEW CandidateLotteryBalls (ball, ball_number)
AS
SELECT B1.ball, COUNT(*)
FROM LotteryBalls AS B1
INNER JOIN
LotteryBalls AS B2
ON B2.ball <= B1.ball
WHERE NOT EXISTS (SELECT *
FROM LotteryBallsDrawn
WHERE ball IN (B1.ball, B2.ball))
GROUP BY B1.ball

/*
The total number of combinations of N things taken R at a time is
N!/R!(N-R)!. For example, the total number of combinations of 5 balls
taken 3 at a time is 5!/3!(2!) = 10. So if the 5 balls are named 1,
2, 3, 4, and 5, the combinations of these balls taken 3 at a time, and
listed lexicographically with zero-based sequence numbers, are:
[0] 3, 2, 1
[1] 4, 2, 1
[2] 4, 3, 1
[3] 4, 3, 2
[4] 5, 2, 1
[5] 5, 3, 1
[6] 5, 3, 2
[7] 5, 4, 1
[8] 5, 4, 2
[9] 5, 4, 3

The following view generates unique nonnegative integral numbers to be
associated with each draw of R balls from a set of N balls.
*/
CREATE VIEW CombinationSequenceNumbers (n, r, sequence_number)
AS
SELECT B1.ball_number AS n,
B2.ball_number AS r,
CAST(
ROUND(EXP(SUM(LOG(
CASE WHEN B3.ball_number >
CASE WHEN B2.ball_number <= B1.ball_number / 2
THEN B1.ball_number - B2.ball_number
ELSE B2.ball_number
END
THEN B3.ball_number
ELSE 1
END))) /
EXP(SUM(LOG(
CASE WHEN B3.ball_number <=
CASE WHEN B2.ball_number <= B1.ball_number / 2
THEN B2.ball_number
ELSE B1.ball_number - B2.ball_number
END
THEN B3.ball_number
ELSE 1
END))), 0) AS INT)
FROM CandidateLotteryBalls AS B1
INNER JOIN
CandidateLotteryBalls AS B2
ON B1.ball_number <
(SELECT MAX(ball_number) FROM CandidateLotteryBalls) AND
B2.ball_number <= B1.ball_number
INNER JOIN
CandidateLotteryBalls AS B3
ON B3.ball_number <= B1.ball_number
GROUP BY B1.ball_number, B2.ball_number

/*
The following is a UDF to return all combinations of R lottery balls
from the N lottery balls not previously drawn. Therefore, 0<=R<=N.
Each combination of a given length is assigned a unique nonnegative
integral identifier.
*/
CREATE FUNCTION LotteryBallCombinationsUpToR (@number_balls_to_draw INT)
RETURNS @ball_drawings TABLE
(number_balls_drawn INT NOT NULL,
ball CHAR(2) NOT NULL,
ball_number INT NOT NULL,
draw_number INT NOT NULL,
prev_draw_number INT NOT NULL,
PRIMARY KEY (number_balls_drawn, draw_number, ball_number))
AS
BEGIN
IF @number_balls_to_draw >= 1
BEGIN
DECLARE @ball_n INT, @prev_ball_n INT
SET @ball_n = 1

DECLARE @candidate_lottery_balls TABLE
(ball CHAR(2) NOT NULL,
ball_number INT NOT NULL PRIMARY KEY)
INSERT INTO @candidate_lottery_balls (ball, ball_number)
SELECT ball, ball_number
FROM CandidateLotteryBalls

DECLARE @combination_sequence_numbers TABLE
(n INT NOT NULL,
r INT NOT NULL,
sequence_number INT NOT NULL,
PRIMARY KEY (n, r))
INSERT INTO @combination_sequence_numbers (n, r, sequence_number)
SELECT n, r, sequence_number
FROM CombinationSequenceNumbers
WHERE r <= @number_balls_to_draw

-- Draw first of R balls from candidate balls
INSERT INTO @ball_drawings
(number_balls_drawn, ball, ball_number, draw_number, prev_draw_number)
SELECT @ball_n, ball, ball_number,
COALESCE(S.sequence_number, 0),
COALESCE(S.sequence_number, 0)
FROM @candidate_lottery_balls AS B
LEFT OUTER JOIN