Minimum Round Card-Based Cryptographic Protocols Using Private Operations †

: This paper shows new card-based cryptographic protocols with the minimum number of rounds, using private operations under the semi-honest model. Physical cards are used in card-based cryptographic protocols instead of computers to achieve secure multiparty computation. Operations that a player executes in a place where the other players cannot see are called private operations. Using three private operations—private random bisection cuts, private reverse cuts, and private reveals—the calculations of two variable Boolean functions and copy operations were realized with the minimum number of cards. Though the number of cards has been discussed, the efﬁciency of these protocols has not been discussed. This paper deﬁnes the number of rounds to evaluate the efﬁciency of the protocols, using private operations. Most of the meaningful calculations using private operations need at least two rounds. This paper presents a new two-round committed-input, committed-output logical XOR protocol, using four cards. Then, we show new two-round committed-input, committed-output logical AND and copy protocols, using six cards. Even if private reveal operations are not used, logical XOR, logical AND, and copy operations can be executed with the minimum number of rounds. Protocols for general n -variable Boolean functions and protocols that preserve an input are also shown. Lastly, protocols with asymmetric cards are shown.

There are several types of protocols with regard to the inputs and outputs of the computations. The first type is committed inputs [7], where the inputs are given as committed values. The players do not know the input values. The other type is noncommitted inputs [35,36], where players give their private inputs to the protocol, using private input operations. The private input operations were also used in the millionaires' problem [11]. Protocols with committed inputs are desirable since they can be used for non-committed inputs: each player can give their private input value as a committed value. Some protocols output their computation results as committed values [7]. The result is unknown to the players unless the players open the output cards. The other type of protocols [6,37] output the result as a non-committed value, that is, the final result is obtained only by opening cards. Protocols with committed outputs are desirable since the committed output result can be used as an input to another computation. If further calculations are unnecessary, the players just open the committed outputs and obtain the result. Thus, this paper discusses protocols with committed inputs and committed outputs.
An example of a calculation with committed inputs is a matching service between men and women. The matching service provider does not allow direct communication between the clients until the matching is over. A client, Anne, receives information about a candidate, Bruce, from her agent, Alice. Anne sends the reply of acceptance/rejection to Alice, but Anne does not want the matching service provider agents to know the reply. Bruce also receives information about Anne from his agent Bob. Bruce sends his reply of acceptance/rejection to Bob, but Bruce does not want the matching service provider agents to know the reply. Alice and Bob must calculate whether the matching is successful or not without knowing the inputs. In this case, a calculation with committed inputs is necessary. To prevent malicious activities by the players, Anne observes all the actions executed by Alice. Bruce observes all the actions executed by Bob. If a player executes some action that is not allowed, the observing person can point out the misbehavior. Thus, Alice and Bob become semi-honest players. Note that Anne (Bruce) cannot observe Bob's (Alice's) actions. If a person observes both players' actions, the person can know a secret value.
Operations that a player executes in a place where the other players cannot see are called private operations. These operations are considered to be executed under the table or in the back so that the operations cannot be seen by the other players. Private operations are shown to be the most powerful primitives in card-based cryptographic protocols. They were first introduced to solve the millionaires' problem [10]. Using private operations, committed-input and committed-output logical AND, logical XOR, and copy protocols can be achieved with the minimum number of cards [9]. Thus, this paper considers protocols using private operations.
The number of cards is the space complexity of the card-based protocols. Thus, the time complexity must also be evaluated. Some studies have been done for protocols that do not use private operations [38]. As for the protocols using private operations, the number of rounds, defined in Section 2, is the most appropriate criterion to evaluate the time complexity. Roughly speaking, the number of rounds counts the number of sending cards between players. Since each private operation is relatively simple, sending cards between players and setting up so that the cards are not seen by the other players is the dominating time to execute private operations. Thus, this paper discusses the number of rounds of card-based protocols, using private operations. This paper shows logical XOR, logical AND, and copy protocols with the minimum number of rounds. The summary of results are shown in Tables 1-3. Note that the protocols in [7] need one shuffle by each player; thus, the actual execution time is larger than that in this paper, though the number of rounds is the same. This paper then shows variations of the protocols that do not use private reveals. Since a private reveal obtains private values, mistakes of private reveals are fatal for security. Thus, it would be better if every reveal operation is publicly executed and verified by multiple players. Thus, we consider protocols that do not use private reveal operations. We show that we can obtain protocols without increasing the number of rounds or cards, even if we cannot use private reveals.
Next, we show protocols that preserve an input. In usual logical AND protocols, the input bits are lost. If one of the inputs is not lost, the input bit can be used for further computations [39]. This paper shows the number of rounds of protocols that preserve an input. Lastly, this paper shows that the protocols can be executed using asymmetric cards.  In Section 2, basic notations, the private operations introduced in [9], and the definition of the rounds are shown. Section 3 shows two-round XOR, AND, and copy protocols. Section 4 shows the protocols that do not use private reveals. Section 5 shows protocols that preserve an input. Section 6 shows parallel execution of the protocols. Section 7 shows protocols with asymmetric cards. Section 8 concludes the paper.

Related Works
Many studies have been done for calculating Boolean functions without private operations; den Boer [6] first showed a five-card protocol to securely calculate logical AND of two inputs. Since then, several protocols to calculate logical AND of two committed inputs have been shown [40][41][42], but they use more than six cards. Mizuki et al. [7] showed a logical AND protocol that uses six cards. It was proved that it is impossible to calculate logical AND with less than six cards when we use closed and uniform shuffles [43]. When it is allowed to use a special kind of shuffle that is not closed or uniform, the minimum number of cards of logical AND protocols is decreased to five [8,44,45]. In addition, when Las Vegas protocols are allowed, logical AND protocols with five or four cards were shown [2,37,46].
For making copies of an input bit, Mizuki et al. showed a protocol with six cards [7]. A five-card protocol was shown that uses non-uniform shuffles [47].
Mizuki et al. [7] showed a logical XOR protocol that uses four cards, which is the minimum. An XOR protocol that uses random cuts was shown [48].

Basic Notations
This section gives the notations and basic definitions of card-based protocols. Most of this paper is based on a standard two-color card model.
In the two-color card model, there are two kinds of marks: and . Cards of the same marks cannot be distinguished. In addition, the back of both types of cards is . It is impossible to determine the mark in the back of a given card of .
One bit data are represented by two cards as follows: = 0 and = 1. One pair of cards that represents one bit x ∈ {0, 1}, whose face is down, is called a commitment of x, and denoted as commit(x). It is written as follows: x . Note that when these two cards are swapped, commit(x) can be obtained. Thus, logical negation can be calculated without private operations.
A set of cards placed in a row is called a sequence of cards. A sequence of cards S whose length is n is denoted as S = s 1 , s 2 , . . . , s n , where s i is the i-th card of the sequence.
. . . , s n . A sequence whose length is even is called an even sequence.
S 1 ||S 2 is a concatenation of sequence S 1 and S 2 . All protocols are executed by multiple players. Throughout this paper, all players are semi-honest, that is, they obey the rule of the protocols but try to obtain information x of commit(x). There is no collusion among players executing one protocol together. No player wants any other player to obtain information on committed values. Since the private operations are executed in a place where the other players cannot see, malicious actions might be easily executed, hence the semi-honest model might not be inappropriate in some cases. To consider malicious actions, two techniques are considered. The first technique executes more than two players [9]. For example, three players-Alice, Bob, and Carol-execute one protocol together. Alice watches Bob's private operations, Bob watches Carol's private operations, and Carol watches Alice's private operations. If a player executes a malicious action, it is detected by the corresponding watching player. The method can be easily introduced to the protocols shown in this paper.
The second technique uses envelopes as an additional tool [64]. The technique is used when the number of players is two. The cards are put into envelopes and sealed in a public place. When the seals are illegally opened during a private operation, they can be detected by the other player. Using the envelopes, all malicious private actions during AND, XOR, and copy protocols are detected or automatically corrected [64]. The technique can also be applied to this paper's protocols. Thus, this paper assumes the semi-honest model to show the fundamental protocols.
In Section 7, protocols with asymmetric cards are written. When we use cards whose face is not symmetric, such as and , but the back is symmetric, one-bit data can be represented by one card as = 0 and = 1. Protocols with this type of card are first considered in [56] and then several protocols are shown in [9,36,60]. This paper shows minimum round protocols using private operations.

Private Operations
We show three private operations introduced in [9] for the two-color model: private random bisection cuts, private reverse cuts, and private reveals.

Primitive 1. (Private random bisection cut)
A private random bisection cut is the following operation on an even sequence S 0 = s 1 , s 2 , . . . , s 2m . A player selects a random bit b ∈ {0, 1} and outputs the following: The player executes this operation in a place where the other players cannot see. The player must not disclose the bit b.
Note that if the private random cut is executed when m = 1 and S 0 = commit(x),

Primitive 2. (Private reverse cut, private reverse selection)
A private reverse cut is the following operation on an even sequence S 2 = s 1 , s 2 , . . . , s 2m and a bit b ∈ {0, 1}. A player outputs the following: The player executes this operation in a place where the other players cannot see. The player must not disclose b.
Note that the bit b is not newly selected by the player. This is the difference between the primitive in Definition 1, where a random bit must be newly selected by the player.
Note that in many protocols below, selecting left m cards is executed after a private reverse cut. The sequence of these two operations is called a private reverse selection. A private reverse selection is the following procedure on an even sequence S 2 = s 1 , s 2 , . . . , s 2m and a bit b ∈ {0, 1}. A player outputs the following: Primitive 3. (Private reveal) A player privately opens a given committed bit. The player must not disclose the obtained value.
Using the obtained value, the player privately sets a sequence of cards. Consider the case when Alice executes a private random bisection cut on commit(x) and Bob executes a private reveal on the bit. Since the committed bit is randomized by the bit b selected by Alice, the revealed bit is x ⊕ b. Bob obtains no information about x if b is randomly selected and not disclosed by Alice. Bob must not disclose the obtained value. If Bob discloses the obtained value to Alice, Alice knows the value of the committed bit.

Definition of Round
The space complexity of card-based protocols is evaluated by the number of cards. We define the number of rounds as a criterion to evaluate the time complexity of card-based protocols, using private operations. The first round begins from the initial state. The first round is (possibly parallel) local executions by each player, using the cards initially given to each player. It ends at the instant when no further local execution is possible without receiving cards from another player. The local executions in each round include sending cards to some other players but do not include receiving cards. The result of every private execution is known to the player. For example, shuffling for which the result is unknown to the player themselves is not executed. Since the private operations are executed in a place where the other players cannot see, it is hard to force the player to execute such operations whose result is unknown to the player. The i(>1)-th round begins with receiving all the cards sent during the (i − 1)-th round. Each player executes local executions using the received cards and the cards left to the player at the end of the (i − 1)-th round. Each player executes local executions until no further local execution is possible without receiving cards from another player. The number of rounds of a protocol is the maximum number of rounds necessary to output the result among all possible inputs and random values.
Let us show an example of a protocol execution and the number of rounds.

1.
Alice executes a private random bisection cut on commit(x). Let the output be commit(x ). Alice sends commit(x ) and commit(y) to Bob.

2.
Bob executes a private reveal on commit(x ). Bob privately sets the following: and sends S 2 to Alice.

3.
Alice executes a private reverse selection on S 2 using the bit b generated in the private random bisection cut. Let the obtained sequence be S 3 . Alice outputs S 3 .
The first round ends at the instant when Alice sends commit(x ) and commit(y) to Bob. The second round begins at receiving the cards by Bob. The second round ends at the instant when Bob sends S 2 to Alice. The third round begins upon receiving the cards by Alice. The number of rounds of this protocol is three.
Since each operation is relatively simple, the dominating time to execute protocols with private operations is the time to send cards between players and set up so that the cards are not seen by the other players. Thus, the number of rounds is the criterion to evaluate the time complexity of card-based protocols with private operations.
The minimum number of rounds of most protocols is two. Suppose that the number of rounds is one. Suppose that a player, for example, Alice, has some (or all) of the final outputs of the protocol. Since the number of rounds is one, sending cards between players is not executed. Thus, all the operations to obtain Alice's outputs are executed by Alice. Thus, Alice knows the relation between the committed inputs and Alice's outputs. If the output cards are faced up to know the results, Alice knows the private input values. Therefore, most protocols need at least two rounds for the privacy of the committed inputs.

Our Results
The protocols in [9] are three rounds and use four cards. We show a two-round logical XOR protocol, using four cards. Then, we show two-round logical AND and copy protocols, using six cards. Though the number of cards is increased, the number of rounds is minimal. Another advantage of these two-round protocols is that each player does not need to remember the random bit. In the protocols in [9], a player needs to remember the random bit until the player receives the cards again to execute a private reverse cut. If a player replies late, the other player must remember the random bit for a very long time. If a player executes many instances of the protocols with many players in parallel, it is hard for the player to remember so many random values. In the two-round protocols, the first player can exit from the protocol after she sends the cards to the other player. Note that Alice obtains the final result by the three-round protocols in [9] but Bob obtains the final result by the two-round protocols in this paper. These protocols can be used only if this change is acceptable by both players. Note that the two-round protocols with the four card logical XOR, six card logical AND, and copy with private operations are implicitly shown by [7] since one public shuffle used in the paper can be realized by two private shuffles by the two players. This paper shows another type of protocol with fewer shuffles.
The above two-round protocols do not use private reverse cuts, using a remembered bit. Thus, there is a question of whether we can obtain protocols without another type of private operation. This paper also answers this question. We show protocols that do not use private reveals. There is a concern in using this primitive: a player might make the mistake of opening cards that are not allowed and obtaining private values. Since no other player sees the operation, it is hard to detect or prevent such a mistake. If private reveals are not executed at all, protections, such as putting each card in an envelope, can be put in place to prove that incorrectly opening cards is not executed during the private operations. Thus, it would be better if all reveals are publicly executed. Even if we do not use private reveals, the number of rounds is unchanged for logical XOR and copy protocols. For AND and copy, both the (1) two-round and six card protocol and (2) three-round and four card protocol can be obtained, even without private reveals.
Next, we show protocols that preserve an input. In most protocols, input values are lost at the end of the protocol. If an input is not lost, the input can be used for further computations, using the same input value. Thus, protocols that preserve an input are considered [39]. Protocols that preserve an input are shown.
Last, we show protocols with asymmetric cards. By using asymmetric cards, the numbers of cards are halved for all protocols.

XOR, AND, and Copy with the Minimum Number of Rounds
This section shows our new two-round protocols for XOR, AND, and copy. These protocols do not use private reverse cuts, using the remembered random bit. Thus, the first player, Alice, does not need to remember the random bit b after she sends the cards to the other player.

Protocol 2. (XOR protocol with the minimum number of rounds)
Input: commit(x) and commit(y). Output: commit(x ⊕ y).

1.
Alice executes a private random bisection cut on input S 0 = commit(x) and S 0 = commit(y), using the same random bit b. Let the output be S 1 = commit(x ) and S 1 = commit(y ), respectively. Note that x = x ⊕ b and y = y ⊕ b. Alice sends S 1 and S 1 to Bob.

2.
Bob executes a private reveal on S 1 = commit(x ). Bob executes a private reverse cut on S 1 using x . Let the result be S 2 . Bob outputs S 2 .
The protocol is two rounds.
Therefore, the output is correct. Alice and Bob's security: Alice sees no open cards. Thus, Alice obtains no information. Bob sees x ⊕ b. Since b is a random value that Bob does not know, Bob obtains no information about x.
The number of cards: At least four cards are necessary for any protocol to input x and y. This protocol uses no additional cards other than the input cards.
Note that though the same bit b is used to randomize x and y, it is not a security problem because y ⊕ b is not opened.
The number of rounds is the minimum. Mizuki et al. showed a four-card protocol with one public shuffle [7]. Since one public shuffle can be changed to two private shuffles by each player, the minimum number of rounds is also achieved by their protocol. However, the protocol needs two shuffles; thus, our new protocol is more simple. A comparison of committed-input, committed-output XOR protocols using private operations is shown in Table 1.

Protocol 3. (AND protocol with the minimum number of rounds)
Input: commit(x) and commit(y). Output: commit(x ∧ y).

1.
Alice executes a private random bisection cut on S 0 = commit(x) and S 0 = commit(0)|| commit(y) using the same random bit b. Two new cards are used to set commit(0). Let the output be S 1 = commit(x ) and S 1 , respectively. Note the following: Alice sends S 1 and S 1 to Bob.

2.
Bob executes a private reveal on S 1 . Bob executes a private reverse selection on S 1 using x . Let the selected cards be S 2 . Bob outputs S 2 as the result.
The protocol is two rounds. The protocol uses six cards since two new cards are used to set commit(0).

Theorem 2.
The AND protocol is correct and secure.
Proof. Correctness: The desired output can be represented as follows.
Alice and Bob's security is the same as in the XOR protocol.
The number of rounds is the minimum. Mizuki et al. showed a six-card protocol with one public shuffle [7]. Since one public shuffle can be changed to two private shuffles by each player, the minimum number of rounds is also achieved by their protocol. However, the protocol needs two shuffles, thus our new protocol is simple. Comparison of committed-input, committed-output logical AND protocols using private operations are shown in Table 2.

Copy Protocol
Next, we show a new copy protocol with the minimum number of rounds. Output: m copies of commit(x).

1.
Alice executes a private random bisection cut on S 0 = commit(x). Let the output be S 1 = commit(x ). Alice sets S 1 as m copies of commit(b), where b is the bit selected in the random bisection cut. Note that x = x ⊕ b. Alice sends S 1 and S 1 to Bob.

2.
Bob executes a private reveal on S 1 and obtains x . Bob executes a private reverse cut on each pair of S 1 using x . Let the result be S 2 . Bob outputs S 2 .
The protocol is two rounds. The protocol uses 2m + 2 cards.
Theorem 3. The copy protocol is correct and secure.
Proof. Correctness: Since Bob obtains Alice and Bob's security is the same as in the XOR protocol.
Though the number of cards is increased, the number of rounds is the minimum. A comparison of the copy protocols (when m = 2) is shown in Table 3. Mizuki et al. showed a six-card protocol with one public shuffle [7]. Since one public shuffle can be changed to two private shuffles by each player, the minimum number of rounds is also achieved by their protocol. However, the protocol needs two shuffles; thus, our new protocol is more simple.

Any Two-Variable Boolean Functions
Though this paper shows logical AND and logical XOR, any two-variable Boolean functions can also be calculated by a similar protocol. Though the protocol differs, the idea of the construction is similar to the one for the three-round protocol in [9].

Theorem 4. Any two-variable Boolean function can be securely calculated in two rounds and at most six cards.
Proof. Any two-variable Boolean function f (x, y) can be written as follows: where f (1, y) and f (0, y) are y,ȳ, 0, or 1. However, we need to consider the case when one of f (1, y) and f (0, y) is y orȳ and the other is 0, or 1. The reason, written in [9] is as follows. First, consider the case when both of f (1, y) and f (0, y) are 0 or 1. ( f (1, y), f (0, y)) = (0, 0) (or (1, 1)) means that f (x, y) = 0 (or f (x, y) = 1), thus we do not need to calculate f . ( f (1, y), f (0, y)) = (1, 0) (or (0, 1)) means the f (x, y) = x (or f (x, y) =x); thus, we do not need to calculate f by a two player protocol. Next, consider the case when both of ( f (1, y), f (0, y)) are y (orȳ). This case is when f (x, y) = y (or f (x, y) =ȳ); thus, we do not need to calculate f by a two-player protocol.
The remaining case is when one of ( f (1, y), f (0, y)) is y orȳ and the other is 0 or 1. We can modify the first step of the AND protocol and Alice sets as follows: using one commit(y) and two new cards, since one of ( f (1, y), f (0, y)) is y orȳ and the other is 0 or 1. Bob executes a private reveal on S 1 = commit(x ) and selects the left(right) pair if x = 0 (x = 1). Thus, Bob selects commit( f (1, y)) if x = 1. Bob selects commit( f (0, y)) if x = 0. Thus, any two-variable Boolean function can be calculated with, at most, six cards and in two rounds.

n-Variable Boolean Functions
Since two-variable Boolean functions, logical negation, and a copy can be executed, any n-variable Boolean function can be calculated by the combination of the above protocols.
As another implementation with more cards, we show that any n-variable Boolean function can be calculated by the following protocol in two rounds, whose technique is similar to the one in [35]. Let f be any n-variable logical function.
The protocol is two-round. The number of cards is 2 n+1 + 2n.

Theorem 5. Protocol 5 is correct and secure.
Proof. Correctness: Since S x 1 ,x 2 ,..., . , x n )), the output is correct. Alice and Bob's security is the same as in the XOR protocol.

Protocols without Private Reveals
This section shows that the above protocols can be executed without the private reveal operations. Since it is hard to prevent mistakes of privately revealing cards that are not allowed, it would be better for all reveal operations to be publicly executed. The general conversion rule is as follows: When Bob executes a private reveal and set a sequence S in the original protocol, Bob executes a private random bisection cut to commit(x ⊕ b) instead. Let b be the random bit selected by Bob. Then, Bob publicly opens the committed bit and publicly sets a sequence S by the original rule. Bob (and Alice) then executes private reverse cuts to undo the randomization by b and b .

1.
Alice executes a private random bisection cut on S 0 = commit(x) and S 0 = commit(y) using the same random bit b. Let the output be S 1 = commit(x ) and S 1 = commit(y ), respectively. Note that x = x ⊕ b and y = y ⊕ b. Alice sends S 1 and S 1 to Bob.

2.
Bob executes a private random bisection cut on S 1 and S 1 using a private bit b . Let the output be S 2 = commit(x ) and S 2 = commit(y ), respectively. x = x ⊕ b ⊕ b and y = y ⊕ b ⊕ b hold. Bob publicly opens S 2 and obtains x . Alice can see x . Bob publicly sets the following: The protocol is two rounds.

Theorem 6.
The XOR protocol is correct and secure. It uses the minimum number of cards.

Proof. Correctness: Bob obtains
Thus, the result is correct. Alice and Bob's security: After Bob executes a private random bisection cut on S 1 , the obtained value commit(x ) = commit(x ⊕ b ⊕ b ). Even if this value is opened, no player can obtain the value of x since Alice knows b and x ⊕ b ⊕ b and Bob knows b and At least four cards are necessary for any protocol to input x and y. This protocol uses no additional cards other than the input cards.

AND Protocol without Private Reveals
We can consider two kinds of protocols: (1) three rounds and four cards (the minimum number of cards); and (2) two rounds (the minimum number of rounds) and six cards.

1.
Alice executes a private random bisection cut on S 0 = commit(x). Let the result be S 1 = commit(x ). Alice sends S 1 and S 0 = commit(y) to Bob.

2.
Bob executes a private random bisection cut on S 1 , using a private bit b . Let the result be Bob publicly opens S 1 and obtains value x .
Alice can see x . Bob publicly sets the following: Bob then executes a private reverse cut on S 2 using the bit b generated in the private random bisection cut. Let the result be S 3 . Bob sends S 3 to Alice.

3.
Alice executes a private reverse selection on S 3 using the bit b generated in the private random bisection cut. Let the result be S 4 . Alice outputs S 4 .
The number of rounds is three.
Theorem 7. Protocol 7 is correct, secure, and uses the minimum number of cards.
Alice and Bob's security is the same as the XOR protocol without private reveals. The number of cards: Any committed input protocol needs at least four cards to input. When Bob sets S 2 , the cards used for commit(x ) can be re-used to set commit(0). Thus, the total number of cards is four and the minimum.

1.
Alice executes a private random bisection cut on S 0 = commit(x) and S 0 = commit(0)|| commit(y) using the same random bit b. Two new cards are used to set commit(0). Let the output be S 1 = commit(x ) and S 1 , respectively. Note the following: Alice sends S 1 and S 1 to Bob.

2.
Bob executes a private random bisection cut on S 1 and S 1 using the same random bit b . Let the result be S 2 and S 2 , respectively. Note that S 2 = commit(x ⊕ b ⊕ b ). Bob publicly opens cards of S 2 and obtains x = x ⊕ b ⊕ b . Alice can see x . Bob publicly selects the left pair of S 2 if x = 0, otherwise selects the right pair of S 2 . Bob outputs the pair as the result.
The protocol is two rounds. The protocol uses six cards since two new cards are used to set commit(0).
Alice and Bob's security is the same as the XOR protocol without private reveals.
Using the argument in Section 3.4, any two-variable Boolean function can also be calculated without private reveals by (1) three rounds and four cards, and (2) two rounds and six cards.

Copy Protocol without Private Reveals
Similar to the AND protocol, we can consider two kinds of copy protocols: (1) three rounds and 2m cards (the minimum number of cards); and (2) two rounds (the minimum number of rounds) and 2m + 2 cards. Protocol 9. (Copy protocol without private reveals (1)) Input: commit(x). Output: m copies of commit(x).

1.
Alice executes a private random bisection cut on S 0 = commit(x). Let the result be Bob executes a private random bisection cut on S 1 using a private random bit b . Let the result be S 2 = commit(x ). Note that Bob publicly opens S 2 and obtains x . Alice can see x . Bob publicly sets m pairs of cards of x . Bob faces down the cards. Let the cards be S 3 . Bob executes a private reverse cut on each pair of S 3 using b . Let the result be S 3 . Bob sends S 3 to Alice.

3.
Alice executes a private reverse cut on each pair of S 3 using b. Alice outputs the pairs.
The protocol is three rounds. The protocol uses 2m cards since the cards of S 2 are reused to set S 3 .
Theorem 9. Protocol 9 is correct and secure.
Proof. Correctness: Bob makes copies of commit(x ). Since x = x ⊕ b ⊕ b , after the private reverse cuts by Bob and Alice, the cards are commit( . Thus, the result is correct.
Alice and Bob's security is the same as the XOR protocol without private reveals.

1.
Alice executes a private random bisection cut on S 0 = commit(x). Let the result be S 1 = commit(x ). Note that x = x ⊕ b. Alice privately sets S 1 as m copies of commit(b). Alice sends S 1 and S 1 to Bob.

2.
Bob executes a private random bisection cut on S 1 and each pair of S 1 using a private random bit b . Let the output be S 2 = commit(x ) and S 2 , respectively. Bob publicly opens S 2 and obtains x . Alice can see x . Bob publicly swaps each pair of S 2 if x = 1. Otherwise, Bob does nothing. Let the result be S 3 . Bob outputs S 3 .
The protocol is two rounds. The protocol uses 2m + 2 cards.
Theorem 10. Protocol 10 is correct and secure.
Proof. Correctness: Bob obtains commit(x ) and . Thus, the result is correct. Alice and Bob's security is the same as the XOR protocol without private reveals.

n-Variable Boolean Functions without Private Reveals
Let f be an n-variable Boolean function.
The protocol is two rounds. The number of cards is 2 n+1 + 2n.
Theorem 11. Protocol 11 is correct and secure.
Proof. Correctness: Since S x 1 ,x 2 ,..., . . , x n )), the output is correct. The security of Alice and Bob is the same as the XOR protocol without private reveals.

Protocols that Preserve an Input
In the above protocols to calculate Boolean functions, the input commitment values are lost. If an input is not lost, the input commitment can be used as an input to another calculation. Thus, protocols that preserve an input are discussed [39]. For the three-round XOR and AND protocols in [9], protocols that preserve an input were shown [9].
First, consider XOR protocols in Sections 3 and 4.

1.
Alice executes a private random bisection cut on input S 0 = commit(x) and S 0 = commit(y) using the same random bit b. Let the output be S 1 = commit(x ) and S 1 = commit(y ), respectively. Note that x = x ⊕ b and y = y ⊕ b. Alice sends S 1 and S 1 to Bob.

2.
Bob executes a private reveal on S 1 = commit(x ). Bob executes a private reverse cut on S 1 , using x . Let the result be S 2 . Bob outputs S 2 . Bob sends back S 1 = commit(x ) to Alice. 3.
Alice executes a private reverse cut on S 1 using b and obtains commit(x).
In Protocol 2, since commit(x ) is unnecessary after Bob's private reveal, the cards can be sent back to Alice. Alice can recover commit(x). The number of rounds is increased to three. Theorem 12. Protocol 12 is correct and secure.

Proof. Correctness: From the correctness of Protocol
The security of Alice and Bob is the same as the XOR protocol without input preserving.

Protocol 13. (XOR protocol that preserves an input without private reveals)
Input: commit(x) and commit(y). Output: commit(x ⊕ y) and commit(x).

1.
Alice executes a private random bisection cut on S 0 = commit(x) and S 0 = commit(y) using the same random bit b. Let the output be S 1 = commit(x ) and S 1 = commit(y ), respectively. Note that x = x ⊕ b and y = y ⊕ b. Alice sends S 1 and S 1 to Bob.

2.
Bob executes a private random bisection cut on S 1 and S 1 using a private bit b . Let the output be S 2 = commit(x ) and S 2 = commit(y ), respectively. x = x ⊕ b ⊕ b and y = y ⊕ b ⊕ b hold. Bob publicly opens S 2 and obtains x . Alice can see x . Bob publicly sets the following: Alice executes a private reverse cut on S 1 using b and obtains commit(x).
Theorem 13. Protocol 13 is correct and secure.
Proof. Correctness: From the correctness of Protocol 6, commit(x ⊕ y) is obtained. After Bob publicly reveals S 2 and obtains x ⊕ b ⊕ b , he can privately recover commit(x ) since he knows b . Thus, Bob can send back commit(x ) to Alice. commit(x) can be obtained since The security of Alice and Bob is the same as the XOR protocol without input preserving.
The protocol is three rounds and uses four cards. Similarly, the AND protocols in Sections 3 and 4 can be modified to a three-round protocol to preserve an input.

1.
Alice executes a private random bisection cut on S 0 = commit(x) and S 0 = commit(0)|| commit(y) using the same random bit b. Two new cards are used to set commit(0). Let the output be S 1 = commit(x ) and S 1 , respectively. Note the following: Alice sends S 1 and S 1 to Bob.

2.
Bob executes a private reveal on S 1 . Bob executes a private reverse selection on S 1 using x . Let the selected cards be S 2 . Bob outputs S 2 as the result. Bob sends back S 1 = commit(x ) to Alice. 3.
Alice executes a private reverse cut on S 1 using b and obtains commit(x).
The number of rounds is three and the number of cards is six. Note that though the characteristics of the Protocol 14 are the same as the protocol in [9], the steps differ: for example, Alice obtains the output in [9] and Bob obtains the output in Protocol 14.
Theorem 14. Protocol 14 is correct and secure.
Proof. Correctness: From the correctness of Protocol 3, commit(x ∧ y) is obtained. After Bob privately reveals S 1 = commit(x ), he can send back commit(x ) to Alice. commit(x) can be obtained since The security of Alice and Bob is the same as the AND protocol without input preserving.
Protocol 15. (AND protocol that preserves an input without private reveals) Input: commit(x) and commit(y). Output: commit(x ∧ y) and commit(x).

1.
Alice executes a private random bisection cut on S 0 = commit(x). Let the result be S 1 = commit(x ). Alice sends S 1 and S 0 = commit(y) to Bob.

2.
Bob executes a private random bisection cut on S 1 using a private bit b . Let the result be S 1 = commit(x ). x = x ⊕ b ⊕ b holds. Bob publicly opens S 1 and obtains value x .
Alice can see x . Bob publicly sets the following: Bob then executes a private reverse cut on S 2 using the bit b generated in the private random bisection cut. Let the result be S 3 . Bob sends S 3 and S 1 to Alice.

3.
Alice executes a private reverse selection on S 3 using the bit b generated in the private random bisection cut. Let the result be S 4 . Alice outputs S 4 . Alice executes a private reverse cut on S 1 using b and obtains commit(x).
The number of rounds is three and the number of cards is six.
Theorem 15. Protocol 15 is correct and secure.
Proof. Correctness: From the correctness of Protocol 7, commit(x ∧ y) is obtained. After Bob publicly reveals S 1 and obtains x ⊕ b ⊕ b , he can privately recover commit(x ) since he knows b . Thus, Bob can send back commit(x ) to Alice. commit(x) can be obtained since The security of Alice and Bob is the same as the AND protocol without input preserving.
As for the AND type protocol, to calculate f (x, y), another protocol that preserves an input without additional cards can be obtained, using the technique in [39]. Note that the function f satisfies that one of ( f (0, y), f (1, y)) is y orȳ and the other is 0 or 1. Otherwise, we do not need to calculate f by the AND type two player protocol. When we execute the four-card AND type protocol without private reveals, two cards are selected by Alice at the final step. The remaining two cards are not used, but they also output some values. The unused two cards' value is the following: 0, y)). The output f (x, y) can be written as x ∧ f (1, y) ⊕x ∧ f (0, y). We execute the above XOR protocol that preserves an input without private reveal for these two output values so that f (x, y) is preserved. The output of Since one of ( f (0, y), f (1, y)) is y orȳ and the other is 0 or 1, the output is y orȳ (depending on f ). Thus, input y can be recovered without additional cards.

Protocol 16. (AND type protocol that preserves an input without private reveals)
Input: commit(x) and commit(y).

1.
Alice executes a private random bisection cut on S 0 = commit(x). Let the result be S 1 = commit(x ). Alice sends S 1 and S 0 = commit(y) to Bob.

2.
Bob executes a private random bisection cut on S 1 , using a private bit b . Let the result be S 1 = commit(x ). x = x ⊕ b ⊕ b holds. Bob publicly opens S 1 and obtains value x .
Alice can see x . Bob publicly sets the following: (1, y))||commit( f (0, y)) if x = 1 commit( f (0, y))||commit( f (1, y)) if x = 0 Bob then executes a private reverse cut on S 2 using the bit b generated in the private random bisection cut. Let the result be S 3 . Bob sends S 3 to Alice.

3.
Alice executes a private reverse selection on S 3 using the bit b generated in the private random bisection cut. Let the result be S 4 . Alice outputs S 4 . Let S 4 be the cards that are not selected.

4.
Alice and Bob execute the XOR protocol that preserves an input without private reveals (Protocol 12) for S 4 and S 4 . Let the preserved input, S 4 , be the result. We obtain commit(y) from the XOR result.
Thus, the protocol achieves preserving an input by four cards. The protocol does not use private reveals. The AND type protocol needs three rounds and the XOR protocol that preserves an input needs three rounds. The last round of the AND type protocol and the first round of the XOR protocol are executed by Alice, thus they can be done in one round. Therefore, the total number of rounds is five. Proof. Correctness: From the correctness of Protocol 7, commit( f (x, y)) is obtained as S 4 . Since S 4 = commit(x ∧ f (1, y) ⊕ x ∧ f (0, y)), the output of the input preserving XOR is f (x, y) ⊕x ∧ f (1, y) ⊕ x ∧ f (0, y) = f (0, y) ⊕ f (1, y), which is y orȳ. The input f (x, y) is preserved, thus the output can be commit(y) and commit( f (x, y)) The security of Alice and Bob comes from the security of the AND protocol and the XOR protocol with input preserving.
Lastly, we show n-variable Boolean function protocols that preserve inputs.

1.
Alice randomly selects bit b. If b=1, Alice privately turns commit(x) upside down, otherwise does nothing. Let the result be S 1 = commit(x ). Note that x = x ⊕ b. Alice privately sets S 1 as m copies of commit(b). Alice sends S 1 and S 1 to Bob.

2.
Bob executes a private reveal on S 1 and obtains x . Bob privately upside down all cards of S 1 if x = 1, otherwise does nothing. Let the results be S 2 . Bob outputs S 2 .
The protocol is two rounds. The protocol uses m + 1 cards.
Theorem 19. Using asymmetric cards, XOR, AND, and a copy can be realized in two rounds.
Proof. The correctness and security proofs are the same as those for the two-color card protocols.

Conclusions
This paper proposes round optimal card-based cryptographic protocols, using private operations. We showed protocols without private reveal operations and several variant protocols. This paper contributes the following new results, compared to the conference version: (1) new XOR and copy protocols without private reveals; (2) correctness and security proofs, given to all protocols; (3) parallel computation of the AND/XOR type protocols; and (4) protocols with asymmetric cards.
Further study will include round optimal protocols for the other fundamental problems.

Data Availability Statement:
No new data were created or analyzed in this study. Data sharing is not applicable to this article.

Conflicts of Interest:
The authors declare no conflict of interest.