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/Verification/Misc.lean | Prod.Lex.mk_min | [312, 9] | [314, 87] | simp | m : Type u → Type v
inst✝² : Monad m
α : Type u_1
β : Type u_2
r₁ : α → α → Prop
r₂ : β → β → Prop
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
x : α
y₁✝ y₂✝ y₁ y₂ : β
⊢ y₁ ≤ y₂ → (fun y => (x, y)) y₁ ≤ (fun y => (x, y)) y₂ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝² : Monad m
α : Type u_1
β : Type u_2
r₁ : α → α → Prop
r₂ : β → β → Prop
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
x : α
y₁✝ y₂✝ y₁ y₂ : β
⊢ y₁ ≤ y₂ → (fun y => (x, y)) y₁ ≤ (fun y => (x, y)) y₂
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | max_le_min_iff | [322, 1] | [324, 24] | have h : max x y ≤ min x y ↔ y = x := by simpa using le_antisymm_iff.symm | m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
inst✝ : LinearOrder α
x y : α
⊢ max x y ≤ min x y ↔ x = y | m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
inst✝ : LinearOrder α
x y : α
h : max x y ≤ min x y ↔ y = x
⊢ max x y ≤ min x y ↔ x = y | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
inst✝ : LinearOrder α
x y : α
⊢ max x y ≤ min x y ↔ x = y
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | max_le_min_iff | [322, 1] | [324, 24] | exact h.trans eq_comm | m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
inst✝ : LinearOrder α
x y : α
h : max x y ≤ min x y ↔ y = x
⊢ max x y ≤ min x y ↔ x = y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
inst✝ : LinearOrder α
x y : α
h : max x y ≤ min x y ↔ y = x
⊢ max x y ≤ min x y ↔ x = y
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | max_le_min_iff | [322, 1] | [324, 24] | simpa using le_antisymm_iff.symm | m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
inst✝ : LinearOrder α
x y : α
⊢ max x y ≤ min x y ↔ y = x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
inst✝ : LinearOrder α
x y : α
⊢ max x y ≤ min x y ↔ y = x
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | max_eq_min_iff | [328, 1] | [329, 63] | simp [h] | m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
inst✝ : LinearOrder α
x y : α
h : x = y
⊢ min x y = max x y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
inst✝ : LinearOrder α
x y : α
h : x = y
⊢ min x y = max x y
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | Finsupp.mul_eq_zero_of_disjoint_support | [332, 1] | [336, 66] | rw [← Finsupp.support_eq_empty, ← Finset.subset_empty] | m : Type u → Type v
inst✝² : Monad m
ι : Type u_1
β : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : MulZeroClass β
f g : ι →₀ β
h : Disjoint f.support g.support
⊢ f * g = 0 | m : Type u → Type v
inst✝² : Monad m
ι : Type u_1
β : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : MulZeroClass β
f g : ι →₀ β
h : Disjoint f.support g.support
⊢ (f * g).support ⊆ ∅ | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝² : Monad m
ι : Type u_1
β : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : MulZeroClass β
f g : ι →₀ β
h : Disjoint f.support g.support
⊢ f * g = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | Finsupp.mul_eq_zero_of_disjoint_support | [332, 1] | [336, 66] | refine Finsupp.support_mul.trans ?_ | m : Type u → Type v
inst✝² : Monad m
ι : Type u_1
β : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : MulZeroClass β
f g : ι →₀ β
h : Disjoint f.support g.support
⊢ (f * g).support ⊆ ∅ | m : Type u → Type v
inst✝² : Monad m
ι : Type u_1
β : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : MulZeroClass β
f g : ι →₀ β
h : Disjoint f.support g.support
⊢ f.support ∩ g.support ⊆ ∅ | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝² : Monad m
ι : Type u_1
β : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : MulZeroClass β
f g : ι →₀ β
h : Disjoint f.support g.support
⊢ (f * g).support ⊆ ∅
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | Finsupp.mul_eq_zero_of_disjoint_support | [332, 1] | [336, 66] | rwa [Finset.subset_empty, ← Finset.disjoint_iff_inter_eq_empty] | m : Type u → Type v
inst✝² : Monad m
ι : Type u_1
β : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : MulZeroClass β
f g : ι →₀ β
h : Disjoint f.support g.support
⊢ f.support ∩ g.support ⊆ ∅ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝² : Monad m
ι : Type u_1
β : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : MulZeroClass β
f g : ι →₀ β
h : Disjoint f.support g.support
⊢ f.support ∩ g.support ⊆ ∅
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | Finsupp.mul_single_eq_zero | [339, 1] | [345, 11] | classical
rw [Finsupp.mul_eq_zero_of_disjoint_support]
simp_rw [Finset.disjoint_iff_ne, Finsupp.mem_support_single]
simp_rw [and_imp, forall_eq]
intros
exact hi | m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
⊢ single i₁ x * single i₂ y = 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
⊢ single i₁ x * single i₂ y = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | Finsupp.mul_single_eq_zero | [339, 1] | [345, 11] | rw [Finsupp.mul_eq_zero_of_disjoint_support] | m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
⊢ single i₁ x * single i₂ y = 0 | case h
m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
⊢ Disjoint (single i₁ x).support (single i₂ y).support | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
⊢ single i₁ x * single i₂ y = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | Finsupp.mul_single_eq_zero | [339, 1] | [345, 11] | simp_rw [Finset.disjoint_iff_ne, Finsupp.mem_support_single] | case h
m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
⊢ Disjoint (single i₁ x).support (single i₂ y).support | case h
m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
⊢ ∀ (a : ι), a = i₁ ∧ x ≠ 0 → ∀ (b : ι), b = i₂ ∧ y ≠ 0 → a ≠ b | Please generate a tactic in lean4 to solve the state.
STATE:
case h
m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
⊢ Disjoint (single i₁ x).support (single i₂ y).support
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | Finsupp.mul_single_eq_zero | [339, 1] | [345, 11] | simp_rw [and_imp, forall_eq] | case h
m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
⊢ ∀ (a : ι), a = i₁ ∧ x ≠ 0 → ∀ (b : ι), b = i₂ ∧ y ≠ 0 → a ≠ b | case h
m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
⊢ x ≠ 0 → y ≠ 0 → i₁ ≠ i₂ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
⊢ ∀ (a : ι), a = i₁ ∧ x ≠ 0 → ∀ (b : ι), b = i₂ ∧ y ≠ 0 → a ≠ b
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | Finsupp.mul_single_eq_zero | [339, 1] | [345, 11] | intros | case h
m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
⊢ x ≠ 0 → y ≠ 0 → i₁ ≠ i₂ | case h
m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
a✝¹ : x ≠ 0
a✝ : y ≠ 0
⊢ i₁ ≠ i₂ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
⊢ x ≠ 0 → y ≠ 0 → i₁ ≠ i₂
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | Finsupp.mul_single_eq_zero | [339, 1] | [345, 11] | exact hi | case h
m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
a✝¹ : x ≠ 0
a✝ : y ≠ 0
⊢ i₁ ≠ i₂ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
m : Type u → Type v
inst✝¹ : Monad m
ι : Type u_1
β : Type u_2
inst✝ : MulZeroClass β
i₁ i₂ : ι
hi : i₁ ≠ i₂
x y : β
a✝¹ : x ≠ 0
a✝ : y ≠ 0
⊢ i₁ ≠ i₂
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | Finsupp.mul_filter | [350, 1] | [353, 60] | ext i | m : Type u → Type v
inst✝³ : Monad m
ι : Type u_2
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
β : Type u_1
inst✝ : MulZeroClass β
f g : ι →₀ β
⊢ filter P f * filter Q g = filter (fun i => P i ∧ Q i) (f * g) | case h
m : Type u → Type v
inst✝³ : Monad m
ι : Type u_2
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
β : Type u_1
inst✝ : MulZeroClass β
f g : ι →₀ β
i : ι
⊢ (filter P f * filter Q g) i = (filter (fun i => P i ∧ Q i) (f * g)) i | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝³ : Monad m
ι : Type u_2
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
β : Type u_1
inst✝ : MulZeroClass β
f g : ι →₀ β
⊢ filter P f * filter Q g = filter (fun i => P i ∧ Q i) (f * g)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | Finsupp.mul_filter | [350, 1] | [353, 60] | by_cases h₁ : P i <;> by_cases h₂ : Q i <;> simp [h₁, h₂] | case h
m : Type u → Type v
inst✝³ : Monad m
ι : Type u_2
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
β : Type u_1
inst✝ : MulZeroClass β
f g : ι →₀ β
i : ι
⊢ (filter P f * filter Q g) i = (filter (fun i => P i ∧ Q i) (f * g)) i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
m : Type u → Type v
inst✝³ : Monad m
ι : Type u_2
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
β : Type u_1
inst✝ : MulZeroClass β
f g : ι →₀ β
i : ι
⊢ (filter P f * filter Q g) i = (filter (fun i => P i ∧ Q i) (f * g)) i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | Finsupp.mul_filter' | [356, 1] | [357, 79] | simp [Finsupp.mul_filter] | m : Type u → Type v
inst✝³ : Monad m
ι : Type u_2
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
β : Type u_1
inst✝ : MulZeroClass β
f g : ι →₀ β
⊢ filter P (f * g) = filter P f * filter P g | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝³ : Monad m
ι : Type u_2
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
β : Type u_1
inst✝ : MulZeroClass β
f g : ι →₀ β
⊢ filter P (f * g) = filter P f * filter P g
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | mul_eq_zero_of | [365, 1] | [371, 34] | rw [h] | m : Type u → Type v
inst✝³ : Monad m
ι : Type ?u.82027
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
α : Type u_1
inst✝ : MulZeroClass α
x y : α
h : x = 0
⊢ x * y = 0 | m : Type u → Type v
inst✝³ : Monad m
ι : Type ?u.82027
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
α : Type u_1
inst✝ : MulZeroClass α
x y : α
h : x = 0
⊢ 0 * y = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝³ : Monad m
ι : Type ?u.82027
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
α : Type u_1
inst✝ : MulZeroClass α
x y : α
h : x = 0
⊢ x * y = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | mul_eq_zero_of | [365, 1] | [371, 34] | exact MulZeroClass.zero_mul y | m : Type u → Type v
inst✝³ : Monad m
ι : Type ?u.82027
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
α : Type u_1
inst✝ : MulZeroClass α
x y : α
h : x = 0
⊢ 0 * y = 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝³ : Monad m
ι : Type ?u.82027
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
α : Type u_1
inst✝ : MulZeroClass α
x y : α
h : x = 0
⊢ 0 * y = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | mul_eq_zero_of | [365, 1] | [371, 34] | rw [h] | m : Type u → Type v
inst✝³ : Monad m
ι : Type ?u.82027
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
α : Type u_1
inst✝ : MulZeroClass α
x y : α
h : y = 0
⊢ x * y = 0 | m : Type u → Type v
inst✝³ : Monad m
ι : Type ?u.82027
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
α : Type u_1
inst✝ : MulZeroClass α
x y : α
h : y = 0
⊢ x * 0 = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝³ : Monad m
ι : Type ?u.82027
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
α : Type u_1
inst✝ : MulZeroClass α
x y : α
h : y = 0
⊢ x * y = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/Misc.lean | mul_eq_zero_of | [365, 1] | [371, 34] | exact MulZeroClass.mul_zero x | m : Type u → Type v
inst✝³ : Monad m
ι : Type ?u.82027
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
α : Type u_1
inst✝ : MulZeroClass α
x y : α
h : y = 0
⊢ x * 0 = 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
m : Type u → Type v
inst✝³ : Monad m
ι : Type ?u.82027
P Q : ι → Prop
inst✝² : DecidablePred P
inst✝¹ : DecidablePred Q
α : Type u_1
inst✝ : MulZeroClass α
x y : α
h : y = 0
⊢ x * 0 = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul.ready.order_eq | [15, 1] | [18, 8] | dsimp only [Stream.toOrder] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // valid a b p = true }
h : ready a b q = true
⊢ toOrder a (valid.fst q) = toOrder b (valid.snd q) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // valid a b p = true }
h : ready a b q = true
⊢ (a.index (valid.fst q), a.ready (valid.fst q)) = (b.index (valid.snd q), b.ready (valid.snd q)) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // valid a b p = true }
h : ready a b q = true
⊢ toOrder a (valid.fst q) = toOrder b (valid.snd q)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul.ready.order_eq | [15, 1] | [18, 8] | aesop | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // valid a b p = true }
h : ready a b q = true
⊢ (a.index (valid.fst q), a.ready (valid.fst q)) = (b.index (valid.snd q), b.ready (valid.snd q)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // valid a b p = true }
h : ready a b q = true
⊢ (a.index (valid.fst q), a.ready (valid.fst q)) = (b.index (valid.snd q), b.ready (valid.snd q))
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.order_eq_of_mul_ready | [20, 1] | [24, 8] | dsimp only [Stream.toOrder] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h : mul.ready a b q = true
⊢ toOrder a (mul.valid.fst q) = toOrder (mul a b) q ∧ toOrder b (mul.valid.snd q) = toOrder (mul a b) q | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h : mul.ready a b q = true
⊢ (a.index (mul.valid.fst q), a.ready (mul.valid.fst q)) = ((mul a b).index q, (mul a b).ready q) ∧
(b.index (mul.valid.snd q), b.ready (mul.valid.snd q)) = ((mul a b).index q, (mul a b).ready q) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h : mul.ready a b q = true
⊢ toOrder a (mul.valid.fst q) = toOrder (mul a b) q ∧ toOrder b (mul.valid.snd q) = toOrder (mul a b) q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.order_eq_of_mul_ready | [20, 1] | [24, 8] | aesop | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h : mul.ready a b q = true
⊢ (a.index (mul.valid.fst q), a.ready (mul.valid.fst q)) = ((mul a b).index q, (mul a b).ready q) ∧
(b.index (mul.valid.snd q), b.ready (mul.valid.snd q)) = ((mul a b).index q, (mul a b).ready q) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h : mul.ready a b q = true
⊢ (a.index (mul.valid.fst q), a.ready (mul.valid.fst q)) = ((mul a b).index q, (mul a b).ready q) ∧
(b.index (mul.valid.snd q), b.ready (mul.valid.snd q)) = ((mul a b).index q, (mul a b).ready q)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.Stream.mul_index' | [26, 1] | [33, 32] | rw [Stream.index'] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
⊢ index' (mul a b) q = max (index' a q.1) (index' b q.2) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
⊢ (if h : (mul a b).valid q = true then ↑((mul a b).index { val := q, property := h }) else ⊤) =
max (index' a q.1) (index' b q.2) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
⊢ index' (mul a b) q = max (index' a q.1) (index' b q.2)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.Stream.mul_index' | [26, 1] | [33, 32] | split_ifs with h | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
⊢ (if h : (mul a b).valid q = true then ↑((mul a b).index { val := q, property := h }) else ⊤) =
max (index' a q.1) (index' b q.2) | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h : (mul a b).valid q = true
⊢ ↑((mul a b).index { val := q, property := h }) = max (index' a q.1) (index' b q.2)
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h : ¬(mul a b).valid q = true
⊢ ⊤ = max (index' a q.1) (index' b q.2) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
⊢ (if h : (mul a b).valid q = true then ↑((mul a b).index { val := q, property := h }) else ⊤) =
max (index' a q.1) (index' b q.2)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.Stream.mul_index' | [26, 1] | [33, 32] | simp at h | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h : (mul a b).valid q = true
⊢ ↑((mul a b).index { val := q, property := h }) = max (index' a q.1) (index' b q.2) | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h✝ : (mul a b).valid q = true
h : a.valid q.1 = true ∧ b.valid q.2 = true
⊢ ↑((mul a b).index { val := q, property := h✝ }) = max (index' a q.1) (index' b q.2) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h : (mul a b).valid q = true
⊢ ↑((mul a b).index { val := q, property := h }) = max (index' a q.1) (index' b q.2)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.Stream.mul_index' | [26, 1] | [33, 32] | simp [index'_val' _ h.1, index'_val' _ h.2] | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h✝ : (mul a b).valid q = true
h : a.valid q.1 = true ∧ b.valid q.2 = true
⊢ ↑((mul a b).index { val := q, property := h✝ }) = max (index' a q.1) (index' b q.2) | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h✝ : (mul a b).valid q = true
h : a.valid q.1 = true ∧ b.valid q.2 = true
⊢ max ↑(a.index (mul.valid.fst { val := q, property := h✝ })) ↑(b.index (mul.valid.snd { val := q, property := h✝ })) =
max ↑(a.index { val := q.1, property := ⋯ }) ↑(b.index { val := q.2, property := ⋯ }) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h✝ : (mul a b).valid q = true
h : a.valid q.1 = true ∧ b.valid q.2 = true
⊢ ↑((mul a b).index { val := q, property := h✝ }) = max (index' a q.1) (index' b q.2)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.Stream.mul_index' | [26, 1] | [33, 32] | rfl | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h✝ : (mul a b).valid q = true
h : a.valid q.1 = true ∧ b.valid q.2 = true
⊢ max ↑(a.index (mul.valid.fst { val := q, property := h✝ })) ↑(b.index (mul.valid.snd { val := q, property := h✝ })) =
max ↑(a.index { val := q.1, property := ⋯ }) ↑(b.index { val := q.2, property := ⋯ }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h✝ : (mul a b).valid q = true
h : a.valid q.1 = true ∧ b.valid q.2 = true
⊢ max ↑(a.index (mul.valid.fst { val := q, property := h✝ })) ↑(b.index (mul.valid.snd { val := q, property := h✝ })) =
max ↑(a.index { val := q.1, property := ⋯ }) ↑(b.index { val := q.2, property := ⋯ })
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.Stream.mul_index' | [26, 1] | [33, 32] | simp [-not_and, not_and_or] at h | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h : ¬(mul a b).valid q = true
⊢ ⊤ = max (index' a q.1) (index' b q.2) | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h : a.valid q.1 = false ∨ b.valid q.2 = false
⊢ ⊤ = max (index' a q.1) (index' b q.2) | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h : ¬(mul a b).valid q = true
⊢ ⊤ = max (index' a q.1) (index' b q.2)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.Stream.mul_index' | [26, 1] | [33, 32] | rcases h with h | h
<;> simp [index'_invalid h] | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h : a.valid q.1 = false ∨ b.valid q.2 = false
⊢ ⊤ = max (index' a q.1) (index' b q.2) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : (mul a b).σ
h : a.valid q.1 = false ∨ b.valid q.2 = false
⊢ ⊤ = max (index' a q.1) (index' b q.2)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.min_toOrder_le | [35, 1] | [42, 10] | rw [Prod.Lex.le_iff''] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q)) ≤ toOrder (mul a b) q | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ (min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 ≤ (toOrder (mul a b) q).1 ∧
((min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 = (toOrder (mul a b) q).1 →
(min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 ≤ (toOrder (mul a b) q).2) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q)) ≤ toOrder (mul a b) q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.min_toOrder_le | [35, 1] | [42, 10] | simp only [Monotone.map_min (@Prod.Lex.fst_mono ι Bool _ _)] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ (min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 ≤ (toOrder (mul a b) q).1 ∧
((min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 = (toOrder (mul a b) q).1 →
(min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 ≤ (toOrder (mul a b) q).2) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ min (toOrder a (mul.valid.fst q)).1 (toOrder b (mul.valid.snd q)).1 ≤ (toOrder (mul a b) q).1 ∧
(min (toOrder a (mul.valid.fst q)).1 (toOrder b (mul.valid.snd q)).1 = (toOrder (mul a b) q).1 →
(min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 ≤ (toOrder (mul a b) q).2) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ (min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 ≤ (toOrder (mul a b) q).1 ∧
((min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 = (toOrder (mul a b) q).1 →
(min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 ≤ (toOrder (mul a b) q).2)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.min_toOrder_le | [35, 1] | [42, 10] | constructor | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ min (toOrder a (mul.valid.fst q)).1 (toOrder b (mul.valid.snd q)).1 ≤ (toOrder (mul a b) q).1 ∧
(min (toOrder a (mul.valid.fst q)).1 (toOrder b (mul.valid.snd q)).1 = (toOrder (mul a b) q).1 →
(min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 ≤ (toOrder (mul a b) q).2) | case left
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ min (toOrder a (mul.valid.fst q)).1 (toOrder b (mul.valid.snd q)).1 ≤ (toOrder (mul a b) q).1
case right
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ min (toOrder a (mul.valid.fst q)).1 (toOrder b (mul.valid.snd q)).1 = (toOrder (mul a b) q).1 →
(min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 ≤ (toOrder (mul a b) q).2 | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ min (toOrder a (mul.valid.fst q)).1 (toOrder b (mul.valid.snd q)).1 ≤ (toOrder (mul a b) q).1 ∧
(min (toOrder a (mul.valid.fst q)).1 (toOrder b (mul.valid.snd q)).1 = (toOrder (mul a b) q).1 →
(min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 ≤ (toOrder (mul a b) q).2)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.min_toOrder_le | [35, 1] | [42, 10] | exact min_le_max | case left
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ min (toOrder a (mul.valid.fst q)).1 (toOrder b (mul.valid.snd q)).1 ≤ (toOrder (mul a b) q).1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case left
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ min (toOrder a (mul.valid.fst q)).1 (toOrder b (mul.valid.snd q)).1 ≤ (toOrder (mul a b) q).1
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.min_toOrder_le | [35, 1] | [42, 10] | simp only [toOrder] | case right
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ min (toOrder a (mul.valid.fst q)).1 (toOrder b (mul.valid.snd q)).1 = (toOrder (mul a b) q).1 →
(min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 ≤ (toOrder (mul a b) q).2 | case right
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ min (a.index (mul.valid.fst q)) (b.index (mul.valid.snd q)) = (mul a b).index q →
(min (a.index (mul.valid.fst q), a.ready (mul.valid.fst q))
(b.index (mul.valid.snd q), b.ready (mul.valid.snd q))).2 ≤
(mul a b).ready q | Please generate a tactic in lean4 to solve the state.
STATE:
case right
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ min (toOrder a (mul.valid.fst q)).1 (toOrder b (mul.valid.snd q)).1 = (toOrder (mul a b) q).1 →
(min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 ≤ (toOrder (mul a b) q).2
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.min_toOrder_le | [35, 1] | [42, 10] | aesop | case right
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ min (a.index (mul.valid.fst q)) (b.index (mul.valid.snd q)) = (mul a b).index q →
(min (a.index (mul.valid.fst q), a.ready (mul.valid.fst q))
(b.index (mul.valid.snd q), b.ready (mul.valid.snd q))).2 ≤
(mul a b).ready q | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case right
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { p // mul.valid a b p = true }
⊢ min (a.index (mul.valid.fst q)) (b.index (mul.valid.snd q)) = (mul a b).index q →
(min (a.index (mul.valid.fst q), a.ready (mul.valid.fst q))
(b.index (mul.valid.snd q), b.ready (mul.valid.snd q))).2 ≤
(mul a b).ready q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.toOrder_le_max | [44, 1] | [49, 10] | rw [Prod.Lex.le_iff'] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ toOrder (mul a b) q ≤ max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q)) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (toOrder (mul a b) q).1 < (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 ∨
(toOrder (mul a b) q).1 = (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 ∧
(toOrder (mul a b) q).2 ≤ (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ toOrder (mul a b) q ≤ max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.toOrder_le_max | [44, 1] | [49, 10] | right | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (toOrder (mul a b) q).1 < (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 ∨
(toOrder (mul a b) q).1 = (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 ∧
(toOrder (mul a b) q).2 ≤ (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 | case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (toOrder (mul a b) q).1 = (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 ∧
(toOrder (mul a b) q).2 ≤ (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (toOrder (mul a b) q).1 < (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 ∨
(toOrder (mul a b) q).1 = (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 ∧
(toOrder (mul a b) q).2 ≤ (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.toOrder_le_max | [44, 1] | [49, 10] | constructor | case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (toOrder (mul a b) q).1 = (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 ∧
(toOrder (mul a b) q).2 ≤ (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 | case h.left
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (toOrder (mul a b) q).1 = (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1
case h.right
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (toOrder (mul a b) q).2 ≤ (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (toOrder (mul a b) q).1 = (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 ∧
(toOrder (mul a b) q).2 ≤ (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.toOrder_le_max | [44, 1] | [49, 10] | simp [Monotone.map_max (@Prod.Lex.fst_mono ι Bool _ _)] | case h.left
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (toOrder (mul a b) q).1 = (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (toOrder (mul a b) q).1 = (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).1
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.toOrder_le_max | [44, 1] | [49, 10] | simp only [Bool.le_iff_imp, toOrder] | case h.right
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (toOrder (mul a b) q).2 ≤ (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2 | case h.right
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (mul a b).ready q = true →
(max (a.index (mul.valid.fst q), a.ready (mul.valid.fst q))
(b.index (mul.valid.snd q), b.ready (mul.valid.snd q))).2 =
true | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (toOrder (mul a b) q).2 ≤ (max (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q))).2
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.toOrder_le_max | [44, 1] | [49, 10] | aesop | case h.right
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (mul a b).ready q = true →
(max (a.index (mul.valid.fst q), a.ready (mul.valid.fst q))
(b.index (mul.valid.snd q), b.ready (mul.valid.snd q))).2 =
true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : Mul α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (mul a b).ready q = true →
(max (a.index (mul.valid.fst q), a.ready (mul.valid.fst q))
(b.index (mul.valid.snd q), b.ready (mul.valid.snd q))).2 =
true
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_map | [63, 1] | [69, 6] | ext <;> try rfl | ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
⊢ map f (mul a b) = mul (map f a) (map f b) | case value
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
⊢ HEq (map f (mul a b)).value (mul (map f a) (map f b)).value | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
⊢ map f (mul a b) = mul (map f a) (map f b)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_map | [63, 1] | [69, 6] | simp only [heq_iff_eq] | case value
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
⊢ HEq (map f (mul a b)).value (mul (map f a) (map f b)).value | case value
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
⊢ (map f (mul a b)).value = (mul (map f a) (map f b)).value | Please generate a tactic in lean4 to solve the state.
STATE:
case value
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
⊢ HEq (map f (mul a b)).value (mul (map f a) (map f b)).value
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_map | [63, 1] | [69, 6] | ext q₁ | case value
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
⊢ (map f (mul a b)).value = (mul (map f a) (map f b)).value | case value.h
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
q₁ : { x // (map f (mul a b)).ready x = true }
⊢ (map f (mul a b)).value q₁ = (mul (map f a) (map f b)).value q₁ | Please generate a tactic in lean4 to solve the state.
STATE:
case value
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
⊢ (map f (mul a b)).value = (mul (map f a) (map f b)).value
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_map | [63, 1] | [69, 6] | simp [map, hf] | case value.h
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
q₁ : { x // (map f (mul a b)).ready x = true }
⊢ (map f (mul a b)).value q₁ = (mul (map f a) (map f b)).value q₁ | case value.h
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
q₁ : { x // (map f (mul a b)).ready x = true }
⊢ f (a.value (mul.ready.fst q₁)) * f (b.value (mul.ready.snd q₁)) =
f (a.value (mul.ready.fst q₁)) * f (b.value (mul.ready.snd q₁)) | Please generate a tactic in lean4 to solve the state.
STATE:
case value.h
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
q₁ : { x // (map f (mul a b)).ready x = true }
⊢ (map f (mul a b)).value q₁ = (mul (map f a) (map f b)).value q₁
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_map | [63, 1] | [69, 6] | rfl | case value.h
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
q₁ : { x // (map f (mul a b)).ready x = true }
⊢ f (a.value (mul.ready.fst q₁)) * f (b.value (mul.ready.snd q₁)) =
f (a.value (mul.ready.fst q₁)) * f (b.value (mul.ready.snd q₁)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case value.h
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
q₁ : { x // (map f (mul a b)).ready x = true }
⊢ f (a.value (mul.ready.fst q₁)) * f (b.value (mul.ready.snd q₁)) =
f (a.value (mul.ready.fst q₁)) * f (b.value (mul.ready.snd q₁))
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_map | [63, 1] | [69, 6] | rfl | case ready
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
⊢ HEq (map f (mul a b)).ready (mul (map f a) (map f b)).ready | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case ready
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : Mul α
β : Type u_1
inst✝¹ : Mul α
inst✝ : Mul β
a b : Stream ι α
f : α → β
hf : ∀ (x y : α), f (x * y) = f x * f y
⊢ HEq (map f (mul a b)).ready (mul (map f a) (map f b)).ready
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀_of_neq | [77, 1] | [83, 14] | contrapose! h | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h : toOrder a (mul.valid.fst q) ≠ toOrder b (mul.valid.snd q)
⊢ eval₀ (mul a b) q = 0 | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h : eval₀ (mul a b) q ≠ 0
⊢ toOrder a (mul.valid.fst q) = toOrder b (mul.valid.snd q) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h : toOrder a (mul.valid.fst q) ≠ toOrder b (mul.valid.snd q)
⊢ eval₀ (mul a b) q = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀_of_neq | [77, 1] | [83, 14] | apply Stream.mul.ready.order_eq | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h : eval₀ (mul a b) q ≠ 0
⊢ toOrder a (mul.valid.fst q) = toOrder b (mul.valid.snd q) | case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h : eval₀ (mul a b) q ≠ 0
⊢ mul.ready a b q = true | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h : eval₀ (mul a b) q ≠ 0
⊢ toOrder a (mul.valid.fst q) = toOrder b (mul.valid.snd q)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀_of_neq | [77, 1] | [83, 14] | simp only [Stream.eval₀, Stream.mul_ready, Stream.mul_index, ge_iff_le, Stream.mul_value, ne_eq, dite_eq_right_iff,
Finsupp.single_eq_zero, not_forall] at h | case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h : eval₀ (mul a b) q ≠ 0
⊢ mul.ready a b q = true | case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h :
∃ (x :
(a.ready (mul.valid.fst q) && b.ready (mul.valid.snd q) &&
decide (a.index (mul.valid.fst q) = b.index (mul.valid.snd q))) =
true),
¬a.value (mul.ready.fst { val := q, property := ⋯ }) * b.value (mul.ready.snd { val := q, property := ⋯ }) = 0
⊢ mul.ready a b q = true | Please generate a tactic in lean4 to solve the state.
STATE:
case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h : eval₀ (mul a b) q ≠ 0
⊢ mul.ready a b q = true
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀_of_neq | [77, 1] | [83, 14] | exact h.fst | case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h :
∃ (x :
(a.ready (mul.valid.fst q) && b.ready (mul.valid.snd q) &&
decide (a.index (mul.valid.fst q) = b.index (mul.valid.snd q))) =
true),
¬a.value (mul.ready.fst { val := q, property := ⋯ }) * b.value (mul.ready.snd { val := q, property := ⋯ }) = 0
⊢ mul.ready a b q = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { p // mul.valid a b p = true }
h :
∃ (x :
(a.ready (mul.valid.fst q) && b.ready (mul.valid.snd q) &&
decide (a.index (mul.valid.fst q) = b.index (mul.valid.snd q))) =
true),
¬a.value (mul.ready.fst { val := q, property := ⋯ }) * b.value (mul.ready.snd { val := q, property := ⋯ }) = 0
⊢ mul.ready a b q = true
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀ | [85, 1] | [96, 15] | rw [Stream.eval₀] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ eval₀ (mul a b) q = eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (if h₂ : (mul a b).ready q = true then fun₀ | (mul a b).index q => (mul a b).value { val := q, property := h₂ }
else 0) =
eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ eval₀ (mul a b) q = eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀ | [85, 1] | [96, 15] | split_ifs with hr | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (if h₂ : (mul a b).ready q = true then fun₀ | (mul a b).index q => (mul a b).value { val := q, property := h₂ }
else 0) =
eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q) | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : (mul a b).ready q = true
⊢ (fun₀ | (mul a b).index q => (mul a b).value { val := q, property := hr }) =
eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q)
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : ¬(mul a b).ready q = true
⊢ 0 = eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
⊢ (if h₂ : (mul a b).ready q = true then fun₀ | (mul a b).index q => (mul a b).value { val := q, property := h₂ }
else 0) =
eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀ | [85, 1] | [96, 15] | simp only [mul_ready, Bool.and_eq_true, decide_eq_true_eq] at hr | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : (mul a b).ready q = true
⊢ (fun₀ | (mul a b).index q => (mul a b).value { val := q, property := hr }) =
eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q) | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr✝ : (mul a b).ready q = true
hr :
(a.ready (mul.valid.fst q) = true ∧ b.ready (mul.valid.snd q) = true) ∧
a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
⊢ (fun₀ | (mul a b).index q => (mul a b).value { val := q, property := hr✝ }) =
eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : (mul a b).ready q = true
⊢ (fun₀ | (mul a b).index q => (mul a b).value { val := q, property := hr }) =
eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀ | [85, 1] | [96, 15] | rcases hr with ⟨⟨hr₁, hr₂⟩, hr₃⟩ | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr✝ : (mul a b).ready q = true
hr :
(a.ready (mul.valid.fst q) = true ∧ b.ready (mul.valid.snd q) = true) ∧
a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
⊢ (fun₀ | (mul a b).index q => (mul a b).value { val := q, property := hr✝ }) =
eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q) | case pos.intro.intro
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : (mul a b).ready q = true
hr₃ : a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
hr₁ : a.ready (mul.valid.fst q) = true
hr₂ : b.ready (mul.valid.snd q) = true
⊢ (fun₀ | (mul a b).index q => (mul a b).value { val := q, property := hr }) =
eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr✝ : (mul a b).ready q = true
hr :
(a.ready (mul.valid.fst q) = true ∧ b.ready (mul.valid.snd q) = true) ∧
a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
⊢ (fun₀ | (mul a b).index q => (mul a b).value { val := q, property := hr✝ }) =
eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀ | [85, 1] | [96, 15] | simp [Stream.eval₀, hr₁, hr₂, hr₃] | case pos.intro.intro
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : (mul a b).ready q = true
hr₃ : a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
hr₁ : a.ready (mul.valid.fst q) = true
hr₂ : b.ready (mul.valid.snd q) = true
⊢ (fun₀ | (mul a b).index q => (mul a b).value { val := q, property := hr }) =
eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q) | case pos.intro.intro
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : (mul a b).ready q = true
hr₃ : a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
hr₁ : a.ready (mul.valid.fst q) = true
hr₂ : b.ready (mul.valid.snd q) = true
⊢ ((fun₀ | b.index (mul.valid.snd q) => a.value (mul.ready.fst { val := q, property := hr })) *
fun₀ | b.index (mul.valid.snd q) => b.value (mul.ready.snd { val := q, property := hr })) =
(fun₀ | b.index (mul.valid.snd q) => a.value { val := mul.valid.fst q, property := ⋯ }) *
fun₀ | b.index (mul.valid.snd q) => b.value { val := mul.valid.snd q, property := ⋯ } | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.intro.intro
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : (mul a b).ready q = true
hr₃ : a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
hr₁ : a.ready (mul.valid.fst q) = true
hr₂ : b.ready (mul.valid.snd q) = true
⊢ (fun₀ | (mul a b).index q => (mul a b).value { val := q, property := hr }) =
eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀ | [85, 1] | [96, 15] | rfl | case pos.intro.intro
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : (mul a b).ready q = true
hr₃ : a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
hr₁ : a.ready (mul.valid.fst q) = true
hr₂ : b.ready (mul.valid.snd q) = true
⊢ ((fun₀ | b.index (mul.valid.snd q) => a.value (mul.ready.fst { val := q, property := hr })) *
fun₀ | b.index (mul.valid.snd q) => b.value (mul.ready.snd { val := q, property := hr })) =
(fun₀ | b.index (mul.valid.snd q) => a.value { val := mul.valid.fst q, property := ⋯ }) *
fun₀ | b.index (mul.valid.snd q) => b.value { val := mul.valid.snd q, property := ⋯ } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.intro.intro
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : (mul a b).ready q = true
hr₃ : a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
hr₁ : a.ready (mul.valid.fst q) = true
hr₂ : b.ready (mul.valid.snd q) = true
⊢ ((fun₀ | b.index (mul.valid.snd q) => a.value (mul.ready.fst { val := q, property := hr })) *
fun₀ | b.index (mul.valid.snd q) => b.value (mul.ready.snd { val := q, property := hr })) =
(fun₀ | b.index (mul.valid.snd q) => a.value { val := mul.valid.fst q, property := ⋯ }) *
fun₀ | b.index (mul.valid.snd q) => b.value { val := mul.valid.snd q, property := ⋯ }
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀ | [85, 1] | [96, 15] | simp only [Stream.eval₀] | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : ¬(mul a b).ready q = true
⊢ 0 = eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q) | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : ¬(mul a b).ready q = true
⊢ 0 =
(if h₂ : a.ready (mul.valid.fst q) = true then
fun₀ | a.index (mul.valid.fst q) => a.value { val := mul.valid.fst q, property := h₂ }
else 0) *
if h₂ : b.ready (mul.valid.snd q) = true then
fun₀ | b.index (mul.valid.snd q) => b.value { val := mul.valid.snd q, property := h₂ }
else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : ¬(mul a b).ready q = true
⊢ 0 = eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀ | [85, 1] | [96, 15] | split_ifs with h₁ h₂ <;> try simp | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : ¬(mul a b).ready q = true
⊢ 0 =
(if h₂ : a.ready (mul.valid.fst q) = true then
fun₀ | a.index (mul.valid.fst q) => a.value { val := mul.valid.fst q, property := h₂ }
else 0) *
if h₂ : b.ready (mul.valid.snd q) = true then
fun₀ | b.index (mul.valid.snd q) => b.value { val := mul.valid.snd q, property := h₂ }
else 0 | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : ¬(mul a b).ready q = true
h₁ : a.ready (mul.valid.fst q) = true
h₂ : b.ready (mul.valid.snd q) = true
⊢ 0 =
(fun₀ | a.index (mul.valid.fst q) => a.value { val := mul.valid.fst q, property := h₁ }) *
fun₀ | b.index (mul.valid.snd q) => b.value { val := mul.valid.snd q, property := h₂ } | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : ¬(mul a b).ready q = true
⊢ 0 =
(if h₂ : a.ready (mul.valid.fst q) = true then
fun₀ | a.index (mul.valid.fst q) => a.value { val := mul.valid.fst q, property := h₂ }
else 0) *
if h₂ : b.ready (mul.valid.snd q) = true then
fun₀ | b.index (mul.valid.snd q) => b.value { val := mul.valid.snd q, property := h₂ }
else 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀ | [85, 1] | [96, 15] | simp only [mul_ready, h₁, h₂, Bool.and_self, Bool.true_and, decide_eq_true_eq] at hr | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : ¬(mul a b).ready q = true
h₁ : a.ready (mul.valid.fst q) = true
h₂ : b.ready (mul.valid.snd q) = true
⊢ 0 =
(fun₀ | a.index (mul.valid.fst q) => a.value { val := mul.valid.fst q, property := h₁ }) *
fun₀ | b.index (mul.valid.snd q) => b.value { val := mul.valid.snd q, property := h₂ } | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
h₁ : a.ready (mul.valid.fst q) = true
h₂ : b.ready (mul.valid.snd q) = true
hr : ¬a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
⊢ 0 =
(fun₀ | a.index (mul.valid.fst q) => a.value { val := mul.valid.fst q, property := h₁ }) *
fun₀ | b.index (mul.valid.snd q) => b.value { val := mul.valid.snd q, property := h₂ } | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : ¬(mul a b).ready q = true
h₁ : a.ready (mul.valid.fst q) = true
h₂ : b.ready (mul.valid.snd q) = true
⊢ 0 =
(fun₀ | a.index (mul.valid.fst q) => a.value { val := mul.valid.fst q, property := h₁ }) *
fun₀ | b.index (mul.valid.snd q) => b.value { val := mul.valid.snd q, property := h₂ }
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀ | [85, 1] | [96, 15] | rw [Finsupp.mul_single_eq_zero] | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
h₁ : a.ready (mul.valid.fst q) = true
h₂ : b.ready (mul.valid.snd q) = true
hr : ¬a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
⊢ 0 =
(fun₀ | a.index (mul.valid.fst q) => a.value { val := mul.valid.fst q, property := h₁ }) *
fun₀ | b.index (mul.valid.snd q) => b.value { val := mul.valid.snd q, property := h₂ } | case pos.hi
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
h₁ : a.ready (mul.valid.fst q) = true
h₂ : b.ready (mul.valid.snd q) = true
hr : ¬a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
⊢ a.index (mul.valid.fst q) ≠ b.index (mul.valid.snd q) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
h₁ : a.ready (mul.valid.fst q) = true
h₂ : b.ready (mul.valid.snd q) = true
hr : ¬a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
⊢ 0 =
(fun₀ | a.index (mul.valid.fst q) => a.value { val := mul.valid.fst q, property := h₁ }) *
fun₀ | b.index (mul.valid.snd q) => b.value { val := mul.valid.snd q, property := h₂ }
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀ | [85, 1] | [96, 15] | assumption | case pos.hi
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
h₁ : a.ready (mul.valid.fst q) = true
h₂ : b.ready (mul.valid.snd q) = true
hr : ¬a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
⊢ a.index (mul.valid.fst q) ≠ b.index (mul.valid.snd q) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hi
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
h₁ : a.ready (mul.valid.fst q) = true
h₂ : b.ready (mul.valid.snd q) = true
hr : ¬a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
⊢ a.index (mul.valid.fst q) ≠ b.index (mul.valid.snd q)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀ | [85, 1] | [96, 15] | simp | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : ¬(mul a b).ready q = true
h₁ : ¬a.ready (mul.valid.fst q) = true
h✝ : ¬b.ready (mul.valid.snd q) = true
⊢ 0 = 0 * 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
q : { q // (mul a b).valid q = true }
hr : ¬(mul a b).ready q = true
h₁ : ¬a.ready (mul.valid.fst q) = true
h✝ : ¬b.ready (mul.valid.snd q) = true
⊢ 0 = 0 * 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀_spec | [98, 1] | [122, 51] | by_cases H : (a.mul b).ready q | ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
⊢ eval₀ (mul a b) q =
Finsupp.filter (fun i => (i, false) < toOrder (mul a b) q) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)) | case pos
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : (mul a b).ready q = true
⊢ eval₀ (mul a b) q =
Finsupp.filter (fun i => (i, false) < toOrder (mul a b) q) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q))
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
⊢ eval₀ (mul a b) q =
Finsupp.filter (fun i => (i, false) < toOrder (mul a b) q) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
⊢ eval₀ (mul a b) q =
Finsupp.filter (fun i => (i, false) < toOrder (mul a b) q) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q))
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀_spec | [98, 1] | [122, 51] | calc
(a.mul b).eval₀ q = a.eval₀ (mul.valid.fst q) * b.eval₀ (mul.valid.snd q) := mul_eval₀ ..
_ = ((a.eval <| mul.valid.fst q).filter fun i => (i, false) <ₗ a.toOrder (mul.valid.fst q)) *
((b.eval <| mul.valid.snd q).filter fun i => (i, false) <ₗ b.toOrder (mul.valid.snd q)) :=
by rw [ha.eval₀_eq_eval_filter, hb.eval₀_eq_eval_filter]
_ = (a.eval (mul.valid.fst q) * b.eval (mul.valid.snd q)).filter fun i =>
(i, false) <ₗ min (a.toOrder (mul.valid.fst q)) (b.toOrder (mul.valid.snd q)) :=
by simp only [Finsupp.mul_filter, lt_min_iff]
_ = (a.eval (mul.valid.fst q) * b.eval (mul.valid.snd q)).filter fun i => (i, false) <ₗ (a.mul b).toOrder q :=
by simp [order_eq_of_mul_ready H] | case pos
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : (mul a b).ready q = true
⊢ eval₀ (mul a b) q =
Finsupp.filter (fun i => (i, false) < toOrder (mul a b) q) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : (mul a b).ready q = true
⊢ eval₀ (mul a b) q =
Finsupp.filter (fun i => (i, false) < toOrder (mul a b) q) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q))
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀_spec | [98, 1] | [122, 51] | rw [ha.eval₀_eq_eval_filter, hb.eval₀_eq_eval_filter] | ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : (mul a b).ready q = true
⊢ eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q) =
Finsupp.filter (fun i => (i, false) < toOrder a (mul.valid.fst q)) (eval a ↑(mul.valid.fst q)) *
Finsupp.filter (fun i => (i, false) < toOrder b (mul.valid.snd q)) (eval b ↑(mul.valid.snd q)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : (mul a b).ready q = true
⊢ eval₀ a (mul.valid.fst q) * eval₀ b (mul.valid.snd q) =
Finsupp.filter (fun i => (i, false) < toOrder a (mul.valid.fst q)) (eval a ↑(mul.valid.fst q)) *
Finsupp.filter (fun i => (i, false) < toOrder b (mul.valid.snd q)) (eval b ↑(mul.valid.snd q))
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀_spec | [98, 1] | [122, 51] | simp only [Finsupp.mul_filter, lt_min_iff] | ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : (mul a b).ready q = true
⊢ Finsupp.filter (fun i => (i, false) < toOrder a (mul.valid.fst q)) (eval a ↑(mul.valid.fst q)) *
Finsupp.filter (fun i => (i, false) < toOrder b (mul.valid.snd q)) (eval b ↑(mul.valid.snd q)) =
Finsupp.filter (fun i => (i, false) < min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q)))
(eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : (mul a b).ready q = true
⊢ Finsupp.filter (fun i => (i, false) < toOrder a (mul.valid.fst q)) (eval a ↑(mul.valid.fst q)) *
Finsupp.filter (fun i => (i, false) < toOrder b (mul.valid.snd q)) (eval b ↑(mul.valid.snd q)) =
Finsupp.filter (fun i => (i, false) < min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q)))
(eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q))
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀_spec | [98, 1] | [122, 51] | simp [order_eq_of_mul_ready H] | ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : (mul a b).ready q = true
⊢ Finsupp.filter (fun i => (i, false) < min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q)))
(eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)) =
Finsupp.filter (fun i => (i, false) < toOrder (mul a b) q) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : (mul a b).ready q = true
⊢ Finsupp.filter (fun i => (i, false) < min (toOrder a (mul.valid.fst q)) (toOrder b (mul.valid.snd q)))
(eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)) =
Finsupp.filter (fun i => (i, false) < toOrder (mul a b) q) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q))
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀_spec | [98, 1] | [122, 51] | symm | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
⊢ eval₀ (mul a b) q =
Finsupp.filter (fun i => (i, false) < toOrder (mul a b) q) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)) | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
⊢ Finsupp.filter (fun i => (i, false) < toOrder (mul a b) q) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)) =
eval₀ (mul a b) q | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
⊢ eval₀ (mul a b) q =
Finsupp.filter (fun i => (i, false) < toOrder (mul a b) q) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q))
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀_spec | [98, 1] | [122, 51] | simp only [Stream.eval₀, H, dite_false, coe_mul_valid_fst,
mul.valid, coe_mul_valid_snd, Finsupp.filter_eq_zero_iff] | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
⊢ Finsupp.filter (fun i => (i, false) < toOrder (mul a b) q) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)) =
eval₀ (mul a b) q | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
⊢ ∀ (x : ι), (x, false) < toOrder (mul a b) q → (eval a (↑q).1 * eval b (↑q).2) x = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
⊢ Finsupp.filter (fun i => (i, false) < toOrder (mul a b) q) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)) =
eval₀ (mul a b) q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀_spec | [98, 1] | [122, 51] | intro i hi | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
⊢ ∀ (x : ι), (x, false) < toOrder (mul a b) q → (eval a (↑q).1 * eval b (↑q).2) x = 0 | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
i : ι
hi : (i, false) < toOrder (mul a b) q
⊢ (eval a (↑q).1 * eval b (↑q).2) i = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
⊢ ∀ (x : ι), (x, false) < toOrder (mul a b) q → (eval a (↑q).1 * eval b (↑q).2) x = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀_spec | [98, 1] | [122, 51] | simp only [Stream.toOrder, H, mul_index, Prod.Lex.mk_snd_mono_lt_iff, lt_max_iff] at hi | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
i : ι
hi : (i, false) < toOrder (mul a b) q
⊢ (eval a (↑q).1 * eval b (↑q).2) i = 0 | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
i : ι
hi : i < a.index (mul.valid.fst q) ∨ i < b.index (mul.valid.snd q)
⊢ (eval a (↑q).1 * eval b (↑q).2) i = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
i : ι
hi : (i, false) < toOrder (mul a b) q
⊢ (eval a (↑q).1 * eval b (↑q).2) i = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_eval₀_spec | [98, 1] | [122, 51] | refine
mul_eq_zero_of
(hi.imp (fun h => ha.1.eq_zero_of_lt_index i ?_) fun h =>
hb.1.eq_zero_of_lt_index i ?_) <;>
rwa [Stream.index'_val', WithTop.coe_lt_coe] | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
i : ι
hi : i < a.index (mul.valid.fst q) ∨ i < b.index (mul.valid.snd q)
⊢ (eval a (↑q).1 * eval b (↑q).2) i = 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsBounded a
inst✝ : IsBounded b
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
H : ¬(mul a b).ready q = true
i : ι
hi : i < a.index (mul.valid.fst q) ∨ i < b.index (mul.valid.snd q)
⊢ (eval a (↑q).1 * eval b (↑q).2) i = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_mono | [124, 1] | [128, 37] | intro q i | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsMonotonic a
hb : IsMonotonic b
⊢ IsMonotonic (mul a b) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsMonotonic a
hb : IsMonotonic b
q : { q // (mul a b).valid q = true }
i : Lex (ι × Bool)
⊢ index' (mul a b) ↑q ≤ index' (mul a b) ((mul a b).seek q i) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsMonotonic a
hb : IsMonotonic b
⊢ IsMonotonic (mul a b)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_mono | [124, 1] | [128, 37] | simp only [Stream.mul_index'] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsMonotonic a
hb : IsMonotonic b
q : { q // (mul a b).valid q = true }
i : Lex (ι × Bool)
⊢ index' (mul a b) ↑q ≤ index' (mul a b) ((mul a b).seek q i) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsMonotonic a
hb : IsMonotonic b
q : { q // (mul a b).valid q = true }
i : Lex (ι × Bool)
⊢ max (index' a (↑q).1) (index' b (↑q).2) ≤ max (index' a ((mul a b).seek q i).1) (index' b ((mul a b).seek q i).2) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsMonotonic a
hb : IsMonotonic b
q : { q // (mul a b).valid q = true }
i : Lex (ι × Bool)
⊢ index' (mul a b) ↑q ≤ index' (mul a b) ((mul a b).seek q i)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_mono | [124, 1] | [128, 37] | exact max_le_max (ha _ _) (hb _ _) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsMonotonic a
hb : IsMonotonic b
q : { q // (mul a b).valid q = true }
i : Lex (ι × Bool)
⊢ max (index' a (↑q).1) (index' b (↑q).2) ≤ max (index' a ((mul a b).seek q i).1) (index' b ((mul a b).seek q i).2) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsMonotonic a
hb : IsMonotonic b
q : { q // (mul a b).valid q = true }
i : Lex (ι × Bool)
⊢ max (index' a (↑q).1) (index' b (↑q).2) ≤ max (index' a ((mul a b).seek q i).1) (index' b ((mul a b).seek q i).2)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_strict_mono | [130, 1] | [139, 22] | simp only [Stream.mul_index'] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
i : StreamOrder ι
H : toOrder (mul a b) q ≤ i
hr : (mul a b).ready q = true
⊢ index' (mul a b) ↑q < index' (mul a b) ((mul a b).seek q i) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
i : StreamOrder ι
H : toOrder (mul a b) q ≤ i
hr : (mul a b).ready q = true
⊢ max (index' a (↑q).1) (index' b (↑q).2) < max (index' a ((mul a b).seek q i).1) (index' b ((mul a b).seek q i).2) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
i : StreamOrder ι
H : toOrder (mul a b) q ≤ i
hr : (mul a b).ready q = true
⊢ index' (mul a b) ↑q < index' (mul a b) ((mul a b).seek q i)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_strict_mono | [130, 1] | [139, 22] | have := order_eq_of_mul_ready hr | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
i : StreamOrder ι
H : toOrder (mul a b) q ≤ i
hr : (mul a b).ready q = true
⊢ max (index' a (↑q).1) (index' b (↑q).2) < max (index' a ((mul a b).seek q i).1) (index' b ((mul a b).seek q i).2) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
i : StreamOrder ι
H : toOrder (mul a b) q ≤ i
hr : (mul a b).ready q = true
this : toOrder a (mul.valid.fst q) = toOrder (mul a b) q ∧ toOrder b (mul.valid.snd q) = toOrder (mul a b) q
⊢ max (index' a (↑q).1) (index' b (↑q).2) < max (index' a ((mul a b).seek q i).1) (index' b ((mul a b).seek q i).2) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
i : StreamOrder ι
H : toOrder (mul a b) q ≤ i
hr : (mul a b).ready q = true
⊢ max (index' a (↑q).1) (index' b (↑q).2) < max (index' a ((mul a b).seek q i).1) (index' b ((mul a b).seek q i).2)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_strict_mono | [130, 1] | [139, 22] | simp at hr | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
i : StreamOrder ι
H : toOrder (mul a b) q ≤ i
hr : (mul a b).ready q = true
this : toOrder a (mul.valid.fst q) = toOrder (mul a b) q ∧ toOrder b (mul.valid.snd q) = toOrder (mul a b) q
⊢ max (index' a (↑q).1) (index' b (↑q).2) < max (index' a ((mul a b).seek q i).1) (index' b ((mul a b).seek q i).2) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
i : StreamOrder ι
H : toOrder (mul a b) q ≤ i
this : toOrder a (mul.valid.fst q) = toOrder (mul a b) q ∧ toOrder b (mul.valid.snd q) = toOrder (mul a b) q
hr :
(a.ready (mul.valid.fst q) = true ∧ b.ready (mul.valid.snd q) = true) ∧
a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
⊢ max (index' a (↑q).1) (index' b (↑q).2) < max (index' a ((mul a b).seek q i).1) (index' b ((mul a b).seek q i).2) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
i : StreamOrder ι
H : toOrder (mul a b) q ≤ i
hr : (mul a b).ready q = true
this : toOrder a (mul.valid.fst q) = toOrder (mul a b) q ∧ toOrder b (mul.valid.snd q) = toOrder (mul a b) q
⊢ max (index' a (↑q).1) (index' b (↑q).2) < max (index' a ((mul a b).seek q i).1) (index' b ((mul a b).seek q i).2)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_strict_mono | [130, 1] | [139, 22] | apply max_lt_max (ha.lt (hr := hr.1.1) ..) (hb.lt (hr := hr.1.2) ..) <;>
simpa [this] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
i : StreamOrder ι
H : toOrder (mul a b) q ≤ i
this : toOrder a (mul.valid.fst q) = toOrder (mul a b) q ∧ toOrder b (mul.valid.snd q) = toOrder (mul a b) q
hr :
(a.ready (mul.valid.fst q) = true ∧ b.ready (mul.valid.snd q) = true) ∧
a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
⊢ max (index' a (↑q).1) (index' b (↑q).2) < max (index' a ((mul a b).seek q i).1) (index' b ((mul a b).seek q i).2) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u
inst✝ : NonUnitalNonAssocSemiring α
a b : Stream ι α
ha : IsStrictMono a
hb : IsStrictMono b
q : { q // (mul a b).valid q = true }
i : StreamOrder ι
H : toOrder (mul a b) q ≤ i
this : toOrder a (mul.valid.fst q) = toOrder (mul a b) q ∧ toOrder b (mul.valid.snd q) = toOrder (mul a b) q
hr :
(a.ready (mul.valid.fst q) = true ∧ b.ready (mul.valid.snd q) = true) ∧
a.index (mul.valid.fst q) = b.index (mul.valid.snd q)
⊢ max (index' a (↑q).1) (index' b (↑q).2) < max (index' a ((mul a b).seek q i).1) (index' b ((mul a b).seek q i).2)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.next_eval_mul_eq | [141, 1] | [153, 80] | ext j | ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
⊢ eval a (advance (mul a b) ↑q).1 * eval b (advance (mul a b) ↑q).2 =
Finsupp.filter (fun i => toOrder (mul a b) q ≤ (i, false)) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)) | case h
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
⊢ (eval a (advance (mul a b) ↑q).1 * eval b (advance (mul a b) ↑q).2) j =
(Finsupp.filter (fun i => toOrder (mul a b) q ≤ (i, false)) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)))
j | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
⊢ eval a (advance (mul a b) ↑q).1 * eval b (advance (mul a b) ↑q).2 =
Finsupp.filter (fun i => toOrder (mul a b) q ≤ (i, false)) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q))
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.next_eval_mul_eq | [141, 1] | [153, 80] | simp only [Finsupp.mul_apply, Finsupp.filter_apply, Stream.advance_val] | case h
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
⊢ (eval a (advance (mul a b) ↑q).1 * eval b (advance (mul a b) ↑q).2) j =
(Finsupp.filter (fun i => toOrder (mul a b) q ≤ (i, false)) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)))
j | case h
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
⊢ (eval a ((mul a b).seek q (toOrder (mul a b) q)).1) j * (eval b ((mul a b).seek q (toOrder (mul a b) q)).2) j =
if toOrder (mul a b) q ≤ (j, false) then (eval a ↑(mul.valid.fst q)) j * (eval b ↑(mul.valid.snd q)) j else 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
⊢ (eval a (advance (mul a b) ↑q).1 * eval b (advance (mul a b) ↑q).2) j =
(Finsupp.filter (fun i => toOrder (mul a b) q ≤ (i, false)) (eval a ↑(mul.valid.fst q) * eval b ↑(mul.valid.snd q)))
j
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.next_eval_mul_eq | [141, 1] | [153, 80] | split_ifs with hj | case h
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
⊢ (eval a ((mul a b).seek q (toOrder (mul a b) q)).1) j * (eval b ((mul a b).seek q (toOrder (mul a b) q)).2) j =
if toOrder (mul a b) q ≤ (j, false) then (eval a ↑(mul.valid.fst q)) j * (eval b ↑(mul.valid.snd q)) j else 0 | case pos
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : toOrder (mul a b) q ≤ (j, false)
⊢ (eval a ((mul a b).seek q (toOrder (mul a b) q)).1) j * (eval b ((mul a b).seek q (toOrder (mul a b) q)).2) j =
(eval a ↑(mul.valid.fst q)) j * (eval b ↑(mul.valid.snd q)) j
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : ¬toOrder (mul a b) q ≤ (j, false)
⊢ (eval a ((mul a b).seek q (toOrder (mul a b) q)).1) j * (eval b ((mul a b).seek q (toOrder (mul a b) q)).2) j = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
⊢ (eval a ((mul a b).seek q (toOrder (mul a b) q)).1) j * (eval b ((mul a b).seek q (toOrder (mul a b) q)).2) j =
if toOrder (mul a b) q ≤ (j, false) then (eval a ↑(mul.valid.fst q)) j * (eval b ↑(mul.valid.snd q)) j else 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.next_eval_mul_eq | [141, 1] | [153, 80] | simp only [Stream.toOrder, Stream.index'_val, Stream.mul_seek] at hj ⊢ | case pos
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : toOrder (mul a b) q ≤ (j, false)
⊢ (eval a ((mul a b).seek q (toOrder (mul a b) q)).1) j * (eval b ((mul a b).seek q (toOrder (mul a b) q)).2) j =
(eval a ↑(mul.valid.fst q)) j * (eval b ↑(mul.valid.snd q)) j | case pos
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : ((mul a b).index q, (mul a b).ready q) ≤ (j, false)
⊢ (eval a (a.seek (mul.valid.fst q) ((mul a b).index q, (mul a b).ready q))) j *
(eval b (b.seek (mul.valid.snd q) ((mul a b).index q, (mul a b).ready q))) j =
(eval a ↑(mul.valid.fst q)) j * (eval b ↑(mul.valid.snd q)) j | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : toOrder (mul a b) q ≤ (j, false)
⊢ (eval a ((mul a b).seek q (toOrder (mul a b) q)).1) j * (eval b ((mul a b).seek q (toOrder (mul a b) q)).2) j =
(eval a ↑(mul.valid.fst q)) j * (eval b ↑(mul.valid.snd q)) j
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.next_eval_mul_eq | [141, 1] | [153, 80] | dsimp only [mul_seek] | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : ¬toOrder (mul a b) q ≤ (j, false)
⊢ (eval a ((mul a b).seek q (toOrder (mul a b) q)).1) j * (eval b ((mul a b).seek q (toOrder (mul a b) q)).2) j = 0 | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : ¬toOrder (mul a b) q ≤ (j, false)
⊢ (eval a (a.seek (mul.valid.fst q) (toOrder (mul a b) q))) j *
(eval b (b.seek (mul.valid.snd q) (toOrder (mul a b) q))) j =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : ¬toOrder (mul a b) q ≤ (j, false)
⊢ (eval a ((mul a b).seek q (toOrder (mul a b) q)).1) j * (eval b ((mul a b).seek q (toOrder (mul a b) q)).2) j = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.next_eval_mul_eq | [141, 1] | [153, 80] | rw [not_le] at hj | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : ¬toOrder (mul a b) q ≤ (j, false)
⊢ (eval a (a.seek (mul.valid.fst q) (toOrder (mul a b) q))) j *
(eval b (b.seek (mul.valid.snd q) (toOrder (mul a b) q))) j =
0 | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : (j, false) < toOrder (mul a b) q
⊢ (eval a (a.seek (mul.valid.fst q) (toOrder (mul a b) q))) j *
(eval b (b.seek (mul.valid.snd q) (toOrder (mul a b) q))) j =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : ¬toOrder (mul a b) q ≤ (j, false)
⊢ (eval a (a.seek (mul.valid.fst q) (toOrder (mul a b) q))) j *
(eval b (b.seek (mul.valid.snd q) (toOrder (mul a b) q))) j =
0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.next_eval_mul_eq | [141, 1] | [153, 80] | rcases le_max_iff.mp <| toOrder_le_max a b q with hj' | hj' | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : (j, false) < toOrder (mul a b) q
⊢ (eval a (a.seek (mul.valid.fst q) (toOrder (mul a b) q))) j *
(eval b (b.seek (mul.valid.snd q) (toOrder (mul a b) q))) j =
0 | case neg.inl
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : (j, false) < toOrder (mul a b) q
hj' : toOrder (mul a b) q ≤ toOrder a (mul.valid.fst q)
⊢ (eval a (a.seek (mul.valid.fst q) (toOrder (mul a b) q))) j *
(eval b (b.seek (mul.valid.snd q) (toOrder (mul a b) q))) j =
0
case neg.inr
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : (j, false) < toOrder (mul a b) q
hj' : toOrder (mul a b) q ≤ toOrder b (mul.valid.snd q)
⊢ (eval a (a.seek (mul.valid.fst q) (toOrder (mul a b) q))) j *
(eval b (b.seek (mul.valid.snd q) (toOrder (mul a b) q))) j =
0 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : (j, false) < toOrder (mul a b) q
⊢ (eval a (a.seek (mul.valid.fst q) (toOrder (mul a b) q))) j *
(eval b (b.seek (mul.valid.snd q) (toOrder (mul a b) q))) j =
0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.next_eval_mul_eq | [141, 1] | [153, 80] | rw [a.strictMono.eval_seek_eq_zero, MulZeroClass.zero_mul] <;> assumption | case neg.inl
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : (j, false) < toOrder (mul a b) q
hj' : toOrder (mul a b) q ≤ toOrder a (mul.valid.fst q)
⊢ (eval a (a.seek (mul.valid.fst q) (toOrder (mul a b) q))) j *
(eval b (b.seek (mul.valid.snd q) (toOrder (mul a b) q))) j =
0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.inl
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : (j, false) < toOrder (mul a b) q
hj' : toOrder (mul a b) q ≤ toOrder a (mul.valid.fst q)
⊢ (eval a (a.seek (mul.valid.fst q) (toOrder (mul a b) q))) j *
(eval b (b.seek (mul.valid.snd q) (toOrder (mul a b) q))) j =
0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.next_eval_mul_eq | [141, 1] | [153, 80] | rw [b.strictMono.eval_seek_eq_zero, MulZeroClass.mul_zero] <;> assumption | case neg.inr
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : (j, false) < toOrder (mul a b) q
hj' : toOrder (mul a b) q ≤ toOrder b (mul.valid.snd q)
⊢ (eval a (a.seek (mul.valid.fst q) (toOrder (mul a b) q))) j *
(eval b (b.seek (mul.valid.snd q) (toOrder (mul a b) q))) j =
0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.inr
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : { q // (mul a b).valid q = true }
j : ι
hj : (j, false) < toOrder (mul a b) q
hj' : toOrder (mul a b) q ≤ toOrder b (mul.valid.snd q)
⊢ (eval a (a.seek (mul.valid.fst q) (toOrder (mul a b) q))) j *
(eval b (b.seek (mul.valid.snd q) (toOrder (mul a b) q))) j =
0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_spec | [156, 1] | [167, 9] | apply (a.mul b).wf.induction q | ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
⊢ eval (mul a b) q = eval a q.1 * eval b q.2 | ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
⊢ ∀ (x : (mul a b).σ),
(∀ (y : (mul a b).σ), WfRel (mul a b) y x → eval (mul a b) y = eval a y.1 * eval b y.2) →
eval (mul a b) x = eval a x.1 * eval b x.2 | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
⊢ eval (mul a b) q = eval a q.1 * eval b q.2
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_spec | [156, 1] | [167, 9] | clear q | ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
⊢ ∀ (x : (mul a b).σ),
(∀ (y : (mul a b).σ), WfRel (mul a b) y x → eval (mul a b) y = eval a y.1 * eval b y.2) →
eval (mul a b) x = eval a x.1 * eval b x.2 | ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
⊢ ∀ (x : (mul a b).σ),
(∀ (y : (mul a b).σ), WfRel (mul a b) y x → eval (mul a b) y = eval a y.1 * eval b y.2) →
eval (mul a b) x = eval a x.1 * eval b x.2 | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
⊢ ∀ (x : (mul a b).σ),
(∀ (y : (mul a b).σ), WfRel (mul a b) y x → eval (mul a b) y = eval a y.1 * eval b y.2) →
eval (mul a b) x = eval a x.1 * eval b x.2
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_spec | [156, 1] | [167, 9] | intro q ih | ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
⊢ ∀ (x : (mul a b).σ),
(∀ (y : (mul a b).σ), WfRel (mul a b) y x → eval (mul a b) y = eval a y.1 * eval b y.2) →
eval (mul a b) x = eval a x.1 * eval b x.2 | ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
⊢ eval (mul a b) q = eval a q.1 * eval b q.2 | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
⊢ ∀ (x : (mul a b).σ),
(∀ (y : (mul a b).σ), WfRel (mul a b) y x → eval (mul a b) y = eval a y.1 * eval b y.2) →
eval (mul a b) x = eval a x.1 * eval b x.2
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_spec | [156, 1] | [167, 9] | by_cases hv : (a.mul b).valid q | ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
⊢ eval (mul a b) q = eval a q.1 * eval b q.2 | case pos
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
hv : (mul a b).valid q = true
⊢ eval (mul a b) q = eval a q.1 * eval b q.2
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
hv : ¬(mul a b).valid q = true
⊢ eval (mul a b) q = eval a q.1 * eval b q.2 | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
⊢ eval (mul a b) q = eval a q.1 * eval b q.2
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_spec | [156, 1] | [167, 9] | swap | case pos
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
hv : (mul a b).valid q = true
⊢ eval (mul a b) q = eval a q.1 * eval b q.2
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
hv : ¬(mul a b).valid q = true
⊢ eval (mul a b) q = eval a q.1 * eval b q.2 | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
hv : ¬(mul a b).valid q = true
⊢ eval (mul a b) q = eval a q.1 * eval b q.2
case pos
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
hv : (mul a b).valid q = true
⊢ eval (mul a b) q = eval a q.1 * eval b q.2 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
hv : (mul a b).valid q = true
⊢ eval (mul a b) q = eval a q.1 * eval b q.2
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
hv : ¬(mul a b).valid q = true
⊢ eval (mul a b) q = eval a q.1 * eval b q.2
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_spec | [156, 1] | [167, 9] | have := hv | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
hv : ¬(mul a b).valid q = true
⊢ eval (mul a b) q = eval a q.1 * eval b q.2 | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
hv this : ¬(mul a b).valid q = true
⊢ eval (mul a b) q = eval a q.1 * eval b q.2 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
hv : ¬(mul a b).valid q = true
⊢ eval (mul a b) q = eval a q.1 * eval b q.2
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_spec | [156, 1] | [167, 9] | simp only [mul_valid, Bool.and_eq_true, not_and_or, Bool.not_eq_true] at hv | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
hv this : ¬(mul a b).valid q = true
⊢ eval (mul a b) q = eval a q.1 * eval b q.2 | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
this : ¬(mul a b).valid q = true
hv : a.valid q.1 = false ∨ b.valid q.2 = false
⊢ eval (mul a b) q = eval a q.1 * eval b q.2 | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
hv this : ¬(mul a b).valid q = true
⊢ eval (mul a b) q = eval a q.1 * eval b q.2
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamMul.lean | Etch.Verification.Stream.mul_spec | [156, 1] | [167, 9] | rcases hv with hv' | hv' <;> simp [this, hv'] | case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
this : ¬(mul a b).valid q = true
hv : a.valid q.1 = false ∨ b.valid q.2 = false
⊢ eval (mul a b) q = eval a q.1 * eval b q.2 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝³ : LinearOrder ι
α : Type u
inst✝² : NonUnitalNonAssocSemiring α
a b : Stream ι α
inst✝¹ : IsStrictLawful a
inst✝ : IsStrictLawful b
q : (mul a b).σ
ih : ∀ (y : (mul a b).σ), WfRel (mul a b) y q → eval (mul a b) y = eval a y.1 * eval b y.2
this : ¬(mul a b).valid q = true
hv : a.valid q.1 = false ∨ b.valid q.2 = false
⊢ eval (mul a b) q = eval a q.1 * eval b q.2
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.