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/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_char' | [133, 1] | [141, 18] | contradiction | case c.mk
α : Type u_1
c✝ : α
x : [] = [c✝]
⊢ PEmpty.{u_2} | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case c.mk
α : Type u_1
c✝ : α
x : [] = [c✝]
⊢ PEmpty.{u_2}
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_or | [148, 1] | [153, 6] | intro P Q | α : Type (max u_1 u_2)
⊢ (P Q : dLang α) → ν' (P ⋃ Q) ≡ (ν' P ⊕ ν' Q) | α : Type (max u_1 u_2)
P Q : dLang α
⊢ ν' (P ⋃ Q) ≡ (ν' P ⊕ ν' Q) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type (max u_1 u_2)
⊢ (P Q : dLang α) → ν' (P ⋃ Q) ≡ (ν' P ⊕ ν' Q)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_or | [148, 1] | [153, 6] | constructor | α : Type (max u_1 u_2)
P Q : dLang α
⊢ ν' (P ⋃ Q) ≡ (ν' P ⊕ ν' Q) | case a
α : Type (max u_1 u_2)
P Q : dLang α
⊢ ν' (P ⋃ Q) = (ν' P ⊕ ν' Q) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type (max u_1 u_2)
P Q : dLang α
⊢ ν' (P ⋃ Q) ≡ (ν' P ⊕ ν' Q)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_or | [148, 1] | [153, 6] | rfl | case a
α : Type (max u_1 u_2)
P Q : dLang α
⊢ ν' (P ⋃ Q) = (ν' P ⊕ ν' Q) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type (max u_1 u_2)
P Q : dLang α
⊢ ν' (P ⋃ Q) = (ν' P ⊕ ν' Q)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_and | [157, 1] | [162, 6] | intro P Q | α : Type (max u_1 u_2)
⊢ (P Q : dLang α) → ν' (P ⋂ Q) ≡ (ν' P × ν' Q) | α : Type (max u_1 u_2)
P Q : dLang α
⊢ ν' (P ⋂ Q) ≡ (ν' P × ν' Q) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type (max u_1 u_2)
⊢ (P Q : dLang α) → ν' (P ⋂ Q) ≡ (ν' P × ν' Q)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_and | [157, 1] | [162, 6] | constructor | α : Type (max u_1 u_2)
P Q : dLang α
⊢ ν' (P ⋂ Q) ≡ (ν' P × ν' Q) | case a
α : Type (max u_1 u_2)
P Q : dLang α
⊢ ν' (P ⋂ Q) = (ν' P × ν' Q) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type (max u_1 u_2)
P Q : dLang α
⊢ ν' (P ⋂ Q) ≡ (ν' P × ν' Q)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_and | [157, 1] | [162, 6] | rfl | case a
α : Type (max u_1 u_2)
P Q : dLang α
⊢ ν' (P ⋂ Q) = (ν' P × ν' Q) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type (max u_1 u_2)
P Q : dLang α
⊢ ν' (P ⋂ Q) = (ν' P × ν' Q)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_scalar | [166, 1] | [171, 6] | intro P Q | α : Type
⊢ (s : Type) → (P : dLang α) → ν' (s · P) ≡ (s × ν' P) | α P : Type
Q : dLang α
⊢ ν' (P · Q) ≡ (P × ν' Q) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
⊢ (s : Type) → (P : dLang α) → ν' (s · P) ≡ (s × ν' P)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_scalar | [166, 1] | [171, 6] | constructor | α P : Type
Q : dLang α
⊢ ν' (P · Q) ≡ (P × ν' Q) | case a
α P : Type
Q : dLang α
⊢ ν' (P · Q) = (P × ν' Q) | Please generate a tactic in lean4 to solve the state.
STATE:
α P : Type
Q : dLang α
⊢ ν' (P · Q) ≡ (P × ν' Q)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_scalar | [166, 1] | [171, 6] | rfl | case a
α P : Type
Q : dLang α
⊢ ν' (P · Q) = (P × ν' Q) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α P : Type
Q : dLang α
⊢ ν' (P · Q) = (P × ν' Q)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_concat | [179, 1] | [183, 8] | sorry | α : Type u_1
⊢ (P Q : dLang α) → ν' (P , Q) ≃ ν' Q × ν' P | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ (P Q : dLang α) → ν' (P , Q) ≃ ν' Q × ν' P
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | nullable_star | [213, 1] | [217, 8] | sorry | α : Type u_1
⊢ (P : dLang α) → ν' (P*) ≃ List (ν' P) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ (P : dLang α) → ν' (P*) ≃ List (ν' P)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_emptySet | [221, 1] | [226, 6] | intro a | α : Type u_1
⊢ (a : α) → δ' ∅ a ≡ ∅ | α : Type u_1
a : α
⊢ δ' ∅ a ≡ ∅ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ (a : α) → δ' ∅ a ≡ ∅
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_emptySet | [221, 1] | [226, 6] | constructor | α : Type u_1
a : α
⊢ δ' ∅ a ≡ ∅ | case a
α : Type u_1
a : α
⊢ δ' ∅ a = ∅ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
a : α
⊢ δ' ∅ a ≡ ∅
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_emptySet | [221, 1] | [226, 6] | rfl | case a
α : Type u_1
a : α
⊢ δ' ∅ a = ∅ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type u_1
a : α
⊢ δ' ∅ a = ∅
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_universal | [230, 1] | [235, 6] | intro a | α : Type u_1
⊢ (a : α) → δ' 𝒰 a ≡ 𝒰 | α : Type u_1
a : α
⊢ δ' 𝒰 a ≡ 𝒰 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ (a : α) → δ' 𝒰 a ≡ 𝒰
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_universal | [230, 1] | [235, 6] | constructor | α : Type u_1
a : α
⊢ δ' 𝒰 a ≡ 𝒰 | case a
α : Type u_1
a : α
⊢ δ' 𝒰 a = 𝒰 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
a : α
⊢ δ' 𝒰 a ≡ 𝒰
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_universal | [230, 1] | [235, 6] | rfl | case a
α : Type u_1
a : α
⊢ δ' 𝒰 a = 𝒰 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type u_1
a : α
⊢ δ' 𝒰 a = 𝒰
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_emptyStr | [240, 1] | [244, 8] | sorry | α : Type u_1
⊢ (a : α) → δ' ε a ≡ ∅ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ (a : α) → δ' ε a ≡ ∅
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_char | [253, 1] | [261, 10] | intros a c | α : Type u_1
⊢ (a c : α) → δ' (char c) a ≡ (a ≡ c · ε) | α : Type u_1
a c : α
⊢ δ' (char c) a ≡ (a ≡ c · ε) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ (a c : α) → δ' (char c) a ≡ (a ≡ c · ε)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_char | [253, 1] | [261, 10] | unfold δ' | α : Type u_1
a c : α
⊢ δ' (char c) a ≡ (a ≡ c · ε) | α : Type u_1
a c : α
⊢ (fun w => char c (a :: w)) ≡ (a ≡ c · ε) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
a c : α
⊢ δ' (char c) a ≡ (a ≡ c · ε)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_char | [253, 1] | [261, 10] | unfold char | α : Type u_1
a c : α
⊢ (fun w => char c (a :: w)) ≡ (a ≡ c · ε) | α : Type u_1
a c : α
⊢ (fun w => a :: w ≡ [c]) ≡ (a ≡ c · ε) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
a c : α
⊢ (fun w => char c (a :: w)) ≡ (a ≡ c · ε)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_char | [253, 1] | [261, 10] | unfold emptyStr | α : Type u_1
a c : α
⊢ (fun w => a :: w ≡ [c]) ≡ (a ≡ c · ε) | α : Type u_1
a c : α
⊢ (fun w => a :: w ≡ [c]) ≡ (a ≡ c · fun w => w ≡ []) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
a c : α
⊢ (fun w => a :: w ≡ [c]) ≡ (a ≡ c · ε)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_char | [253, 1] | [261, 10] | unfold scalar | α : Type u_1
a c : α
⊢ (fun w => a :: w ≡ [c]) ≡ (a ≡ c · fun w => w ≡ []) | α : Type u_1
a c : α
⊢ (fun w => a :: w ≡ [c]) ≡ fun w => a ≡ c × (fun w => w ≡ []) w | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
a c : α
⊢ (fun w => a :: w ≡ [c]) ≡ (a ≡ c · fun w => w ≡ [])
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_char | [253, 1] | [261, 10] | sorry | α : Type u_1
a c : α
⊢ (fun w => a :: w ≡ [c]) ≡ fun w => a ≡ c × (fun w => w ≡ []) w | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
a c : α
⊢ (fun w => a :: w ≡ [c]) ≡ fun w => a ≡ c × (fun w => w ≡ []) w
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_or | [265, 1] | [270, 6] | intro a P Q | α : Type u_1
⊢ (a : α) → (P Q : dLang α) → δ' (P ⋃ Q) a ≡ (δ' P a ⋃ δ' Q a) | α : Type u_1
a : α
P Q : dLang α
⊢ δ' (P ⋃ Q) a ≡ (δ' P a ⋃ δ' Q a) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ (a : α) → (P Q : dLang α) → δ' (P ⋃ Q) a ≡ (δ' P a ⋃ δ' Q a)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_or | [265, 1] | [270, 6] | constructor | α : Type u_1
a : α
P Q : dLang α
⊢ δ' (P ⋃ Q) a ≡ (δ' P a ⋃ δ' Q a) | case a
α : Type u_1
a : α
P Q : dLang α
⊢ δ' (P ⋃ Q) a = (δ' P a ⋃ δ' Q a) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
a : α
P Q : dLang α
⊢ δ' (P ⋃ Q) a ≡ (δ' P a ⋃ δ' Q a)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_or | [265, 1] | [270, 6] | rfl | case a
α : Type u_1
a : α
P Q : dLang α
⊢ δ' (P ⋃ Q) a = (δ' P a ⋃ δ' Q a) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type u_1
a : α
P Q : dLang α
⊢ δ' (P ⋃ Q) a = (δ' P a ⋃ δ' Q a)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_and | [274, 1] | [279, 6] | intro a P Q | α : Type u_1
⊢ (a : α) → (P Q : dLang α) → δ' (P ⋂ Q) a ≡ (δ' P a ⋂ δ' Q a) | α : Type u_1
a : α
P Q : dLang α
⊢ δ' (P ⋂ Q) a ≡ (δ' P a ⋂ δ' Q a) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ (a : α) → (P Q : dLang α) → δ' (P ⋂ Q) a ≡ (δ' P a ⋂ δ' Q a)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_and | [274, 1] | [279, 6] | constructor | α : Type u_1
a : α
P Q : dLang α
⊢ δ' (P ⋂ Q) a ≡ (δ' P a ⋂ δ' Q a) | case a
α : Type u_1
a : α
P Q : dLang α
⊢ δ' (P ⋂ Q) a = (δ' P a ⋂ δ' Q a) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
a : α
P Q : dLang α
⊢ δ' (P ⋂ Q) a ≡ (δ' P a ⋂ δ' Q a)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_and | [274, 1] | [279, 6] | rfl | case a
α : Type u_1
a : α
P Q : dLang α
⊢ δ' (P ⋂ Q) a = (δ' P a ⋂ δ' Q a) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type u_1
a : α
P Q : dLang α
⊢ δ' (P ⋂ Q) a = (δ' P a ⋂ δ' Q a)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_scalar | [283, 1] | [288, 6] | intro a s P | α : Type
⊢ (a : α) → (s : Type) → (P : dLang α) → δ (s · P) a ≡ (s · δ' P a) | α : Type
a : α
s : Type
P : dLang α
⊢ δ (s · P) a ≡ (s · δ' P a) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
⊢ (a : α) → (s : Type) → (P : dLang α) → δ (s · P) a ≡ (s · δ' P a)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_scalar | [283, 1] | [288, 6] | constructor | α : Type
a : α
s : Type
P : dLang α
⊢ δ (s · P) a ≡ (s · δ' P a) | case a
α : Type
a : α
s : Type
P : dLang α
⊢ δ (s · P) a = (s · δ' P a) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
a : α
s : Type
P : dLang α
⊢ δ (s · P) a ≡ (s · δ' P a)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_scalar | [283, 1] | [288, 6] | rfl | case a
α : Type
a : α
s : Type
P : dLang α
⊢ δ (s · P) a = (s · δ' P a) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
α : Type
a : α
s : Type
P : dLang α
⊢ δ (s · P) a = (s · δ' P a)
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_concat | [301, 1] | [306, 8] | sorry | α : Type u_1
⊢ (a : α) → (P Q : dLang α) → δ' (P , Q) a ≡ (ν' P · δ' Q a ⋃ (δ' P a , Q)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ (a : α) → (P Q : dLang α) → δ' (P , Q) a ≡ (ν' P · δ' Q a ⋃ (δ' P a , Q))
TACTIC:
|
https://github.com/katydid/proofs.git | 8105af686a3bdf193909567f5165835001240640 | Katydid/Conal/Calculus.lean | derivative_star | [341, 1] | [346, 8] | sorry | α : Type u_1
⊢ (a : α) → (P : dLang α) → δ' (P*) a ≡ (List (ν' P) · δ' P a , P*) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ (a : α) → (P : dLang α) → δ' (P*) a ≡ (List (ν' P) · δ' P a , P*)
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toNat_eq_iff_ofNatAux_eq | [14, 1] | [19, 68] | simp only [toNat, ofNatAux] | c : ASCII.Char
n : Nat
hn : n < 128
⊢ c.toNat = n ↔ ofNatAux n hn = c | c : ASCII.Char
n : Nat
hn : n < 128
⊢ c.toByte.toNat = n ↔ { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
n : Nat
hn : n < 128
⊢ c.toNat = n ↔ ofNatAux n hn = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toNat_eq_iff_ofNatAux_eq | [14, 1] | [19, 68] | constructor | c : ASCII.Char
n : Nat
hn : n < 128
⊢ c.toByte.toNat = n ↔ { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c | case mp
c : ASCII.Char
n : Nat
hn : n < 128
⊢ c.toByte.toNat = n → { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c
case mpr
c : ASCII.Char
n : Nat
hn : n < 128
⊢ { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c → c.toByte.toNat = n | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
n : Nat
hn : n < 128
⊢ c.toByte.toNat = n ↔ { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toNat_eq_iff_ofNatAux_eq | [14, 1] | [19, 68] | intro h | case mp
c : ASCII.Char
n : Nat
hn : n < 128
⊢ c.toByte.toNat = n → { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c | case mp
c : ASCII.Char
n : Nat
hn : n < 128
h : c.toByte.toNat = n
⊢ { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
c : ASCII.Char
n : Nat
hn : n < 128
⊢ c.toByte.toNat = n → { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toNat_eq_iff_ofNatAux_eq | [14, 1] | [19, 68] | cases h | case mp
c : ASCII.Char
n : Nat
hn : n < 128
h : c.toByte.toNat = n
⊢ { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c | case mp.refl
c : ASCII.Char
hn : c.toByte.toNat < 128
⊢ { toByte := { val := ⟨c.toByte.toNat, ⋯⟩ }, valid := hn } = c | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
c : ASCII.Char
n : Nat
hn : n < 128
h : c.toByte.toNat = n
⊢ { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toNat_eq_iff_ofNatAux_eq | [14, 1] | [19, 68] | ext | case mp.refl
c : ASCII.Char
hn : c.toByte.toNat < 128
⊢ { toByte := { val := ⟨c.toByte.toNat, ⋯⟩ }, valid := hn } = c | case mp.refl.a.a
c : ASCII.Char
hn : c.toByte.toNat < 128
⊢ { toByte := { val := ⟨c.toByte.toNat, ⋯⟩ }, valid := hn }.toByte.toNat = c.toByte.toNat | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.refl
c : ASCII.Char
hn : c.toByte.toNat < 128
⊢ { toByte := { val := ⟨c.toByte.toNat, ⋯⟩ }, valid := hn } = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toNat_eq_iff_ofNatAux_eq | [14, 1] | [19, 68] | simp only [dif_pos c.toNat_lt, UInt8.toNat] | case mp.refl.a.a
c : ASCII.Char
hn : c.toByte.toNat < 128
⊢ { toByte := { val := ⟨c.toByte.toNat, ⋯⟩ }, valid := hn }.toByte.toNat = c.toByte.toNat | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.refl.a.a
c : ASCII.Char
hn : c.toByte.toNat < 128
⊢ { toByte := { val := ⟨c.toByte.toNat, ⋯⟩ }, valid := hn }.toByte.toNat = c.toByte.toNat
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toNat_eq_iff_ofNatAux_eq | [14, 1] | [19, 68] | intro h | case mpr
c : ASCII.Char
n : Nat
hn : n < 128
⊢ { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c → c.toByte.toNat = n | case mpr
c : ASCII.Char
n : Nat
hn : n < 128
h : { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c
⊢ c.toByte.toNat = n | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
c : ASCII.Char
n : Nat
hn : n < 128
⊢ { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c → c.toByte.toNat = n
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toNat_eq_iff_ofNatAux_eq | [14, 1] | [19, 68] | cases h | case mpr
c : ASCII.Char
n : Nat
hn : n < 128
h : { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c
⊢ c.toByte.toNat = n | case mpr.refl
n : Nat
hn : n < 128
⊢ { toByte := { val := ⟨n, ⋯⟩ }, valid := hn }.toByte.toNat = n | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
c : ASCII.Char
n : Nat
hn : n < 128
h : { toByte := { val := ⟨n, ⋯⟩ }, valid := hn } = c
⊢ c.toByte.toNat = n
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toNat_eq_iff_ofNatAux_eq | [14, 1] | [19, 68] | simp only [dif_pos hn, ofNatAux, UInt8.toNat] | case mpr.refl
n : Nat
hn : n < 128
⊢ { toByte := { val := ⟨n, ⋯⟩ }, valid := hn }.toByte.toNat = n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.refl
n : Nat
hn : n < 128
⊢ { toByte := { val := ⟨n, ⋯⟩ }, valid := hn }.toByte.toNat = n
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toNat_ofNatAux | [21, 1] | [22, 32] | rw [toNat_eq_iff_ofNatAux_eq] | n : Nat
hn : n < 128
⊢ (ofNatAux n hn).toNat = n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
hn : n < 128
⊢ (ofNatAux n hn).toNat = n
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.ofNatAux_toNat | [24, 1] | [25, 34] | rw [← toNat_eq_iff_ofNatAux_eq] | c : ASCII.Char
⊢ ofNatAux c.toNat ⋯ = c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ ofNatAux c.toNat ⋯ = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toNat_eq_iff_ofNat_eq | [27, 1] | [29, 60] | rw [ofNat, dif_pos hn] | c : ASCII.Char
n : Nat
hn : n < 128
⊢ c.toNat = n ↔ ofNat n = c | c : ASCII.Char
n : Nat
hn : n < 128
⊢ c.toNat = n ↔ ofNatAux n hn = c | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
n : Nat
hn : n < 128
⊢ c.toNat = n ↔ ofNat n = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toNat_eq_iff_ofNat_eq | [27, 1] | [29, 60] | exact toNat_eq_iff_ofNatAux_eq .. | c : ASCII.Char
n : Nat
hn : n < 128
⊢ c.toNat = n ↔ ofNatAux n hn = c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
n : Nat
hn : n < 128
⊢ c.toNat = n ↔ ofNatAux n hn = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toNat_ofNat | [31, 1] | [32, 39] | rw [toNat_eq_iff_ofNat_eq] | n : Nat
hn : n < 128
⊢ (ofNat n).toNat = n | case hn
n : Nat
hn : n < 128
⊢ n < 128 | Please generate a tactic in lean4 to solve the state.
STATE:
n : Nat
hn : n < 128
⊢ (ofNat n).toNat = n
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toNat_ofNat | [31, 1] | [32, 39] | exact hn | case hn
n : Nat
hn : n < 128
⊢ n < 128 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hn
n : Nat
hn : n < 128
⊢ n < 128
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.ofNat_toNat | [34, 1] | [35, 49] | rw [← toNat_eq_iff_ofNat_eq] | c : ASCII.Char
⊢ ofNat c.toNat = c | case hn
c : ASCII.Char
⊢ c.toNat < 128 | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ ofNat c.toNat = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.ofNat_toNat | [34, 1] | [35, 49] | exact c.toNat_lt | case hn
c : ASCII.Char
⊢ c.toNat < 128 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hn
c : ASCII.Char
⊢ c.toNat < 128
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | simp only [Char.toUnicode, ofUnicode] | c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
⊢ ↑c = u ↔ ofUnicode u hu = c | c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
⊢ { val := c.toByte.toUInt32, valid := ⋯ } = u ↔ { toByte := u.val.toUInt8, valid := ⋯ } = c | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
⊢ ↑c = u ↔ ofUnicode u hu = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | constructor | c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
⊢ { val := c.toByte.toUInt32, valid := ⋯ } = u ↔ { toByte := u.val.toUInt8, valid := ⋯ } = c | case mp
c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
⊢ { val := c.toByte.toUInt32, valid := ⋯ } = u → { toByte := u.val.toUInt8, valid := ⋯ } = c
case mpr
c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
⊢ { toByte := u.val.toUInt8, valid := ⋯ } = c → { val := c.toByte.toUInt32, valid := ⋯ } = u | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
⊢ { val := c.toByte.toUInt32, valid := ⋯ } = u ↔ { toByte := u.val.toUInt8, valid := ⋯ } = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | intro h | case mp
c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
⊢ { val := c.toByte.toUInt32, valid := ⋯ } = u → { toByte := u.val.toUInt8, valid := ⋯ } = c | case mp
c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
h : { val := c.toByte.toUInt32, valid := ⋯ } = u
⊢ { toByte := u.val.toUInt8, valid := ⋯ } = c | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
⊢ { val := c.toByte.toUInt32, valid := ⋯ } = u → { toByte := u.val.toUInt8, valid := ⋯ } = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | cases h | case mp
c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
h : { val := c.toByte.toUInt32, valid := ⋯ } = u
⊢ { toByte := u.val.toUInt8, valid := ⋯ } = c | case mp.refl
c : ASCII.Char
hu : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
⊢ { toByte := { val := c.toByte.toUInt32, valid := ⋯ }.val.toUInt8, valid := ⋯ } = c | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
h : { val := c.toByte.toUInt32, valid := ⋯ } = u
⊢ { toByte := u.val.toUInt8, valid := ⋯ } = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | simp [_root_.Char.isASCII, _root_.Char.toNat] at hu | case mp.refl
c : ASCII.Char
hu : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
⊢ { toByte := { val := c.toByte.toUInt32, valid := ⋯ }.val.toUInt8, valid := ⋯ } = c | case mp.refl
c : ASCII.Char
hu✝ : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
hu : c.toByte.toNat < 128
⊢ { toByte := { val := c.toByte.toUInt32, valid := ⋯ }.val.toUInt8, valid := ⋯ } = c | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.refl
c : ASCII.Char
hu : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
⊢ { toByte := { val := c.toByte.toUInt32, valid := ⋯ }.val.toUInt8, valid := ⋯ } = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | have hlt : c.toNat < 256 := by apply Nat.lt_trans hu; decide | case mp.refl
c : ASCII.Char
hu✝ : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
hu : c.toByte.toNat < 128
⊢ { toByte := { val := c.toByte.toUInt32, valid := ⋯ }.val.toUInt8, valid := ⋯ } = c | case mp.refl
c : ASCII.Char
hu✝ : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
hu : c.toByte.toNat < 128
hlt : c.toNat < 256
⊢ { toByte := { val := c.toByte.toUInt32, valid := ⋯ }.val.toUInt8, valid := ⋯ } = c | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.refl
c : ASCII.Char
hu✝ : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
hu : c.toByte.toNat < 128
⊢ { toByte := { val := c.toByte.toUInt32, valid := ⋯ }.val.toUInt8, valid := ⋯ } = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | ext | case mp.refl
c : ASCII.Char
hu✝ : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
hu : c.toByte.toNat < 128
hlt : c.toNat < 256
⊢ { toByte := { val := c.toByte.toUInt32, valid := ⋯ }.val.toUInt8, valid := ⋯ } = c | case mp.refl.a.a
c : ASCII.Char
hu✝ : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
hu : c.toByte.toNat < 128
hlt : c.toNat < 256
⊢ { toByte := { val := c.toByte.toUInt32, valid := ⋯ }.val.toUInt8, valid := ⋯ }.toByte.toNat = c.toByte.toNat | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.refl
c : ASCII.Char
hu✝ : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
hu : c.toByte.toNat < 128
hlt : c.toNat < 256
⊢ { toByte := { val := c.toByte.toUInt32, valid := ⋯ }.val.toUInt8, valid := ⋯ } = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | simp [Nat.mod_eq_of_lt hlt] | case mp.refl.a.a
c : ASCII.Char
hu✝ : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
hu : c.toByte.toNat < 128
hlt : c.toNat < 256
⊢ { toByte := { val := c.toByte.toUInt32, valid := ⋯ }.val.toUInt8, valid := ⋯ }.toByte.toNat = c.toByte.toNat | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.refl.a.a
c : ASCII.Char
hu✝ : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
hu : c.toByte.toNat < 128
hlt : c.toNat < 256
⊢ { toByte := { val := c.toByte.toUInt32, valid := ⋯ }.val.toUInt8, valid := ⋯ }.toByte.toNat = c.toByte.toNat
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | apply Nat.lt_trans hu | c : ASCII.Char
hu✝ : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
hu : c.toByte.toNat < 128
⊢ c.toNat < 256 | c : ASCII.Char
hu✝ : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
hu : c.toByte.toNat < 128
⊢ 128 < 256 | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
hu✝ : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
hu : c.toByte.toNat < 128
⊢ c.toNat < 256
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | decide | c : ASCII.Char
hu✝ : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
hu : c.toByte.toNat < 128
⊢ 128 < 256 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
hu✝ : { val := c.toByte.toUInt32, valid := ⋯ }.isASCII = true
hu : c.toByte.toNat < 128
⊢ 128 < 256
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | intro h | case mpr
c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
⊢ { toByte := u.val.toUInt8, valid := ⋯ } = c → { val := c.toByte.toUInt32, valid := ⋯ } = u | case mpr
c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
h : { toByte := u.val.toUInt8, valid := ⋯ } = c
⊢ { val := c.toByte.toUInt32, valid := ⋯ } = u | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
⊢ { toByte := u.val.toUInt8, valid := ⋯ } = c → { val := c.toByte.toUInt32, valid := ⋯ } = u
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | cases h | case mpr
c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
h : { toByte := u.val.toUInt8, valid := ⋯ } = c
⊢ { val := c.toByte.toUInt32, valid := ⋯ } = u | case mpr.refl
u : Unicode.Char
hu : Char.isASCII u = true
⊢ { val := { toByte := u.val.toUInt8, valid := ⋯ }.toByte.toUInt32, valid := ⋯ } = u | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
c : ASCII.Char
u : Unicode.Char
hu : Char.isASCII u = true
h : { toByte := u.val.toUInt8, valid := ⋯ } = c
⊢ { val := c.toByte.toUInt32, valid := ⋯ } = u
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | simp [_root_.Char.isASCII, _root_.Char.toNat] at hu | case mpr.refl
u : Unicode.Char
hu : Char.isASCII u = true
⊢ { val := { toByte := u.val.toUInt8, valid := ⋯ }.toByte.toUInt32, valid := ⋯ } = u | case mpr.refl
u : Unicode.Char
hu✝ : Char.isASCII u = true
hu : u.val.toNat < 128
⊢ { val := { toByte := u.val.toUInt8, valid := ⋯ }.toByte.toUInt32, valid := ⋯ } = u | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.refl
u : Unicode.Char
hu : Char.isASCII u = true
⊢ { val := { toByte := u.val.toUInt8, valid := ⋯ }.toByte.toUInt32, valid := ⋯ } = u
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | have hlt : u.val.toNat < 256 := by apply Nat.lt_trans hu; decide | case mpr.refl
u : Unicode.Char
hu✝ : Char.isASCII u = true
hu : u.val.toNat < 128
⊢ { val := { toByte := u.val.toUInt8, valid := ⋯ }.toByte.toUInt32, valid := ⋯ } = u | case mpr.refl
u : Unicode.Char
hu✝ : Char.isASCII u = true
hu : u.val.toNat < 128
hlt : u.val.toNat < 256
⊢ { val := { toByte := u.val.toUInt8, valid := ⋯ }.toByte.toUInt32, valid := ⋯ } = u | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.refl
u : Unicode.Char
hu✝ : Char.isASCII u = true
hu : u.val.toNat < 128
⊢ { val := { toByte := u.val.toUInt8, valid := ⋯ }.toByte.toUInt32, valid := ⋯ } = u
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | ext | case mpr.refl
u : Unicode.Char
hu✝ : Char.isASCII u = true
hu : u.val.toNat < 128
hlt : u.val.toNat < 256
⊢ { val := { toByte := u.val.toUInt8, valid := ⋯ }.toByte.toUInt32, valid := ⋯ } = u | case mpr.refl.a.a
u : Unicode.Char
hu✝ : Char.isASCII u = true
hu : u.val.toNat < 128
hlt : u.val.toNat < 256
⊢ { val := { toByte := u.val.toUInt8, valid := ⋯ }.toByte.toUInt32, valid := ⋯ }.val.toNat = u.val.toNat | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.refl
u : Unicode.Char
hu✝ : Char.isASCII u = true
hu : u.val.toNat < 128
hlt : u.val.toNat < 256
⊢ { val := { toByte := u.val.toUInt8, valid := ⋯ }.toByte.toUInt32, valid := ⋯ } = u
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | simp [Nat.mod_eq_of_lt hlt] | case mpr.refl.a.a
u : Unicode.Char
hu✝ : Char.isASCII u = true
hu : u.val.toNat < 128
hlt : u.val.toNat < 256
⊢ { val := { toByte := u.val.toUInt8, valid := ⋯ }.toByte.toUInt32, valid := ⋯ }.val.toNat = u.val.toNat | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.refl.a.a
u : Unicode.Char
hu✝ : Char.isASCII u = true
hu : u.val.toNat < 128
hlt : u.val.toNat < 256
⊢ { val := { toByte := u.val.toUInt8, valid := ⋯ }.toByte.toUInt32, valid := ⋯ }.val.toNat = u.val.toNat
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | apply Nat.lt_trans hu | u : Unicode.Char
hu✝ : Char.isASCII u = true
hu : u.val.toNat < 128
⊢ u.val.toNat < 256 | u : Unicode.Char
hu✝ : Char.isASCII u = true
hu : u.val.toNat < 128
⊢ 128 < 256 | Please generate a tactic in lean4 to solve the state.
STATE:
u : Unicode.Char
hu✝ : Char.isASCII u = true
hu : u.val.toNat < 128
⊢ u.val.toNat < 256
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_eq_iff_ofUnicode_eq | [39, 1] | [50, 37] | decide | u : Unicode.Char
hu✝ : Char.isASCII u = true
hu : u.val.toNat < 128
⊢ 128 < 256 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
u : Unicode.Char
hu✝ : Char.isASCII u = true
hu : u.val.toNat < 128
⊢ 128 < 256
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.toUnicode_ofUnicode | [52, 1] | [54, 37] | rw [toUnicode_eq_iff_ofUnicode_eq] | u : Unicode.Char
hu : Char.isASCII u = true
⊢ ↑(ofUnicode u hu) = u | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
u : Unicode.Char
hu : Char.isASCII u = true
⊢ ↑(ofUnicode u hu) = u
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.ofUnicode_toUnicode | [56, 1] | [58, 39] | rw [← toUnicode_eq_iff_ofUnicode_eq] | c : ASCII.Char
⊢ ofUnicode ↑c ⋯ = c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ ofUnicode ↑c ⋯ = c
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.ofUnicode?_eq_ofUnicode | [60, 1] | [61, 77] | simp [ofUnicode?, dif_pos hu] | u : Unicode.Char
hu : Char.isASCII u = true
⊢ ofUnicode? u = some (ofUnicode u hu) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
u : Unicode.Char
hu : Char.isASCII u = true
⊢ ofUnicode? u = some (ofUnicode u hu)
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.ofUnicode!_eq_ofUnicode | [63, 1] | [64, 70] | simp [ofUnicode!, dif_pos hu] | u : Unicode.Char
hu : Char.isASCII u = true
⊢ ofUnicode! u = ofUnicode u hu | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
u : Unicode.Char
hu : Char.isASCII u = true
⊢ ofUnicode! u = ofUnicode u hu
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.isLower_iff | [68, 1] | [69, 22] | simp [isLower] | c : ASCII.Char
⊢ c.isLower = true ↔ 97 ≤ c.toNat ∧ c.toNat ≤ 122 | c : ASCII.Char
⊢ 97 ≤ c.toByte ∧ c.toByte ≤ 122 ↔ 97 ≤ c.toNat ∧ c.toNat ≤ 122 | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ c.isLower = true ↔ 97 ≤ c.toNat ∧ c.toNat ≤ 122
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.isLower_iff | [68, 1] | [69, 22] | rfl | c : ASCII.Char
⊢ 97 ≤ c.toByte ∧ c.toByte ≤ 122 ↔ 97 ≤ c.toNat ∧ c.toNat ≤ 122 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ 97 ≤ c.toByte ∧ c.toByte ≤ 122 ↔ 97 ≤ c.toNat ∧ c.toNat ≤ 122
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.isUpper_iff | [71, 1] | [72, 22] | simp [isUpper] | c : ASCII.Char
⊢ c.isUpper = true ↔ 65 ≤ c.toNat ∧ c.toNat ≤ 90 | c : ASCII.Char
⊢ 65 ≤ c.toByte ∧ c.toByte ≤ 90 ↔ 65 ≤ c.toNat ∧ c.toNat ≤ 90 | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ c.isUpper = true ↔ 65 ≤ c.toNat ∧ c.toNat ≤ 90
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.isUpper_iff | [71, 1] | [72, 22] | rfl | c : ASCII.Char
⊢ 65 ≤ c.toByte ∧ c.toByte ≤ 90 ↔ 65 ≤ c.toNat ∧ c.toNat ≤ 90 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ 65 ≤ c.toByte ∧ c.toByte ≤ 90 ↔ 65 ≤ c.toNat ∧ c.toNat ≤ 90
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_of_isLower | [74, 1] | [80, 9] | simp only [isLower_iff, isUpper_iff] | c : ASCII.Char
⊢ c.isLower = true → ¬c.isUpper = true | c : ASCII.Char
⊢ 97 ≤ c.toNat ∧ c.toNat ≤ 122 → ¬(65 ≤ c.toNat ∧ c.toNat ≤ 90) | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ c.isLower = true → ¬c.isUpper = true
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_of_isLower | [74, 1] | [80, 9] | intro ⟨hl, _⟩ ⟨_, hu⟩ | c : ASCII.Char
⊢ 97 ≤ c.toNat ∧ c.toNat ≤ 122 → ¬(65 ≤ c.toNat ∧ c.toNat ≤ 90) | c : ASCII.Char
hl : 97 ≤ c.toNat
right✝ : c.toNat ≤ 122
left✝ : 65 ≤ c.toNat
hu : c.toNat ≤ 90
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ 97 ≤ c.toNat ∧ c.toNat ≤ 122 → ¬(65 ≤ c.toNat ∧ c.toNat ≤ 90)
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_of_isLower | [74, 1] | [80, 9] | apply Nat.lt_irrefl c.toNat | c : ASCII.Char
hl : 97 ≤ c.toNat
right✝ : c.toNat ≤ 122
left✝ : 65 ≤ c.toNat
hu : c.toNat ≤ 90
⊢ False | c : ASCII.Char
hl : 97 ≤ c.toNat
right✝ : c.toNat ≤ 122
left✝ : 65 ≤ c.toNat
hu : c.toNat ≤ 90
⊢ c.toNat < c.toNat | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
hl : 97 ≤ c.toNat
right✝ : c.toNat ≤ 122
left✝ : 65 ≤ c.toNat
hu : c.toNat ≤ 90
⊢ False
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_of_isLower | [74, 1] | [80, 9] | apply Nat.lt_of_le_of_lt hu | c : ASCII.Char
hl : 97 ≤ c.toNat
right✝ : c.toNat ≤ 122
left✝ : 65 ≤ c.toNat
hu : c.toNat ≤ 90
⊢ c.toNat < c.toNat | c : ASCII.Char
hl : 97 ≤ c.toNat
right✝ : c.toNat ≤ 122
left✝ : 65 ≤ c.toNat
hu : c.toNat ≤ 90
⊢ 90 < c.toNat | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
hl : 97 ≤ c.toNat
right✝ : c.toNat ≤ 122
left✝ : 65 ≤ c.toNat
hu : c.toNat ≤ 90
⊢ c.toNat < c.toNat
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_of_isLower | [74, 1] | [80, 9] | apply Nat.lt_of_lt_of_le _ hl | c : ASCII.Char
hl : 97 ≤ c.toNat
right✝ : c.toNat ≤ 122
left✝ : 65 ≤ c.toNat
hu : c.toNat ≤ 90
⊢ 90 < c.toNat | c : ASCII.Char
hl : 97 ≤ c.toNat
right✝ : c.toNat ≤ 122
left✝ : 65 ≤ c.toNat
hu : c.toNat ≤ 90
⊢ 90 < 97 | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
hl : 97 ≤ c.toNat
right✝ : c.toNat ≤ 122
left✝ : 65 ≤ c.toNat
hu : c.toNat ≤ 90
⊢ 90 < c.toNat
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_of_isLower | [74, 1] | [80, 9] | decide | c : ASCII.Char
hl : 97 ≤ c.toNat
right✝ : c.toNat ≤ 122
left✝ : 65 ≤ c.toNat
hu : c.toNat ≤ 90
⊢ 90 < 97 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
hl : 97 ≤ c.toNat
right✝ : c.toNat ≤ 122
left✝ : 65 ≤ c.toNat
hu : c.toNat ≤ 90
⊢ 90 < 97
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_toLower | [85, 1] | [95, 15] | simp [-not_and, toLower, isUpper_iff] | c : ASCII.Char
⊢ ¬c.toLower.isUpper = true | c : ASCII.Char
⊢ ¬(65 ≤ (if h : 65 ≤ c.toNat ∧ c.toNat ≤ 90 then ofNatAux (c.toNat + 32) ⋯ else c).toNat ∧
(if h : 65 ≤ c.toNat ∧ c.toNat ≤ 90 then ofNatAux (c.toNat + 32) ⋯ else c).toNat ≤ 90) | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ ¬c.toLower.isUpper = true
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_toLower | [85, 1] | [95, 15] | split | c : ASCII.Char
⊢ ¬(65 ≤ (if h : 65 ≤ c.toNat ∧ c.toNat ≤ 90 then ofNatAux (c.toNat + 32) ⋯ else c).toNat ∧
(if h : 65 ≤ c.toNat ∧ c.toNat ≤ 90 then ofNatAux (c.toNat + 32) ⋯ else c).toNat ≤ 90) | case isTrue
c : ASCII.Char
h✝ : 65 ≤ c.toNat ∧ c.toNat ≤ 90
⊢ ¬(65 ≤ (ofNatAux (c.toNat + 32) ⋯).toNat ∧ (ofNatAux (c.toNat + 32) ⋯).toNat ≤ 90)
case isFalse
c : ASCII.Char
h✝ : ¬(65 ≤ c.toNat ∧ c.toNat ≤ 90)
⊢ ¬(65 ≤ c.toNat ∧ c.toNat ≤ 90) | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ ¬(65 ≤ (if h : 65 ≤ c.toNat ∧ c.toNat ≤ 90 then ofNatAux (c.toNat + 32) ⋯ else c).toNat ∧
(if h : 65 ≤ c.toNat ∧ c.toNat ≤ 90 then ofNatAux (c.toNat + 32) ⋯ else c).toNat ≤ 90)
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_toLower | [85, 1] | [95, 15] | next h =>
simp [-not_and, toNat_ofNatAux]
intro h'
absurd h'.2
apply Nat.not_le_of_gt
apply Nat.lt_of_lt_of_le _ h.1
decide | case isTrue
c : ASCII.Char
h✝ : 65 ≤ c.toNat ∧ c.toNat ≤ 90
⊢ ¬(65 ≤ (ofNatAux (c.toNat + 32) ⋯).toNat ∧ (ofNatAux (c.toNat + 32) ⋯).toNat ≤ 90) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case isTrue
c : ASCII.Char
h✝ : 65 ≤ c.toNat ∧ c.toNat ≤ 90
⊢ ¬(65 ≤ (ofNatAux (c.toNat + 32) ⋯).toNat ∧ (ofNatAux (c.toNat + 32) ⋯).toNat ≤ 90)
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_toLower | [85, 1] | [95, 15] | simp [-not_and, toNat_ofNatAux] | c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
⊢ ¬(65 ≤ (ofNatAux (c.toNat + 32) ⋯).toNat ∧ (ofNatAux (c.toNat + 32) ⋯).toNat ≤ 90) | c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
⊢ ¬(33 ≤ c.toNat ∧ c.toNat ≤ 58) | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
⊢ ¬(65 ≤ (ofNatAux (c.toNat + 32) ⋯).toNat ∧ (ofNatAux (c.toNat + 32) ⋯).toNat ≤ 90)
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_toLower | [85, 1] | [95, 15] | intro h' | c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
⊢ ¬(33 ≤ c.toNat ∧ c.toNat ≤ 58) | c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
h' : 33 ≤ c.toNat ∧ c.toNat ≤ 58
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
⊢ ¬(33 ≤ c.toNat ∧ c.toNat ≤ 58)
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_toLower | [85, 1] | [95, 15] | absurd h'.2 | c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
h' : 33 ≤ c.toNat ∧ c.toNat ≤ 58
⊢ False | c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
h' : 33 ≤ c.toNat ∧ c.toNat ≤ 58
⊢ ¬c.toNat ≤ 58 | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
h' : 33 ≤ c.toNat ∧ c.toNat ≤ 58
⊢ False
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_toLower | [85, 1] | [95, 15] | apply Nat.not_le_of_gt | c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
h' : 33 ≤ c.toNat ∧ c.toNat ≤ 58
⊢ ¬c.toNat ≤ 58 | case h
c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
h' : 33 ≤ c.toNat ∧ c.toNat ≤ 58
⊢ c.toNat > 58 | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
h' : 33 ≤ c.toNat ∧ c.toNat ≤ 58
⊢ ¬c.toNat ≤ 58
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_toLower | [85, 1] | [95, 15] | apply Nat.lt_of_lt_of_le _ h.1 | case h
c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
h' : 33 ≤ c.toNat ∧ c.toNat ≤ 58
⊢ c.toNat > 58 | c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
h' : 33 ≤ c.toNat ∧ c.toNat ≤ 58
⊢ 58 < 65 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
h' : 33 ≤ c.toNat ∧ c.toNat ≤ 58
⊢ c.toNat > 58
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_toLower | [85, 1] | [95, 15] | decide | c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
h' : 33 ≤ c.toNat ∧ c.toNat ≤ 58
⊢ 58 < 65 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : 65 ≤ c.toNat ∧ c.toNat ≤ 90
h' : 33 ≤ c.toNat ∧ c.toNat ≤ 58
⊢ 58 < 65
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isUpper_toLower | [85, 1] | [95, 15] | assumption | case isFalse
c : ASCII.Char
h✝ : ¬(65 ≤ c.toNat ∧ c.toNat ≤ 90)
⊢ ¬(65 ≤ c.toNat ∧ c.toNat ≤ 90) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case isFalse
c : ASCII.Char
h✝ : ¬(65 ≤ c.toNat ∧ c.toNat ≤ 90)
⊢ ¬(65 ≤ c.toNat ∧ c.toNat ≤ 90)
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isLower_toUpper | [97, 1] | [107, 15] | simp [-not_and, toUpper, isLower_iff] | c : ASCII.Char
⊢ ¬c.toUpper.isLower = true | c : ASCII.Char
⊢ ¬(97 ≤ (if h : 97 ≤ c.toNat ∧ c.toNat ≤ 122 then ofNatAux (c.toNat - 32) ⋯ else c).toNat ∧
(if h : 97 ≤ c.toNat ∧ c.toNat ≤ 122 then ofNatAux (c.toNat - 32) ⋯ else c).toNat ≤ 122) | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ ¬c.toUpper.isLower = true
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isLower_toUpper | [97, 1] | [107, 15] | split | c : ASCII.Char
⊢ ¬(97 ≤ (if h : 97 ≤ c.toNat ∧ c.toNat ≤ 122 then ofNatAux (c.toNat - 32) ⋯ else c).toNat ∧
(if h : 97 ≤ c.toNat ∧ c.toNat ≤ 122 then ofNatAux (c.toNat - 32) ⋯ else c).toNat ≤ 122) | case isTrue
c : ASCII.Char
h✝ : 97 ≤ c.toNat ∧ c.toNat ≤ 122
⊢ ¬(97 ≤ (ofNatAux (c.toNat - 32) ⋯).toNat ∧ (ofNatAux (c.toNat - 32) ⋯).toNat ≤ 122)
case isFalse
c : ASCII.Char
h✝ : ¬(97 ≤ c.toNat ∧ c.toNat ≤ 122)
⊢ ¬(97 ≤ c.toNat ∧ c.toNat ≤ 122) | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
⊢ ¬(97 ≤ (if h : 97 ≤ c.toNat ∧ c.toNat ≤ 122 then ofNatAux (c.toNat - 32) ⋯ else c).toNat ∧
(if h : 97 ≤ c.toNat ∧ c.toNat ≤ 122 then ofNatAux (c.toNat - 32) ⋯ else c).toNat ≤ 122)
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isLower_toUpper | [97, 1] | [107, 15] | next h =>
simp [-not_and, toNat_ofNatAux]
intro h'
absurd h'.1
apply Nat.not_le_of_gt
apply Nat.lt_of_le_of_lt (Nat.sub_le_sub_right h.2 32)
decide | case isTrue
c : ASCII.Char
h✝ : 97 ≤ c.toNat ∧ c.toNat ≤ 122
⊢ ¬(97 ≤ (ofNatAux (c.toNat - 32) ⋯).toNat ∧ (ofNatAux (c.toNat - 32) ⋯).toNat ≤ 122) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case isTrue
c : ASCII.Char
h✝ : 97 ≤ c.toNat ∧ c.toNat ≤ 122
⊢ ¬(97 ≤ (ofNatAux (c.toNat - 32) ⋯).toNat ∧ (ofNatAux (c.toNat - 32) ⋯).toNat ≤ 122)
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isLower_toUpper | [97, 1] | [107, 15] | simp [-not_and, toNat_ofNatAux] | c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
⊢ ¬(97 ≤ (ofNatAux (c.toNat - 32) ⋯).toNat ∧ (ofNatAux (c.toNat - 32) ⋯).toNat ≤ 122) | c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
⊢ ¬(97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122) | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
⊢ ¬(97 ≤ (ofNatAux (c.toNat - 32) ⋯).toNat ∧ (ofNatAux (c.toNat - 32) ⋯).toNat ≤ 122)
TACTIC:
|
https://github.com/fgdorais/lean4-ascii.git | c01f0c30c6c0bca60d2f2216a70f500de38d75f2 | ASCII/Lemmas.lean | ASCII.Char.not_isLower_toUpper | [97, 1] | [107, 15] | intro h' | c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
⊢ ¬(97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122) | c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
h' : 97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
c : ASCII.Char
h : 97 ≤ c.toNat ∧ c.toNat ≤ 122
⊢ ¬(97 ≤ c.toNat - 32 ∧ c.toNat - 32 ≤ 122)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.