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/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.eval_seek_eq_zero
|
[525, 1]
|
[533, 41]
|
refine lt_of_lt_of_le ?_ (hs.1 _ _)
|
case inr.a
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddZeroClass α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : StreamOrder ι
j : ι
h₁ : (j, false) < i
h₂✝ : i ≤ toOrder s q
h₂ : i < toOrder s q
⊢ ↑j < index' s (s.seek q i)
|
case inr.a
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddZeroClass α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : StreamOrder ι
j : ι
h₁ : (j, false) < i
h₂✝ : i ≤ toOrder s q
h₂ : i < toOrder s q
⊢ ↑j < index' s ↑q
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inr.a
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddZeroClass α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : StreamOrder ι
j : ι
h₁ : (j, false) < i
h₂✝ : i ≤ toOrder s q
h₂ : i < toOrder s q
⊢ ↑j < index' s (s.seek q i)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.eval_seek_eq_zero
|
[525, 1]
|
[533, 41]
|
simpa using fst_lt_of_lt_of_lt h₁ h₂
|
case inr.a
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddZeroClass α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : StreamOrder ι
j : ι
h₁ : (j, false) < i
h₂✝ : i ≤ toOrder s q
h₂ : i < toOrder s q
⊢ ↑j < index' s ↑q
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inr.a
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddZeroClass α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : StreamOrder ι
j : ι
h₁ : (j, false) < i
h₂✝ : i ≤ toOrder s q
h₂ : i < toOrder s q
⊢ ↑j < index' s ↑q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter
|
[539, 1]
|
[551, 47]
|
rw [s.eval_valid, Finsupp.filter_add]
|
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ eval₀ s q = Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s ↑q)
|
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ eval₀ s q =
Finsupp.filter (fun i => (i, false) < toOrder s q) (eval₀ s q) +
Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s (advance s ↑q))
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ eval₀ s q = Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s ↑q)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter
|
[539, 1]
|
[551, 47]
|
convert (add_zero (M := ι →₀ α) _).symm
|
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ eval₀ s q =
Finsupp.filter (fun i => (i, false) < toOrder s q) (eval₀ s q) +
Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s (advance s ↑q))
|
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ Finsupp.filter (fun i => (i, false) < toOrder s q) (eval₀ s q) = eval₀ s q
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s (advance s ↑q)) = 0
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ eval₀ s q =
Finsupp.filter (fun i => (i, false) < toOrder s q) (eval₀ s q) +
Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s (advance s ↑q))
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter
|
[539, 1]
|
[551, 47]
|
rw [Finsupp.filter_eq_self_iff]
|
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ Finsupp.filter (fun i => (i, false) < toOrder s q) (eval₀ s q) = eval₀ s q
|
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ ∀ (x : ι), (eval₀ s q) x ≠ 0 → (x, false) < toOrder s q
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ Finsupp.filter (fun i => (i, false) < toOrder s q) (eval₀ s q) = eval₀ s q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter
|
[539, 1]
|
[551, 47]
|
intro i hi
|
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ ∀ (x : ι), (eval₀ s q) x ≠ 0 → (x, false) < toOrder s q
|
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (eval₀ s q) i ≠ 0
⊢ (i, false) < toOrder s q
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ ∀ (x : ι), (eval₀ s q) x ≠ 0 → (x, false) < toOrder s q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter
|
[539, 1]
|
[551, 47]
|
rw [s.eval₀_support' q hi]
|
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (eval₀ s q) i ≠ 0
⊢ (i, false) < toOrder s q
|
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (eval₀ s q) i ≠ 0
⊢ (i, false) < (i, true)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (eval₀ s q) i ≠ 0
⊢ (i, false) < toOrder s q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter
|
[539, 1]
|
[551, 47]
|
simp
|
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (eval₀ s q) i ≠ 0
⊢ (i, false) < (i, true)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (eval₀ s q) i ≠ 0
⊢ (i, false) < (i, true)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter
|
[539, 1]
|
[551, 47]
|
rw [Finsupp.filter_eq_zero_iff]
|
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s (advance s ↑q)) = 0
|
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ ∀ (x : ι), (x, false) < toOrder s q → (eval s (advance s ↑q)) x = 0
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s (advance s ↑q)) = 0
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter
|
[539, 1]
|
[551, 47]
|
intro i hi
|
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ ∀ (x : ι), (x, false) < toOrder s q → (eval s (advance s ↑q)) x = 0
|
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (i, false) < toOrder s q
⊢ (eval s (advance s ↑q)) i = 0
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ ∀ (x : ι), (x, false) < toOrder s q → (eval s (advance s ↑q)) x = 0
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter
|
[539, 1]
|
[551, 47]
|
rw [Stream.advance_val]
|
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (i, false) < toOrder s q
⊢ (eval s (advance s ↑q)) i = 0
|
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (i, false) < toOrder s q
⊢ (eval s (s.seek q (toOrder s q))) i = 0
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (i, false) < toOrder s q
⊢ (eval s (advance s ↑q)) i = 0
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter
|
[539, 1]
|
[551, 47]
|
exact hs.eq_zero_of_lt_index q rfl.le i hi
|
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (i, false) < toOrder s q
⊢ (eval s (s.seek q (toOrder s q))) i = 0
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (i, false) < toOrder s q
⊢ (eval s (s.seek q (toOrder s q))) i = 0
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.evalOption_zero
|
[556, 1]
|
[557, 27]
|
simp [Stream.evalOption]
|
ι : Type
inst✝ : LinearOrder ι
α : Type u_1
q : 0.σ
i : ι
⊢ evalOption 0 q i = none
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝ : LinearOrder ι
α : Type u_1
q : 0.σ
i : ι
⊢ evalOption 0 q i = none
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.evalOption_invalid
|
[559, 1]
|
[561, 30]
|
simp [Stream.evalOption, h]
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
q : s.σ
i : ι
h : ¬s.valid q = true
⊢ evalOption s q i = none
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
q : s.σ
i : ι
h : ¬s.valid q = true
⊢ evalOption s q i = none
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_advance_of_ready
|
[563, 1]
|
[568, 24]
|
apply h.1.eq_empty_of_lt_index
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ (evalMultiset s (advance s ↑q)) (s.index q) = 0
|
case a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ ↑(s.index q) < index' s (advance s ↑q)
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ (evalMultiset s (advance s ↑q)) (s.index q) = 0
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_advance_of_ready
|
[563, 1]
|
[568, 24]
|
rw [advance_val]
|
case a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ ↑(s.index q) < index' s (advance s ↑q)
|
case a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ ↑(s.index q) < index' s (s.seek q (toOrder s q))
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ ↑(s.index q) < index' s (advance s ↑q)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_advance_of_ready
|
[563, 1]
|
[568, 24]
|
exact h.lt' rfl.le hr
|
case a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ ↑(s.index q) < index' s (s.seek q (toOrder s q))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ ↑(s.index q) < index' s (s.seek q (toOrder s q))
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_ready
|
[570, 1]
|
[573, 62]
|
simp [h.evalMultiset_advance_of_ready hr, hr, -advance_val]
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ (evalMultiset s ↑q) (s.index q) = {s.value { val := q, property := hr }}
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ (evalMultiset s ↑q) (s.index q) = {s.value { val := q, property := hr }}
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le
|
[575, 1]
|
[586, 31]
|
apply s.wf.induction q
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : s.σ
i : ι
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : s.σ
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ), WfRel s y x → Multiset.card ((evalMultiset s y) i) ≤ 1) → Multiset.card ((evalMultiset s x) i) ≤ 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : s.σ
i : ι
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le
|
[575, 1]
|
[586, 31]
|
clear q
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : s.σ
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ), WfRel s y x → Multiset.card ((evalMultiset s y) i) ≤ 1) → Multiset.card ((evalMultiset s x) i) ≤ 1
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ), WfRel s y x → Multiset.card ((evalMultiset s y) i) ≤ 1) → Multiset.card ((evalMultiset s x) i) ≤ 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : s.σ
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ), WfRel s y x → Multiset.card ((evalMultiset s y) i) ≤ 1) → Multiset.card ((evalMultiset s x) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le
|
[575, 1]
|
[586, 31]
|
intro q ih
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ), WfRel s y x → Multiset.card ((evalMultiset s y) i) ≤ 1) → Multiset.card ((evalMultiset s x) i) ≤ 1
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ), WfRel s y x → Multiset.card ((evalMultiset s y) i) ≤ 1) → Multiset.card ((evalMultiset s x) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le
|
[575, 1]
|
[586, 31]
|
by_cases hq : s.valid q
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
|
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : ¬s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le
|
[575, 1]
|
[586, 31]
|
swap
|
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : ¬s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
|
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : ¬s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : ¬s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le
|
[575, 1]
|
[586, 31]
|
simp [hq]
|
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : ¬s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : ¬s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le
|
[575, 1]
|
[586, 31]
|
by_cases hr : s.ready ⟨q, hq⟩ ∧ s.index ⟨q, hq⟩ = i
|
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
|
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le
|
[575, 1]
|
[586, 31]
|
rw [← hr.2, h.evalMultiset_ready hr.1, Multiset.card_singleton]
|
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le
|
[575, 1]
|
[586, 31]
|
rw [Stream.evalMultiset_not_ready (q := ⟨q, hq⟩)]
|
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
|
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ Multiset.card ((evalMultiset s (advance s ↑{ val := q, property := hq })) i) ≤ 1
case neg.hr
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ ¬s.ready { val := q, property := hq } = true ∨ s.index { val := q, property := hq } ≠ i
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le
|
[575, 1]
|
[586, 31]
|
apply ih
|
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ Multiset.card ((evalMultiset s (advance s ↑{ val := q, property := hq })) i) ≤ 1
|
case neg.a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ WfRel s (advance s ↑{ val := q, property := hq }) q
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ Multiset.card ((evalMultiset s (advance s ↑{ val := q, property := hq })) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le
|
[575, 1]
|
[586, 31]
|
exact s.next_wf ⟨q, hq⟩
|
case neg.a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ WfRel s (advance s ↑{ val := q, property := hq }) q
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ WfRel s (advance s ↑{ val := q, property := hq }) q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le
|
[575, 1]
|
[586, 31]
|
exact not_and_or.mp hr
|
case neg.hr
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ ¬s.ready { val := q, property := hq } = true ∨ s.index { val := q, property := hq } ≠ i
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.hr
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ ¬s.ready { val := q, property := hq } = true ∨ s.index { val := q, property := hq } ≠ i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalOption_ready
|
[588, 1]
|
[591, 45]
|
simp [evalOption, h.evalMultiset_ready hr]
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ evalOption s (↑q) (s.index q) = some (s.value { val := q, property := hr })
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ evalOption s (↑q) (s.index q) = some (s.value { val := q, property := hr })
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.evalOption_not_ready
|
[593, 1]
|
[597, 39]
|
simp only [Stream.evalOption]
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
q : { q // s.valid q = true }
i : ι
hr : ¬s.ready q = true ∨ s.index q ≠ i
⊢ evalOption s (↑q) i = evalOption s (advance s ↑q) i
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
q : { q // s.valid q = true }
i : ι
hr : ¬s.ready q = true ∨ s.index q ≠ i
⊢ Multiset.get ((evalMultiset s ↑q) i) = Multiset.get ((evalMultiset s (advance s ↑q)) i)
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
q : { q // s.valid q = true }
i : ι
hr : ¬s.ready q = true ∨ s.index q ≠ i
⊢ evalOption s (↑q) i = evalOption s (advance s ↑q) i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.evalOption_not_ready
|
[593, 1]
|
[597, 39]
|
rw [s.evalMultiset_not_ready q i hr]
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
q : { q // s.valid q = true }
i : ι
hr : ¬s.ready q = true ∨ s.index q ≠ i
⊢ Multiset.get ((evalMultiset s ↑q) i) = Multiset.get ((evalMultiset s (advance s ↑q)) i)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
q : { q // s.valid q = true }
i : ι
hr : ¬s.ready q = true ∨ s.index q ≠ i
⊢ Multiset.get ((evalMultiset s ↑q) i) = Multiset.get ((evalMultiset s (advance s ↑q)) i)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalOption_eq_iff
|
[599, 1]
|
[609, 27]
|
rw [Multiset.card_eq_zero] at H
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 0 ≤ 1
H : Multiset.card ((evalMultiset s q) i) = 0
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 0 ≤ 1
H : (evalMultiset s q) i = 0
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 0 ≤ 1
H : Multiset.card ((evalMultiset s q) i) = 0
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalOption_eq_iff
|
[599, 1]
|
[609, 27]
|
simp [H, evalOption]
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 0 ≤ 1
H : (evalMultiset s q) i = 0
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 0 ≤ 1
H : (evalMultiset s q) i = 0
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalOption_eq_iff
|
[599, 1]
|
[609, 27]
|
rw [Multiset.card_eq_one] at H
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
H : Multiset.card ((evalMultiset s q) i) = 1
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
H : ∃ a, (evalMultiset s q) i = {a}
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
H : Multiset.card ((evalMultiset s q) i) = 1
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalOption_eq_iff
|
[599, 1]
|
[609, 27]
|
rcases H with ⟨a', ha'⟩
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
H : ∃ a, (evalMultiset s q) i = {a}
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
|
case intro
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
a' : α
ha' : (evalMultiset s q) i = {a'}
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
H : ∃ a, (evalMultiset s q) i = {a}
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalOption_eq_iff
|
[599, 1]
|
[609, 27]
|
simp [evalOption, ha']
|
case intro
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
a' : α
ha' : (evalMultiset s q) i = {a'}
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case intro
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
a' : α
ha' : (evalMultiset s q) i = {a'}
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.IsStrictMono.evalMultiset_eq_evalOption
|
[611, 1]
|
[614, 87]
|
cases h : s.evalOption q i <;>
simpa [(hs.evalOption_eq_iff (q := q)).1, (hs.evalOption_eq_iff (q := q)).2] using h
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
⊢ (evalMultiset s q) i = Option.getD (Option.map (fun x => {x}) (evalOption s q i)) 0
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
⊢ (evalMultiset s q) i = Option.getD (Option.map (fun x => {x}) (evalOption s q i)) 0
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.seek_spec
|
[646, 1]
|
[651, 31]
|
rw [Finsupp.filter_ext_iff]
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
⊢ Finsupp.filter (fun j => i ≤ (j, false)) (evalMultiset s (s.seek q i)) =
Finsupp.filter (fun j => i ≤ (j, false)) (evalMultiset s ↑q)
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
⊢ ∀ (a : ι), i ≤ (a, false) → (evalMultiset s (s.seek q i)) a = (evalMultiset s ↑q) a
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
⊢ Finsupp.filter (fun j => i ≤ (j, false)) (evalMultiset s (s.seek q i)) =
Finsupp.filter (fun j => i ≤ (j, false)) (evalMultiset s ↑q)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.seek_spec
|
[646, 1]
|
[651, 31]
|
exact IsLawful.seek_spec q i
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
⊢ ∀ (a : ι), i ≤ (a, false) → (evalMultiset s (s.seek q i)) a = (evalMultiset s ↑q) a
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
⊢ ∀ (a : ι), i ≤ (a, false) → (evalMultiset s (s.seek q i)) a = (evalMultiset s ↑q) a
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.seek_lt_toOrder
|
[653, 1]
|
[662, 64]
|
ext j
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
⊢ evalMultiset s (s.seek q i) = evalMultiset s ↑q
|
case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
⊢ evalMultiset s (s.seek q i) = evalMultiset s ↑q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.seek_lt_toOrder
|
[653, 1]
|
[662, 64]
|
by_cases H : s.toOrder q ≤ (j, true)
|
case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
|
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : toOrder s q ≤ (j, true)
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.seek_lt_toOrder
|
[653, 1]
|
[662, 64]
|
have : ↑j < s.index' q := by
simpa using fst_lt_of_lt_of_lt (show (j, false) <ₗ (j, true) by simp) (not_le.mp H)
|
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
|
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
this : ↑j < index' s ↑q
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.seek_lt_toOrder
|
[653, 1]
|
[662, 64]
|
rw [s.mono.eq_empty_of_lt_index j this,
s.mono.eq_empty_of_lt_index _ (this.trans_le (s.mono q i))]
|
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
this : ↑j < index' s ↑q
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
this : ↑j < index' s ↑q
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.seek_lt_toOrder
|
[653, 1]
|
[662, 64]
|
rw [IsLawful.seek_spec q]
|
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : toOrder s q ≤ (j, true)
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
|
case pos.a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : toOrder s q ≤ (j, true)
⊢ i ≤ (j, false)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : toOrder s q ≤ (j, true)
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.seek_lt_toOrder
|
[653, 1]
|
[662, 64]
|
simpa [Prod.Lex.lt_iff'', Prod.Lex.le_iff''] using lt_of_lt_of_le hi H
|
case pos.a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : toOrder s q ≤ (j, true)
⊢ i ≤ (j, false)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos.a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : toOrder s q ≤ (j, true)
⊢ i ≤ (j, false)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.seek_lt_toOrder
|
[653, 1]
|
[662, 64]
|
simpa using fst_lt_of_lt_of_lt (show (j, false) <ₗ (j, true) by simp) (not_le.mp H)
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
⊢ ↑j < index' s ↑q
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
⊢ ↑j < index' s ↑q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.seek_lt_toOrder
|
[653, 1]
|
[662, 64]
|
simp
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
⊢ (j, false) < (j, true)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
⊢ (j, false) < (j, true)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.eval_seek_eq_of_false
|
[664, 1]
|
[670, 70]
|
by_cases hr : s.ready q
|
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
|
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.eval_seek_eq_of_false
|
[664, 1]
|
[670, 70]
|
. ext i
simp [s.evalMultiset_not_ready q i (.inl hr), Stream.toOrder, hr]
|
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.eval_seek_eq_of_false
|
[664, 1]
|
[670, 70]
|
apply Stream.seek_lt_toOrder
|
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
|
case pos.hi
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ (s.index q, false) < toOrder s q
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.eval_seek_eq_of_false
|
[664, 1]
|
[670, 70]
|
simp [Stream.toOrder, hr]
|
case pos.hi
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ (s.index q, false) < toOrder s q
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hi
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ (s.index q, false) < toOrder s q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.eval_seek_eq_of_false
|
[664, 1]
|
[670, 70]
|
ext i
|
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
|
case neg.h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
i : ι
⊢ (evalMultiset s (s.seek q (s.index q, false))) i = (evalMultiset s ↑q) i
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/StreamProof.lean
|
Etch.Verification.Stream.eval_seek_eq_of_false
|
[664, 1]
|
[670, 70]
|
simp [s.evalMultiset_not_ready q i (.inl hr), Stream.toOrder, hr]
|
case neg.h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
i : ι
⊢ (evalMultiset s (s.seek q (s.index q, false))) i = (evalMultiset s ↑q) i
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
i : ι
⊢ (evalMultiset s (s.seek q (s.index q, false))) i = (evalMultiset s ↑q) i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Multiply.lean
|
Etch.Verification.Stream.bothand_spec
|
[10, 9]
|
[10, 73]
|
decide
|
⊢ ∀ (x y : Bool), bothand x y = (x && y)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
⊢ ∀ (x y : Bool), bothand x y = (x && y)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulModifiable.get_update'
|
[61, 1]
|
[65, 50]
|
split_ifs with h
|
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
⊢ Readable.get (Modifiable.update m₀ x v) t = if x = t then v (Readable.get m₀ t) else Readable.get m₀ t
|
case pos
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
h : x = t
⊢ Readable.get (Modifiable.update m₀ x v) t = v (Readable.get m₀ t)
case neg
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
h : ¬x = t
⊢ Readable.get (Modifiable.update m₀ x v) t = Readable.get m₀ t
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
⊢ Readable.get (Modifiable.update m₀ x v) t = if x = t then v (Readable.get m₀ t) else Readable.get m₀ t
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulModifiable.get_update'
|
[61, 1]
|
[65, 50]
|
rw [← h, LawfulModifiable.get_update]
|
case pos
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
h : x = t
⊢ Readable.get (Modifiable.update m₀ x v) t = v (Readable.get m₀ t)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
h : x = t
⊢ Readable.get (Modifiable.update m₀ x v) t = v (Readable.get m₀ t)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulModifiable.get_update'
|
[61, 1]
|
[65, 50]
|
rw [LawfulModifiable.get_update_ne _ _ _ _ h]
|
case neg
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
h : ¬x = t
⊢ Readable.get (Modifiable.update m₀ x v) t = Readable.get m₀ t
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
h : ¬x = t
⊢ Readable.get (Modifiable.update m₀ x v) t = Readable.get m₀ t
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
apply s.wf.induction q
|
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
q : s.σ
i : ι
⊢ ∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
|
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
q : s.σ
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ),
WfRel s y x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) x b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) x) i
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
q : s.σ
i : ι
⊢ ∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
clear q
|
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
q : s.σ
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ),
WfRel s y x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) x b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) x) i
|
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ),
WfRel s y x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) x b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) x) i
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
q : s.σ
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ),
WfRel s y x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) x b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) x) i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
intro q ih b
|
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ),
WfRel s y x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) x b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) x) i
|
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ),
WfRel s y x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) x b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) x) i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
by_cases hv : s.valid q
|
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : s.valid q = true
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
revert ih
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : s.valid q = true
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
b : m
hv : s.valid q = true
⊢ (∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : s.valid q = true
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
refine Subtype.with_prop (fun t => s.valid t) q hv ?_
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
b : m
hv : s.valid q = true
⊢ (∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
b : m
hv : s.valid q = true
⊢ ∀ (x : { t // s.valid t = true }),
(∀ (y : s.σ),
WfRel s y ↑x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑x) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑x) i
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
b : m
hv : s.valid q = true
⊢ (∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
clear q hv
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
b : m
hv : s.valid q = true
⊢ ∀ (x : { t // s.valid t = true }),
(∀ (y : s.σ),
WfRel s y ↑x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑x) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑x) i
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
⊢ ∀ (x : { t // s.valid t = true }),
(∀ (y : s.σ),
WfRel s y ↑x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑x) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑x) i
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
b : m
hv : s.valid q = true
⊢ ∀ (x : { t // s.valid t = true }),
(∀ (y : s.σ),
WfRel s y ↑x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑x) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑x) i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
intro q ih
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
⊢ ∀ (x : { t // s.valid t = true }),
(∀ (y : s.σ),
WfRel s y ↑x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑x) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑x) i
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑q) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑q) i
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
⊢ ∀ (x : { t // s.valid t = true }),
(∀ (y : s.σ),
WfRel s y ↑x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑x) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑x) i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
rw [Stream.fold_wf_spec, Stream.eval_valid, Stream.eval₀]
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑q) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑q) i
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (advance (map OfStream.eval s) ↑q)
(if hr : (map OfStream.eval s).ready q = true then
Modifiable.update b ((map OfStream.eval s).index q)
((map OfStream.eval s).value { val := q, property := hr })
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : (map (⇑evalFinsupp) s).ready q = true then
fun₀ | (map (⇑evalFinsupp) s).index q => (map (⇑evalFinsupp) s).value { val := q, property := h₂ }
else 0) +
eval (map (⇑evalFinsupp) s) (advance (map (⇑evalFinsupp) s) ↑q))
i
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑q) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑q) i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
dsimp only [map_σ, map_valid, map_ready, map_index, map_value, Finsupp.coe_add, Pi.add_apply]
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (advance (map OfStream.eval s) ↑q)
(if hr : (map OfStream.eval s).ready q = true then
Modifiable.update b ((map OfStream.eval s).index q)
((map OfStream.eval s).value { val := q, property := hr })
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : (map (⇑evalFinsupp) s).ready q = true then
fun₀ | (map (⇑evalFinsupp) s).index q => (map (⇑evalFinsupp) s).value { val := q, property := h₂ }
else 0) +
eval (map (⇑evalFinsupp) s) (advance (map (⇑evalFinsupp) s) ↑q))
i
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (advance (map OfStream.eval s) ↑q)
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (advance (map (⇑evalFinsupp) s) ↑q)) i)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (advance (map OfStream.eval s) ↑q)
(if hr : (map OfStream.eval s).ready q = true then
Modifiable.update b ((map OfStream.eval s).index q)
((map OfStream.eval s).value { val := q, property := hr })
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : (map (⇑evalFinsupp) s).ready q = true then
fun₀ | (map (⇑evalFinsupp) s).index q => (map (⇑evalFinsupp) s).value { val := q, property := h₂ }
else 0) +
eval (map (⇑evalFinsupp) s) (advance (map (⇑evalFinsupp) s) ↑q))
i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
simp only [advance_val, map_seek, map_toOrder]
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (advance (map OfStream.eval s) ↑q)
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (advance (map (⇑evalFinsupp) s) ↑q)) i)
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (s.seek q (toOrder s q))
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (advance (map OfStream.eval s) ↑q)
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (advance (map (⇑evalFinsupp) s) ↑q)) i)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
rw [ih]
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (s.seek q (toOrder s q))
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b)
i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
case pos.a
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ WfRel s (s.seek q (toOrder s q)) ↑q
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (s.seek q (toOrder s q))
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
split_ifs with hr
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b)
i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
case pos.a
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ WfRel s (s.seek q (toOrder s q)) ↑q
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
⊢ evalFinsupp
(Readable.get (Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))) i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((fun₀ | s.index q => evalFinsupp (s.value { val := q, property := hr })) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : ¬s.ready q = true
⊢ evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + (0 i + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
case pos.a
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ WfRel s (s.seek q (toOrder s q)) ↑q
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b)
i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
case pos.a
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ WfRel s (s.seek q (toOrder s q)) ↑q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
rw [Finsupp.single_apply, LawfulModifiable.get_update']
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
⊢ evalFinsupp
(Readable.get (Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))) i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((fun₀ | s.index q => evalFinsupp (s.value { val := q, property := hr })) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
⊢ evalFinsupp
(if s.index q = i then OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)
else Readable.get b i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((if s.index q = i then evalFinsupp (s.value { val := q, property := hr }) else 0) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
⊢ evalFinsupp
(Readable.get (Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))) i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((fun₀ | s.index q => evalFinsupp (s.value { val := q, property := hr })) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
split_ifs with heq
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
⊢ evalFinsupp
(if s.index q = i then OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)
else Readable.get b i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((if s.index q = i then evalFinsupp (s.value { val := q, property := hr }) else 0) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : s.index q = i
⊢ evalFinsupp (OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
(evalFinsupp (s.value { val := q, property := hr }) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : ¬s.index q = i
⊢ evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + (0 + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
⊢ evalFinsupp
(if s.index q = i then OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)
else Readable.get b i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((if s.index q = i then evalFinsupp (s.value { val := q, property := hr }) else 0) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
rw [← add_assoc]
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : s.index q = i
⊢ evalFinsupp (OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
(evalFinsupp (s.value { val := q, property := hr }) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : s.index q = i
⊢ evalFinsupp (OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + evalFinsupp (s.value { val := q, property := hr }) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : s.index q = i
⊢ evalFinsupp (OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
(evalFinsupp (s.value { val := q, property := hr }) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
rw [LawfulOfStream.eval_of_stream]
|
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : s.index q = i
⊢ evalFinsupp (OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + evalFinsupp (s.value { val := q, property := hr }) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : s.index q = i
⊢ evalFinsupp (OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + evalFinsupp (s.value { val := q, property := hr }) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
simp
|
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : ¬s.index q = i
⊢ evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + (0 + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : ¬s.index q = i
⊢ evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + (0 + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
simp
|
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : ¬s.ready q = true
⊢ evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + (0 i + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : ¬s.ready q = true
⊢ evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + (0 i + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
exact s.progress rfl.le
|
case pos.a
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ WfRel s (s.seek q (toOrder s q)) ↑q
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos.a
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ WfRel s (s.seek q (toOrder s q)) ↑q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
rw [Stream.fold_wf_invalid, Stream.eval_invalid]
|
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
|
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get b i) = evalFinsupp (Readable.get b i) + 0 i
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map (⇑evalFinsupp) s).valid q = true
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
all_goals (try exact hv)
|
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get b i) = evalFinsupp (Readable.get b i) + 0 i
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map (⇑evalFinsupp) s).valid q = true
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true
|
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get b i) = evalFinsupp (Readable.get b i) + 0 i
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get b i) = evalFinsupp (Readable.get b i) + 0 i
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map (⇑evalFinsupp) s).valid q = true
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
simp
|
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get b i) = evalFinsupp (Readable.get b i) + 0 i
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get b i) = evalFinsupp (Readable.get b i) + 0 i
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
(try exact hv)
|
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
try exact hv
|
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/OfStream.lean
|
Etch.Verification.Stream.LawfulOfStream.get_fold
|
[67, 1]
|
[91, 9]
|
exact hv
|
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/Verification/FinsuppLemmas.lean
|
Finsupp.sumRange_eq_sum
|
[21, 1]
|
[21, 91]
|
simp [sumRange, mapDomain]
|
α : Type u_2
β : Type u_1
γ : Type ?u.8099
inst✝ : AddCommMonoid β
f g : α →₀ β
⊢ sumRange f = sum f fun x v => v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_2
β : Type u_1
γ : Type ?u.8099
inst✝ : AddCommMonoid β
f g : α →₀ β
⊢ sumRange f = sum f fun x v => v
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/Verification/FinsuppLemmas.lean
|
Finsupp.sumRange_single
|
[25, 1]
|
[25, 90]
|
simp [sumRange]
|
α : Type u_2
β : Type u_1
γ : Type ?u.14307
inst✝ : AddCommMonoid β
f g : α →₀ β
x : α
y : β
⊢ (sumRange fun₀ | x => y) = y
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_2
β : Type u_1
γ : Type ?u.14307
inst✝ : AddCommMonoid β
f g : α →₀ β
x : α
y : β
⊢ (sumRange fun₀ | x => y) = y
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/Verification/FinsuppLemmas.lean
|
Finsupp.mapDomain_sumRange
|
[29, 1]
|
[30, 36]
|
simp [sumRange, ← mapDomain_comp]
|
α : Type u_3
β : Type u_1
γ : Type u_2
inst✝ : AddCommMonoid β
f g : α →₀ β
h : α → γ
⊢ sumRange (mapDomain h f) = sumRange f
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_3
β : Type u_1
γ : Type u_2
inst✝ : AddCommMonoid β
f g : α →₀ β
h : α → γ
⊢ sumRange (mapDomain h f) = sumRange f
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/Imap.lean
|
Etch.Verification.Stream.lt_iff_of_eq_compare
|
[8, 1]
|
[11, 30]
|
simp only [compareOfLessAndEq] at h
|
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ a < b ↔ c < d
|
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h :
(if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) =
if c < d then Ordering.lt else if c = d then Ordering.eq else Ordering.gt
⊢ a < b ↔ c < d
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ a < b ↔ c < d
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/Imap.lean
|
Etch.Verification.Stream.lt_iff_of_eq_compare
|
[8, 1]
|
[11, 30]
|
split_ifs at h <;> simp [*]
|
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h :
(if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) =
if c < d then Ordering.lt else if c = d then Ordering.eq else Ordering.gt
⊢ a < b ↔ c < d
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h :
(if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) =
if c < d then Ordering.lt else if c = d then Ordering.eq else Ordering.gt
⊢ a < b ↔ c < d
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/Imap.lean
|
Etch.Verification.Stream.eq_iff_of_eq_compare
|
[13, 1]
|
[16, 38]
|
simp only [compareOfLessAndEq] at h
|
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ a = b ↔ c = d
|
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h :
(if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) =
if c < d then Ordering.lt else if c = d then Ordering.eq else Ordering.gt
⊢ a = b ↔ c = d
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ a = b ↔ c = d
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/Imap.lean
|
Etch.Verification.Stream.eq_iff_of_eq_compare
|
[13, 1]
|
[16, 38]
|
split_ifs at h with h₁ h₂ <;> aesop
|
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h :
(if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) =
if c < d then Ordering.lt else if c = d then Ordering.eq else Ordering.gt
⊢ a = b ↔ c = d
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h :
(if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) =
if c < d then Ordering.lt else if c = d then Ordering.eq else Ordering.gt
⊢ a = b ↔ c = d
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/Imap.lean
|
Etch.Verification.Stream.le_iff_of_eq_compare
|
[18, 1]
|
[20, 73]
|
simp [le_iff_lt_or_eq, lt_iff_of_eq_compare h, eq_iff_of_eq_compare h]
|
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ a ≤ b ↔ c ≤ d
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ a ≤ b ↔ c ≤ d
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/Imap.lean
|
Etch.Verification.Stream.gt_iff_of_eq_compare
|
[22, 1]
|
[24, 43]
|
simpa using (le_iff_of_eq_compare h).not
|
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ b < a ↔ d < c
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ b < a ↔ d < c
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/Imap.lean
|
Etch.Verification.Stream.IsBounded.imap
|
[28, 1]
|
[38, 46]
|
refine ⟨s.wfRel, ?_⟩
|
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
⊢ IsBounded (imap_general f g s)
|
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
⊢ ∀ (q : { x // (imap_general f g s).valid x = true }) (i : Lex (ι' × Bool)),
WellFoundedRelation.rel ((imap_general f g s).seek q i) ↑q ∨
i < toOrder (imap_general f g s) q ∧ (imap_general f g s).seek q i = ↑q
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
⊢ IsBounded (imap_general f g s)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/Imap.lean
|
Etch.Verification.Stream.IsBounded.imap
|
[28, 1]
|
[38, 46]
|
rintro q ⟨j, b⟩
|
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
⊢ ∀ (q : { x // (imap_general f g s).valid x = true }) (i : Lex (ι' × Bool)),
WellFoundedRelation.rel ((imap_general f g s).seek q i) ↑q ∨
i < toOrder (imap_general f g s) q ∧ (imap_general f g s).seek q i = ↑q
|
case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ WellFoundedRelation.rel ((imap_general f g s).seek q (j, b)) ↑q ∨
(j, b) < toOrder (imap_general f g s) q ∧ (imap_general f g s).seek q (j, b) = ↑q
|
Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
⊢ ∀ (q : { x // (imap_general f g s).valid x = true }) (i : Lex (ι' × Bool)),
WellFoundedRelation.rel ((imap_general f g s).seek q i) ↑q ∨
i < toOrder (imap_general f g s) q ∧ (imap_general f g s).seek q i = ↑q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/Imap.lean
|
Etch.Verification.Stream.IsBounded.imap
|
[28, 1]
|
[38, 46]
|
refine (s.wf_valid q (g (s.index q) j, b)).imp_right (And.imp_left ?_)
|
case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ WellFoundedRelation.rel ((imap_general f g s).seek q (j, b)) ↑q ∨
(j, b) < toOrder (imap_general f g s) q ∧ (imap_general f g s).seek q (j, b) = ↑q
|
case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ (g (s.index q) j, b) < toOrder s q → (j, b) < toOrder (imap_general f g s) q
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ WellFoundedRelation.rel ((imap_general f g s).seek q (j, b)) ↑q ∨
(j, b) < toOrder (imap_general f g s) q ∧ (imap_general f g s).seek q (j, b) = ↑q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/Imap.lean
|
Etch.Verification.Stream.IsBounded.imap
|
[28, 1]
|
[38, 46]
|
dsimp [toOrder]
|
case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ (g (s.index q) j, b) < toOrder s q → (j, b) < toOrder (imap_general f g s) q
|
case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ (g (s.index q) j, b) < (s.index q, s.ready q) → (j, b) < (f (s.index q), s.ready q)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ (g (s.index q) j, b) < toOrder s q → (j, b) < toOrder (imap_general f g s) q
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/Imap.lean
|
Etch.Verification.Stream.IsBounded.imap
|
[28, 1]
|
[38, 46]
|
convert id
|
case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ (g (s.index q) j, b) < (s.index q, s.ready q) → (j, b) < (f (s.index q), s.ready q)
|
case h'.a
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
a✝ : (g (s.index q) j, b) < (s.index q, s.ready q)
⊢ (j, b) < (f (s.index q), s.ready q) ↔ (g (s.index q) j, b) < (s.index q, s.ready q)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ (g (s.index q) j, b) < (s.index q, s.ready q) → (j, b) < (f (s.index q), s.ready q)
TACTIC:
|
https://github.com/kovach/etch.git
|
b9e66fe99c33dc1edd926626e598ba00d5d78627
|
Etch/StreamFusion/Proofs/Imap.lean
|
Etch.Verification.Stream.IsBounded.imap
|
[28, 1]
|
[38, 46]
|
simp only [Prod.Lex.lt_iff', ← lt_iff_of_eq_compare (hfg (s.index q) j),
eq_iff_of_eq_compare (hfg (s.index q) j)]
|
case h'.a
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
a✝ : (g (s.index q) j, b) < (s.index q, s.ready q)
⊢ (j, b) < (f (s.index q), s.ready q) ↔ (g (s.index q) j, b) < (s.index q, s.ready q)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h'.a
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
a✝ : (g (s.index q) j, b) < (s.index q, s.ready q)
⊢ (j, b) < (f (s.index q), s.ready q) ↔ (g (s.index q) j, b) < (s.index q, s.ready q)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.