Study guide

7.4 Boolean Expressions, Truth Tables, and Boolean Algebra

Praxis Computer Science 5652

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Praxis 5652 Exam Overview and ETS Pseudocode

1.1 Praxis 5652 Test Facts, Scoring, and Registration 1.2 Official ETS Pseudocode Notation and Tracing Strategy

2 Chapter 2: Impacts of Computing: Innovation, Access, and Effects

2.1 Computing for Creativity, Problem Solving, Communication, and Innovation 2.2 Equal Access, the Digital Divide, and Accessibility 2.3 Beneficial and Harmful Effects of Computing Innovations

3 Chapter 3: Impacts of Computing: Intellectual Property, Ethics, Privacy, and Security

3.1 Intellectual Property: Copyright, Open Source, and Creative Commons 3.2 Ethical and Unethical Computing Practices and Their Implications 3.3 Privacy, Security, Data Collection, and Local vs. Cloud Storage

4 Chapter 4: Algorithms and Computational Thinking: Abstraction, Decomposition, Number Bases, and Representation

4.1 Abstraction and Abstraction Hierarchies 4.2 Decomposition, Pattern Recognition, and Developing Algorithms 4.3 Number Bases: Binary, Octal, Decimal, and Hexadecimal 4.4 Algorithm Formats: Natural Language, Flowcharts, Pseudocode, and Tracing

5 Chapter 5: Algorithms: Efficiency, Limits of Computing, and Randomization

5.1 Algorithm Efficiency: Linear, Quadratic, Exponential, and Logarithmic Growth 5.2 Limits of Computing: Unsolvable Problems, Intractability, and Heuristics 5.3 Randomization, Random vs. Pseudorandom Numbers, and Scaling to a Range

6 Chapter 6: Algorithms: Searching, Sorting, and Recursion

6.1 Searching Algorithms: Linear Search and Binary Search 6.2 Sorting Algorithms: Tracing, Comparisons, Correctness, and Efficiency 6.3 Recursion: Base Cases, Tracing, Errors, and Iterative Equivalents

7 Chapter 7: Programming: Variables, Data Types, Strings, and Expressions

7.1 Variables, Data Types, and Type Conversion 7.2 Strings and String Operations 7.3 Operators, Precedence, Expressions, and Formulas 7.4 Boolean Expressions, Truth Tables, and Boolean Algebra

8 Chapter 8: Programming: Selection, Iteration, and Writing Code

8.1 Sequence and Selection: if, else, Chained and Nested Conditions 8.2 Iteration: for, while, do … while, and repeat … until Loops 8.3 Reading, Completing, and Modifying Code

9 Chapter 9: Programming: Procedures, Arrays, and Data Structures

9.1 Procedures, Parameters, Return Values, Nested Calls, and Scope 9.2 Arrays, Lists, and Two-Dimensional Arrays 9.3 Stacks, Queues, and Dictionaries (Maps)

10 Chapter 10: Programming: Correctness, Errors, Testing, and Code Quality

10.1 Program Correctness: Preconditions, Postconditions, Invariants, and Testing vs. Proof 10.2 Error Types and Debugging Techniques 10.3 Choosing Useful Test Cases: Boundaries, Partitions, Coverage, and Regression 10.4 Extensibility, Modifiability, and Reusability: Constants and Parameterization 10.5 Documentation, Code Reviews, Peer Feedback, and End-User Feedback

11 Chapter 11: Programming: Events, Usability, Input Validation, and APIs

11.1 Event-Driven Programming, Asynchronous Events, and Concurrency 11.2 Usability, Meaningful Error Messages, and Input Validation vs. Verification 11.3 Libraries and APIs: Reading Definitions, Making Calls, and Weighing Trade-offs

12 Chapter 12: Programming: Languages, Tools, Paradigms, and Object-Oriented Design

12.1 Low- and High-Level Languages, Compilers and Interpreters, and IDEs 12.2 Programming Paradigms: Procedural, Object-Oriented, and Others 12.3 Classes, Objects, Instance Variables, Methods, and Encapsulation 12.4 Inheritance, Polymorphism, and Overloading vs. Overriding

13 Chapter 13: Data: Bits, Encoding, Compression, and Encryption

13.1 Bits and Bytes: Why Binary, Storage Calculations, and Signed Integers 13.2 Encoding Text, Images, and Sound 13.3 Lossless and Lossy Compression: Run-Length Encoding, Huffman Coding, and Media Formats 13.4 Encoding vs. Encryption, Symmetric and Public-Key Encryption, and Their Trade-offs

14 Chapter 14: Data: Analysis Tools, Simulation, Storage, and Collection

14.1 Analyzing Data with Spreadsheets: Cleaning, Transforming, and Visualizing 14.2 Simulation and Modeling 14.3 Files, Databases, and Storage Requirements: Scale, Redundancy, and Backup 14.4 Collecting, Aggregating, and Generating Data: Public Data Sets, Surveys, Sensors, and Crowdsourcing

15 Chapter 15: Computing Systems: Hardware, Operating Systems, and Computing Environments

15.1 Hardware Components and the Fetch–Decode–Execute Cycle 15.2 Operating Systems, Software Components, and Resource Issues 15.3 Embedded Systems, the Internet of Things, and Types of Computing Systems 15.4 Local, Network, and Cloud Computing and Storage; How Binary Data Are Stored

16 Chapter 16: Networks, the Internet, the Web, and Cybersecurity

16.1 Network Types and Wired and Wireless Communication 16.2 Network Hardware and Layered Network Models (OSI and TCP/IP) 16.3 Network Performance: Bandwidth, Latency, Load, and Estimating Needs 16.4 How the Internet Works: Protocols, IP Addressing, DNS, URLs, and Reliability 16.5 The Web: HTTP, HTML and Markup Languages, Browsers, Servers, and Clients 16.6 Cybersecurity: The Five Pillars, Strong Passwords, Security Strategies, and Trade-offs

7.4 Boolean Expressions, Truth Tables, and Boolean Algebra

Key Takeaways Explain This Topic AI

and is true only when both operands are true; or is true when at least one is true; not reverses a value; a truth table for n variables has 2ⁿ rows.

De Morgan's laws: not ( A and B ) equals ( not A ) or ( not B ), and not ( A or B ) equals ( not A ) and ( not B ).

Negating a comparison flips it: not ( x > 10 ) is x ≤ 10, and not ( x == y ) is x ≠ y.

Nested if statements that both must pass are equivalent to one condition joined with and; alternative conditions that lead to the same action are joined with or.

Short-circuit evaluation skips the right operand of and when the left is false, and the right operand of or when the left is true, so ( i < n ) and ( a[i] > 0 ) never reads a[n].

Last updated: September 2026

What this competency asks

Within the operators competency, ETS lists two Boolean skills:

Use Boolean algebra to identify equivalent Boolean expressions.

Write a Boolean expression equivalent to given code, or identify code equivalent to a given Boolean expression or English description.

ETS's sample question on this topic gives ( age > 10 ) and ( height > 36 ) and asks for an equivalent expression. The answer is not ( ( age ≤ 10 ) or ( height ≤ 36 ) ) , which uses De Morgan's law and flips each comparison correctly. The trap choices negate > as < instead of ≤ , or keep and where De Morgan's law requires or .

Operators and truth tables

  • A B not A A and B A or B A xor B
  • false false true false false false
  • false true true false true true
  • true false false false true true
  • true true false true true false

ETS pseudocode uses the words and , or , and not . Other languages write && , || , and ! . XOR (exclusive or) is true when exactly one operand is true. It is not an ETS keyword, but it can be written as ( A or B ) and not ( A and B ) .

A truth table for n variables has 2ⁿ rows . Two expressions are equivalent exactly when their truth-table columns match in every row. For three variables that is 8 rows. For example, ( A and not B ) or ( not A and C ) is true in rows (A, B, C) = (F, F, T), (F, T, T), (T, F, F), and (T, F, T), and false in the other four.

Precedence

not is evaluated first, then and , then or . So A or B and C means A or ( B and C ) , and not A and B means ( not A ) and B . With A = false, B = true, and C = true:

not A and B or not C and A = ( true and true ) or ( false and false ) = true or false = true .

Laws of Boolean algebra

  • Law And form Or form
  • Identity A and true = A A or false = A
  • Domination A and false = false A or true = true
  • Idempotent A and A = A A or A = A
  • Complement A and not A = false A or not A = true
  • Double negation not ( not A ) = A
  • Commutative A and B = B and A A or B = B or A
  • Distributive A and ( B or C ) = ( A and B ) or ( A and C ) A or ( B and C ) = ( A or B ) and ( A or C )
  • Absorption A and ( A or B ) = A A or ( A and B ) = A
  • De Morgan not ( A and B ) = not A or not B not ( A or B ) = not A and not B
  • Worked simplification

Simplify not ( not A or B ) or ( A and B ) :

De Morgan on the first part: not ( not A or B ) = not not A and not B = A and not B .

The expression is now ( A and not B ) or ( A and B ) .

Factor out A: A and ( not B or B ) .

Complement law: not B or B = true, so the expression is A and true .

Identity law: A .

Negating comparisons

To apply De Morgan to real conditions, you must negate each comparison exactly :

  • Condition Its negation
  • x > 10 x ≤ 10
  • x ≥ 10 x < 10
  • x == y x ≠ y
  • ( x ≥ 10 ) and ( x ≤ 20 ) (in the range) ( x < 10 ) or ( x > 20 ) (outside the range)

Example: the loop while ( ( loggedIn ) and ( tries < 5 ) ) stops when not ( loggedIn and ( tries < 5 ) ) becomes true, which is ( not loggedIn ) or ( tries ≥ 5 ) .

  • From code to a Boolean expression, and back
  • Nested ifs mean "and" if ( x > 0 )
  • if ( y > 0 )
  • print "both positive"
  • end if
  • end if

This prints exactly when ( x > 0 ) and ( y > 0 ) .

  • Separate conditions with the same action mean "or" boolean discount ← false
  • if ( age < 13 )
  • discount ← true
  • end if
  • if ( age ≥ 65 )
  • discount ← true
  • end if

This is equivalent to discount ← ( age < 13 ) or ( age ≥ 65 ) .

If/else that returns a Boolean

if ( score ≥ 70 ) return true else return false end if is simply return score ≥ 70 .

From English

  • Description Expression
  • "x is between 10 and 20, inclusive" ( x ≥ 10 ) and ( x ≤ 20 )
  • "x is outside that range" ( x < 10 ) or ( x > 20 )
  • "neither a nor b is true" not a and not b , which is not ( a or b )
  • "not both a and b" not ( a and b ) , which is not a or not b
  • "exactly one of a and b" ( a or b ) and not ( a and b )

A frequent error is writing ( x < 10 ) and ( x > 20 ) for "outside the range." No number is both below 10 and above 20, so that condition is always false.

Short-circuit evaluation

Most languages stop evaluating as soon as the result is known:

In A and B , if A is false, B is not evaluated (the result must be false).

In A or B , if A is true, B is not evaluated (the result must be true).

Programmers use this as a guard: if ( ( i < n ) and ( list[i] == target ) )

When i = n, the left side is false, so list[n] is never read. Reversing the order would read past the end. The same idea guards against division by zero, as in ( count ≠ 0 ) and ( total / count > 50 ) . Because the right side might not run, avoid putting required actions, such as a procedure call that updates a counter, inside a condition.

Boolean logic in hardware

The same algebra describes logic gates . AND, OR, and NOT gates, built from transistors, compute these functions on voltages. NAND (not-and) and NOR (not-or) are each functionally complete : any Boolean function can be built using only NAND gates, or only NOR gates. For example, NOT A = A NAND A. This is why logic gates sit near the bottom of the abstraction hierarchy in Section 4.1.