1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Ordinal.bsup_lt_ord
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [o.card.lift_id]
state_before: α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
c : Ordinal.{u}
ho : o.card < c.cof
⊢ Cardinal.lift.{u, u} o.card < c.cof
state_after: no goals
Theorem: derivWithin_congr_set
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: simp only [derivWithin, fderivWithin_congr_set h]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
h : s =ᶠ[𝓝 x] t
⊢ derivWithin f s x = derivWithin f t x
state_after: no goals
Theorem: Cardinal.toNat_ne_zero
File: Mathlib/SetTheory/Cardinal/ToNat.lean

tactic: simp [not_or]
state_before: α : Type u
c d : Cardinal.{u}
⊢ toNat c ≠ 0 ↔ c ≠ 0 ∧ c < ℵ₀
state_after: no goals
Theorem: Multiset.le_count_iff_replicate_le
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp only [quot_mk_to_coe'', mem_coe, coe_count]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
n : ℕ
_l : List α
⊢ n ≤ count a (Quot.mk Setoid.r _l) ↔ replicate n a ≤ Quot.mk Setoid.r _l
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
n : ℕ
_l : List α
⊢ n ≤ List.count a _l ↔ replicate n a ≤ ↑_l

tactic: exact le_count_iff_replicate_sublist.trans replicate_le_coe.symm
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
n : ℕ
_l : List α
⊢ n ≤ List.count a _l ↔ replicate n a ≤ ↑_l
state_after: no goals
Theorem: CategoryTheory.Limits.Concrete.widePullback_ext
File: Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean

tactic: apply Concrete.limit_ext
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
B : C
ι : Type w
X : ι → C
f : (j : ι) → X j ⟶ B
inst✝¹ : HasWidePullback B X f
inst✝ : PreservesLimit (wideCospan B X f) (forget C)
x y : (forget C).obj (widePullback B X f)
h₀ : (base f) x = (base f) y
h : ∀ (j : ι), (π f j) x = (π f j) y
⊢ x = y
state_after: case a
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
B : C
ι : Type w
X : ι → C
f : (j : ι) → X j ⟶ B
inst✝¹ : HasWidePullback B X f
inst✝ : PreservesLimit (wideCospan B X f) (forget C)
x y : (forget C).obj (widePullback B X f)
h₀ : (base f) x = (base f) y
h : ∀ (j : ι), (π f j) x = (π f j) y
⊢ ∀ (j : WidePullbackShape ι), (limit.π (wideCospan B X f) j) x = (limit.π (wideCospan B X f) j) y

tactic: rintro (_ | j)
state_before: case a
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
B : C
ι : Type w
X : ι → C
f : (j : ι) → X j ⟶ B
inst✝¹ : HasWidePullback B X f
inst✝ : PreservesLimit (wideCospan B X f) (forget C)
x y : (forget C).obj (widePullback B X f)
h₀ : (base f) x = (base f) y
h : ∀ (j : ι), (π f j) x = (π f j) y
⊢ ∀ (j : WidePullbackShape ι), (limit.π (wideCospan B X f) j) x = (limit.π (wideCospan B X f) j) y
state_after: case a.none
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
B : C
ι : Type w
X : ι → C
f : (j : ι) → X j ⟶ B
inst✝¹ : HasWidePullback B X f
inst✝ : PreservesLimit (wideCospan B X f) (forget C)
x y : (forget C).obj (widePullback B X f)
h₀ : (base f) x = (base f) y
h : ∀ (j : ι), (π f j) x = (π f j) y
⊢ (limit.π (wideCospan B X f) none) x = (limit.π (wideCospan B X f) none) y

case a.some
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
B : C
ι : Type w
X : ι → C
f : (j : ι) → X j ⟶ B
inst✝¹ : HasWidePullback B X f
inst✝ : PreservesLimit (wideCospan B X f) (forget C)
x y : (forget C).obj (widePullback B X f)
h₀ : (base f) x = (base f) y
h : ∀ (j : ι), (π f j) x = (π f j) y
j : ι
⊢ (limit.π (wideCospan B X f) (some j)) x = (limit.π (wideCospan B X f) (some j)) y

tactic: exact h₀
state_before: case a.none
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
B : C
ι : Type w
X : ι → C
f : (j : ι) → X j ⟶ B
inst✝¹ : HasWidePullback B X f
inst✝ : PreservesLimit (wideCospan B X f) (forget C)
x y : (forget C).obj (widePullback B X f)
h₀ : (base f) x = (base f) y
h : ∀ (j : ι), (π f j) x = (π f j) y
⊢ (limit.π (wideCospan B X f) none) x = (limit.π (wideCospan B X f) none) y
state_after: no goals

tactic: apply h
state_before: case a.some
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
B : C
ι : Type w
X : ι → C
f : (j : ι) → X j ⟶ B
inst✝¹ : HasWidePullback B X f
inst✝ : PreservesLimit (wideCospan B X f) (forget C)
x y : (forget C).obj (widePullback B X f)
h₀ : (base f) x = (base f) y
h : ∀ (j : ι), (π f j) x = (π f j) y
j : ι
⊢ (limit.π (wideCospan B X f) (some j)) x = (limit.π (wideCospan B X f) (some j)) y
state_after: no goals
Theorem: Fin.univ_succAbove
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
p : Fin (n + 1)
⊢ p ∉ map p.succAboveEmb univ
state_after: no goals

tactic: simp [map_eq_image]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
p : Fin (n + 1)
⊢ univ = Finset.cons p (map p.succAboveEmb univ) ⋯
state_after: no goals
Theorem: List.getD_append
File: Mathlib/Data/List/GetD.lean

tactic: rw [getD_eq_get _ _ (Nat.lt_of_lt_of_le h (length_append _ _ ▸ Nat.le_add_right _ _)),
  get_append _ h, getD_eq_get]
state_before: α : Type u
β : Type v
l✝ : List α
x : α
xs : List α
n✝ : ℕ
d✝ : α
l l' : List α
d : α
n : ℕ
h : n < l.length
⊢ (l ++ l').getD n d = l.getD n d
state_after: no goals
Theorem: Finset.noncommProd_erase_mul
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: classical
simpa only [← Multiset.map_erase_of_mem _ _ h] using
  Multiset.noncommProd_erase_mul (s.1.map f) (Multiset.mem_map_of_mem f h) _
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝³ : Monoid β
inst✝² : Monoid γ
inst✝¹ : FunLike F β γ
inst✝ : DecidableEq α
s : Finset α
a : α
h : a ∈ s
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
comm' : optParam (∀ x ∈ ↑(s.erase a), ∀ y ∈ ↑(s.erase a), x ≠ y → (fun a b => Commute (f a) (f b)) x y) ⋯
⊢ (s.erase a).noncommProd f comm' * f a = s.noncommProd f comm
state_after: no goals

tactic: simpa only [← Multiset.map_erase_of_mem _ _ h] using
  Multiset.noncommProd_erase_mul (s.1.map f) (Multiset.mem_map_of_mem f h) _
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝³ : Monoid β
inst✝² : Monoid γ
inst✝¹ : FunLike F β γ
inst✝ : DecidableEq α
s : Finset α
a : α
h : a ∈ s
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
comm' : optParam (∀ x ∈ ↑(s.erase a), ∀ y ∈ ↑(s.erase a), x ≠ y → (fun a b => Commute (f a) (f b)) x y) ⋯
⊢ (s.erase a).noncommProd f comm' * f a = s.noncommProd f comm
state_after: no goals
Theorem: MonoidAlgebra.support_mul_single_eq_image
File: Mathlib/Algebra/MonoidAlgebra/Support.lean

tactic: refine subset_antisymm (support_mul_single_subset f _ _) fun y hy => ?_
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x : G
rx : IsRightRegular x
⊢ (f * single x r).support = image (fun x_1 => x_1 * x) f.support
state_after: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x : G
rx : IsRightRegular x
y : G
hy : y ∈ image (fun x_1 => x_1 * x) f.support
⊢ y ∈ (f * single x r).support

tactic: obtain ⟨y, yf, rfl⟩ : ∃ a : G, a ∈ f.support ∧ a * x = y := by
  simpa only [Finset.mem_image, exists_prop] using hy
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x : G
rx : IsRightRegular x
y : G
hy : y ∈ image (fun x_1 => x_1 * x) f.support
⊢ y ∈ (f * single x r).support
state_after: case intro.intro
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x : G
rx : IsRightRegular x
y : G
yf : y ∈ f.support
hy : y * x ∈ image (fun x_1 => x_1 * x) f.support
⊢ y * x ∈ (f * single x r).support

tactic: simp only [mul_apply, mem_support_iff.mp yf, hr, mem_support_iff, sum_single_index,
  Finsupp.sum_ite_eq', Ne, not_false_iff, if_true, mul_zero, ite_self, sum_zero, rx.eq_iff]
state_before: case intro.intro
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x : G
rx : IsRightRegular x
y : G
yf : y ∈ f.support
hy : y * x ∈ image (fun x_1 => x_1 * x) f.support
⊢ y * x ∈ (f * single x r).support
state_after: no goals

tactic: simpa only [Finset.mem_image, exists_prop] using hy
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), y * r = 0 ↔ y = 0
x : G
rx : IsRightRegular x
y : G
hy : y ∈ image (fun x_1 => x_1 * x) f.support
⊢ ∃ a ∈ f.support, a * x = y
state_after: no goals
Theorem: MeasureTheory.stoppedValue_piecewise_const
File: Mathlib/Probability/Process/Stopping.lean

tactic: ext ω
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : Preorder ι
𝒢 : Filtration ι m
τ η : Ω → ι
i✝ j✝ : ι
s : Set Ω
inst✝ : DecidablePred fun x => x ∈ s
ι' : Type u_4
i j : ι'
f : ι' → Ω → ℝ
⊢ stoppedValue f (s.piecewise (fun x => i) fun x => j) = s.piecewise (f i) (f j)
state_after: case h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : Preorder ι
𝒢 : Filtration ι m
τ η : Ω → ι
i✝ j✝ : ι
s : Set Ω
inst✝ : DecidablePred fun x => x ∈ s
ι' : Type u_4
i j : ι'
f : ι' → Ω → ℝ
ω : Ω
⊢ stoppedValue f (s.piecewise (fun x => i) fun x => j) ω = s.piecewise (f i) (f j) ω

tactic: rw [stoppedValue]
state_before: case h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : Preorder ι
𝒢 : Filtration ι m
τ η : Ω → ι
i✝ j✝ : ι
s : Set Ω
inst✝ : DecidablePred fun x => x ∈ s
ι' : Type u_4
i j : ι'
f : ι' → Ω → ℝ
ω : Ω
⊢ stoppedValue f (s.piecewise (fun x => i) fun x => j) ω = s.piecewise (f i) (f j) ω
state_after: case h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : Preorder ι
𝒢 : Filtration ι m
τ η : Ω → ι
i✝ j✝ : ι
s : Set Ω
inst✝ : DecidablePred fun x => x ∈ s
ι' : Type u_4
i j : ι'
f : ι' → Ω → ℝ
ω : Ω
⊢ f (s.piecewise (fun x => i) (fun x => j) ω) ω = s.piecewise (f i) (f j) ω

tactic: by_cases hx : ω ∈ s <;> simp [hx]
state_before: case h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : Preorder ι
𝒢 : Filtration ι m
τ η : Ω → ι
i✝ j✝ : ι
s : Set Ω
inst✝ : DecidablePred fun x => x ∈ s
ι' : Type u_4
i j : ι'
f : ι' → Ω → ℝ
ω : Ω
⊢ f (s.piecewise (fun x => i) (fun x => j) ω) ω = s.piecewise (f i) (f j) ω
state_after: no goals
Theorem: AddCommGroup.not_modEq_iff_ne_add_zsmul
File: Mathlib/Algebra/ModEq.lean

tactic: rw [modEq_iff_eq_add_zsmul, not_exists]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ ¬a ≡ b [PMOD p] ↔ ∀ (z : ℤ), b ≠ a + z • p
state_after: no goals
Theorem: MvPolynomial.totalDegree_list_prod
File: Mathlib/Algebra/MvPolynomial/Degrees.lean

tactic: rw [@List.prod_nil (MvPolynomial σ R) _, totalDegree_one]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
⊢ [].prod.totalDegree ≤ (List.map totalDegree []).sum
state_after: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
⊢ 0 ≤ (List.map totalDegree []).sum

tactic: rfl
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
⊢ 0 ≤ (List.map totalDegree []).sum
state_after: no goals

tactic: rw [@List.prod_cons (MvPolynomial σ R) _, List.map, List.sum_cons]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
ps : List (MvPolynomial σ R)
⊢ (p :: ps).prod.totalDegree ≤ (List.map totalDegree (p :: ps)).sum
state_after: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
ps : List (MvPolynomial σ R)
⊢ (p * ps.prod).totalDegree ≤ p.totalDegree + (List.map totalDegree ps).sum

tactic: exact le_trans (totalDegree_mul _ _) (add_le_add_left (totalDegree_list_prod ps) _)
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
ps : List (MvPolynomial σ R)
⊢ (p * ps.prod).totalDegree ≤ p.totalDegree + (List.map totalDegree ps).sum
state_after: no goals
Theorem: OmegaCompletePartialOrder.continuous_comp
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: dsimp [Continuous] at *
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
hfc : Continuous f
hgc : Continuous g
⊢ Continuous (g.comp f)
state_after: α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
hfc : ∀ (c : Chain α), f (ωSup c) = ωSup (c.map f)
hgc : ∀ (c : Chain β), g (ωSup c) = ωSup (c.map g)
⊢ ∀ (c : Chain α), g (f (ωSup c)) = ωSup (c.map (g.comp f))

tactic: intro
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
hfc : ∀ (c : Chain α), f (ωSup c) = ωSup (c.map f)
hgc : ∀ (c : Chain β), g (ωSup c) = ωSup (c.map g)
⊢ ∀ (c : Chain α), g (f (ωSup c)) = ωSup (c.map (g.comp f))
state_after: α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
hfc : ∀ (c : Chain α), f (ωSup c) = ωSup (c.map f)
hgc : ∀ (c : Chain β), g (ωSup c) = ωSup (c.map g)
c✝ : Chain α
⊢ g (f (ωSup c✝)) = ωSup (c✝.map (g.comp f))

tactic: rw [hfc, hgc, Chain.map_comp]
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
hfc : ∀ (c : Chain α), f (ωSup c) = ωSup (c.map f)
hgc : ∀ (c : Chain β), g (ωSup c) = ωSup (c.map g)
c✝ : Chain α
⊢ g (f (ωSup c✝)) = ωSup (c✝.map (g.comp f))
state_after: no goals
Theorem: Set.Ici_add_bij
File: Mathlib/Algebra/Order/Interval/Set/Monoid.lean

tactic: refine
  ⟨fun x h => add_le_add_right (mem_Ici.mp h) _, (add_left_injective d).injOn, fun _ h => ?_⟩
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ici a) (Ici (a + d))
state_after: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d x✝ : M
h : x✝ ∈ Ici (a + d)
⊢ x✝ ∈ (fun x => x + d) '' Ici a

tactic: obtain ⟨c, rfl⟩ := exists_add_of_le (mem_Ici.mp h)
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d x✝ : M
h : x✝ ∈ Ici (a + d)
⊢ x✝ ∈ (fun x => x + d) '' Ici a
state_after: case intro
M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a + d + c ∈ Ici (a + d)
⊢ a + d + c ∈ (fun x => x + d) '' Ici a

tactic: rw [mem_Ici, add_right_comm, add_le_add_iff_right] at h
state_before: case intro
M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a + d + c ∈ Ici (a + d)
⊢ a + d + c ∈ (fun x => x + d) '' Ici a
state_after: case intro
M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a ≤ a + c
⊢ a + d + c ∈ (fun x => x + d) '' Ici a

tactic: exact ⟨a + c, h, by rw [add_right_comm]⟩
state_before: case intro
M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a ≤ a + c
⊢ a + d + c ∈ (fun x => x + d) '' Ici a
state_after: no goals

tactic: rw [add_right_comm]
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a ≤ a + c
⊢ (fun x => x + d) (a + c) = a + d + c
state_after: no goals
Theorem: CategoryTheory.ComposableArrows.homMk₅_app_two
File: Mathlib/CategoryTheory/ComposableArrows.lean

tactic: valid
state_before: C : Type u_1
inst✝ : Category.{?u.416065, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 5
app₀ : f.obj' 0 ⋯ ⟶ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ⟶ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ⟶ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ⟶ g.obj' 3 ⋯
app₄ : f.obj' 4 ⋯ ⟶ g.obj' 4 ⋯
app₅ : f.obj' 5 ⋯ ⟶ g.obj' 5 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁ = app₀ ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂ = app₁ ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃ = app₂ ≫ g.map' 2 3 ⋯ ⋯
w₃ : f.map' 3 4 ⋯ ⋯ ≫ app₄ = app₃ ≫ g.map' 3 4 ⋯ ⋯
w₄ : f.map' 4 5 ⋯ ⋯ ≫ app₅ = app₄ ≫ g.map' 4 5 ⋯ ⋯
⊢ 2 < 5 + 1
state_after: no goals
Theorem: Int.testBit_lor
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [← bitwise_or, testBit_bitwise]
state_before: m n : ℤ
k : ℕ
⊢ (m.lor n).testBit k = (m.testBit k || n.testBit k)
state_after: no goals
Theorem: FractionalIdeal.count_inv
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

tactic: rw [← zpow_neg_one, count_neg_zpow K v (1 : ℤ) I, zpow_one]
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : FractionalIdeal R⁰ K
⊢ count K v I⁻¹ = -count K v I
state_after: no goals
Theorem: AddMonoidHom.apply_int
File: Mathlib/Data/Int/Cast/Lemmas.lean

tactic: rw [← zmultiplesHom_symm_apply, ← zmultiplesHom_apply, Equiv.apply_symm_apply]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝¹ : Group α
inst✝ : AddGroup α
f : ℤ →+ α
n : ℤ
⊢ f n = n • f 1
state_after: no goals
Theorem: NNReal.hasSum_lt
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: have A : ∀ a : α, (f a : ℝ) ≤ g a := fun a => NNReal.coe_le_coe.2 (h a)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → ℝ≥0
sf sg : ℝ≥0
i : α
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
hf : HasSum f sf
hg : HasSum g sg
⊢ sf < sg
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → ℝ≥0
sf sg : ℝ≥0
i : α
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
hf : HasSum f sf
hg : HasSum g sg
A : ∀ (a : α), ↑(f a) ≤ ↑(g a)
⊢ sf < sg

tactic: have : (sf : ℝ) < sg := hasSum_lt A (NNReal.coe_lt_coe.2 hi) (hasSum_coe.2 hf) (hasSum_coe.2 hg)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → ℝ≥0
sf sg : ℝ≥0
i : α
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
hf : HasSum f sf
hg : HasSum g sg
A : ∀ (a : α), ↑(f a) ≤ ↑(g a)
⊢ sf < sg
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → ℝ≥0
sf sg : ℝ≥0
i : α
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
hf : HasSum f sf
hg : HasSum g sg
A : ∀ (a : α), ↑(f a) ≤ ↑(g a)
this : ↑sf < ↑sg
⊢ sf < sg

tactic: exact NNReal.coe_lt_coe.1 this
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → ℝ≥0
sf sg : ℝ≥0
i : α
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
hf : HasSum f sf
hg : HasSum g sg
A : ∀ (a : α), ↑(f a) ≤ ↑(g a)
this : ↑sf < ↑sg
⊢ sf < sg
state_after: no goals
Theorem: le_symmDiff_sup_right
File: Mathlib/Order/SymmDiff.lean

tactic: convert symmDiff_triangle a b ⊥ <;> rw [symmDiff_bot]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c d a b : α
⊢ a ≤ a ∆ b ⊔ b
state_after: no goals
Theorem: Real.logb_le_logb
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [logb, logb, div_le_div_right (log_pos hb), log_le_log_iff h h₁]
state_before: b x y : ℝ
hb : 1 < b
h : 0 < x
h₁ : 0 < y
⊢ logb b x ≤ logb b y ↔ x ≤ y
state_after: no goals
Theorem: Monoid.one_lt_exponent
File: Mathlib/GroupTheory/Exponent.lean

tactic: rw [Nat.one_lt_iff_ne_zero_and_ne_one]
state_before: G : Type u
inst✝² : LeftCancelMonoid G
inst✝¹ : Finite G
inst✝ : Nontrivial G
⊢ 1 < exponent G
state_after: G : Type u
inst✝² : LeftCancelMonoid G
inst✝¹ : Finite G
inst✝ : Nontrivial G
⊢ exponent G ≠ 0 ∧ exponent G ≠ 1

tactic: exact ⟨exponent_ne_zero_of_finite, mt exp_eq_one_iff.mp (not_subsingleton G)⟩
state_before: G : Type u
inst✝² : LeftCancelMonoid G
inst✝¹ : Finite G
inst✝ : Nontrivial G
⊢ exponent G ≠ 0 ∧ exponent G ≠ 1
state_after: no goals
Theorem: IsOfFinOrder.of_mem_zpowers
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: obtain ⟨k, rfl⟩ := Subgroup.mem_zpowers_iff.mp h'
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x y : G
i : ℤ
h : IsOfFinOrder x
h' : y ∈ zpowers x
⊢ IsOfFinOrder y
state_after: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x : G
i : ℤ
h : IsOfFinOrder x
k : ℤ
h' : x ^ k ∈ zpowers x
⊢ IsOfFinOrder (x ^ k)

tactic: exact h.zpow
state_before: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x : G
i : ℤ
h : IsOfFinOrder x
k : ℤ
h' : x ^ k ∈ zpowers x
⊢ IsOfFinOrder (x ^ k)
state_after: no goals
Theorem: CochainComplex.mappingCone.lift_snd
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

tactic: simp
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
α : Cocycle K F 1
β : Cochain K G 0
eq : δ 0 1 β + (↑α).comp (Cochain.ofHom φ) ⋯ = 0
⊢ (Cochain.ofHom (lift φ α β eq)).comp (snd φ) ⋯ = β
state_after: no goals
Theorem: MeasureTheory.Measure.fst_map_swap
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: rw [Measure.fst, Measure.map_map measurable_fst measurable_swap]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SFinite ν
ρ : Measure (α × β)
⊢ (map Prod.swap ρ).fst = ρ.snd
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SFinite ν
ρ : Measure (α × β)
⊢ map (Prod.fst ∘ Prod.swap) ρ = ρ.snd

tactic: rfl
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SFinite ν
ρ : Measure (α × β)
⊢ map (Prod.fst ∘ Prod.swap) ρ = ρ.snd
state_after: no goals