url stringclasses 147 values | commit stringclasses 147 values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_ran_iff | [80, 1] | [85, 38] | intro t | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ ∀ (x_1 : V), opair x_1 x ∈ r → x ∈ ⋃ ⋃ r | V : Type u_1
inst✝ : Zermelo V
r x y z t : V
⊢ opair t x ∈ r → x ∈ ⋃ ⋃ r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ ∀ (x_1 : V), opair x_1 x ∈ r → x ∈ ⋃ ⋃ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_ran_iff | [80, 1] | [85, 38] | exact opair_right_mem_sUnion_sUnion | V : Type u_1
inst✝ : Zermelo V
r x y z t : V
⊢ opair t x ∈ r → x ∈ ⋃ ⋃ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z t : V
⊢ opair t x ∈ r → x ∈ ⋃ ⋃ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memRan | [88, 1] | [90, 38] | rw [mem_ran_iff, interpret_memRan'] | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memRan x r) v l ↔ interpretTerm V v l x ∈ ran (interpretTerm V v l r) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memRan x r) v l ↔ interpretTerm V v l x ∈ ran (interpretTerm V v l r)
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memImage' | [99, 1] | [103, 8] | unfold BoundedFormula.memImage | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memImage x y r) v l ↔
∃ z, z ∈ interpretTerm V v l y ∧ opair z (interpretTerm V v l x) ∈ interpretTerm V v l r | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y r : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.mem (Sum.inr { val := n, isLt := (_ : n < n + (1 + 1)) }) (termSucc (termSucc y)))
(BoundedFormula.eqOPair (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (0 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (1 + 1)) }) (termSucc (termSucc x))))
(BoundedFormula.mem (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (0 + 1)) })
(termSucc (termSucc r))))))
v l ↔
∃ z, z ∈ interpretTerm V v l y ∧ opair z (interpretTerm V v l x) ∈ interpretTerm V v l r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memImage x y r) v l ↔
∃ z, z ∈ interpretTerm V v l y ∧ opair z (interpretTerm V v l x) ∈ interpretTerm V v l r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memImage' | [99, 1] | [103, 8] | aesop | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y r : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.mem (Sum.inr { val := n, isLt := (_ : n < n + (1 + 1)) }) (termSucc (termSucc y)))
(BoundedFormula.eqOPair (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (0 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (1 + 1)) }) (termSucc (termSucc x))))
(BoundedFormula.mem (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (0 + 1)) })
(termSucc (termSucc r))))))
v l ↔
∃ z, z ∈ interpretTerm V v l y ∧ opair z (interpretTerm V v l x) ∈ interpretTerm V v l r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y r : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.mem (Sum.inr { val := n, isLt := (_ : n < n + (1 + 1)) }) (termSucc (termSucc y)))
(BoundedFormula.eqOPair (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (0 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (1 + 1)) }) (termSucc (termSucc x))))
(BoundedFormula.mem (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (0 + 1)) })
(termSucc (termSucc r))))))
v l ↔
∃ z, z ∈ interpretTerm V v l y ∧ opair z (interpretTerm V v l x) ∈ interpretTerm V v l r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_image_iff | [111, 1] | [114, 8] | unfold image | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈ image r y ↔ ∃ z, z ∈ y ∧ opair z x ∈ r | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈
sep (BoundedFormula.memImage (Sum.inr 0) (Sum.inl false) (Sum.inl true)) (fun i => if i = true then r else y)
(ran r) ↔
∃ z, z ∈ y ∧ opair z x ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈ image r y ↔ ∃ z, z ∈ y ∧ opair z x ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_image_iff | [111, 1] | [114, 8] | simp only [mem_sep_iff, mem_ran_iff, interpret_memImage'] | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈
sep (BoundedFormula.memImage (Sum.inr 0) (Sum.inl false) (Sum.inl true)) (fun i => if i = true then r else y)
(ran r) ↔
∃ z, z ∈ y ∧ opair z x ∈ r | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ ((∃ z, opair z x ∈ r) ∧
∃ z,
z ∈ interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inl false) ∧
opair z (interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inr 0)) ∈
interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inl true)) ↔
∃ z, z ∈ y ∧ opair z x ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈
sep (BoundedFormula.memImage (Sum.inr 0) (Sum.inl false) (Sum.inl true)) (fun i => if i = true then r else y)
(ran r) ↔
∃ z, z ∈ y ∧ opair z x ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_image_iff | [111, 1] | [114, 8] | aesop | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ ((∃ z, opair z x ∈ r) ∧
∃ z,
z ∈ interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inl false) ∧
opair z (interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inr 0)) ∈
interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inl true)) ↔
∃ z, z ∈ y ∧ opair z x ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ ((∃ z, opair z x ∈ r) ∧
∃ z,
z ∈ interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inl false) ∧
opair z (interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inr 0)) ∈
interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inl true)) ↔
∃ z, z ∈ y ∧ opair z x ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memImage | [117, 1] | [120, 42] | rw [mem_image_iff, interpret_memImage'] | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memImage x y r) v l ↔
interpretTerm V v l x ∈ image (interpretTerm V v l r) (interpretTerm V v l y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memImage x y r) v l ↔
interpretTerm V v l x ∈ image (interpretTerm V v l r) (interpretTerm V v l y)
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memPreimage' | [129, 1] | [133, 8] | unfold BoundedFormula.memPreimage | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memPreimage x y r) v l ↔
∃ z, z ∈ interpretTerm V v l y ∧ opair (interpretTerm V v l x) z ∈ interpretTerm V v l r | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y r : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.mem (Sum.inr { val := n, isLt := (_ : n < n + (1 + 1)) }) (termSucc (termSucc y)))
(BoundedFormula.eqOPair (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (0 + 1)) })
(termSucc (termSucc x)) (Sum.inr { val := n, isLt := (_ : n < n + (1 + 1)) })))
(BoundedFormula.mem (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (0 + 1)) })
(termSucc (termSucc r))))))
v l ↔
∃ z, z ∈ interpretTerm V v l y ∧ opair (interpretTerm V v l x) z ∈ interpretTerm V v l r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memPreimage x y r) v l ↔
∃ z, z ∈ interpretTerm V v l y ∧ opair (interpretTerm V v l x) z ∈ interpretTerm V v l r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memPreimage' | [129, 1] | [133, 8] | aesop | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y r : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.mem (Sum.inr { val := n, isLt := (_ : n < n + (1 + 1)) }) (termSucc (termSucc y)))
(BoundedFormula.eqOPair (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (0 + 1)) })
(termSucc (termSucc x)) (Sum.inr { val := n, isLt := (_ : n < n + (1 + 1)) })))
(BoundedFormula.mem (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (0 + 1)) })
(termSucc (termSucc r))))))
v l ↔
∃ z, z ∈ interpretTerm V v l y ∧ opair (interpretTerm V v l x) z ∈ interpretTerm V v l r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y r : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.mem (Sum.inr { val := n, isLt := (_ : n < n + (1 + 1)) }) (termSucc (termSucc y)))
(BoundedFormula.eqOPair (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (0 + 1)) })
(termSucc (termSucc x)) (Sum.inr { val := n, isLt := (_ : n < n + (1 + 1)) })))
(BoundedFormula.mem (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (0 + 1)) })
(termSucc (termSucc r))))))
v l ↔
∃ z, z ∈ interpretTerm V v l y ∧ opair (interpretTerm V v l x) z ∈ interpretTerm V v l r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_preimage_iff | [141, 1] | [144, 8] | unfold preimage | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈ preimage r y ↔ ∃ z, z ∈ y ∧ opair x z ∈ r | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈
sep (BoundedFormula.memPreimage (Sum.inr 0) (Sum.inl false) (Sum.inl true)) (fun i => if i = true then r else y)
(dom r) ↔
∃ z, z ∈ y ∧ opair x z ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈ preimage r y ↔ ∃ z, z ∈ y ∧ opair x z ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_preimage_iff | [141, 1] | [144, 8] | simp only [mem_sep_iff, mem_dom_iff, interpret_memPreimage'] | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈
sep (BoundedFormula.memPreimage (Sum.inr 0) (Sum.inl false) (Sum.inl true)) (fun i => if i = true then r else y)
(dom r) ↔
∃ z, z ∈ y ∧ opair x z ∈ r | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ ((∃ z, opair x z ∈ r) ∧
∃ z,
z ∈ interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inl false) ∧
opair (interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inr 0)) z ∈
interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inl true)) ↔
∃ z, z ∈ y ∧ opair x z ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈
sep (BoundedFormula.memPreimage (Sum.inr 0) (Sum.inl false) (Sum.inl true)) (fun i => if i = true then r else y)
(dom r) ↔
∃ z, z ∈ y ∧ opair x z ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_preimage_iff | [141, 1] | [144, 8] | aesop | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ ((∃ z, opair x z ∈ r) ∧
∃ z,
z ∈ interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inl false) ∧
opair (interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inr 0)) z ∈
interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inl true)) ↔
∃ z, z ∈ y ∧ opair x z ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ ((∃ z, opair x z ∈ r) ∧
∃ z,
z ∈ interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inl false) ∧
opair (interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inr 0)) z ∈
interpretTerm V (fun i => if i = true then r else y) (fun x_1 => x) (Sum.inl true)) ↔
∃ z, z ∈ y ∧ opair x z ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memPreimage | [147, 1] | [150, 48] | rw [mem_preimage_iff, interpret_memPreimage'] | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memPreimage x y r) v l ↔
interpretTerm V v l x ∈ preimage (interpretTerm V v l r) (interpretTerm V v l y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memPreimage x y r) v l ↔
interpretTerm V v l x ∈ preimage (interpretTerm V v l r) (interpretTerm V v l y)
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memInverse' | [165, 1] | [169, 8] | unfold BoundedFormula.memInverse | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memInverse x r) v l ↔
∃ y z, interpretTerm V v l x = opair y z ∧ opair z y ∈ interpretTerm V v l r | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x r : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.eqOPair (termSucc (termSucc (termSucc x)))
(Sum.inr { val := n, isLt := (_ : n < n + (2 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (1 + 1)) }))
(BoundedFormula.eqOPair (Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (0 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (1 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (2 + 1)) })))
(BoundedFormula.mem (Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (0 + 1)) })
(termSucc (termSucc (termSucc r))))))))
v l ↔
∃ y z, interpretTerm V v l x = opair y z ∧ opair z y ∈ interpretTerm V v l r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memInverse x r) v l ↔
∃ y z, interpretTerm V v l x = opair y z ∧ opair z y ∈ interpretTerm V v l r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memInverse' | [165, 1] | [169, 8] | aesop | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x r : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.eqOPair (termSucc (termSucc (termSucc x)))
(Sum.inr { val := n, isLt := (_ : n < n + (2 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (1 + 1)) }))
(BoundedFormula.eqOPair (Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (0 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (1 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (2 + 1)) })))
(BoundedFormula.mem (Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (0 + 1)) })
(termSucc (termSucc (termSucc r))))))))
v l ↔
∃ y z, interpretTerm V v l x = opair y z ∧ opair z y ∈ interpretTerm V v l r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x r : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.eqOPair (termSucc (termSucc (termSucc x)))
(Sum.inr { val := n, isLt := (_ : n < n + (2 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (1 + 1)) }))
(BoundedFormula.eqOPair (Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (0 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (1 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (2 + 1)) })))
(BoundedFormula.mem (Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (0 + 1)) })
(termSucc (termSucc (termSucc r))))))))
v l ↔
∃ y z, interpretTerm V v l x = opair y z ∧ opair z y ∈ interpretTerm V v l r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_inverse_iff | [177, 1] | [189, 20] | unfold inverse | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈ inverse r ↔ ∃ y z, x = opair y z ∧ opair z y ∈ r | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈ sep (BoundedFormula.memInverse (Sum.inr 0) (Sum.inl ())) (fun x => r) (prod (ran r) (dom r)) ↔
∃ y z, x = opair y z ∧ opair z y ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈ inverse r ↔ ∃ y z, x = opair y z ∧ opair z y ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_inverse_iff | [177, 1] | [189, 20] | simp only [mem_sep_iff, interpret_memInverse'] | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈ sep (BoundedFormula.memInverse (Sum.inr 0) (Sum.inl ())) (fun x => r) (prod (ran r) (dom r)) ↔
∃ y z, x = opair y z ∧ opair z y ∈ r | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ (x ∈ prod (ran r) (dom r) ∧
∃ y z,
interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inr 0) = opair y z ∧
opair z y ∈ interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inl ())) ↔
∃ y z, x = opair y z ∧ opair z y ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ x ∈ sep (BoundedFormula.memInverse (Sum.inr 0) (Sum.inl ())) (fun x => r) (prod (ran r) (dom r)) ↔
∃ y z, x = opair y z ∧ opair z y ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_inverse_iff | [177, 1] | [189, 20] | constructor | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ (x ∈ prod (ran r) (dom r) ∧
∃ y z,
interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inr 0) = opair y z ∧
opair z y ∈ interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inl ())) ↔
∃ y z, x = opair y z ∧ opair z y ∈ r | case mp
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ (x ∈ prod (ran r) (dom r) ∧
∃ y z,
interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inr 0) = opair y z ∧
opair z y ∈ interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inl ())) →
∃ y z, x = opair y z ∧ opair z y ∈ r
case mpr
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ (∃ y z, x = opair y z ∧ opair z y ∈ r) →
x ∈ prod (ran r) (dom r) ∧
∃ y z,
interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inr 0) = opair y z ∧
opair z y ∈ interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inl ()) | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ (x ∈ prod (ran r) (dom r) ∧
∃ y z,
interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inr 0) = opair y z ∧
opair z y ∈ interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inl ())) ↔
∃ y z, x = opair y z ∧ opair z y ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_inverse_iff | [177, 1] | [189, 20] | aesop | case mp
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ (x ∈ prod (ran r) (dom r) ∧
∃ y z,
interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inr 0) = opair y z ∧
opair z y ∈ interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inl ())) →
∃ y z, x = opair y z ∧ opair z y ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ (x ∈ prod (ran r) (dom r) ∧
∃ y z,
interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inr 0) = opair y z ∧
opair z y ∈ interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inl ())) →
∃ y z, x = opair y z ∧ opair z y ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_inverse_iff | [177, 1] | [189, 20] | rintro ⟨a, b, rfl, ha⟩ | case mpr
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ (∃ y z, x = opair y z ∧ opair z y ∈ r) →
x ∈ prod (ran r) (dom r) ∧
∃ y z,
interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inr 0) = opair y z ∧
opair z y ∈ interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inl ()) | case mpr.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ opair a b ∈ prod (ran r) (dom r) ∧
∃ y z,
interpretTerm V (fun x => r) (fun x => opair a b) (Sum.inr 0) = opair y z ∧
opair z y ∈ interpretTerm V (fun x => r) (fun x => opair a b) (Sum.inl ()) | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ (∃ y z, x = opair y z ∧ opair z y ∈ r) →
x ∈ prod (ran r) (dom r) ∧
∃ y z,
interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inr 0) = opair y z ∧
opair z y ∈ interpretTerm V (fun x => r) (fun x_1 => x) (Sum.inl ())
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_inverse_iff | [177, 1] | [189, 20] | refine ⟨?_, by aesop⟩ | case mpr.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ opair a b ∈ prod (ran r) (dom r) ∧
∃ y z,
interpretTerm V (fun x => r) (fun x => opair a b) (Sum.inr 0) = opair y z ∧
opair z y ∈ interpretTerm V (fun x => r) (fun x => opair a b) (Sum.inl ()) | case mpr.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ opair a b ∈ prod (ran r) (dom r) | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ opair a b ∈ prod (ran r) (dom r) ∧
∃ y z,
interpretTerm V (fun x => r) (fun x => opair a b) (Sum.inr 0) = opair y z ∧
opair z y ∈ interpretTerm V (fun x => r) (fun x => opair a b) (Sum.inl ())
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_inverse_iff | [177, 1] | [189, 20] | rw [mem_prod_iff] | case mpr.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ opair a b ∈ prod (ran r) (dom r) | case mpr.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ ∃ a_1, a_1 ∈ ran r ∧ ∃ b_1, b_1 ∈ dom r ∧ opair a b = opair a_1 b_1 | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ opair a b ∈ prod (ran r) (dom r)
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_inverse_iff | [177, 1] | [189, 20] | refine ⟨a, ?_, b, ?_, rfl⟩ | case mpr.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ ∃ a_1, a_1 ∈ ran r ∧ ∃ b_1, b_1 ∈ dom r ∧ opair a b = opair a_1 b_1 | case mpr.intro.intro.intro.refine_1
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ a ∈ ran r
case mpr.intro.intro.intro.refine_2
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ b ∈ dom r | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ ∃ a_1, a_1 ∈ ran r ∧ ∃ b_1, b_1 ∈ dom r ∧ opair a b = opair a_1 b_1
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_inverse_iff | [177, 1] | [189, 20] | aesop | V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ ∃ y z,
interpretTerm V (fun x => r) (fun x => opair a b) (Sum.inr 0) = opair y z ∧
opair z y ∈ interpretTerm V (fun x => r) (fun x => opair a b) (Sum.inl ()) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ ∃ y z,
interpretTerm V (fun x => r) (fun x => opair a b) (Sum.inr 0) = opair y z ∧
opair z y ∈ interpretTerm V (fun x => r) (fun x => opair a b) (Sum.inl ())
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_inverse_iff | [177, 1] | [189, 20] | rw [mem_ran_iff] | case mpr.intro.intro.intro.refine_1
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ a ∈ ran r | case mpr.intro.intro.intro.refine_1
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ ∃ z, opair z a ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.intro.intro.refine_1
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ a ∈ ran r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_inverse_iff | [177, 1] | [189, 20] | exact ⟨b, ha⟩ | case mpr.intro.intro.intro.refine_1
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ ∃ z, opair z a ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.intro.intro.refine_1
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ ∃ z, opair z a ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_inverse_iff | [177, 1] | [189, 20] | rw [mem_dom_iff] | case mpr.intro.intro.intro.refine_2
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ b ∈ dom r | case mpr.intro.intro.intro.refine_2
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ ∃ z, opair b z ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.intro.intro.refine_2
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ b ∈ dom r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_inverse_iff | [177, 1] | [189, 20] | exact ⟨a, ha⟩ | case mpr.intro.intro.intro.refine_2
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ ∃ z, opair b z ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.intro.intro.refine_2
V : Type u_1
inst✝ : Zermelo V
r y z a b : V
ha : opair b a ∈ r
⊢ ∃ z, opair b z ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memInverse | [192, 1] | [195, 46] | rw [mem_inverse_iff, interpret_memInverse'] | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memInverse x r) v l ↔ interpretTerm V v l x ∈ inverse (interpretTerm V v l r) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memInverse x r) v l ↔ interpretTerm V v l x ∈ inverse (interpretTerm V v l r)
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.inverse_inverse | [198, 1] | [205, 36] | ext x | V : Type u_1
inst✝ : Zermelo V
r x y z : V
hr : IsRelation r
⊢ inverse (inverse r) = r | case h
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
⊢ x ∈ inverse (inverse r) ↔ x ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
hr : IsRelation r
⊢ inverse (inverse r) = r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.inverse_inverse | [198, 1] | [205, 36] | simp only [mem_inverse_iff] | case h
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
⊢ x ∈ inverse (inverse r) ↔ x ∈ r | case h
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
⊢ (∃ y z, x = opair y z ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r) ↔ x ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
⊢ x ∈ inverse (inverse r) ↔ x ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.inverse_inverse | [198, 1] | [205, 36] | constructor | case h
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
⊢ (∃ y z, x = opair y z ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r) ↔ x ∈ r | case h.mp
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
⊢ (∃ y z, x = opair y z ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r) → x ∈ r
case h.mpr
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
⊢ x ∈ r → ∃ y z, x = opair y z ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
⊢ (∃ y z, x = opair y z ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r) ↔ x ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.inverse_inverse | [198, 1] | [205, 36] | aesop | case h.mp
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
⊢ (∃ y z, x = opair y z ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r) → x ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
⊢ (∃ y z, x = opair y z ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r) → x ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.inverse_inverse | [198, 1] | [205, 36] | intro h | case h.mpr
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
⊢ x ∈ r → ∃ y z, x = opair y z ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r | case h.mpr
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
h : x ∈ r
⊢ ∃ y z, x = opair y z ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
⊢ x ∈ r → ∃ y z, x = opair y z ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.inverse_inverse | [198, 1] | [205, 36] | obtain ⟨y, z, rfl⟩ := hr x h | case h.mpr
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
h : x ∈ r
⊢ ∃ y z, x = opair y z ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r | case h.mpr.intro.intro
V : Type u_1
inst✝ : Zermelo V
r x y✝ z✝ : V
hr : IsRelation r
y z : V
h : opair y z ∈ r
⊢ ∃ y_1 z_1, opair y z = opair y_1 z_1 ∧ ∃ y z, opair z_1 y_1 = opair y z ∧ opair z y ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr
V : Type u_1
inst✝ : Zermelo V
r x✝ y z : V
hr : IsRelation r
x : V
h : x ∈ r
⊢ ∃ y z, x = opair y z ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.inverse_inverse | [198, 1] | [205, 36] | exact ⟨y, z, rfl, z, y, rfl, h⟩ | case h.mpr.intro.intro
V : Type u_1
inst✝ : Zermelo V
r x y✝ z✝ : V
hr : IsRelation r
y z : V
h : opair y z ∈ r
⊢ ∃ y_1 z_1, opair y z = opair y_1 z_1 ∧ ∃ y z, opair z_1 y_1 = opair y z ∧ opair z y ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.intro.intro
V : Type u_1
inst✝ : Zermelo V
r x y✝ z✝ : V
hr : IsRelation r
y z : V
h : opair y z ∈ r
⊢ ∃ y_1 z_1, opair y z = opair y_1 z_1 ∧ ∃ y z, opair z_1 y_1 = opair y z ∧ opair z y ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.image_inverse | [208, 1] | [211, 8] | ext y | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ image (inverse r) x = preimage r x | case h
V : Type u_1
inst✝ : Zermelo V
r x y✝ z y : V
⊢ y ∈ image (inverse r) x ↔ y ∈ preimage r x | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ image (inverse r) x = preimage r x
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.image_inverse | [208, 1] | [211, 8] | simp only [mem_image_iff, mem_preimage_iff, mem_inverse_iff] | case h
V : Type u_1
inst✝ : Zermelo V
r x y✝ z y : V
⊢ y ∈ image (inverse r) x ↔ y ∈ preimage r x | case h
V : Type u_1
inst✝ : Zermelo V
r x y✝ z y : V
⊢ (∃ z, z ∈ x ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r) ↔ ∃ z, z ∈ x ∧ opair y z ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h
V : Type u_1
inst✝ : Zermelo V
r x y✝ z y : V
⊢ y ∈ image (inverse r) x ↔ y ∈ preimage r x
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.image_inverse | [208, 1] | [211, 8] | aesop | case h
V : Type u_1
inst✝ : Zermelo V
r x y✝ z y : V
⊢ (∃ z, z ∈ x ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r) ↔ ∃ z, z ∈ x ∧ opair y z ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
V : Type u_1
inst✝ : Zermelo V
r x y✝ z y : V
⊢ (∃ z, z ∈ x ∧ ∃ y_1 z_1, opair z y = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r) ↔ ∃ z, z ∈ x ∧ opair y z ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.preimage_inverse | [214, 1] | [217, 8] | ext y | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ preimage (inverse r) x = image r x | case h
V : Type u_1
inst✝ : Zermelo V
r x y✝ z y : V
⊢ y ∈ preimage (inverse r) x ↔ y ∈ image r x | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ preimage (inverse r) x = image r x
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.preimage_inverse | [214, 1] | [217, 8] | simp only [mem_image_iff, mem_preimage_iff, mem_inverse_iff] | case h
V : Type u_1
inst✝ : Zermelo V
r x y✝ z y : V
⊢ y ∈ preimage (inverse r) x ↔ y ∈ image r x | case h
V : Type u_1
inst✝ : Zermelo V
r x y✝ z y : V
⊢ (∃ z, z ∈ x ∧ ∃ y_1 z_1, opair y z = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r) ↔ ∃ z, z ∈ x ∧ opair z y ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h
V : Type u_1
inst✝ : Zermelo V
r x y✝ z y : V
⊢ y ∈ preimage (inverse r) x ↔ y ∈ image r x
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.preimage_inverse | [214, 1] | [217, 8] | aesop | case h
V : Type u_1
inst✝ : Zermelo V
r x y✝ z y : V
⊢ (∃ z, z ∈ x ∧ ∃ y_1 z_1, opair y z = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r) ↔ ∃ z, z ∈ x ∧ opair z y ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
V : Type u_1
inst✝ : Zermelo V
r x y✝ z y : V
⊢ (∃ z, z ∈ x ∧ ∃ y_1 z_1, opair y z = opair y_1 z_1 ∧ opair z_1 y_1 ∈ r) ↔ ∃ z, z ∈ x ∧ opair z y ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memRComp' | [240, 1] | [247, 19] | unfold BoundedFormula.memRComp | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x s r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memRComp x s r) v l ↔
∃ a b c, interpretTerm V v l x = opair a c ∧ opair b c ∈ interpretTerm V v l s ∧ opair a b ∈ interpretTerm V v l r | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x s r : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.eqOPair (termSucc (termSucc (termSucc (termSucc (termSucc x)))))
(Sum.inr { val := n, isLt := (_ : n < n + (4 + 1)) })
(Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (2 + 1)) }))
(BoundedFormula.eqOPair (Sum.inr { val := n + 3, isLt := (_ : n + 3 < n + 3 + (1 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (4 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (3 + 1)) })))
(BoundedFormula.eqOPair (Sum.inr { val := n + 4, isLt := (_ : n + 4 < n + 4 + (0 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (3 + 1)) })
(Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (2 + 1)) })))
(BoundedFormula.mem (Sum.inr { val := n + 4, isLt := (_ : n + 4 < n + 4 + (0 + 1)) })
(termSucc (termSucc (termSucc (termSucc (termSucc s)))))))
(BoundedFormula.mem (Sum.inr { val := n + 3, isLt := (_ : n + 3 < n + 3 + (1 + 1)) })
(termSucc (termSucc (termSucc (termSucc (termSucc r))))))))))))
v l ↔
∃ a b c, interpretTerm V v l x = opair a c ∧ opair b c ∈ interpretTerm V v l s ∧ opair a b ∈ interpretTerm V v l r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x s r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memRComp x s r) v l ↔
∃ a b c, interpretTerm V v l x = opair a c ∧ opair b c ∈ interpretTerm V v l s ∧ opair a b ∈ interpretTerm V v l r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memRComp' | [240, 1] | [247, 19] | simp [and_assoc] | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x s r : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.eqOPair (termSucc (termSucc (termSucc (termSucc (termSucc x)))))
(Sum.inr { val := n, isLt := (_ : n < n + (4 + 1)) })
(Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (2 + 1)) }))
(BoundedFormula.eqOPair (Sum.inr { val := n + 3, isLt := (_ : n + 3 < n + 3 + (1 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (4 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (3 + 1)) })))
(BoundedFormula.eqOPair (Sum.inr { val := n + 4, isLt := (_ : n + 4 < n + 4 + (0 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (3 + 1)) })
(Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (2 + 1)) })))
(BoundedFormula.mem (Sum.inr { val := n + 4, isLt := (_ : n + 4 < n + 4 + (0 + 1)) })
(termSucc (termSucc (termSucc (termSucc (termSucc s)))))))
(BoundedFormula.mem (Sum.inr { val := n + 3, isLt := (_ : n + 3 < n + 3 + (1 + 1)) })
(termSucc (termSucc (termSucc (termSucc (termSucc r))))))))))))
v l ↔
∃ a b c, interpretTerm V v l x = opair a c ∧ opair b c ∈ interpretTerm V v l s ∧ opair a b ∈ interpretTerm V v l r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x s r : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.exists
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.and
(BoundedFormula.eqOPair (termSucc (termSucc (termSucc (termSucc (termSucc x)))))
(Sum.inr { val := n, isLt := (_ : n < n + (4 + 1)) })
(Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (2 + 1)) }))
(BoundedFormula.eqOPair (Sum.inr { val := n + 3, isLt := (_ : n + 3 < n + 3 + (1 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (4 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (3 + 1)) })))
(BoundedFormula.eqOPair (Sum.inr { val := n + 4, isLt := (_ : n + 4 < n + 4 + (0 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (3 + 1)) })
(Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (2 + 1)) })))
(BoundedFormula.mem (Sum.inr { val := n + 4, isLt := (_ : n + 4 < n + 4 + (0 + 1)) })
(termSucc (termSucc (termSucc (termSucc (termSucc s)))))))
(BoundedFormula.mem (Sum.inr { val := n + 3, isLt := (_ : n + 3 < n + 3 + (1 + 1)) })
(termSucc (termSucc (termSucc (termSucc (termSucc r))))))))))))
v l ↔
∃ a b c, interpretTerm V v l x = opair a c ∧ opair b c ∈ interpretTerm V v l s ∧ opair a b ∈ interpretTerm V v l r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_rcomp_iff | [256, 1] | [266, 18] | unfold rcomp | V : Type u_1
inst✝ : Zermelo V
r x y z s : V
⊢ x ∈ rcomp s r ↔ ∃ a b c, x = opair a c ∧ opair b c ∈ s ∧ opair a b ∈ r | V : Type u_1
inst✝ : Zermelo V
r x y z s : V
⊢ x ∈
sep (BoundedFormula.memRComp (Sum.inr 0) (Sum.inl true) (Sum.inl false)) (fun i => if i = true then s else r)
(prod (dom r) (ran s)) ↔
∃ a b c, x = opair a c ∧ opair b c ∈ s ∧ opair a b ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
⊢ x ∈ rcomp s r ↔ ∃ a b c, x = opair a c ∧ opair b c ∈ s ∧ opair a b ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_rcomp_iff | [256, 1] | [266, 18] | simp only [mem_sep_iff, interpret_memRComp', interpret_inr, interpret_inl, ite_true, ite_false,
and_iff_right_iff_imp, forall_exists_index, and_imp] | V : Type u_1
inst✝ : Zermelo V
r x y z s : V
⊢ x ∈
sep (BoundedFormula.memRComp (Sum.inr 0) (Sum.inl true) (Sum.inl false)) (fun i => if i = true then s else r)
(prod (dom r) (ran s)) ↔
∃ a b c, x = opair a c ∧ opair b c ∈ s ∧ opair a b ∈ r | V : Type u_1
inst✝ : Zermelo V
r x y z s : V
⊢ ∀ (x_1 x_2 x_3 : V), x = opair x_1 x_3 → opair x_2 x_3 ∈ s → opair x_1 x_2 ∈ r → x ∈ prod (dom r) (ran s) | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
⊢ x ∈
sep (BoundedFormula.memRComp (Sum.inr 0) (Sum.inl true) (Sum.inl false)) (fun i => if i = true then s else r)
(prod (dom r) (ran s)) ↔
∃ a b c, x = opair a c ∧ opair b c ∈ s ∧ opair a b ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_rcomp_iff | [256, 1] | [266, 18] | rintro a b c rfl hs hr | V : Type u_1
inst✝ : Zermelo V
r x y z s : V
⊢ ∀ (x_1 x_2 x_3 : V), x = opair x_1 x_3 → opair x_2 x_3 ∈ s → opair x_1 x_2 ∈ r → x ∈ prod (dom r) (ran s) | V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ opair a c ∈ prod (dom r) (ran s) | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
⊢ ∀ (x_1 x_2 x_3 : V), x = opair x_1 x_3 → opair x_2 x_3 ∈ s → opair x_1 x_2 ∈ r → x ∈ prod (dom r) (ran s)
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_rcomp_iff | [256, 1] | [266, 18] | rw [mem_prod_iff] | V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ opair a c ∈ prod (dom r) (ran s) | V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ ∃ a_1, a_1 ∈ dom r ∧ ∃ b, b ∈ ran s ∧ opair a c = opair a_1 b | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ opair a c ∈ prod (dom r) (ran s)
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_rcomp_iff | [256, 1] | [266, 18] | refine ⟨a, ?_, c, ?_, rfl⟩ | V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ ∃ a_1, a_1 ∈ dom r ∧ ∃ b, b ∈ ran s ∧ opair a c = opair a_1 b | case refine_1
V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ a ∈ dom r
case refine_2
V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ c ∈ ran s | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ ∃ a_1, a_1 ∈ dom r ∧ ∃ b, b ∈ ran s ∧ opair a c = opair a_1 b
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_rcomp_iff | [256, 1] | [266, 18] | rw [mem_dom_iff] | case refine_1
V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ a ∈ dom r | case refine_1
V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ ∃ z, opair a z ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1
V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ a ∈ dom r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_rcomp_iff | [256, 1] | [266, 18] | exact ⟨b, hr⟩ | case refine_1
V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ ∃ z, opair a z ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_1
V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ ∃ z, opair a z ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_rcomp_iff | [256, 1] | [266, 18] | rw [mem_ran_iff] | case refine_2
V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ c ∈ ran s | case refine_2
V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ ∃ z, opair z c ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ c ∈ ran s
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_rcomp_iff | [256, 1] | [266, 18] | exact ⟨b, hs⟩ | case refine_2
V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ ∃ z, opair z c ∈ s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refine_2
V : Type u_1
inst✝ : Zermelo V
r y z s a b c : V
hs : opair b c ∈ s
hr : opair a b ∈ r
⊢ ∃ z, opair z c ∈ s
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.opair_mem_rcomp_iff | [269, 1] | [271, 8] | rw [mem_rcomp_iff] | V : Type u_1
inst✝ : Zermelo V
r x y z a c s : V
⊢ opair a c ∈ rcomp s r ↔ ∃ b, opair b c ∈ s ∧ opair a b ∈ r | V : Type u_1
inst✝ : Zermelo V
r x y z a c s : V
⊢ (∃ a_1 b c_1, opair a c = opair a_1 c_1 ∧ opair b c_1 ∈ s ∧ opair a_1 b ∈ r) ↔ ∃ b, opair b c ∈ s ∧ opair a b ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z a c s : V
⊢ opair a c ∈ rcomp s r ↔ ∃ b, opair b c ∈ s ∧ opair a b ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.opair_mem_rcomp_iff | [269, 1] | [271, 8] | aesop | V : Type u_1
inst✝ : Zermelo V
r x y z a c s : V
⊢ (∃ a_1 b c_1, opair a c = opair a_1 c_1 ∧ opair b c_1 ∈ s ∧ opair a_1 b ∈ r) ↔ ∃ b, opair b c ∈ s ∧ opair a b ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z a c s : V
⊢ (∃ a_1 b c_1, opair a c = opair a_1 c_1 ∧ opair b c_1 ∈ s ∧ opair a_1 b ∈ r) ↔ ∃ b, opair b c ∈ s ∧ opair a b ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memRComp | [273, 1] | [276, 42] | rw [mem_rcomp_iff, interpret_memRComp'] | V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x s r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memRComp x s r) v l ↔
interpretTerm V v l x ∈ rcomp (interpretTerm V v l s) (interpretTerm V v l r) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r✝ x✝ y z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x s r : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memRComp x s r) v l ↔
interpretTerm V v l x ∈ rcomp (interpretTerm V v l s) (interpretTerm V v l r)
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.rcomp_assoc | [278, 1] | [281, 8] | ext | V : Type u_1
inst✝ : Zermelo V
r x y z t s : V
⊢ rcomp (rcomp t s) r = rcomp t (rcomp s r) | case h
V : Type u_1
inst✝ : Zermelo V
r x y z t s z✝ : V
⊢ z✝ ∈ rcomp (rcomp t s) r ↔ z✝ ∈ rcomp t (rcomp s r) | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z t s : V
⊢ rcomp (rcomp t s) r = rcomp t (rcomp s r)
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.rcomp_assoc | [278, 1] | [281, 8] | simp only [mem_rcomp_iff] | case h
V : Type u_1
inst✝ : Zermelo V
r x y z t s z✝ : V
⊢ z✝ ∈ rcomp (rcomp t s) r ↔ z✝ ∈ rcomp t (rcomp s r) | case h
V : Type u_1
inst✝ : Zermelo V
r x y z t s z✝ : V
⊢ (∃ a b c,
z✝ = opair a c ∧ (∃ a b_1 c_1, opair b c = opair a c_1 ∧ opair b_1 c_1 ∈ t ∧ opair a b_1 ∈ s) ∧ opair a b ∈ r) ↔
∃ a b c, z✝ = opair a c ∧ opair b c ∈ t ∧ ∃ a_1 b_1 c, opair a b = opair a_1 c ∧ opair b_1 c ∈ s ∧ opair a_1 b_1 ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h
V : Type u_1
inst✝ : Zermelo V
r x y z t s z✝ : V
⊢ z✝ ∈ rcomp (rcomp t s) r ↔ z✝ ∈ rcomp t (rcomp s r)
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.rcomp_assoc | [278, 1] | [281, 8] | aesop | case h
V : Type u_1
inst✝ : Zermelo V
r x y z t s z✝ : V
⊢ (∃ a b c,
z✝ = opair a c ∧ (∃ a b_1 c_1, opair b c = opair a c_1 ∧ opair b_1 c_1 ∈ t ∧ opair a b_1 ∈ s) ∧ opair a b ∈ r) ↔
∃ a b c, z✝ = opair a c ∧ opair b c ∈ t ∧ ∃ a_1 b_1 c, opair a b = opair a_1 c ∧ opair b_1 c ∈ s ∧ opair a_1 b_1 ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
V : Type u_1
inst✝ : Zermelo V
r x y z t s z✝ : V
⊢ (∃ a b c,
z✝ = opair a c ∧ (∃ a b_1 c_1, opair b c = opair a c_1 ∧ opair b_1 c_1 ∈ t ∧ opair a b_1 ∈ s) ∧ opair a b ∈ r) ↔
∃ a b c, z✝ = opair a c ∧ opair b c ∈ t ∧ ∃ a_1 b_1 c, opair a b = opair a_1 c ∧ opair b_1 c ∈ s ∧ opair a_1 b_1 ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.rcomp_isRelation | [283, 1] | [286, 8] | intro x hx | V : Type u_1
inst✝ : Zermelo V
r x y z s : V
hr : IsRelation r
⊢ IsRelation (rcomp s r) | V : Type u_1
inst✝ : Zermelo V
r x✝ y z s : V
hr : IsRelation r
x : V
hx : x ∈ rcomp s r
⊢ IsOPair x | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
hr : IsRelation r
⊢ IsRelation (rcomp s r)
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.rcomp_isRelation | [283, 1] | [286, 8] | rw [mem_rcomp_iff] at hx | V : Type u_1
inst✝ : Zermelo V
r x✝ y z s : V
hr : IsRelation r
x : V
hx : x ∈ rcomp s r
⊢ IsOPair x | V : Type u_1
inst✝ : Zermelo V
r x✝ y z s : V
hr : IsRelation r
x : V
hx : ∃ a b c, x = opair a c ∧ opair b c ∈ s ∧ opair a b ∈ r
⊢ IsOPair x | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x✝ y z s : V
hr : IsRelation r
x : V
hx : x ∈ rcomp s r
⊢ IsOPair x
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.rcomp_isRelation | [283, 1] | [286, 8] | aesop | V : Type u_1
inst✝ : Zermelo V
r x✝ y z s : V
hr : IsRelation r
x : V
hx : ∃ a b c, x = opair a c ∧ opair b c ∈ s ∧ opair a b ∈ r
⊢ IsOPair x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x✝ y z s : V
hr : IsRelation r
x : V
hx : ∃ a b c, x = opair a c ∧ opair b c ∈ s ∧ opair a b ∈ r
⊢ IsOPair x
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.dom_rcomp | [288, 1] | [301, 43] | ext t | V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
⊢ dom (rcomp s r) = dom r | case h
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t : V
⊢ t ∈ dom (rcomp s r) ↔ t ∈ dom r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
⊢ dom (rcomp s r) = dom r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.dom_rcomp | [288, 1] | [301, 43] | simp only [mem_dom_iff, mem_rcomp_iff, opair_injective] | case h
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t : V
⊢ t ∈ dom (rcomp s r) ↔ t ∈ dom r | case h
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t : V
⊢ (∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r) ↔ ∃ z, opair t z ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t : V
⊢ t ∈ dom (rcomp s r) ↔ t ∈ dom r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.dom_rcomp | [288, 1] | [301, 43] | constructor | case h
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t : V
⊢ (∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r) ↔ ∃ z, opair t z ∈ r | case h.mp
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t : V
⊢ (∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r) → ∃ z, opair t z ∈ r
case h.mpr
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t : V
⊢ (∃ z, opair t z ∈ r) → ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t : V
⊢ (∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r) ↔ ∃ z, opair t z ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.dom_rcomp | [288, 1] | [301, 43] | rintro ⟨z, _, b, _, ⟨rfl, rfl⟩, _, hc⟩ | case h.mp
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t : V
⊢ (∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r) → ∃ z, opair t z ∈ r | case h.mp.intro.intro.intro.intro.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r x y z✝ s : V
h : ran r ⊆ dom s
t z b : V
left✝ : opair b z ∈ s
hc : opair t b ∈ r
⊢ ∃ z, opair t z ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t : V
⊢ (∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r) → ∃ z, opair t z ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.dom_rcomp | [288, 1] | [301, 43] | exact ⟨_, hc⟩ | case h.mp.intro.intro.intro.intro.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r x y z✝ s : V
h : ran r ⊆ dom s
t z b : V
left✝ : opair b z ∈ s
hc : opair t b ∈ r
⊢ ∃ z, opair t z ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp.intro.intro.intro.intro.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r x y z✝ s : V
h : ran r ⊆ dom s
t z b : V
left✝ : opair b z ∈ s
hc : opair t b ∈ r
⊢ ∃ z, opair t z ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.dom_rcomp | [288, 1] | [301, 43] | rintro ⟨b, hb⟩ | case h.mpr
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t : V
⊢ (∃ z, opair t z ∈ r) → ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r | case h.mpr.intro
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t : V
⊢ (∃ z, opair t z ∈ r) → ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.dom_rcomp | [288, 1] | [301, 43] | have : b ∈ ran r := by
rw [mem_ran_iff]
exact ⟨t, hb⟩ | case h.mpr.intro
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r | case h.mpr.intro
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
this : b ∈ ran r
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.intro
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.dom_rcomp | [288, 1] | [301, 43] | have := h this | case h.mpr.intro
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
this : b ∈ ran r
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r | case h.mpr.intro
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
this✝ : b ∈ ran r
this : b ∈ dom s
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.intro
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
this : b ∈ ran r
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.dom_rcomp | [288, 1] | [301, 43] | rw [mem_dom_iff] at this | case h.mpr.intro
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
this✝ : b ∈ ran r
this : b ∈ dom s
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r | case h.mpr.intro
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
this✝ : b ∈ ran r
this : ∃ z, opair b z ∈ s
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.intro
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
this✝ : b ∈ ran r
this : b ∈ dom s
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.dom_rcomp | [288, 1] | [301, 43] | obtain ⟨z, hz⟩ := this | case h.mpr.intro
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
this✝ : b ∈ ran r
this : ∃ z, opair b z ∈ s
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r | case h.mpr.intro.intro
V : Type u_1
inst✝ : Zermelo V
r x y z✝ s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
this : b ∈ ran r
z : V
hz : opair b z ∈ s
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.intro
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
this✝ : b ∈ ran r
this : ∃ z, opair b z ∈ s
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.dom_rcomp | [288, 1] | [301, 43] | exact ⟨z, _, b, _, ⟨rfl, rfl⟩, hz, hb⟩ | case h.mpr.intro.intro
V : Type u_1
inst✝ : Zermelo V
r x y z✝ s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
this : b ∈ ran r
z : V
hz : opair b z ∈ s
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr.intro.intro
V : Type u_1
inst✝ : Zermelo V
r x y z✝ s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
this : b ∈ ran r
z : V
hz : opair b z ∈ s
⊢ ∃ z a b c, (t = a ∧ z = c) ∧ opair b c ∈ s ∧ opair a b ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.dom_rcomp | [288, 1] | [301, 43] | rw [mem_ran_iff] | V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
⊢ b ∈ ran r | V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
⊢ ∃ z, opair z b ∈ r | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
⊢ b ∈ ran r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.dom_rcomp | [288, 1] | [301, 43] | exact ⟨t, hb⟩ | V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
⊢ ∃ z, opair z b ∈ r | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
h : ran r ⊆ dom s
t b : V
hb : opair t b ∈ r
⊢ ∃ z, opair z b ∈ r
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.ran_rcomp | [303, 1] | [307, 16] | intro t | V : Type u_1
inst✝ : Zermelo V
r x y z s : V
⊢ ran (rcomp s r) ⊆ ran s | V : Type u_1
inst✝ : Zermelo V
r x y z s t : V
⊢ t ∈ ran (rcomp s r) → t ∈ ran s | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z s : V
⊢ ran (rcomp s r) ⊆ ran s
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.ran_rcomp | [303, 1] | [307, 16] | simp only [mem_ran_iff, mem_rcomp_iff, opair_injective] | V : Type u_1
inst✝ : Zermelo V
r x y z s t : V
⊢ t ∈ ran (rcomp s r) → t ∈ ran s | V : Type u_1
inst✝ : Zermelo V
r x y z s t : V
⊢ (∃ z a b c, (z = a ∧ t = c) ∧ opair b c ∈ s ∧ opair a b ∈ r) → ∃ z, opair z t ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z s t : V
⊢ t ∈ ran (rcomp s r) → t ∈ ran s
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.ran_rcomp | [303, 1] | [307, 16] | rintro ⟨z, _, b, _, ⟨rfl, rfl⟩, hc, _⟩ | V : Type u_1
inst✝ : Zermelo V
r x y z s t : V
⊢ (∃ z a b c, (z = a ∧ t = c) ∧ opair b c ∈ s ∧ opair a b ∈ r) → ∃ z, opair z t ∈ s | case intro.intro.intro.intro.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r x y z✝ s t z b : V
hc : opair b t ∈ s
right✝ : opair z b ∈ r
⊢ ∃ z, opair z t ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z s t : V
⊢ (∃ z a b c, (z = a ∧ t = c) ∧ opair b c ∈ s ∧ opair a b ∈ r) → ∃ z, opair z t ∈ s
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.ran_rcomp | [303, 1] | [307, 16] | exact ⟨_, hc⟩ | case intro.intro.intro.intro.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r x y z✝ s t z b : V
hc : opair b t ∈ s
right✝ : opair z b ∈ r
⊢ ∃ z, opair z t ∈ s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro.intro.intro
V : Type u_1
inst✝ : Zermelo V
r x y z✝ s t z b : V
hc : opair b t ∈ s
right✝ : opair z b ∈ r
⊢ ∃ z, opair z t ∈ s
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memId' | [315, 1] | [319, 7] | unfold BoundedFormula.memId | V : Type u_1
inst✝ : Zermelo V
r x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memId x y) v l ↔ ∃ z, z ∈ interpretTerm V v l y ∧ interpretTerm V v l x = opair z z | V : Type u_1
inst✝ : Zermelo V
r x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.and (BoundedFormula.mem (Sum.inr (Fin.last n)) (termSucc y))
(BoundedFormula.eqOPair (termSucc x) (Sum.inr (Fin.last n)) (Sum.inr (Fin.last n)))))
v l ↔
∃ z, z ∈ interpretTerm V v l y ∧ interpretTerm V v l x = opair z z | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memId x y) v l ↔ ∃ z, z ∈ interpretTerm V v l y ∧ interpretTerm V v l x = opair z z
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memId' | [315, 1] | [319, 7] | simp | V : Type u_1
inst✝ : Zermelo V
r x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.and (BoundedFormula.mem (Sum.inr (Fin.last n)) (termSucc y))
(BoundedFormula.eqOPair (termSucc x) (Sum.inr (Fin.last n)) (Sum.inr (Fin.last n)))))
v l ↔
∃ z, z ∈ interpretTerm V v l y ∧ interpretTerm V v l x = opair z z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.and (BoundedFormula.mem (Sum.inr (Fin.last n)) (termSucc y))
(BoundedFormula.eqOPair (termSucc x) (Sum.inr (Fin.last n)) (Sum.inr (Fin.last n)))))
v l ↔
∃ z, z ∈ interpretTerm V v l y ∧ interpretTerm V v l x = opair z z
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_id_iff | [327, 1] | [330, 8] | unfold id | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ y ∈ id x ↔ ∃ z, z ∈ x ∧ y = opair z z | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ y ∈ sep (BoundedFormula.memId (Sum.inr 0) (Sum.inl ())) (fun x_1 => x) (prod x x) ↔ ∃ z, z ∈ x ∧ y = opair z z | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ y ∈ id x ↔ ∃ z, z ∈ x ∧ y = opair z z
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_id_iff | [327, 1] | [330, 8] | simp only [mem_sep_iff, interpret_memId'] | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ y ∈ sep (BoundedFormula.memId (Sum.inr 0) (Sum.inl ())) (fun x_1 => x) (prod x x) ↔ ∃ z, z ∈ x ∧ y = opair z z | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ (y ∈ prod x x ∧
∃ z,
z ∈ interpretTerm V (fun x_1 => x) (fun x => y) (Sum.inl ()) ∧
interpretTerm V (fun x_1 => x) (fun x => y) (Sum.inr 0) = opair z z) ↔
∃ z, z ∈ x ∧ y = opair z z | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ y ∈ sep (BoundedFormula.memId (Sum.inr 0) (Sum.inl ())) (fun x_1 => x) (prod x x) ↔ ∃ z, z ∈ x ∧ y = opair z z
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.mem_id_iff | [327, 1] | [330, 8] | aesop | V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ (y ∈ prod x x ∧
∃ z,
z ∈ interpretTerm V (fun x_1 => x) (fun x => y) (Sum.inl ()) ∧
interpretTerm V (fun x_1 => x) (fun x => y) (Sum.inr 0) = opair z z) ↔
∃ z, z ∈ x ∧ y = opair z z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z : V
⊢ (y ∈ prod x x ∧
∃ z,
z ∈ interpretTerm V (fun x_1 => x) (fun x => y) (Sum.inl ()) ∧
interpretTerm V (fun x_1 => x) (fun x => y) (Sum.inr 0) = opair z z) ↔
∃ z, z ∈ x ∧ y = opair z z
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Relation.lean | SetTheory.interpret_memId | [333, 1] | [336, 36] | rw [mem_id_iff, interpret_memId'] | V : Type u_1
inst✝ : Zermelo V
r x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memId x y) v l ↔ interpretTerm V v l x ∈ id (interpretTerm V v l y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x✝ y✝ z : V
α : Type
n : Nat
v : α → V
l : Fin n → V
x y : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.memId x y) v l ↔ interpretTerm V v l x ∈ id (interpretTerm V v l y)
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Function.lean | SetTheory.interpret_isFunction | [33, 1] | [36, 8] | unfold BoundedFormula.isFunction IsFunction | V : Type u_1
inst✝ : Zermelo V
r x y z a b c : V
α : Type
n : Nat
v : α → V
l : Fin n → V
f : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.isFunction f) v l ↔ IsFunction (interpretTerm V v l f) | V : Type u_1
inst✝ : Zermelo V
r x y z a b c : V
α : Type
n : Nat
v : α → V
l : Fin n → V
f : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.and (BoundedFormula.isRelation f)
(BoundedFormula.all
(BoundedFormula.all
(BoundedFormula.all
(BoundedFormula.all
(BoundedFormula.all
(BoundedFormula.imp
(BoundedFormula.eqOPair (Sum.inr { val := n + 3, isLt := (_ : n + 3 < n + 3 + (1 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (4 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (3 + 1)) }))
(BoundedFormula.imp
(BoundedFormula.eqOPair (Sum.inr { val := n + 4, isLt := (_ : n + 4 < n + 4 + (0 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (4 + 1)) })
(Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (2 + 1)) }))
(BoundedFormula.imp
(BoundedFormula.mem (Sum.inr { val := n + 3, isLt := (_ : n + 3 < n + 3 + (1 + 1)) })
(termSucc (termSucc (termSucc (termSucc (termSucc f))))))
(BoundedFormula.imp
(BoundedFormula.mem (Sum.inr { val := n + 4, isLt := (_ : n + 4 < n + 4 + (0 + 1)) })
(termSucc (termSucc (termSucc (termSucc (termSucc f))))))
(BoundedFormula.eq (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (3 + 1)) })
(Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (2 + 1)) }))))))))))))
v l ↔
IsRelation (interpretTerm V v l f) ∧
∀ (x s t : V), opair x s ∈ interpretTerm V v l f → opair x t ∈ interpretTerm V v l f → s = t | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z a b c : V
α : Type
n : Nat
v : α → V
l : Fin n → V
f : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.isFunction f) v l ↔ IsFunction (interpretTerm V v l f)
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Function.lean | SetTheory.interpret_isFunction | [33, 1] | [36, 8] | aesop | V : Type u_1
inst✝ : Zermelo V
r x y z a b c : V
α : Type
n : Nat
v : α → V
l : Fin n → V
f : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.and (BoundedFormula.isRelation f)
(BoundedFormula.all
(BoundedFormula.all
(BoundedFormula.all
(BoundedFormula.all
(BoundedFormula.all
(BoundedFormula.imp
(BoundedFormula.eqOPair (Sum.inr { val := n + 3, isLt := (_ : n + 3 < n + 3 + (1 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (4 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (3 + 1)) }))
(BoundedFormula.imp
(BoundedFormula.eqOPair (Sum.inr { val := n + 4, isLt := (_ : n + 4 < n + 4 + (0 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (4 + 1)) })
(Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (2 + 1)) }))
(BoundedFormula.imp
(BoundedFormula.mem (Sum.inr { val := n + 3, isLt := (_ : n + 3 < n + 3 + (1 + 1)) })
(termSucc (termSucc (termSucc (termSucc (termSucc f))))))
(BoundedFormula.imp
(BoundedFormula.mem (Sum.inr { val := n + 4, isLt := (_ : n + 4 < n + 4 + (0 + 1)) })
(termSucc (termSucc (termSucc (termSucc (termSucc f))))))
(BoundedFormula.eq (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (3 + 1)) })
(Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (2 + 1)) }))))))))))))
v l ↔
IsRelation (interpretTerm V v l f) ∧
∀ (x s t : V), opair x s ∈ interpretTerm V v l f → opair x t ∈ interpretTerm V v l f → s = t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z a b c : V
α : Type
n : Nat
v : α → V
l : Fin n → V
f : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.and (BoundedFormula.isRelation f)
(BoundedFormula.all
(BoundedFormula.all
(BoundedFormula.all
(BoundedFormula.all
(BoundedFormula.all
(BoundedFormula.imp
(BoundedFormula.eqOPair (Sum.inr { val := n + 3, isLt := (_ : n + 3 < n + 3 + (1 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (4 + 1)) })
(Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (3 + 1)) }))
(BoundedFormula.imp
(BoundedFormula.eqOPair (Sum.inr { val := n + 4, isLt := (_ : n + 4 < n + 4 + (0 + 1)) })
(Sum.inr { val := n, isLt := (_ : n < n + (4 + 1)) })
(Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (2 + 1)) }))
(BoundedFormula.imp
(BoundedFormula.mem (Sum.inr { val := n + 3, isLt := (_ : n + 3 < n + 3 + (1 + 1)) })
(termSucc (termSucc (termSucc (termSucc (termSucc f))))))
(BoundedFormula.imp
(BoundedFormula.mem (Sum.inr { val := n + 4, isLt := (_ : n + 4 < n + 4 + (0 + 1)) })
(termSucc (termSucc (termSucc (termSucc (termSucc f))))))
(BoundedFormula.eq (Sum.inr { val := n + 1, isLt := (_ : n + 1 < n + 1 + (3 + 1)) })
(Sum.inr { val := n + 2, isLt := (_ : n + 2 < n + 2 + (2 + 1)) }))))))))))))
v l ↔
IsRelation (interpretTerm V v l f) ∧
∀ (x s t : V), opair x s ∈ interpretTerm V v l f → opair x t ∈ interpretTerm V v l f → s = t
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Function.lean | SetTheory.interpret_maps | [45, 1] | [49, 7] | unfold BoundedFormula.maps | V : Type u_1
inst✝ : Zermelo V
r x✝ y✝ z a b c : V
α : Type
n : Nat
v : α → V
l : Fin n → V
f x y : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.maps f x y) v l ↔
opair (interpretTerm V v l x) (interpretTerm V v l y) ∈ interpretTerm V v l f | V : Type u_1
inst✝ : Zermelo V
r x✝ y✝ z a b c : V
α : Type
n : Nat
v : α → V
l : Fin n → V
f x y : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.and (BoundedFormula.eqOPair (Sum.inr (Fin.last n)) (termSucc x) (termSucc y))
(BoundedFormula.mem (Sum.inr (Fin.last n)) (termSucc f))))
v l ↔
opair (interpretTerm V v l x) (interpretTerm V v l y) ∈ interpretTerm V v l f | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x✝ y✝ z a b c : V
α : Type
n : Nat
v : α → V
l : Fin n → V
f x y : α ⊕ Fin n
⊢ Interpret V (BoundedFormula.maps f x y) v l ↔
opair (interpretTerm V v l x) (interpretTerm V v l y) ∈ interpretTerm V v l f
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Function.lean | SetTheory.interpret_maps | [45, 1] | [49, 7] | simp | V : Type u_1
inst✝ : Zermelo V
r x✝ y✝ z a b c : V
α : Type
n : Nat
v : α → V
l : Fin n → V
f x y : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.and (BoundedFormula.eqOPair (Sum.inr (Fin.last n)) (termSucc x) (termSucc y))
(BoundedFormula.mem (Sum.inr (Fin.last n)) (termSucc f))))
v l ↔
opair (interpretTerm V v l x) (interpretTerm V v l y) ∈ interpretTerm V v l f | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x✝ y✝ z a b c : V
α : Type
n : Nat
v : α → V
l : Fin n → V
f x y : α ⊕ Fin n
⊢ Interpret V
(BoundedFormula.exists
(BoundedFormula.and (BoundedFormula.eqOPair (Sum.inr (Fin.last n)) (termSucc x) (termSucc y))
(BoundedFormula.mem (Sum.inr (Fin.last n)) (termSucc f))))
v l ↔
opair (interpretTerm V v l x) (interpretTerm V v l y) ∈ interpretTerm V v l f
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Function.lean | SetTheory.mem_of_mem_dom | [61, 1] | [62, 22] | rwa [← f.dom_eq] | V : Type u_1
inst✝ : Zermelo V
r x y z a b c : V
f : a ⟶ b
hx : x ∈ dom f.graph
⊢ x ∈ a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z a b c : V
f : a ⟶ b
hx : x ∈ dom f.graph
⊢ x ∈ a
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Function.lean | SetTheory.mem_dom_of_mem | [64, 1] | [65, 20] | rwa [f.dom_eq] | V : Type u_1
inst✝ : Zermelo V
r x y z a b c : V
f : a ⟶ b
hx : x ∈ a
⊢ x ∈ dom f.graph | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z a b c : V
f : a ⟶ b
hx : x ∈ a
⊢ x ∈ dom f.graph
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Function.lean | SetTheory.mem_apply_iff | [77, 1] | [79, 23] | unfold apply | V : Type u_1
inst✝ : Zermelo V
r x y z a b c f : V
⊢ y ∈ apply f x ↔ ∃ z, opair x z ∈ f ∧ y ∈ z | V : Type u_1
inst✝ : Zermelo V
r x y z a b c f : V
⊢ y ∈ ⋃ image f {x} ↔ ∃ z, opair x z ∈ f ∧ y ∈ z | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z a b c f : V
⊢ y ∈ apply f x ↔ ∃ z, opair x z ∈ f ∧ y ∈ z
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Function.lean | SetTheory.mem_apply_iff | [77, 1] | [79, 23] | simp [mem_image_iff] | V : Type u_1
inst✝ : Zermelo V
r x y z a b c f : V
⊢ y ∈ ⋃ image f {x} ↔ ∃ z, opair x z ∈ f ∧ y ∈ z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z a b c f : V
⊢ y ∈ ⋃ image f {x} ↔ ∃ z, opair x z ∈ f ∧ y ∈ z
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Function.lean | SetTheory.eq_of_opair_mem_graph | [81, 1] | [89, 14] | ext z | V : Type u_1
inst✝ : Zermelo V
r x y z a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
⊢ y = apply f.graph x | case h
V : Type u_1
inst✝ : Zermelo V
r x y z✝ a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
z : V
⊢ z ∈ y ↔ z ∈ apply f.graph x | Please generate a tactic in lean4 to solve the state.
STATE:
V : Type u_1
inst✝ : Zermelo V
r x y z a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
⊢ y = apply f.graph x
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Function.lean | SetTheory.eq_of_opair_mem_graph | [81, 1] | [89, 14] | rw [mem_apply_iff] | case h
V : Type u_1
inst✝ : Zermelo V
r x y z✝ a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
z : V
⊢ z ∈ y ↔ z ∈ apply f.graph x | case h
V : Type u_1
inst✝ : Zermelo V
r x y z✝ a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
z : V
⊢ z ∈ y ↔ ∃ z_1, opair x z_1 ∈ f.graph ∧ z ∈ z_1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
V : Type u_1
inst✝ : Zermelo V
r x y z✝ a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
z : V
⊢ z ∈ y ↔ z ∈ apply f.graph x
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Function.lean | SetTheory.eq_of_opair_mem_graph | [81, 1] | [89, 14] | constructor | case h
V : Type u_1
inst✝ : Zermelo V
r x y z✝ a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
z : V
⊢ z ∈ y ↔ ∃ z_1, opair x z_1 ∈ f.graph ∧ z ∈ z_1 | case h.mp
V : Type u_1
inst✝ : Zermelo V
r x y z✝ a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
z : V
⊢ z ∈ y → ∃ z_1, opair x z_1 ∈ f.graph ∧ z ∈ z_1
case h.mpr
V : Type u_1
inst✝ : Zermelo V
r x y z✝ a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
z : V
⊢ (∃ z_1, opair x z_1 ∈ f.graph ∧ z ∈ z_1) → z ∈ y | Please generate a tactic in lean4 to solve the state.
STATE:
case h
V : Type u_1
inst✝ : Zermelo V
r x y z✝ a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
z : V
⊢ z ∈ y ↔ ∃ z_1, opair x z_1 ∈ f.graph ∧ z ∈ z_1
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Function.lean | SetTheory.eq_of_opair_mem_graph | [81, 1] | [89, 14] | intro h' | case h.mp
V : Type u_1
inst✝ : Zermelo V
r x y z✝ a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
z : V
⊢ z ∈ y → ∃ z_1, opair x z_1 ∈ f.graph ∧ z ∈ z_1 | case h.mp
V : Type u_1
inst✝ : Zermelo V
r x y z✝ a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
z : V
h' : z ∈ y
⊢ ∃ z_1, opair x z_1 ∈ f.graph ∧ z ∈ z_1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp
V : Type u_1
inst✝ : Zermelo V
r x y z✝ a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
z : V
⊢ z ∈ y → ∃ z_1, opair x z_1 ∈ f.graph ∧ z ∈ z_1
TACTIC:
|
https://github.com/zeramorphic/set-theory.git | 37e9d6e920ff687317f50fa33984b273f1637716 | SetTheory/Function.lean | SetTheory.eq_of_opair_mem_graph | [81, 1] | [89, 14] | exact ⟨_, h, h'⟩ | case h.mp
V : Type u_1
inst✝ : Zermelo V
r x y z✝ a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
z : V
h' : z ∈ y
⊢ ∃ z_1, opair x z_1 ∈ f.graph ∧ z ∈ z_1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp
V : Type u_1
inst✝ : Zermelo V
r x y z✝ a b c : V
f : a ⟶ b
h : opair x y ∈ f.graph
z : V
h' : z ∈ y
⊢ ∃ z_1, opair x z_1 ∈ f.graph ∧ z ∈ z_1
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.