ForHosting KIT · Math

Logical NOR calculator

False NOR false is true, and every other pair gives false. Enter two true-or-false values and get the NOR result with the expression written out, ready to check a truth table or a logic exercise. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

If either operand is true, the result is false. That rule is the negation of inclusive OR, written NOT (a OR b), or equivalently (NOT a) AND (NOT b) by De Morgan's law.

What NOR means, in one row of a truth table

NOR is short for not-or. It takes two true-or-false inputs and answers true only when neither of them is true. Out of the four possible pairs, just one gives true: false and false. True with false, false with true, and true with true all give false. Written as a rule, NOR of a and b is NOT (a OR b), and by De Morgan's law that is the same as (NOT a) AND (NOT b). Algebra books also write it as the Peirce arrow, a ↓ b, and digital-logic diagrams draw it as an OR gate with a small bubble on its output.

Where NOR shows up, and the usual slips

Logic courses lean on NOR because it is functionally complete: NOT, OR and AND can each be wired from NOR gates and nothing else, so exercises often ask students to do exactly that. Checking each row here before handing in a circuit or an answer catches a wrong line early. The usual mistakes are reading NOR as plain OR, when it gives the exact opposite result on every row, and confusing it with other negated gates such as NAND. Another is typing 1 or 0: the inputs here are true or false, and anything else is refused instead of being guessed.

What you can do with it

Functionally complete gate drills

Mark exercises that build NOT, OR, and AND from NOR alone, using a deterministic two-input oracle instead of executing untrusted student circuits.

FAQ

When does logical NOR return true?

Only when both inputs are false. true NOR false, false NOR true, and true NOR true are all false. The identity is NOT (a OR b).

How is NOR different from NAND and from OR?

OR is true if at least one input is true. NAND is false only when both inputs are true. NOR is true only when both inputs are false: it is the negation of OR, not the negation of AND.

Is this the same as a bitwise NOR of two integers?

For inclusive bitwise OR of integers, use a bitwise OR calculator.

Why is NOR called a universal gate?

Because NOT, OR and AND can all be built from NOR alone. Feeding the same value into both inputs already gives NOT, which is why logic courses set drills that build every other gate out of NOR.

Can I enter 1 and 0 instead of true and false?

No. Each input must be true or false; numbers such as 0 and 1, text or empty values are refused rather than converted, so a typing slip never turns into a wrong truth value.

Related tools

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/math/nor

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/math/nor \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"a":false,"b":false}'

const res = await fetch("https://api.kit.forhosting.com/math/nor", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "a": false,
    "b": false
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/math/nor",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "a": false,
    "b": false
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/nor", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"a":false,"b":false}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"a":false,"b":false}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/nor", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "a": false,
  "b": false
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "math.nor",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Technical notes

Logical NOR is the Boolean operation that is true only when both inputs are false. Students meet NOR as a two-input gate in digital logic, as the Peirce arrow in Boolean algebra, and as a functionally complete primitive from which every other gate can be built. This calculator accepts two JSON booleans, evaluates that definition, and returns the Boolean result plus a short expression and formula. Values that are not booleans—numbers such as zero and one, strings, null, or missing fields—fail with invalid_input instead of being coerced.

What logical NOR means and when it is true

For two inputs that means the output is true only for the pair false and false; true NOR false, false NOR true, and true NOR true are all false. The algebraic identity is NOR(a, b) equals NOT (a OR b), which is the same as (NOT a) AND (NOT b) by De Morgan's law. Digital-logic courses draw the same function as a NOR gate: a curved OR body with a small inversion bubble on the output. The four-row truth table is the entire specification: false NOR false is true; every other combination is false. Logical NOR, short for not-or, is the binary Boolean operation whose output is true solely when every operand is false. Boolean algebra also writes it as the Peirce arrow a ↓ b. That single row of true is why NOR is functionally complete on its own: NOT a is a NOR a, a OR b is NOT (a NOR b), and a AND b is (NOT a) NOR (NOT b), so any Boolean circuit can be built from NOR cells alone. This calculator applies that two-input definition to JSON booleans rather than to integers or bit vectors. It does not walk the bits of a machine word the way a bitwise operator would, and it does not treat 0 and 1 as honorary booleans: those values are numbers, so they are rejected. The result is a single Boolean together with a display expression such as false NOR false equals true and a formula string restating NOT (a OR b). Use a bitwise integer tool if you need column-wise operations on words; use this endpoint when the question is the logical gate on true and false.

Input contract, output shape, and validation

The implementation never silently coerces: sending 0 is an error, not a false, and sending 1 is an error, not a true. On success the body echoes a and b, returns result as the logical NOR of the pair, includes an expression string such as false NOR false equals true, and includes formula as the identity NOT (a OR b) so you can show the algebra next to the answer. Failed validation is not billed. Because both operands are required booleans, a request that omits b does not default the second input to false: it fails, naming b, which is the correct behaviour for a two-input gate that should never invent an operand. POST a JSON object with two required booleans, a and b. Each field must arrive as JSON true or false. Aliases x or left are accepted for a, and y or right for b; the canonical names still appear in the response. Missing fields, empty strings, null, numbers, objects, arrays, and any text including the words true or false fail with invalid_input and name the offending field, so a form renderer can highlight the control. That closed contract prevents the classic bug where a language truthiness rule turns an empty string or a zero into a Boolean and still returns a result. The arithmetic is a single Boolean operation: result is true if and only if neither operand is true. Pair the JSON with your own UI if you want a drawn gate symbol or a four-row table; this capability only evaluates one pair. Keep the payload to those two flags and you get a stable, testable contract for homework checkers, rule engines, and edge workers.

Where a logical NOR calculator earns its keep

Computer-science and electronics courses introduce NOR in the same week as AND, OR, NAND, and XOR. Digital designers use NOR as a primitive cell; checking a two-input row of a truth table from a script is faster than opening a simulator for a one-off. Invalid input does not consume balance. If you need column-wise integer OR, use a bitwise calculator. A deterministic oracle lets a learning platform mark the Boolean answer without executing untrusted student code, and it rejects 0/1 so learners practise the Boolean type instead of integer stand-ins. Rule engines and fail-closed safety logic often want an alarm only when two interlocks are both off—both flags false—which is exactly NOR, and calling a tiny parse API avoids reimplementing the gate in every language of a pipeline. This endpoint is not a bitwise NOR of integers and is not an inclusive OR of numbers; those are different search intents and different types. If you need the Boolean gate that is true only when both inputs are false, this is the contract.

Integration use cases

Digital-logic homework and truth tables

Let students submit two booleans and check that NOR is true only for false/false, with invalid_input when they send 0 or 1 instead of true or false.

Fail-closed flags and safety rules

Fire an alert only when two interlocks are both off (both false). Logical NOR is that test; the API returns a Boolean you can branch on without coercing integers.

Technical questions

Can I send 0 and 1 instead of true and false?

No. Operands must be JSON booleans. Numbers, strings, null, and missing fields fail with invalid_input naming the field and are not billed.

What does the NOR calculator cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free