You do not have permission to edit this page, for the following reasons:

This IP address has been blocked from editing Wikipedia.
This does not affect your ability to read Wikipedia pages.
Most people who see this message have done nothing wrong. Some kinds of blocks restrict editing from specific service providers or telecom companies in response to recent abuse or vandalism, and can sometimes affect other users who are unrelated to that abuse. Review the information below for assistance if you do not believe that you have done anything wrong.

The IP address or range 75.101.128.0/17 has been blocked (disabled) by ‪JJMC89‬ for the following reason(s):

The IP address that you are currently using has been blocked because it is believed to be a web host provider or colocation provider. To prevent abuse, web hosts and colocation providers may be blocked from editing Wikipedia.
You will not be able to edit Wikipedia using a web host or colocation provider because it hides your IP address, much like a proxy or VPN.
We recommend that you attempt to use another connection to edit. For example, if you use a proxy or VPN to connect to the internet, turn it off when editing Wikipedia. If you edit using a mobile connection, try using a Wi-Fi connection, and vice versa. If you are using a corporate internet connection, switch to a different Wi-Fi network. If you have a Wikipedia account, please log in.
If you do not have any other way to edit Wikipedia, you will need to request an IP block exemption.

How to appeal if you are confident that your connection does not use a colocation provider's IP address:
If you are confident that you are not using a web host, you may appeal this block by adding the following text on your talk page: ((unblock|reason=Caught by a colocation web host block but this host or IP is not a web host. My IP address is _______. Place any further information here. ~~~~)). You must fill in the blank with your IP address for this block to be investigated. Your IP address can be determined here. Alternatively, if you wish to keep your IP address private you can use the unblock ticket request system. There are several reasons you might be editing using the IP address of a web host or colocation provider (such as if you are using VPN software or a business network); please use this method of appeal only if you think your IP address is in fact not a web host or colocation provider.

Administrators: The IP block exemption user right should only be applied to allow users to edit using web host in exceptional circumstances, and requests should usually be directed to the functionaries team via email. If you intend to give the IPBE user right, a CheckUser needs to take a look at the account. This can be requested most easily at SPI Quick Checkuser Requests. Unblocking an IP or IP range with this template is highly discouraged without at least contacting the blocking administrator.

This block will expire on 05:39, 2 October 2024.

Even when blocked, you will usually still be able to edit your user talk page, as well as email administrators and other editors.

For information on how to proceed, please read the FAQ for blocked users and the guideline on block appeals. The guide to appealing blocks may also be helpful.

Other useful links: Blocking policy · Help:I have been blocked
Your IP address is in a range that has been blocked on all Wikimedia Foundation wikis. The block was made by ‪Jon Kolbert‬. The reason given is Open proxy/Webhost: See the help page if you are affected .
- Start of block: 05:40, 21 February 2024
- Expiry of block: 05:40, 21 February 2029
Your current IP address is 75.101.254.2. The blocked range is 75.101.128.0/17. Please include all above details in any queries you make. If you believe you were blocked by mistake, you can find additional information and instructions in the No open proxies global policy. Otherwise, to discuss the block please post a request for review on Meta-Wiki. You could also send an email to the stewards VRT queue at stewards@wikimedia.org including all above details.

You can view and copy the source of this page:

((Short description|Bit added to a binary string for error detection))
((broader|Parity (mathematics)))
((more citations needed|date=January 2022))

{| class="wikitable" style="float: right; text-align: center; margin: 1em;"
|-
! rowspan="2" | 7 bits of data<br/>
! rowspan="2" | (count of 1-bits)
! colspan="2" | 8 bits including parity
|- 
! even
! odd
|-
| 0000000 
|0
| 0000000'''0'''
| 0000000'''1'''
|- 
| 1010001
| 3
| 1010001'''1'''
| 1010001'''0'''
|- 
| 1101001
|4
| 1101001'''0'''
| 1101001'''1'''
|-
| 1111111 
|7
| 1111111'''1'''
| 1111111'''0'''
|}

A '''parity bit''', or '''check bit''', is a [[bit]] added to a string of [[binary code]]. Parity bits are a simple form of [[Error detection and correction|error detecting code]]. Parity bits are generally applied to the smallest units of a communication protocol, typically 8-bit [[octet (computing)|octets]] (bytes), although they can also be applied separately to an entire message string of bits.

The parity bit ensures that the [[Hamming weight|total number of 1-bits]] in the string is [[Even and odd numbers|even or odd]].<ref>((Cite book |title=Principles of communication : systems, modulation, and noise |last1=Ziemer |first1=RodgerE. |last2=Tranter |first2=William H. |date=17 March 2014 |isbn=9781118078914 |edition=Seventh |location=Hoboken, New Jersey |oclc=856647730))</ref> Accordingly, there are two variants of parity bits: '''even parity bit''' and '''odd parity bit'''. In the case of even parity, for a given set of bits, the bits whose value is 1 are counted. If that count is odd, the parity bit value is set to 1, making the total count of occurrences of 1s in the whole set (including the parity bit) an even number. If the count of 1s in a given set of bits is already even, the parity bit's value is 0. In the case of odd parity, the coding is reversed. For a given set of bits, if the count of bits with a value of 1 is even, the parity bit value is set to 1 making the total count of 1s in the whole set (including the parity bit) an odd number. If the count of bits with a value of 1 is odd, the count is already odd so the parity bit's value is 0. Even parity is a special case of a [[cyclic redundancy check]] (CRC), where the 1-bit CRC is generated by the [[polynomial]] ''x''+1.

==Parity==
In mathematics ''[[parity (mathematics)|parity]]'' can refer to the evenness or oddness of an integer, which, when written in its [[binary numeral system|binary form]], can be determined just by examining only its [[least significant bit]]. 

In information technology parity refers to the evenness or oddness, given any set of binary digits, of the number of those bits with value one. Because parity is determined by the state of every one of the bits, this property of parity—being dependent upon all the bits and changing its value from even to odd parity if any one bit changes—allows for its use in error detection and correction schemes.

In telecommunications the parity referred to by some protocols is for error-''detection''. The transmission medium is preset, at both end points, to agree on either odd parity or even parity. For each string of bits ready to transmit (data packet) the sender calculates its parity bit, zero or one, to make it conform to the agreed parity, even or odd. The receiver of that packet first checks that the parity of the packet as a whole is in accordance with the preset agreement, then, if there was a parity error in that packet, requests a retransmission of that packet.

In computer science the parity stripe or parity disk in a [[RAID]] provides [[Error detection and correction#Parity bits|error-''correction'']]. Parity bits are written at the rate of one parity bit per ''n'' bits, where ''n'' is the number of disks in the array. When a read error occurs, each bit in the error region is recalculated from its set of ''n'' bits. In this way, using one parity bit creates "redundancy" for a region from the size of one bit to the size of one disk. See ((section link||Redundant Array of Independent Disks)) below.

In electronics, transcoding data with parity can be very efficient, as [[XOR#More that two inputs|XOR]] gates output what is equivalent to a check bit that creates an even parity, and XOR logic design easily scales to any number of inputs. XOR and AND structures comprise the bulk of most integrated circuitry.

==Error detection==
If an odd number of bits (including the parity bit) are [[Transmission (telecommunications)|transmitted]] incorrectly, the parity bit will be incorrect, thus indicating that a '''parity error''' occurred in the transmission. The parity bit is suitable only for detecting errors; it cannot [[Error correction code|correct]] any errors, as there is no way to determine the particular bit that is corrupted. The data must be discarded entirely, and [[automatic repeat-request|retransmitted from scratch]]. On a noisy transmission medium, successful transmission can therefore take a long time or even never occur. However, parity has the advantage that it uses only a single bit and requires only a number of [[XOR gate]]s to generate. See [[Hamming code]] for an example of an error-correcting code.

Parity bit checking is used occasionally for transmitting [[ASCII]] characters, which have 7 bits, leaving the 8th bit as a parity bit.

For example, the parity bit can be computed as follows. Assume [[Alice and Bob]] are communicating and Alice wants to send Bob the simple 4-bit message 1001.
{| class="wikitable"
|-
! Type of bit parity !! Successful transmission scenario
|-
| Even parity ||
Alice wants to transmit:          1001 and 1011

Alice computes parity bit value: <br>1+0+0+1 (mod 2) = 0
<br>1+0+1+1 (mod 2) = 1

Alice adds parity bit and sends: <br>1001'''0''' and 1011'''1'''

Bob receives:                   10010 and 10111

Bob computes parity:            <br>1+0+0+1+0 (mod 2) = 0
<br>1+0+1+1+1 (mod 2) = 0

Bob reports correct transmission after observing expected even result.
|-
| Odd parity ||
Alice wants to transmit:          1001 and 1011

Alice computes parity bit value: 
<br>1+0+0+1 (+ 1 mod 2) = 1
<br>1+0+1+1 (+ 1 mod 2) = 0

Alice adds parity bit and sends: <br>1001'''1''' and 1011'''0'''

Bob receives:                   10011 and 10110

Bob computes overall parity:    <br>1+0+0+1+1 (mod 2) = 1
<br>1+0+1+1+0 (mod 2) = 1

Bob reports correct transmission after observing expected odd result.
|}

This mechanism enables the detection of single bit errors, because if one bit gets flipped due to line noise, there will be an incorrect number of ones in the received data. In the two examples above, Bob's calculated parity value matches the parity bit in its received value, indicating there are no single bit errors. Consider the following example with a transmission error in the second bit using XOR:

{| class="wikitable"
|-
! Type of bit parity error !! Failed transmission scenario
|-
| Even parity
Error in the second bit 
|| Alice wants to transmit:          1001

Alice computes parity bit value: 1^0^0^1 = 0

Alice adds parity bit and sends: 10010

'''...TRANSMISSION ERROR...'''

Bob receives:                   1'''1'''010

Bob computes overall parity:    1^1^0^1^0 = 1

Bob reports incorrect transmission after observing unexpected odd result.
|-
| Even parity
Error in the parity bit 
||Alice wants to transmit:          1001

Alice computes even parity value: 1^0^0^1 = 0

Alice sends:                      10010

'''...TRANSMISSION ERROR...'''

Bob receives:                   1001'''1'''

Bob computes overall parity:    1^0^0^1^1 = 1

Bob reports incorrect transmission after observing unexpected odd result.
|}

There is a limitation to parity schemes. A parity bit is guaranteed to detect only an odd number of bit errors. If an even number of bits have errors, the parity bit records the correct number of ones even though the data is corrupt. (See also [[error detection and correction]].) Consider the same example as before but with an even number of corrupted bits:

{| class="wikitable"
|-
! Type of bit parity error !! Failed transmission scenario
|-
| Even parity
Two corrupted bits 
|| Alice wants to transmit:          1001

Alice computes even parity value: 1^0^0^1 = 0

Alice sends:                      10010

'''...TRANSMISSION ERROR...'''

Bob receives:                   1'''1'''01'''1'''

Bob computes overall parity:    1^1^0^1^1 = 0

Bob reports correct transmission though actually incorrect.
|}
Bob observes even parity, as expected, thereby failing to catch the two bit errors.

==Usage==
Because of its simplicity, parity is used in many [[computer hardware|hardware]] applications in which an operation can be repeated in case of difficulty, or simply detecting the error is helpful. For example, the [[SCSI]] and [[PCI bus]]es use parity to detect transmission errors, and many [[microprocessor]] instruction [[CPU cache|caches]] include parity protection. Because the [[Instruction cache]] data is just a copy of the [[main memory]], it can be disregarded and refetched if it is found to be corrupted.

In [[serial communications|serial]] [[data transmission]], a common format is 7 data bits, an even parity bit, and one or two [[stop bit]]s. That format accommodates all the 7-bit [[ASCII]] characters in an 8-bit byte. Other formats are possible; 8 bits of data plus a parity bit can convey all 8-bit byte values.

In serial communication contexts, parity is usually generated and checked by interface hardware (such as a [[Universal asynchronous receiver-transmitter|UART]]) and, on reception, the result made available to a [[Processor (computing)|processor]] such as the CPU (and so too, for instance, the [[operating system]]) via a status bit in a [[hardware register]] in the [[Interface (computing)|interface]] hardware. Recovery from the error is usually done by retransmitting the data, the details of which are usually handled by software (such as the operating system I/O routines).

When the total number of transmitted bits, including the parity bit, is even, odd parity has the advantage that both all-zeros and all-ones patterns are detected as errors. If the total number of bits is odd, only one of the patterns is detected as an error, and the choice can be made based on what the more common error is expected to be.

=== RAID array ===
Parity data is used by RAID arrays ([[RAID|redundant array of independent/inexpensive disks]]) to achieve [[Redundancy (engineering)|redundancy]]. If a drive in the array fails, remaining data on the other drives can be combined with the parity data (using the Boolean [[XOR]] function) to reconstruct the missing data.

For example, suppose two drives in a three-drive [[RAID 4]] array contained the following data:

{|
|-
|Drive 1:
|'''01101101'''
|-
|Drive 2:
|'''11010100'''
|}

To calculate parity data for the two drives, an XOR is performed on their data:

{|
|-
|
|'''01101101'''
|-
|&nbsp;&nbsp;XOR&nbsp;&nbsp;&nbsp;&nbsp;
|<ins>'''11010100'''</ins>
|-
|
|'''10111001'''
|}

The resulting parity data, '''10111001''', is then stored on Drive 3.

Should any of the three drives fail, the contents of the failed drive can be reconstructed on a replacement drive by subjecting the data from the remaining drives to the same XOR operation. If Drive 2 were to fail, its data could be rebuilt using the XOR results of the contents of the two remaining drives, Drive 1 and Drive 3:

{|
|-
|Drive 1:
|'''01101101'''
|-
|Drive 3:
|'''10111001'''
|}

as follows:

{|
|-
| || '''01101101''' || Drive 1
|-
| XOR || <ins>'''10111001'''</ins> || Drive 3
|-
| || '''11010100''' || Reconstructed Drive 2
|}

The result of that XOR calculation yields Drive 2's contents. '''11010100''' is then stored on Drive 2, fully repairing the array. 

XOR logic is also equivalent to even parity (because ''a'' XOR ''b'' XOR ''c'' XOR ... may be treated as XOR(''a'',''b'',''c'',...), which is an n-ary operator that is true if and only if an odd number of arguments is true). So the same XOR concept above applies similarly to larger RAID arrays with parity, using any number of disks. In the case of a RAID 3 array of 12 drives, 11 drives participate in the XOR calculation shown above and yield a value that is then stored on the dedicated parity drive.

Extensions and variations on the parity bit mechanism "double," "dual," or "diagonal" parity, are used in [[Non-standard RAID levels#RAID-DP|RAID-DP]].

== History ==
A ''parity track'' was present on the first [[magnetic-tape data storage]] in 1951. Parity in this form, applied across multiple parallel signals, is known as a [[transverse redundancy check]]. This can be combined with parity computed over multiple bits sent on a single signal, a [[longitudinal redundancy check]]. In a parallel bus, there is one longitudinal redundancy check bit per parallel signal.

Parity was also used on at least some paper-tape ([[punched tape]]) data entry systems (which preceded magnetic-tape systems). On the systems sold by British company ICL (formerly ICT) the ((convert|1|in|mm|adj=mid|-wide)) paper tape had 8 hole positions running across it, with the 8th being for parity. 7 positions were used for the data, e.g., 7-bit ASCII. The 8th position had a hole punched in it depending on the number of data holes punched.

== See also ==
* [[BIP-8]]
* [[Parity function]]
* [[Single-event upset]]
* [[8-N-1]]
* [[Check digit]]

==References==
((reflist))

==External links==
* [http://graphics.stanford.edu/~seander/bithacks.html Different methods of generating the parity bit, among other bit operations]

[[Category:Binary arithmetic]]
[[Category:Data transmission]]
[[Category:Error detection and correction]]
[[Category:Parity (mathematics)]]
[[Category:RAID]]

[[fr:Somme de contrôle#Exemple : bit de parité]]

Pages transcluded onto the current version of this page (help):

Parity bit (edit)
Template:Ambox (view source) (template editor protected)
Template:Broader (view source) (semi-protected)
Template:Cite book (view source) (protected)
Template:Convert (view source) (template editor protected)
Template:Find sources mainspace (view source) (template editor protected)
Template:Main other (view source) (protected)
Template:More citations needed (view source) (template editor protected)
Template:Pagetype (view source) (protected)
Template:Reflist (view source) (protected)
Template:Reflist/styles.css (view source) (protected)
Template:SDcat (view source) (protected)
Template:Section link (view source) (template editor protected)
Template:Short description (view source) (protected)
Template:Short description/lowercasecheck (view source) (protected)
Module:Arguments (view source) (protected)
Module:Broader (view source) (semi-protected)
Module:Category handler (view source) (protected)
Module:Category handler/blacklist (view source) (protected)
Module:Category handler/config (view source) (protected)
Module:Category handler/data (view source) (protected)
Module:Category handler/shared (view source) (protected)
Module:Check for unknown parameters (view source) (protected)
Module:Citation/CS1 (view source) (protected)
Module:Citation/CS1/COinS (view source) (protected)
Module:Citation/CS1/Configuration (view source) (protected)
Module:Citation/CS1/Date validation (view source) (protected)
Module:Citation/CS1/Identifiers (view source) (protected)
Module:Citation/CS1/Utilities (view source) (protected)
Module:Citation/CS1/Whitelist (view source) (protected)
Module:Citation/CS1/styles.css (view source) (protected)
Module:Convert (view source) (template editor protected)
Module:Convert/data (view source) (template editor protected)
Module:Convert/text (view source) (template editor protected)
Module:Disambiguation/templates (view source) (protected)
Module:Find sources (view source) (template editor protected)
Module:Find sources/config (view source) (template editor protected)
Module:Find sources/links (view source) (template editor protected)
Module:Find sources/templates/Find sources mainspace (view source) (template editor protected)
Module:Format link (view source) (template editor protected)
Module:Hatnote (view source) (template editor protected)
Module:Hatnote/styles.css (view source) (template editor protected)
Module:Hatnote list (view source) (template editor protected)
Module:Message box (view source) (protected)
Module:Message box/ambox.css (view source) (protected)
Module:Message box/configuration (view source) (protected)
Module:Namespace detect/config (view source) (protected)
Module:Namespace detect/data (view source) (protected)
Module:Pagetype (view source) (protected)
Module:Pagetype/config (view source) (protected)
Module:Pagetype/disambiguation (view source) (protected)
Module:Pagetype/setindex (view source) (protected)
Module:Pagetype/softredirect (view source) (protected)
Module:SDcat (view source) (protected)
Module:Section link (view source) (template editor protected)
Module:String (view source) (protected)
Module:TableTools (view source) (protected)
Module:Unsubst (view source) (protected)
Module:Wikitext Parsing (view source) (protected)
Module:Yesno (view source) (protected)

Return to Parity bit.

Retrieved from "https://en.wikipedia.org/wiki/Parity_bit"