Prädikatenlogik: Wie überprüfen Sie selbst die logische Struktur Ihrer eigenen Argumente?

In der Aussagenlogik gibt es Wahrheitstabellen. So können Sie überprüfen, ob die logische Struktur Ihrer Argumentation nicht per se korrekt ist, sondern ob sie beabsichtigt ist.

In der Prädikatenlogik habe ich keinen Verweis auf Wahrheitstabellen gesehen, noch habe ich eine Verwendung (wörtliche Verwendung) von Wahrheitstabellen gesehen, als ich nach Beispielen gesucht habe, in denen Wahrheitstabellen in PL verwendet werden.

Es wäre schön, die logische Struktur meiner eigenen Argumente zu überprüfen, da ich nicht immer jemanden haben werde, der meine eigene Arbeit validiert. Ich habe vor, meine logischen Fähigkeiten einzusetzen, aber ich möchte einen sicheren Weg, um sicherzustellen, dass meine Form korrekt ist :)

Es gibt bekannte Schlußregeln .
Es gibt mehrere Proof-Verifizierungs-Softwarepakete, die kostenlos online verfügbar sind.
Ausgehend von einer Reihe von Axiomen können Sie Ihren Beweis in einem Hilbert-Stil-Deduktionssystem führen . Tatsächlich können "natürliche" Beweise (die wir täglich verwenden) als Anweisungen zum Aufbau einer formalen Deduktion im Hilbert-Kalkül angesehen werden ...

Antworten (1)

Wahrheitstabellen reichen nicht aus, um die Logik erster Ordnung (mit Quantoren) zu erfassen, daher verwenden wir stattdessen Inferenzregeln. Jede Folgerungsregel wird so gewählt, dass sie solide ist, was bedeutet, dass Sie, wenn Sie mit wahren Aussagen beginnen und die Regel anwenden, nur wahre Aussagen ableiten werden. Wir sagen, dass diese Regeln wahrheitserhaltend sind. Wenn Sie sorgfältig genug auswählen, können Sie es so machen, dass die Regeln nicht nur wahrheitserhaltend sind, sondern es Ihnen auch ermöglichen, jede (wohlgeformte) Aussage abzuleiten, die notwendigerweise (in allen Situationen) wahr ist.

Was Sie wahrscheinlich suchen (nämlich eine praktische Möglichkeit, die logische Gültigkeit Ihrer Argumente streng zu überprüfen), ist die natürliche Deduktion. Es gibt viele verschiedene Stile, der intuitivste Typ ist der Fitch-Stil , der Unterkontexte durch Einrückung oder eine ähnliche visuelle Abgrenzung markiert. Das folgende System verwendet Einrückungen und folgt meiner Meinung nach der Intuition am ehesten.


Kontexte

Jede Zeile ist entweder eine Überschrift oder eine Anweisung. Wir setzen einen Doppelpunkt nach jeder Überschrift und einen Punkt nach jeder Anweisung. Jeder Header gibt einen Subkontext an (der im aktuellen Kontext enthalten ist), und die Zeilen, die von diesem Header gesteuert werden, werden durch die Einrückung angezeigt. Der vollständige Kontext jeder Zeile wird durch alle Header angegeben, die sie regeln (dh alle nächsten Header darüber auf jeder niedrigeren Einrückungsebene).

Eine verschachtelte Fallanalyse könnte beispielsweise so aussehen:

Wenn  A :   Wenn  B :   . . . Wenn  ¬ B :   . . . Wenn  ¬ A :   . . .

Und über ein willkürliches Mitglied einer Sammlung nachdenken S würde aussehen wie:

Gegeben  X S :   . . .

Beachten Sie, dass das, was in manchen Zusammenhängen gesagt wird, in anderen Zusammenhängen ungültig sein kann. Sobald Sie das Prinzip hinter Kontexten und Einrückungen verstanden haben, sind die folgenden Regeln sehr natürlich. Beachten Sie auch, dass für die Logik erster Ordnung diese beiden Arten von Kontextheadern (für bedingte Unterkontexte bzw. universelle Unterkontexte) die einzigen Arten sind, die benötigt werden.

Syntaxregeln

Eine Aussage muss eine atomare (unteilbare) Aussage oder eine zusammengesetzte Aussage sein, die auf die übliche Weise unter Verwendung von Booleschen Operationen oder Quantoren gebildet wird, mit der Einschränkung, dass nicht jede Variable, die durch einen Quantor gebunden ist, bereits verwendet wird, um auf ein Objekt im aktuellen Kontext zu verweisen , und dass es keine verschachtelten Quantoren gibt, die dieselbe Variable binden.

Natürliche Abzugsregeln

Jede Folgerungsregel hat die Form:

X Y

Das heißt, wenn die letzten Zeilen, die Sie geschrieben haben, mit "X" übereinstimmen, können Sie unmittelbar danach auf derselben Einrückungsebene "Y" schreiben. Jede Anwendung einer Inferenzregel ist auch an den aktuellen Kontext gebunden, nämlich den Kontext von "X". Wir werden nicht ständig den „aktuellen Kontext“ erwähnen.


Boolesche Operationen

Nehmen Sie irgendwelche Aussagen A , B , C (im aktuellen Kontext).

restate : Wenn wir etwas beweisen, können wir es im gleichen Kontext noch einmal bestätigen.

A . . . . A .

Beachten Sie, dass " . . . " bezeichnen eine beliebige Anzahl von Zeilen, die sich mindestens auf der dargestellten Einrückungsebene befinden. In der obigen Regel bedeutet dies, dass alle seit dem früheren Schreiben von " geschriebenen Zeilen A . " muss sich im selben Kontext (oder einem Unterkontext) befinden.

In der Praxis schreiben wir eigentlich nie dieselbe Zeile zweimal. Um anzuzeigen, dass wir eine Zeile in einem Beweis weglassen können, markiere ich sie mit eckigen Klammern wie folgt:

A . . . . [ A . ]

⇒sub       ⇒restate     (Wir können einen bedingten Subkontext erstellen, in dem A hält.)

Wenn  A :   [ A . ] B . . . . Wenn  A :   . . .   [ B . ]

⇒Einleitung       ⇒elim

Wenn  A :   . . . B . [ A B . ] A B . A . B .

∧Einleitung     ∧elim

A . B . A B . A B . [ A . ] [ B . ]

∨Einleitung     ∨elim

A . [ A B . ] [ B A . ] A B . A C . B C . C .

¬intro     ¬elim     ¬¬elim

A . ¬ A . A . ¬ A . . ¬ ¬ A . A .

Beachten Sie, dass wir durch die Verwendung von ¬intro und ¬¬elim die folgende zusätzliche Inferenzregel erhalten können:

¬ A . A .

was dem entspricht, wie man zu beweisen versuchen würde A durch Widerspruch , nämlich um zu zeigen, dass vorausgesetzt ¬ A impliziert eine Unwahrheit.

⇔Einleitung     ⇔elim

A B . B A . A B . A B . [ A B . ] [ B A . ]

Quantoren und Gleichheit

Die Regeln hier gelten für eingeschränkte Quantifizierer, weil wir normalerweise in Bezug auf sie denken. Zuerst brauchen wir einige Definitionen.

Benutzte Variable : Eine Variable, die im Header eines enthaltenden ∀-Kontexts oder in einem vorangegangenen ∃-Eliminierungsschritt ("let") in einem enthaltenden Kontext deklariert ist.

Nicht verwendete Variable : Eine Variable, die nicht verwendet wird.

Frische Variable : Eine Variable, die in keiner vorherigen Anweisung in irgendeinem enthaltenden Kontext erscheint.

Objektausdruck : Ein Ausdruck, der sich auf ein Objekt bezieht (z. B. eine verwendete Variable oder ein Funktionssymbol, das auf Objektausdrücke angewendet wird).

Eigentum mit k Parameter : Eine Zeichenfolge P mit einigen Leerzeichen, wobei jedes Leerzeichen ein Etikett von hat 1 Zu k , sodass jedes Leerzeichen in ersetzt wird P durch einen Objektausdruck ergibt eine Aussage. Wenn k = 2 , Dann P ( E , F ) ist das Ergebnis des Ersetzens jedes beschrifteten Leerzeichens 1 von E und Ersetzen jedes markierten Leerzeichens 2 von F . Ähnlich für andere k .

In diesem Abschnitt, E , F (falls beteiligt) können beliebige Objektausdrücke (im aktuellen Kontext) sein.

Wir beginnen mit den folgenden Regeln, die einen Typ aller Objekte liefern.

Universum : Ö B J ist ein Typ.

[ E Ö B J . ]

Nehmen Sie jetzt einen beliebigen Typ S und eine 1-Parameter-Eigenschaft P und eine unbenutzte Variable X das taucht nicht auf S oder P .

∀sub           ∀restate         (Wir können einen ∀-Subkontext erzeugen, in dem X ist vom Typ S .)

Gegeben  X S :   [ X S . ] A . . . . Gegeben  X S :   . . .   [ A . ] ( X darf nicht vorkommen A )

∀Einführung           ∀elim

Gegeben  X S :   . . . P ( X ) . X S   (   P ( X )   ) . X S   (   P ( X )   ) . E S . P ( E ) . ( E darf keine ungenutzten Variablen mit teilen P )

∃Einleitung           ∃elim

E S . P ( E ) . X S   (   P ( X )   ) . X S   (   P ( X )   ) . Lassen  j S  so dass  P ( j ) . [ j S . ] [ P ( j ) . ] (Wo j ist eine frische Variable)

=Einführung       =elimin

[ E = E . ] E = F . P ( E ) . P ( F ) . ( F darf keine ungenutzte Variable mit teilen P )

Umbenennen von Variablen

Schließlich sind die folgenden Regeln zur Variablenumbenennung redundant, würden aber Beweise verkürzen.

∀umbenennen         ∃umbenennen

X S   (   P ( X )   ) . [ j S   (   P ( j )   ) . ] X S   (   P ( X )   ) . [ j S   (   P ( j )   ) . ]

  (Wo j ist eine unbenutzte Variable, die nicht in erscheint P )

Kurz Formen

Der Einfachheit halber schreiben wir " X , j S   (   P ( X , j )   ) „als Kurzform für“ X S   (   j S   (   P ( X , j )   )   ) ", und ähnlich für weitere Variablen und für " ". Wir werden auch verschachtelte ∀-Unterkontext-Header in der folgenden Form komprimieren:

Gegeben  X S :   Gegeben  j S :   . . .

Zu:

Gegeben  X , j S :   . . .

Zusätzlich, " ! X S   (   P ( X )   ) " ist eine Kurzform für " X S   (   P ( X ) j S   (   P ( j ) X = j   )   ) ".


Beispiel

Hier ist ein Beispiel, wo S , T sind alle Arten und P ist eine beliebige Eigenschaft mit zwei Parametern.

Zuerst mit allen angezeigten Zeilen:

  Wenn X S   (   j T   (   P ( X , j )   )   ) : [⇒sub]
    X S   (   j T   (   P ( X , j )   )   ) . [⇒sub]
    Let A S so dass j T   (   P ( A , j )   ) . [∃elim]
    A S . [∃elim]
    j T   (   P ( A , j )   ) . [∃elim]
    z T   (   P ( A , z )   ) . [∀umbenennen]
    Gegeben j T : [∀sub]
      j T . [∀sub]
      z T   (   P ( A , z )   ) . [∀wiederholen]
      j T . [wiederholen]
      P ( A , j ) . [∀elim]
      A S . [∀wiederholen]
      X S   (   P ( X , j )   ) . [∃Einführung]
    j T   (   X S   (   P ( X , j )   )   ) . [∀Einleitung]
X S   (   j T   (   P ( X , j )   )   ) j T   (   X S   (   P ( X , j )   )   ) . [⇒Einleitung]

Schließlich mit allen Zeilen in eckigen Klammern entfernt:

  Wenn X S   (   j T   (   P ( X , j )   )   ) : [⇒sub]
    Let A S so dass j T   (   P ( A , j )   ) . [∃elim]
    Gegeben j T : [∀sub]
      P ( A , j ) . [∀elim]
      X S   (   P ( X , j )   ) . [∃Einführung]
    j T   (   X S   (   P ( X , j )   )   ) . [∀Einleitung]
X S   (   j T   (   P ( X , j )   )   ) j T   (   X S   (   P ( X , j )   )   ) . [⇒Einleitung]

Dieser endgültige Beweis ist sauber und dennoch leicht computerüberprüfbar.

Definitive Erweiterung

Um Definitionen zu erleichtern , die Beweise erheblich verkürzen können, haben wir auch die folgenden definitorialen Erweiterungsregeln.

Für jede k -parameter-Eigenschaft P und frisches Prädikatsymbol Q :

Lassen  Q ( X 1 , . . . X k ) P ( X 1 , . . . X k )  für jede  X 1 S 1  und und  X k S k . [ X 1 S 1   X k S k   (   Q ( X 1 , . . . X k ) P ( X 1 , . . . X k )   ) . ]

Für jede ( k + 1 ) -parameter-Eigenschaft R und frisches Funktionssymbol F :

X 1 S 1 X k S k   ! j T (   R ( X 1 , . . . X k , j )   ) Lassen  F : S 1 × × S k T  so dass  R ( X 1 , . . . X k , F ( X 1 , . . . X k ) )  für jede  X 1 S 1  und und  X k S k . [ X 1 S 1   X k S k   (   F ( X 1 , . . . X k ) T R ( X 1 , . . . X k , F ( X 1 , . . . X k ) )   ) . ]

Diese Regeln sind insofern überflüssig, als dass jede beweisbare Aussage, die keines der neuen Symbole verwendet, bewiesen werden kann, ohne die definitorische Erweiterung zu verwenden.

Anmerkungen

Die obigen Regeln vermeiden die üblichen Schwierigkeiten, die viele andere Systeme haben, wo Variablen, die für Zeugen existentieller Aussagen verwendet werden, von Variablen unterschieden werden müssen, die für beliebige Objekte verwendet werden. Der Grund ist, dass hier jede Variable entweder durch einen ∀-Unterkontext oder durch eine „let“-Anweisung spezifiziert wird; dh es gibt keine freien Variablen. Die Tatsache, dass jede Variable gebunden ist, hängt stark damit zusammen, dass dieses System ein leeres Universum zulässt, wenn es keine anderen Axiome gibt.

Außerdem wird jede Variable durch einen eindeutigen Header oder eine "let"-Anweisung im aktuellen Kontext angegeben; mit anderen Worten, es gibt keine variable Abschattung. Dies ist so beabsichtigt, und in der tatsächlichen mathematischen Praxis halten wir uns auch daran, obwohl die meisten anderen formalen Systeme dies nicht tun. Als Konsequenz werden Sätze wie „ X   X   ( X = X ) ." kann in diesem System einfach nicht geschrieben werden. Wenn Sie solche schrecklichen Sätze zulassen möchten, müssten Sie die Regeln entsprechend ändern, aber es wird höchstwahrscheinlich Kopfschmerzen verursachen.

Schließlich gab es einige subtile technische Entscheidungen. Für die Quantifiziererregeln, der Grund, warum ich das verlangt habe X taucht nicht auf S , P ist, dass wir, wenn wir später Regeln zum Spezifizieren von Typen hinzufügen, normalerweise Variablennamen in seiner Syntax haben würden, was Probleme verursachen würde. Wenn wir zum Beispiel im aktuellen Kontext geschrieben haben " X { j : j S j T } " Und " X U "Es wird nicht sinnvoll sein, das Schreiben zuzulassen" j U   ( j { j : j S j T } ) ". Ebenso, wenn wir geschrieben haben " X = { j : P ( j ) } " Und " j U   ( Q ( X , j ) ) "Wir wollen das Schreiben nicht zulassen" j U   ( Q ( { j : P ( j ) } , j ) ) ".

Damit eine Variable nach dem Verlassen des Subkontexts, in dem sie deklariert wurde, wieder frisch wird, habe ich gefordert, dass die ⇒intro- und ∀intro-Regeln nur unmittelbar nach dem entsprechenden ⇒-Subkontext oder ∀-Subkontext angewendet werden können. Es wäre einfacher, eine neue Variable einfach als eine zu definieren, die in keiner vorherigen Zeile vorkommt, aber dann können uns in einem langen Beweis leicht die frischen Variablennamen ausgehen.

~ ~ ~ ~ ~ ~ ~

Um die Flexibilität dieses Systems zu veranschaulichen, werde ich sowohl die Peano-Arithmetik als auch die Mengenlehre als zusätzliche Regeln ausdrücken, die dem System einfach hinzugefügt werden können.

Peano-Arithmetik

Fügen Sie den Typ hinzu N und die Symbole von PA, nämlich die Konstantensymbole 0 , 1 und das 2 -Funktionssymbole eingeben + , · und das 2 -Eingabe Prädikat-Symbol < .

Fügen Sie die Axiome von PA hinzu , angepasst von hier :

  • X , j N   (   X + j N   ) .
  • X , j N   (   X · j N   ) .
  • X , j N   (   X + j = j + X   ) .
  • X , j N   (   X · j = j · X   ) .
  • X , j , z N   (   X + ( j + z ) = ( X + j ) + z   ) .
  • X , j , z N   (   X · ( j · z ) = ( X · j ) · z   ) .
  • X , j , z N   (   X · ( j + z ) = X · j + X · z   ) .
  • X N   (   X + 0 = X   ) .
  • X N   (   X · 1 = X   ) .
  • X N   (   ¬ X < X   ) .
  • X , j N   (   X < j j < X X = j   ) .
  • X , j , z N   (   X < j j < z X < z   ) .
  • X , j , z N   (   X < j X + z < j + z   ) .
  • X , j , z N   (   X < j 0 < z X · z < j · z   ) .
  • X , j N   (   X < j z N   (   X + z = j   )   ) .
  • 0 < 1 .
  • X N   (   0 = X 1 = X 1 < X   ) .

Fügen Sie die Induktionsaxiome hinzu, und zwar für jede Eigenschaft P mit nur den Symbolen von PA und Quantoren über N füge das folgende Axiom hinzu (wobei k taucht nicht auf P ):

  • P ( 0 ) k N   (   P ( k ) P ( k + 1 )   ) k N   (   P ( k )   ) .

Mengenlehre

Fügen Sie den Typ hinzu S e T und die Regel, dass jedes Mitglied von S e T ist auch ein typ.

Fügen Sie die unären Funktionssymbole hinzu P , , die binären Funktionssymbole × , , und das Konstantensymbol . Wir verwenden das binäre Prädikat-Symbol wieder , da es keine Zweideutigkeit geben wird. Fügen Sie auch die folgenden Regeln (in jedem Kontext) für die andere Notation hinzu:

  • Wenn E , F Ö B J , Dann ( E , F ) Ö B J Und { E , F } S e T .
  • Wenn S , T S e T , Dann S × T S e T Und ( S T ) S e T Und P ( S ) S e T .
  • Wenn S , T S e T Und F ( S T ) Und X S , Dann F ( X ) T .
  • Wenn S S e T Und X S   (   X S e T   ) , Dann ( S ) S e T .

Fügen Sie die folgenden Axiome hinzu:

  • Extensionalität :   S , T S e T   (   S = T X Ö B J   (   X S X T   )   ) .
  • leerer Satz :   X Ö B J   (   ¬ X   ) .
  • Natur :   N S e T .
  • power-set :   S S e T   (   P ( S ) = { T : T S e T X T   (   X S   ) } ) .
  • Paar :   X , j Ö B J   (   { X , j } = { z : z = X z = j } ) .
  • bestelltes Paar :   X , j Ö B J   z , w Ö B J   (   ( X , j ) = ( z , w ) X = z j = w   ) .
  • Produkttyp :   S , T S e T   (   S × T = { T : X S   j T   (   T = ( X , j )   ) }   ) .
  • Funktionstyp :   S , T S e T   (   ( S T ) = { F : F P ( S × T ) X S   ! j T   (   ( X , j ) F   ) }   ) .
  • Funktionsanwendung :   S , T S e T   F ( S T )   X S   (   ( X , F ( X ) ) F   ) .
  • Vereinigung :   S S e T   (   ( S ) = { X : T S e T   (   X T T S   ) }   ) .
  • Wahl :   S , T S e T   R P ( S × T )   (   X S   j T   (   ( X , j ) R   ) F ( S T )   X S   (   ( X , F ( X ) ) R   )   ) .

Fügen Sie die folgenden Regeln hinzu:

Typ-Notation

Nehmen Sie (im aktuellen Kontext) eine beliebige Eigenschaft P und Objektausdruck E und unbenutzte Variable X .

Dann { X : P ( X ) } ist ein Typ und seine Mitgliedschaft wird geregelt durch:

E { X : P ( X ) } P ( E ) . . ( X darf nicht vorkommen E oder P )

Verständnis

Nimm irgendein Eigentum P und unbenutzte Variable X .

S S e T . { X : X S P ( X ) } S e T . . ( X darf nicht vorkommen S oder P )

Ersatz

Such dir irgendeine aus 2 -parameter-Eigenschaft P und ungenutzte Variablen X , j .

S S e T . X S   ! j Ö B J   (   P ( X , j )   ) . { j : X S   (   P ( X , j )   ) } S e T . ( X , j darf nicht vorkommen S oder P )

Induktion

Nimm irgendein Eigentum P mit 1 Parameter ab N .

P ( 0 ) . k N   (   P ( k ) P ( k + 1 )   ) . k N   (   P ( k )   ) . ( k darf nicht vorkommen P )

Die Induktionsregel fasst die Induktionsaxiome für PA zusammen, und im Wesentlichen besteht der einzige Unterschied darin, dass die Eigenschaft P kann Mengenoperationen und Quantifizierung über Mengen umfassen.

Funktionsnotation

Diese Regel ist theoretisch unnötig, aber pragmatisch sehr praktisch (in der Informatik auch als Lambda-Ausdrücke bekannt).

Nimm irgendein Set S und jeder Objektausdruck E mit 1 Parameter ab S , und unbenutzte Variable X .

Dann ( S   X E ( X ) ) ist ein Objekt und sein Verhalten wird bestimmt durch:

X S   (   E ( X ) T   ) . F = ( S   X E ( X ) ) . F ( S T ) X S (   F ( X ) = E ( X )   ) .

Grundlegendes System

Die Kombination der obigen Peano-Arithmetik plus der Mengenlehre ergibt ein grundlegendes System, das im Wesentlichen so stark wie ZFC, aber viel benutzerfreundlicher ist. Es ist auch agnostisch gegenüber der Existenz von Objekten, die keine Mengen sind, und geht nicht einmal davon aus, dass die Mitglieder von N sind Sätze. Es behandelt auch kartesische Produkte und geordnete Paare als eingebaute abstrakte Begriffe. So verwenden wir sie in der eigentlichen Mathematik. (Genauer gesagt interpretiert das obige System ZFC minus Regularität direkt.)

Hey Mann, vielen Dank für all deine Hilfe :)
@user108262: Gern geschehen und ich hoffe, es hilft dir genauso wie es mir geholfen hat! Als ich diese Regeln entwickelte, war ich stark von der Programmierung beeinflusst, bei der der Kontext jeder Anweisung explizit ist. Das ist wirklich der Schlüssel, weil es dann einfach ist, die Inferenzregeln basierend auf Intuition zu konstruieren. Wie beim Programmieren können mehrere Anweisungen im selben Kontext vorhanden sein, was den erforderlichen Schreibaufwand minimiert, im krassen Gegensatz zu Systemen im Hilbert-Stil. Ich habe es hier im Fitch-Stil dargestellt, aber wir können genauso gut geschweifte Klammern oder Einrückungen verwenden wie in C oder Python.
Ich beschloss, meinen Beitrag mit allen Regeln zu aktualisieren, und wechselte zum Python-Stil. Die zugrunde liegende Idee ist sicherlich richtig, da ich sie seit Jahren verwende. Aber es ist ein langer Beitrag und es kann Fehler geben, also wenn jemand Fragen hat, kann er mich gerne unter chat.stackexchange.com/rooms/44058/logic fragen .
Ist das von Ihnen beschriebene System der Fithch-Stil
@Buraian: "fithch" ≠ "Fitch", und mein Beitrag verlinkt explizit auf den Wikipedia-Artikel, der den Fitch-Stil beschreibt. Ein Stil ist kein System, genau wie das ausführbare Dateiformat keine Anwendungssoftware ist. In jedem Fall ist der Zweck dieses Beitrags, ein vollständiges benutzerfreundliches Grundlagensystem für Mathematik vorzustellen, und dafür ist es eigentlich unwichtig zu wissen, welchen Stil es verwendet. Nachdem Sie gelernt haben, es zu verwenden, wird es trivial offensichtlich, warum der Fitch-Stil besser ist als andere Stile, aber ein solches Verständnis kommt erst, nachdem Sie ihn gelernt und gesehen haben, wie unbrauchbar alternative Systeme sind.
(Ich zitiere Fitch nur aus Gründen der Anerkennung, nicht aus pädagogischen Gründen.)
@Buraian: Wenn Sie lernen möchten, dieses System zu verwenden, können Sie mich im Basic Math -Chatroom danach fragen.
@kjo: Verwenden Sie die Restatement- Regeln, um ein vorheriges Theorem aus einem enthaltenden Kontext in den Unterkontext zu ziehen, in dem Sie es verwenden möchten. Für weitere Fragen können Sie gerne im verlinkten Chatroom nachfragen, zu dem ich Ihnen Zugang gegeben habe.