First steps in set theory

Here we start with the axioms of Zermelo–Fraenkel set theory and prove theorems for a few of the basic concepts: empty set, singletons, and unordered pairs. Other topics of set theory are treated elsewhere, such as ordered pairs, relations, functions, some kinds of unions, intersection, set difference, and so on.

We start by importing the theorems of propositional logic and predicate logic, and the axioms of Interface:Zermelo–Fraenkel set theory. We also define some variables.  import (CLASSICAL Interface:Classical_propositional_calculus ) import (FIRSTORDER Interface:First-order_logic_with_quantifiability (CLASSICAL) ) import (AXIOMS Interface:Zermelo–Fraenkel_set_theory (CLASSICAL FIRSTORDER) )

var (variable x y z w result x′) var (variable a b) var (object A B C D A0 A1 B0 B1) var (formula φ antecedent) 

Builders
Here are some more membership builders, slight variants of the ones we have.  thm (buildMembershipLL ((H (B0 = B1))) ((A ∈ B0) ↔ (A ∈ B1)) ( H       B0 B1 A MembershipBuilderLL applyModusPonens ))

thm (buildMembershipRR ((H (A0 = A1))) ((A0 ∈ B) ↔ (A1 ∈ B)) ( H       A0 A1 B MembershipBuilderRR applyModusPonens ))

thm (buildMembershipLLInConsequent  ((H (antecedent → (B0 = B1))))  (antecedent → ((A ∈ B0) ↔ (A ∈ B1))) ( H       B0 B1 A MembershipBuilderLL applySyllogism ))

thm (buildMembershipRRInConsequent  ((H (antecedent → (A0 = A1))))  (antecedent → ((A0 ∈ B) ↔ (A1 ∈ B))) ( H       A0 A1 B MembershipBuilderRR applySyllogism )) 

Membership with a substitution
Here are two ways to express  in terms of a substitution.  thm (MembershipForAll ((x A) (x B))  ((A ∈ B) ↔ (∀ x (((value x) = A) → ((value x) ∈ B)))) ( (value x) A B MembershipBuilderRR ImplicitForAll swapBiconditional ))

thm (MembershipThereExists ((x A) (x B))  ((A ∈ B) ↔ (∃ x (((value x) = A) ∧ ((value x) ∈ B)))) ( (value x) A B MembershipBuilderRR ImplicitThereExists swapBiconditional )) 

Empty set
The empty set, or null set, is the set with no elements. We start with the conventional form of the axiom of empty set. For us (and for many other axiomizations of set theory), this "axiom" is a theorem rather than an axiom.  thm (axnul ((x y z)) (∃ x (∀ y (¬ ((value y) ∈ (value x))))) (  The only set theory axiom we use in the proof is the axiom of separation, which says that given the existence of any set (which is implicit in some of the predicate logic steps), we can construct a subset of it which has no elements. Here is our application of separation, which we will use at the end of the proof (after a bunch of logical steps).  x y z (((value y) ∈ (value y)) ∧ (¬ ((value y) ∈ (value y)))) SeparationThereExists  The proof starts with  (¬ ((value y) ∈ (value y))) TertiumNonDatur collectNegationNDN  We now add  to get  ((value y) ∈ (value z)) (((value y) ∈ (value y)) ∧ (¬ ((value y) ∈ (value y)))) ConjunctionLeftElimination introduceTransposition applyModusPonens  We note that  implies itself.  (((value y) ∈ (value x)) ↔ (((value y) ∈ (value z)) ∧ (((value y) ∈ (value y)) ∧ (¬ ((value y) ∈ (value y)))))) ImplicationReflexivity  We detach half the biconditional to get  negatedDetachImplicationBiconditionalRight </jh> We're almost there. We just need to add the quantifiers and apply the instance of the axiom of separation that we started with.  y addForAll x addThereExists applyModusPonens )) </jh>

Now we introduce the symbol  for the empty set.

 var (variable emptyElement) def ((∅) (abstract emptyElement (⊥)))

thm (EmptySetVariable ((result x y)) ((value x) ∉ (abstract y (⊥))) ( </jh> To apply, we need. This follows from, the   relationship between negation and  , and the fact that substituting a variable in   has no effect.  result x axnul

((value x) ∈ (value result)) NegationBiconditional ((value x) ∈ (value result)) BiconditionalReflexivity (value x) y (⊥) NullSubstitution swapBiconditional buildBiconditional applyBiconditionalTransitivity

x buildForAll result buildThereExists

eliminateBiconditionalReverse applyModusPonens </jh> Now that we have, we can apply   to get.  Abstraction </jh> Moving the substitution which has no effect  (value x) y (⊥) NullSubstitution applyBiconditionalTransitivity </jh> gives us and then   gives us our desired result.  ((value x) ∈ (abstract y (⊥))) NegationBiconditional eliminateBiconditionalForward applyModusPonens )) </jh>

We provide a version with object instead of variable.  thm (EmptySetObject ((x A y)) (A ∉ (abstract y (⊥))) ( </jh> The substitution to apply  is   (value x) A (abstract y (⊥)) MembershipBuilderRR addNegationInConsequent

x y EmptySetVariable

VariableToObject ))

thm (EmptySet ((A emptyElement)) (A ∉ (∅)) ( A emptyElement EmptySetObject )) </jh>

Pairing for objects
The  axiom allows us to form a set given two elements, where the given sets are represented by variables. Here we prove the same thing, but with object in place of variable. The proof is by straightforward application of  with the usual substitution machinery.  thm (PairingObject-1 ((A x z w) (y x z w)) (∃ w (∀ z (((value z) ∈ (value w)) ↔ (((value z) = A) ∨ ((value z) = (value y)))))) ( (value x) A (value z) EqualityBuilderLL ((value z) = (value y)) buildDisjunctionRRInConsequent ((value z) ∈ (value w)) buildBiconditionalLLInConsequent z buildForAllInConsequent w buildThereExistsInConsequent

w z x y Pairing

VariableToObject ))

thm (PairingObject ((A y z w) (B y z w)) (∃ w (∀ z (((value z) ∈ (value w)) ↔ (((value z) = A) ∨ ((value z) = B))))) ( (value y) B (value z) EqualityBuilderLL ((value z) = A) buildDisjunctionLLInConsequent ((value z) ∈ (value w)) buildBiconditionalLLInConsequent z buildForAllInConsequent w buildThereExistsInConsequent

w z A y PairingObject-1

VariableToObject )) </jh>

Extensionality
Extensionality, that sets with the same elements are equal, is an axiom. Here we prove a few simple consequences of that axiom.

Objects instead of variables
Here is a variant of extensionality,, which changes variables to objects. We first prove a lemma.

 thm (Extensionality-1 ((z A) (x y z) (x A)) ((∀ z (((value z) ∈ A) ↔ ((value z) ∈ (value y)))) → (A = (value y))) ( </jh> This lemma changes  to , using   applied to   (value x) A (value z) MembershipBuilderLL ((value z) ∈ (value y)) buildBiconditionalRRInConsequent z buildForAllInConsequent

(value x) A (value y) EqualityBuilderRR

buildImplicationInConsequent

z x y ExtensionalityVariable VariableToObject ))

thm (Extensionality ((A z) (B z) (z y) (A y) (B y))   ((∀ z (((value z) ∈ A) ↔ ((value z) ∈ B))) → (A = B)) ( </jh> To prove this, we change  to , using   applied to   (value y) B (value z) MembershipBuilderLL ((value z) ∈ A) buildBiconditionalLLInConsequent z buildForAllInConsequent

(value y) B A EqualityBuilderLL

buildImplicationInConsequent

z A y Extensionality-1 VariableToObject )) </jh>

It will also be convenient to have a rule form.  thm (applyExtensionality ((x A) (x B)) ((H (((value x) ∈ A) ↔ ((value x) ∈ B))))  (A = B) ( H       x generalize x A B Extensionality applyModusPonens )) </jh>

Biconditional
Although the converse of  is just a substitution, the biconditionalized version of   will be convenient sometimes.  thm (ExtensionalityBiconditional ((A z) (B z))  ((A = B) ↔ (∀ z (((value z) ∈ A) ↔ ((value z) ∈ B)))) ( A B (value z) MembershipBuilderLL z addForAllToConsequent

z A B Extensionality

introduceBiconditionalFromImplications )) </jh>

Version without distinct variable constraints
Here's a version of  which replaces the distinct variable constraints with.  thm (ExtensionalityNotFree ((y A) (y B) (y x)) ((HA (x is-not-free-in ((value y) ∈ A))) (HB (x is-not-free-in ((value y) ∈ B))) ) ((A = B) ↔ (∀ x (((value x) ∈ A) ↔ ((value x) ∈ B)))) ( A B y ExtensionalityBiconditional </jh> The key to the proof is. It comes about as a variable change, specifically. The first step is. <jh> HA       HB        biconditionalNotFree </jh> Next we need. <jh> y (((value x) ∈ A) ↔ ((value x) ∈ B)) DistinctNotFree </jh> Finally is. <jh> (value x) (value y) A MembershipBuilderRR (value x) (value y) B MembershipBuilderRR buildBiconditionalInConsequent

ChangeVariableForAllNotFree </jh> That gives us. Now we just need to combine with. <jh> swapBiconditional applyBiconditionalTransitivity )) </jh>

Introducing a notation for a set
Many of the axioms (or theorems) of set theory assert the existence of certain sets. That is, they take the form that there is a set whose elements are those which satisfy a certain formula. In symbols,. For each of these, we want to introduce a notation for the set. Most of the work of doing this is some substitution machinery, which can be in part factored out to the following theorems. <jh> var (formula φy φz φC) thm (SetVariable ((result y φz) (result y z) (z φy))  ((HSUBZ (((value z) = (value y)) → (φz ↔ φy))) (HEXISTS (∃ result (∀ y (((value y) ∈ (value result)) ↔ φy))))) (((value y) ∈ (abstract z φz)) ↔ φy) ( HEXISTS </jh> The first step is. <jh> HSUBZ makeSubstExplicit </jh> We now apply builders to get <jh> ((value y) ∈ (value result)) buildBiconditionalLL y buildForAll result buildThereExists </jh> The right hand side of this is just our existence theorem, though (which we had left on the proof stack), so we detach it. <jh> eliminateBiconditionalForward applyModusPonens </jh> Applying  to   gives   and simplying the last part gives us. <jh> Abstraction

HSUBZ makeSubstExplicit

applyBiconditionalTransitivity )) </jh> Getting rid of the distinct variable constraint and changing  from a variable to an object are accomplished by invoking. <jh> thm (SetObject ((y C) (result y φz) (result y z) (z φy) (y φz) (y φC))  ((HSUBZ (((value z) = (value y)) → (φz ↔ φy))) (HSUBC (((value y) = C) → (φy ↔ φC))) (HEXISTS (∃ result (∀ y (((value y) ∈ (value result)) ↔ φy))))) ((C ∈ (abstract z φz)) ↔ φC) ( </jh> Our substitution is. <jh> (value y) C (abstract z φz) MembershipBuilderRR HSUBC buildBiconditionalInConsequent

HSUBZ HEXISTS SetVariable

VariableToObject )) </jh>

Unordered pair
The unordered pair  has   and   as elements. That is, we seek to prove. We apply pairing to  and   (again via  ).

<jh> thm (UnorderedPair-sub  ((C = D) → (((C = A) ∨ (C = B)) ↔ ((D = A) ∨ (D = B)))) ( C D A EqualityBuilderRR C D B EqualityBuilderRR buildDisjunctionInConsequent ))

thm (UnorderedPairObject ((y C) (result y A z) (result y B z)) ((C ∈ (abstract z (((value z) = A) ∨ ((value z) = B)))) ↔ ((C = A) ∨ (C = B))) ( (value z) (value y) A B UnorderedPair-sub (value y) C A B UnorderedPair-sub result y A B PairingObject SetObject )) </jh>

Because the notation  is not available, we call it. <jh> def ((unorderedPair A B) (abstract y (((value y) = A) ∨ ((value y) = B))))

thm (UnorderedPair ((z A) (z B)) ((C ∈ (unorderedPair A B)) ↔ ((C = A) ∨ (C = B))) ( C z A B UnorderedPairObject )) </jh>

Builder
The builder for unordered pairs is. <jh> thm (UnorderedPairBuilder-1 ((z a) (z A0) (z A1) (z b) (z B0) (z B1) (a A0) (a A1) (b B0) (b B1))    (((A0 = B0) ∧ (A1 = B1)) → ((abstract a (((value a) = A0) ∨ ((value a) = A1))) = (abstract b (((value b) = B0) ∨ ((value b) = B1))))) ( </jh> Applying builders for equality and disjunction, we get. <jh> (A0 = B0) (A1 = B1) ConjunctionRightElimination A0 B0 (value z) EqualityBuilderLL applySyllogism

(A0 = B0) (A1 = B1) ConjunctionLeftElimination A1 B1 (value z) EqualityBuilderLL applySyllogism

composeConjunction

((value z) = A0) ((value z) = B0) ((value z) = A1) ((value z) = B1) DisjunctionFunction applySyllogism </jh> Applying, we get. <jh> (value z) a A0 A1 UnorderedPairObject swapBiconditional transformImplicationBiconditionalLeft

(value z) b B0 B1 UnorderedPairObject swapBiconditional transformImplicationBiconditionalRight </jh> By extensionality, the right hand side implies. <jh> z addForAllToConsequent z (abstract a (((value a) = A0) ∨ ((value a) = A1))) (abstract b (((value b) = B0) ∨ ((value b) = B1))) Extensionality applySyllogism ))

thm (UnorderedPairBuilder-2 ((a A0) (a A1) (b B0) (b B1)) (((A0 = B0) ∧ (A1 = B1)) → ((abstract a (((value a) = A0) ∨ ((value a) = A1))) = (unorderedPair B0 B1))) ( A0 B0 A1 B1 a b UnorderedPairBuilder-1 ))

thm (UnorderedPairBuilder ( (a A0) (a A1)) (((A0 = B0) ∧ (A1 = B1)) → ((unorderedPair A0 A1) = (unorderedPair B0 B1))) ( A0 B0 A1 B1 a UnorderedPairBuilder-2 )) </jh>

Singleton
Given a set (object), the singleton of   is a set   which has   as its only element. Singletons are an easy special case of unordered pairs: we define  to be. Because the notation  is not available in JHilbert, we call it.

<jh> def ((singleton A) (unorderedPair A A)) </jh>

The key theorem regarding membership in a singleton is. <jh> thm (Singleton  ((B ∈ (singleton A)) ↔ (B = A)) ( B A A UnorderedPair

(B = A) DisjunctionIdempotence swapBiconditional

applyBiconditionalTransitivity )) </jh>

The builder for singletons is. <jh> thm (SingletonBuilder  ((A = B) → ((singleton A) = (singleton B))) ( (A = B) ConjunctionIdempotence eliminateBiconditionalReverse

A B A B UnorderedPairBuilder applySyllogism )) </jh>

Union
This section introduces the union of a set,. We go through much the same process as for unordered pairs, but based on the axiom of union.

First is a version of the axiom of union for  rather than.

<jh> thm (UnionAxiomObject ((A x y z w)) (∃ y (∀ z (((value z) ∈ (value y)) ↔ (∃ w (((value z) ∈ (value w)) ∧ ((value w) ∈ A)))))) ( (value x) A (value w) MembershipBuilderLL ((value z) ∈ (value w)) buildConjunctionLLInConsequent w buildThereExistsInConsequent ((value z) ∈ (value y)) buildBiconditionalLLInConsequent z buildForAllInConsequent y buildThereExistsInConsequent

y z w x UnionAxiom

VariableToObject )) </jh>

Then we prove  using   in the usual way. The main complication we didn't have with unordered pairs is the need to change the variable of quantification via.

<jh> thm (Union-sub ((x C) (x D)) ((C = D) → ((∃ x ((C ∈ (value x)) ∧ ((value x) ∈ A))) ↔ (∃ x ((D ∈ (value x)) ∧ ((value x) ∈ A))))) ( C D (value x) MembershipBuilderRR ((value x) ∈ A) buildConjunctionRRInConsequent x buildThereExistsInConsequent ))

thm (Union-changeVariable ((x′ C) (x′ x) (x′ A) (x C) (x A))  ((∃ x ((C ∈ (value x)) ∧ ((value x) ∈ A))) ↔ (∃ x′ ((C ∈ (value x′)) ∧ ((value x′) ∈ A)))) ( (value x) (value x′) C MembershipBuilderLL (value x) (value x′) A MembershipBuilderRR buildConjunctionInConsequent

ChangeVariableThereExists ))

thm (UnionObject ((y B) (x B) (z result y x A x′)) ((B ∈ (abstract z (∃ x′ (((value z) ∈ (value x′)) ∧ ((value x′) ∈ A))))) ↔ (∃ x ((B ∈ (value x)) ∧ ((value x) ∈ A)))) ( (value z) (value y) x A Union-sub x (value z) A x′ Union-changeVariable transformImplicationBiconditionalLeft

(value y) B x A Union-sub

result y x A UnionAxiomObject

SetObject ))

def ((⋃ A) (abstract z (∃ x (((value z) ∈ (value x)) ∧ ((value x) ∈ A)))))

thm (Union ((x A) (x B) (z A) (z x) (z x′) (x′ x) (x′ A))   ((B ∈ (⋃ A)) ↔ (∃ x ((B ∈ (value x)) ∧ ((value x) ∈ A)))) ( B z x′ A x UnionObject )) </jh>

Subset
A set is a subset of another if and only if being an element of the first set implies being a member of the second. <jh> def ((⊆ A B) (∀ x (((value x) ∈ A) → ((value x) ∈ B))))

thm (Subset ((x A) (x B) (y A) (y B) (y x))   ((A ⊆ B) ↔ (∀ x (((value x) ∈ A) → ((value x) ∈ B)))) ( (value y) (value x) A MembershipBuilderRR (value y) (value x) B MembershipBuilderRR buildImplicationInConsequent ChangeVariableForAll )) </jh>

Partial order
The subset relationship has the three properties of a partial order. That is, it is reflexive, antisymmetric, and transitive.

First we prove transitivity. <jh> thm (SubsetTransitivity ( (x A) (x B) (x C)) (((A ⊆ B) ∧ (B ⊆ C)) → (A ⊆ C)) ( A B x Subset B C x Subset buildConjunction eliminateBiconditionalReverse

x         (((value x) ∈ A) → ((value x) ∈ B)) (((value x) ∈ B) → ((value x) ∈ C)) ForAllConjunction eliminateBiconditionalForward applySyllogism

((value x) ∈ A) ((value x) ∈ B) ((value x) ∈ C) ImplicationTransitivity x addForAll applySyllogism

A C x Subset eliminateBiconditionalForward applySyllogism )) </jh>

Antisymmetry and reflexivity follow from the equivalence. To prove this equivalence, take, decompose the biconditional into implications, and distribute the quantifier across both of them. The left side is  by extensionality, and the right side is   by. <jh> thm (EqualitySubset ( (x A) (x B))  ((A = B) ↔ ((A ⊆ B) ∧ (B ⊆ A))) ( A B x ExtensionalityBiconditional

((value x) ∈ A) ((value x) ∈ B) BiconditionalImplication x buildForAll applyBiconditionalTransitivity

x         (((value x) ∈ A) → ((value x) ∈ B)) (((value x) ∈ B) → ((value x) ∈ A)) ForAllConjunction applyBiconditionalTransitivity

A B x Subset B A x Subset buildConjunction swapBiconditional applyBiconditionalTransitivity ))

thm (SubsetReflexivity  (A ⊆ A) ( A EqualityReflexivity

A A EqualitySubset eliminateBiconditionalReverse applyModusPonens

conflateConjunction ))

thm (SubsetAntisymmetry  (((A ⊆ B) ∧ (B ⊆ A)) → (A = B)) ( A B EqualitySubset eliminateBiconditionalForward )) </jh>

Power set
Introducing a notation for power set is much like union. Because of issues with distinct variable declarations, we won't be able to to use the subset notation until the very end.

First is a version of the axiom of power set for  rather than.

<jh> thm (PowerSetAxiomObject ((A x y z w)) (∃ y (∀ z (((value z) ∈ (value y)) ↔ (∀ w (((value w) ∈ (value z)) → ((value w) ∈ A)))))) ( (value x) A (value w) MembershipBuilderLL ((value w) ∈ (value z)) buildCommonAntecedentInConsequent w buildForAllInConsequent ((value z) ∈ (value y)) buildBiconditionalLLInConsequent z buildForAllInConsequent y buildThereExistsInConsequent

y z w x PowerSetAxiom

VariableToObject )) </jh>

Then we prove  using   in the usual way. Similarly to the proof for unions, we will need to change the variable of quantification, in our case via.

<jh> thm (PowerSet-sub ((x C) (x D)) ((C = D) → ((∀ x (((value x) ∈ C) → ((value x) ∈ A))) ↔ (∀ x (((value x) ∈ D) → ((value x) ∈ A))))) ( C D (value x) MembershipBuilderLL ((value x) ∈ A) buildCommonConsequentInConsequent x buildForAllInConsequent ))

thm (PowerSet-changeVariable ((x′ C) (x′ x) (x′ A) (x C) (x A))  ((∀ x (((value x) ∈ C) → ((value x) ∈ A))) ↔ (∀ x′ (((value x′) ∈ C) → ((value x′) ∈ A)))) ( (value x) (value x′) C MembershipBuilderRR (value x) (value x′) A MembershipBuilderRR buildImplicationInConsequent

ChangeVariableForAll ))

thm (PowerSetObject ((y B) (x B) (z result y x A x′)) ((B ∈ (abstract z (∀ x′ (((value x′) ∈ (value z)) → ((value x′) ∈ A))))) ↔ (∀ x (((value x) ∈ B) → ((value x) ∈ A)))) ( (value z) (value y) x A PowerSet-sub x (value z) A x′ PowerSet-changeVariable transformImplicationBiconditionalLeft

(value y) B x A PowerSet-sub

result y x A PowerSetAxiomObject

SetObject ))

def ((power A) (abstract z (∀ x (((value x) ∈ (value z)) → ((value x) ∈ A)))))

thm (PowerSetForAll ((x A) (x B) (z A) (z x) (z x′) (x′ x) (x′ A))   ((B ∈ (power A)) ↔ (∀ x (((value x) ∈ B) → ((value x) ∈ A)))) ( B z x′ A x PowerSetObject ))

thm (PowerSet ( (x A) (x B)) ((B ∈ (power A)) ↔ (B ⊆ A)) ( B A x PowerSetForAll

B A x Subset swapBiconditional

applyBiconditionalTransitivity )) </jh>

Separation
Here we provide the ability to form a set containing those elements of a given set which satisfy an arbitrary formula. In other words, we can form the set of all  in   such that , which is commonly notated as. We will use that notation in discussion but JHilbert's syntax is not that flexible, so for JHilbert we will call it. Restricted set abstraction is one term for this (contrasted with the unrestricted set abstraction of ).

Introducing this notation follows much the process as for the other existence theorems/axioms, in this case working from. We are trying to prove.

First we provide a version of  where we turn the variable   into the object <jh> thm (SeparationThereExistsObject ((x y A) (φ y) (A y) (z x y A) (z φ))   (∃ y (∀ x (((value x) ∈ (value y)) ↔ (((value x) ∈ A) ∧ φ)))) ( (value z) A (value x) MembershipBuilderLL φ buildConjunctionRRInConsequent ((value x) ∈ (value y)) buildBiconditionalLLInConsequent x buildForAllInConsequent y buildThereExistsInConsequent

y x z φ SeparationThereExists

VariableToObject ))

thm (SeparationThereExistsSubst ((result y A) (φ result) (A result) (x result A))   (∃ result (∀ y (((value y) ∈ (value result)) ↔ (((value y) ∈ A) ∧ (subst (value y) x φ))))) ( result y A (subst (value y) x φ) SeparationThereExistsObject )) </jh>

From here we apply  in much the usual way. <jh> thm (Separation-sub  ((C = D) → (((C ∈ A) ∧ (subst C x φ)) ↔ ((D ∈ A) ∧ (subst D x φ)))) ( C D A MembershipBuilderRR C D x φ SubstBuilderReplacement buildConjunctionInConsequent ))

thm (SeparationObject ((y C) (result y A z) (result y φ z) (result y x z) (x A))  ((C ∈ (abstract z (((value z) ∈ A) ∧ (subst (value z) x φ)))) ↔ ((C ∈ A) ∧ (subst C x φ))) ( (value z) (value y) A x φ Separation-sub (value y) C A x φ Separation-sub result y A x φ SeparationThereExistsSubst SetObject ))

def ((separate x A φ) (abstract y (((value y) ∈ A) ∧ (subst (value y) x φ))))

thm (Separation ((x A) (z A) (z B) (z φ) (z x))   ((C ∈ (separate x A φ)) ↔ ((C ∈ A) ∧ (subst C x φ))) ( C z A x φ SeparationObject )) </jh>

Membership
Here's a theorem which combines  with a substitution. <jh> thm (ImplicitMembership ((x A) (x B))  ((A ∈ B) ↔ (∀ x (((value x) = A) → ((value x) ∈ B)))) ( (value x) A B MembershipBuilderRR ImplicitForAll swapBiconditional )) </jh>

Done
We have now proved all the theorems in Interface:Basic operations of general set theory, and in Interface:First steps in set theory.

<jh> export (GENERAL Interface:Basic_operations_of_general_set_theory (CLASSICAL FIRSTORDER) ) export (FIRST Interface:First_steps_in_set_theory (CLASSICAL FIRSTORDER) ) </jh>