Logic

/ˈbuːliən/

adjective … “Relating to true/false logic.”

Boolean refers to a data type, algebra, or logic system based on two possible values: true and false. Boolean concepts underpin digital electronics, logic gates, computer programming, and decision-making systems. Named after mathematician George Boole, Boolean logic allows complex conditions to be expressed using operators like AND, OR, and NOT.

Key characteristics of Boolean include:

• Binary values: only true or false.
• Operators: AND, OR, NOT, XOR, NAND, NOR, etc.
• Expression evaluation: determines outcomes in conditional statements and circuits.
• Digital foundation: essential for logic circuits, CPUs, and software control flow.
• Algebraic structure: forms Boolean algebra for simplifying logical expressions.

Applications of Boolean include programming conditionals, database queries, digital circuit design, search algorithms, and control systems.

Workflow example: Evaluating a Boolean expression:

a = True
b = False
result = a and not b
print(result)   -- True

Here, the Boolean expression combines AND and NOT operators to yield a logical outcome.

Conceptually, Boolean is like a simple switch: either ON (true) or OFF (false), forming the building blocks for complex logical structures.

See Logic Gates, Transistor, Digital, Control Logic, ALU.

/steɪt trænsˈɪʃən/

noun … “Change from one system state to another.”

State Transition refers to the movement of a system, device, or computational model from one defined state to another in response to inputs, events, or conditions. State transitions are fundamental in finite-state machines, sequential circuits, software workflows, and control systems, enabling predictable and deterministic behavior based on system rules.

Key characteristics of State Transition include:

• Trigger: an event, input, or condition that causes the transition.
• Source state: the current state before the transition occurs.
• Destination state: the state entered after the transition.
• Deterministic vs nondeterministic: may have one or multiple possible outcomes per input.
• Output association: may produce an output or action during the transition (Mealy machine) or after reaching the new state (Moore machine).

Applications of State Transition include traffic light controllers, protocol handling, UI navigation, software state management, and digital circuit design.

Workflow example: Traffic light transition:

states = ["Green", "Yellow", "Red"]
current_state = "Green"

def transition(event):
    if current_state == "Green" && event == "timer":
        return "Yellow"
    elif current_state == "Yellow" && event == "timer":
        return "Red"
    elif current_state == "Red" && event == "timer":
        return "Green"
    return current_state

current_state = transition("timer")

Here, the system moves between states predictably based on input events.

Conceptually, a State Transition is like a person moving between rooms in a building: the transition occurs only when certain conditions are met, and the person occupies only one room at a time.

See Finite-State Machine, Sequential Circuit, Control Logic, Flip-Flop, Digital.

/kənˈtroʊl ˈlɑːdʒɪk/

noun … “Circuitry that directs operations in digital systems.”

Control Logic is the part of a CPU or digital system responsible for orchestrating the flow of data, managing instruction execution, and coordinating the operation of various components such as the ALU, Registers, and memory. It interprets instructions, generates timing signals, and ensures that each part of the system performs the correct operation at the right time.

Key characteristics of Control Logic include:

• Instruction decoding: determines the operation to perform based on the instruction set.
• Signal generation: produces control signals for registers, ALU, memory, and I/O devices.
• Timing management: synchronizes operations using clock signals.
• Sequential or combinational design: can involve both logic types to manage system states.
• Critical for CPU operation: ensures correct execution order and prevents conflicts.

Applications of Control Logic include managing instruction cycles in processors, controlling data paths in digital circuits, implementing finite-state machines, and coordinating peripheral devices.

Workflow example: Executing an ADD instruction:

instruction = fetch(pc)
decoded = control_logic.decode(instruction)
control_signals = control_logic.generate(decoded)
ALU.execute(control_signals, operands)

Here, the control logic interprets the instruction, issues control signals, and coordinates the ALU and registers to perform the operation.

Conceptually, Control Logic is like a conductor in an orchestra: it ensures that every component plays its part at the right time to produce correct and harmonious operation.

See CPU, ALU, Register, Sequential Circuit, Finite-State Machine.

/ˈfaɪnɪt steɪt məˌʃiːn/

noun … “Model of computation with a limited number of states.”

Finite-State Machine (FSM) is an abstract computational model used to design sequential circuits or software systems. It consists of a finite set of states, a set of inputs that trigger transitions between states, and a set of outputs determined by its current state (and sometimes input). FSMs are widely used for modeling control logic, communication protocols, parsers, and embedded systems.

Key characteristics of Finite-State Machine include:

• Finite number of states: the system can only be in one state at a time.
• State transitions: movement between states triggered by input events.
• Deterministic or nondeterministic: deterministic FSMs have exactly one next state per input, while nondeterministic FSMs can have multiple possibilities.
• Outputs: determined either solely by state (Moore machine) or by state and input (Mealy machine).
• Applications: control systems, protocol design, sequence detection, UI navigation, and parser design.

Workflow example: Simple traffic light controller:

states = ["Green", "Yellow", "Red"]
current_state = "Green"

def transition(input_event):
    if current_state == "Green" && input_event == "timer":
        return "Yellow"
    elif current_state == "Yellow" && input_event == "timer":
        return "Red"
    elif current_state == "Red" && input_event == "timer":
        return "Green"
    return current_state

current_state = transition("timer")

Here, the traffic light cycles through a fixed set of states based on input events, illustrating a deterministic FSM.

Conceptually, a Finite-State Machine is like a board game with defined spaces: the player moves from one state to another according to the rules triggered by dice rolls or cards.

See Sequential Circuit, Flip-Flop, Digital, Control Logic, State Transition.

/ˈflɪp flɑːp/

noun … “Basic memory element in digital circuits.”

Flip-Flop is a bistable sequential circuit that can store one bit of binary information, holding a state of 0 or 1 until it is changed by a control signal. Flip-flops are the building blocks of digital memory, registers, counters, and finite state machines (FSMs), providing the essential ability to store and remember information in digital systems.

Key characteristics of Flip-Flop include:

• Bistable operation: maintains either a high (1) or low (0) state indefinitely until triggered.
• Clocked or triggered: changes state based on input signals and/or clock edges.
• Types: SR (Set-Reset), D (Data), JK, and T (Toggle) flip-flops, each with different input behavior.
• Applications: memory storage, counters, shift registers, synchronization, and state machines.
• Edge sensitivity: many flip-flops change state on the rising or falling edge of a clock signal.

Workflow example: D flip-flop storing a bit:

d_input = 1
clk_edge = detect_rising_edge(clock)
if clk_edge:
    q_output = d_input   -- store input at clock edge

Here, the flip-flop captures the value of d_input at the clock edge and maintains it until the next trigger.

Conceptually, a Flip-Flop is like a light switch with memory: once set, it stays in the on or off position until someone flips it again.

See Sequential Circuit, Registers, Finite State Machine, Clock Signal, Digital.

/sɪˈkwɛnʃəl ˈsɜːrkɪt/

noun … “Logic circuit whose output depends on current and past inputs.”

Sequential Circuit is a type of digital logic circuit in which the output depends not only on the present input values but also on the circuit’s history or previous states. Unlike combinational circuits, sequential circuits incorporate memory elements such as flip-flops or latches to store state information, enabling complex behaviors like counting, timing, and controlled sequencing.

Key characteristics of Sequential Circuit include:

• State dependency: output depends on both current inputs and stored state.
• Memory elements: flip-flops, latches, or registers store past information.
• Clocked operation: often synchronized with a clock signal to update state predictably.
• Deterministic behavior: follows state transition rules defined by logic and memory.
• Applications: counters, shift registers, finite state machines (FSMs), control units, and pipelines in CPUs.

Workflow example: Simple 2-bit counter using flip-flops:

clock_signal = generate_clock()
counter_state = 0b00
for tick in clock_signal:
    counter_state = (counter_state + 1) & 0b11   -- increment modulo 4
    output(counter_state)

Here, the output depends on both the incoming clock signal and the previous counter state, demonstrating sequential logic.

Conceptually, a Sequential Circuit is like a combination lock: the current output depends not only on the dial’s present position but also on the sequence of previous positions.

See Combinational Circuit, Flip-Flop, Digital, Finite State Machine, CPU.

/ˌkɑːmbɪˈneɪʃənəl ˈsɜːrkɪt/

noun … “Logic circuit with output determined only by current inputs.”

Combinational Circuit is a type of digital logic circuit whose output depends solely on the present values of its inputs, with no reliance on past states or stored memory. Unlike sequential circuits, combinational circuits have no internal state, clock, or feedback loops. They are built entirely from logic gates and implement Boolean expressions directly.

In a Combinational Circuit, any change in input propagates through the circuit and produces a corresponding change in output after a finite propagation delay. This makes combinational logic predictable, fast, and foundational to digital computation.

Key characteristics of Combinational Circuit include:

• Stateless behavior: no memory of previous inputs.
• Deterministic output: same inputs always produce the same output.
• No clock signal: operates purely on signal propagation.
• Boolean foundation: described using Boolean logic equations.
• Hardware simplicity: constructed from interconnected logic gates.

Common examples of Combinational Circuits include adders, subtractors, multiplexers, demultiplexers, encoders, decoders, and comparators. These circuits form the arithmetic and decision-making core of CPUs and digital systems.

Workflow example: Simple combinational logic (half adder):

a = 1
b = 1
sum = a XOR b        -- sum = 0
carry = a AND b     -- carry = 1

Here, the outputs sum and carry depend only on the current values of a and b, with no stored state involved.

Conceptually, a Combinational Circuit is like a calculator keypress: the result depends only on what you press right now, not on what you pressed before.

See Logic Gates, Boolean Logic, Digital, CPU, Sequential Circuit.