Логическая арифметика

В этой статье приведены некоторые часто используемые логические утверждения. Когда возможно, приведено русское название утверждения (группы утверждений).

## Соглашение о скобках

Зачастую в логических формулах получается слишком много скобок, так что приняты следующие правила по их опусканию:

# * φ

(
φ
)

{\displaystyle \varphi = \left( \varphi \right)}
* В выражениях типа

φ
1

∧
⋯
∧

φ
n

{\displaystyle \varphi\_1 \wedge \dots \wedge \varphi\_n}

,

φ
1

∨
⋯
∨

φ
n

{\displaystyle \varphi\_1 \vee \dots \vee \varphi\_n}

,

φ
1

⊠
1

⋯

⊠

n
−
1

φ
n

{\displaystyle \varphi\_1 \boxtimes\_1 \dots \boxtimes\_{n - 1} \varphi\_n}

 и

φ
1

↔
⋯
↔

φ
n

{\displaystyle \varphi\_1 \leftrightarrow \dots \leftrightarrow \varphi\_n}

, (где каждое из

φ
1

,
…
,

φ
n

{\displaystyle \varphi\_1, \dots, \varphi\_n}

 - либо элементарное утверждение, записанное без конъюнкции, дизъюнкции, импликации, эквиваленции, кванторов, следствия и эквивалентности, либо выражение вида

(
ψ
)

{\displaystyle \left( \psi \right)}

, где

ψ

{\displaystyle \psi}

 - утверждение, и каждое из

⊠
1

,
…
,

⊠

n
−
1

{\displaystyle \boxtimes\_1, \dots, \boxtimes\_{n - 1}}

→
,
←

{\displaystyle \to, \leftarrow}

 или равнозначный одному из этих символ) скобки восстанавливаются согласно правилам для *n*-арной конъюнкции, *n*-арной дизъюнкции, последовательности импликаций и последовательности эквиваленций.
* В выражениях типа

φ
1

⊠
1

⋯

⊠
n

φ

n
1

{\displaystyle \varphi\_1 \boxtimes\_1 \dots \boxtimes\_n \varphi\_{n + 1}}

, (где каждое из

φ
1

,
…
,

φ

n
1

{\displaystyle \varphi\_1, \dots, \varphi\_{n + 1}}

 - либо утверждение, записанное без следствия и эквивалентности, либо выражение вида

(
ψ
)

{\displaystyle \left( \psi \right)}

, где

ψ

{\displaystyle \psi}

 - утверждение, и каждое из

⊠
1

,
…
,

⊠
n

{\displaystyle \boxtimes\_1, \dots, \boxtimes\_n}

⇒
,
⇐
,
⇔

{\displaystyle \Rightarrow, \Leftarrow, \Leftrightarrow}

 или равнозначный одному из этих символ), вокруг каждого из

φ
1

,
…
,

φ
n

{\displaystyle \varphi\_1, \dots, \varphi\_n}

 ставятся скобки, и получившееся выражение читается по правилам для последовательности следований с эквивалентностями.
* При стоящих рядом разных операциях скобки расставляются согласно их приоритету.
	+ Операции по возрастанию приоритета:

	↔
	,
	→
	,
	∨
	,
	∧
	,
	¬

	{\displaystyle \leftrightarrow, \to, \vee, \wedge, \neg}
	+ Примеры:

	φ
	1

	∧

	φ
	2

	∨

	φ
	3

	→

	φ
	4

	↔
	¬

	φ
	5

	=

	(

	(

	φ
	1

	∧

	φ
	2

	)

	∨

	φ
	3

	)

	↔

	(

	¬

	φ
	5

	)

	{\displaystyle \varphi\_1 \wedge \varphi\_2 \vee \varphi\_3 \to \varphi\_4 \leftrightarrow \neg \varphi\_5 = \left( \left( \varphi\_1 \wedge \varphi\_2 \right) \vee \varphi\_3 \right) \leftrightarrow \left( \neg \varphi\_5 \right)}

	φ
	1

	∧

	φ
	2

	∨

	φ
	1

	∧

	φ
	3

	=

	(

	φ
	1

	∧

	φ
	2

	)

	∨

	(

	φ
	1

	∧

	φ
	3

	)

	{\displaystyle \varphi\_1 \wedge \varphi\_2 \vee \varphi\_1 \wedge \varphi\_3 = \left( \varphi\_1 \wedge \varphi\_2 \right) \vee \left( \varphi\_1 \wedge \varphi\_3 \right)}

	¬
	φ
	∧
	ψ
	=

	(

	¬
	φ

	)

	∧
	ψ

	{\displaystyle \neg \varphi \wedge \psi = \left( \neg \varphi \right) \wedge \psi}
	+ Программистское пояснение:
	Если вам непонятны правила расстановки скобок по приоритетам, замените в логическом выражении, состоящем только из элементарных утверждений и логических операций (то есть, без кванторов, следствия и эквивалентности) каждое

	↔

	{\displaystyle \leftrightarrow}

	 на e, каждое

	→

	{\displaystyle \to}

	 - на i, каждое

	∨

	{\displaystyle \vee}

	 - на o, каждое

	∧

	{\displaystyle \wedge}

	 - на a, каждое

	¬

	{\displaystyle \neg}

	 на n и все переменные этого утверждения - на наборы вида "латинская буква кроме e, i, o, a и n" + "последовательность цифр" (например, l2 или b3456 (разумеется, одинаковые переменные на одинаковые наборы, разные переменные - на разные)) и проделайте мысленно (или не мысленно) следующую программу на питоне (python) с получившейся последовательностью символов как вводимым:

```
        return a
    b = []
    for c in a:
        b.append(make_copy_of_the_list(c))
    return b

def brackets_in_case_we_are_working_with_elementary_statement_or_its_negation(s):
    if s[0] == "n":
        return "(" + s + ")"
    return s

def brackets_in_case_we_are_working_not_with_elementary_statement_and_not_with_its_negation(s):
    return "(" + s + ")"

def split_operands_of_implication(s):
    return s.split("i")

def nearly_split_operands_of_or(s):
    return s.split("o")

def split_operands_of_or(a):
    return list(map(nearly_split_operands_of_or, a))

def nearly_nearly_split_operands_of_and(s):
    return s.split("a")

def nearly_split_operands_of_and(a):
    return(list(map(nearly_nearly_split_operands_of_and, a)))

def split_operands_of_and(a):
    return list(map(nearly_split_operands_of_and, a))

        return brackets_in_case_we_are_working_with_elementary_statement_or_its_negation(a[0])
    return brackets_in_case_we_are_working_not_with_elementary_statement_and_not_with_its_negation("a".join(map(brackets_in_case_we_are_working_with_elementary_statement_or_its_negation, a)))

        return join_back_operands_of_and(a[0])
    return brackets_in_case_we_are_working_not_with_elementary_statement_and_not_with_its_negation("o".join(map(join_back_operands_of_and, a)))

        return join_back_operands_of_or(a[0])
    return brackets_in_case_we_are_working_not_with_elementary_statement_and_not_with_its_negation("i".join(map(join_back_operands_of_or, a)))

not_answer = input()
if "e" in not_answer:
    not_answer = not_answer.split("e")
    not_answer = list(map(split_operands_of_implication, not_answer))
    not_answer = list(map(split_operands_of_or, not_answer))
    not_answer = list(map(split_operands_of_and, not_answer))
    answer = make_copy_of_the_list(not_answer)
    answer = "e".join(map(join_back_operands_of_implication, answer))
elif "i" in not_answer:
    not_answer = not_answer.split("i")
    not_answer = list(map(nearly_split_operands_of_or, not_answer))
    not_answer = list(map(nearly_split_operands_of_and, not_answer))
    answer = make_copy_of_the_list(not_answer)
    answer = "i".join(map(join_back_operands_of_or, not_answer))
elif "o" in not_answer:
    not_answer = not_answer.split("o")
    not_answer = list(map(nearly_nearly_split_operands_of_and, not_answer))
    answer = make_copy_of_the_list(not_answer)
    answer = "o".join(map(join_back_operands_of_and, not_answer))
elif "a" in not_answer:
    not_answer = not_answer.split("a")
    answer = make_copy_of_the_list(not_answer)
    answer = "a".join(map(brackets_in_case_we_are_working_with_elementary_statement_or_its_negation, not_answer))
else:
    answer = not_answer
print(answer)

```

После выполнения программы замените "e", "i", "o", "a", "n" обратно на

↔
,
→
,
∨
,
∧
,
¬

{\displaystyle \leftrightarrow, \to, \vee, \wedge, \neg}

, а последовательности букв и цифр - на соответствующие им элементарные утверждения. Это и будет эквивалентное утверждение с расставленными необходимыми скобками.

## Доказательства

* Для утверждений, использующих только символы переменных и

¬
,
∧
,
∨
,
→
,
↔

{\displaystyle \neg, \wedge, \vee, \to, \leftrightarrow}

, доказательство в каждом случае - простое составление таблицы истинности, что подозрительный читатель вполне может проделать самостоятельно.
* Утверждения, использующие символы

∀
,
∃
,
⇒
,
⇔

{\displaystyle \forall, \exists, \Rightarrow, \Leftrightarrow}

 ввиду неизученности мною формальной логики предлагается воспринимать как аксиомы.

## Примечания

1. ↑ Если вы видите путь оптимизировать код, напишите мне, пожалуйста. Если вы знаете, как заставить вики подсвечивать код, как надо - заставьте, пожалуйста.

## Смотрите также

Правда

Ложь

Квантор всеобщности

Квантор существования