1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ConcaveOn.slope_anti_adjacent
File: Mathlib/Analysis/Convex/Slope.lean

tactic: have := neg_le_neg (ConvexOn.slope_mono_adjacent hf.neg hx hz hxy hyz)
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
⊢ (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
this : -(((-f) z - (-f) y) / (z - y)) ≤ -(((-f) y - (-f) x) / (y - x))
⊢ (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)

tactic: simp only [Pi.neg_apply, ← neg_div, neg_sub', neg_neg] at this
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
this : -(((-f) z - (-f) y) / (z - y)) ≤ -(((-f) y - (-f) x) / (y - x))
⊢ (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
this : (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
⊢ (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)

tactic: exact this
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : ConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
this : (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
⊢ (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
state_after: no goals
Theorem: Set.image2_subset_iff_left
File: Mathlib/Data/Set/NAry.lean

tactic: simp_rw [image2_subset_iff, image_subset_iff, subset_def, mem_preimage]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f s t ⊆ u ↔ ∀ a ∈ s, (fun b => f a b) '' t ⊆ u
state_after: no goals
Theorem: Con.induction_on_units
File: Mathlib/GroupTheory/Congruence/Basic.lean

tactic: rcases u with ⟨⟨x⟩, ⟨y⟩, h₁, h₂⟩
state_before: M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
inst✝ : Monoid M
c : Con M
p : c.Quotientˣ → Prop
u : c.Quotientˣ
H : ∀ (x y : M) (hxy : c (x * y) 1) (hyx : c (y * x) 1), p { val := ↑x, inv := ↑y, val_inv := ⋯, inv_val := ⋯ }
⊢ p u
state_after: case mk.mk.mk
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
inst✝ : Monoid M
c : Con M
p : c.Quotientˣ → Prop
H : ∀ (x y : M) (hxy : c (x * y) 1) (hyx : c (y * x) 1), p { val := ↑x, inv := ↑y, val_inv := ⋯, inv_val := ⋯ }
val✝ inv✝ : c.Quotient
x y : M
h₁ : Quot.mk r x * Quot.mk r y = 1
h₂ : Quot.mk r y * Quot.mk r x = 1
⊢ p { val := Quot.mk r x, inv := Quot.mk r y, val_inv := h₁, inv_val := h₂ }

tactic: exact H x y (c.eq.1 h₁) (c.eq.1 h₂)
state_before: case mk.mk.mk
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
inst✝ : Monoid M
c : Con M
p : c.Quotientˣ → Prop
H : ∀ (x y : M) (hxy : c (x * y) 1) (hyx : c (y * x) 1), p { val := ↑x, inv := ↑y, val_inv := ⋯, inv_val := ⋯ }
val✝ inv✝ : c.Quotient
x y : M
h₁ : Quot.mk r x * Quot.mk r y = 1
h₂ : Quot.mk r y * Quot.mk r x = 1
⊢ p { val := Quot.mk r x, inv := Quot.mk r y, val_inv := h₁, inv_val := h₂ }
state_after: no goals
Theorem: iSup_split_single
File: Mathlib/Order/CompleteLattice.lean

tactic: convert iSup_split f (fun i => i = i₀)
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : β → α
i₀ : β
⊢ ⨆ i, f i = f i₀ ⊔ ⨆ i, ⨆ (_ : i ≠ i₀), f i
state_after: case h.e'_3.h.e'_3
α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : β → α
i₀ : β
⊢ f i₀ = ⨆ i, ⨆ (_ : i = i₀), f i

tactic: simp
state_before: case h.e'_3.h.e'_3
α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : β → α
i₀ : β
⊢ f i₀ = ⨆ i, ⨆ (_ : i = i₀), f i
state_after: no goals
Theorem: Filter.prod_map_atTop_eq
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [prod_map_map_eq, prod_atTop_atTop_eq, Prod.map_def]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
α₁ : Type u_6
α₂ : Type u_7
β₁ : Type u_8
β₂ : Type u_9
inst✝¹ : Preorder β₁
inst✝ : Preorder β₂
u₁ : β₁ → α₁
u₂ : β₂ → α₂
⊢ map u₁ atTop ×ˢ map u₂ atTop = map (Prod.map u₁ u₂) atTop
state_after: no goals
Theorem: MvFunctor.LiftP_def
File: Mathlib/Control/Functor/Multivariate.lean

tactic: simp [MvFunctor.map_map]
state_before: n : ℕ
α β γ : TypeVec.{u} n
F : TypeVec.{u} n → Type v
inst✝¹ : MvFunctor F
P : α ⟹ TypeVec.repeat n Prop
R : α ⊗ α ⟹ TypeVec.repeat n Prop
inst✝ : LawfulMvFunctor F
x : F α
⊢ ∀ (u : F fun i => Subtype ((fun i x => ofRepeat (P i x)) i)),
    (fun i => Subtype.val) <$$> u = x ↔ subtypeVal P <$$> toSubtype P <$$> u = x
state_after: no goals
Theorem: Int.gcd_least_linear
File: Mathlib/Data/Int/GCD.lean

tactic: simp_rw [← gcd_dvd_iff]
state_before: a b : ℤ
ha : a ≠ 0
⊢ IsLeast {n | 0 < n ∧ ∃ x y, ↑n = a * x + b * y} (a.gcd b)
state_after: a b : ℤ
ha : a ≠ 0
⊢ IsLeast {n | 0 < n ∧ a.gcd b ∣ n} (a.gcd b)

tactic: constructor
state_before: a b : ℤ
ha : a ≠ 0
⊢ IsLeast {n | 0 < n ∧ a.gcd b ∣ n} (a.gcd b)
state_after: case left
a b : ℤ
ha : a ≠ 0
⊢ a.gcd b ∈ {n | 0 < n ∧ a.gcd b ∣ n}

case right
a b : ℤ
ha : a ≠ 0
⊢ a.gcd b ∈ lowerBounds {n | 0 < n ∧ a.gcd b ∣ n}

tactic: simpa [and_true_iff, dvd_refl, Set.mem_setOf_eq] using gcd_pos_of_ne_zero_left b ha
state_before: case left
a b : ℤ
ha : a ≠ 0
⊢ a.gcd b ∈ {n | 0 < n ∧ a.gcd b ∣ n}
state_after: no goals

tactic: simp only [lowerBounds, and_imp, Set.mem_setOf_eq]
state_before: case right
a b : ℤ
ha : a ≠ 0
⊢ a.gcd b ∈ lowerBounds {n | 0 < n ∧ a.gcd b ∣ n}
state_after: case right
a b : ℤ
ha : a ≠ 0
⊢ ∀ ⦃a_1 : ℕ⦄, 0 < a_1 → a.gcd b ∣ a_1 → a.gcd b ≤ a_1

tactic: exact fun n hn_pos hn => Nat.le_of_dvd hn_pos hn
state_before: case right
a b : ℤ
ha : a ≠ 0
⊢ ∀ ⦃a_1 : ℕ⦄, 0 < a_1 → a.gcd b ∣ a_1 → a.gcd b ≤ a_1
state_after: no goals
Theorem: CategoryTheory.NatTrans.congr_app
File: Mathlib/CategoryTheory/Functor/Category.lean

tactic: rw [h]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G H I : C ⥤ D
α β : F ⟶ G
h : α = β
X : C
⊢ α.app X = β.app X
state_after: no goals
Theorem: pow_le_pow_left
File: Mathlib/Algebra/Order/Ring/Basic.lean

tactic: simp
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedSemiring R
a✝ b✝ x y : R
n m : ℕ
a b : R
ha : 0 ≤ a
hab : a ≤ b
⊢ a ^ 0 ≤ b ^ 0
state_after: no goals

tactic: simpa only [pow_succ']
using mul_le_mul hab (pow_le_pow_left ha hab _) (pow_nonneg ha _) (ha.trans hab)
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedSemiring R
a✝ b✝ x y : R
n✝ m : ℕ
a b : R
ha : 0 ≤ a
hab : a ≤ b
n : ℕ
⊢ a ^ (n + 1) ≤ b ^ (n + 1)
state_after: no goals
Theorem: Fin.list_succ_last
File: .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean

tactic: rw [list_succ]
state_before: n : Nat
⊢ list (n + 1) = List.map castSucc (list n) ++ [last n]
state_after: n : Nat
⊢ 0 :: List.map succ (list n) = List.map castSucc (list n) ++ [last n]

tactic: induction n with
| zero => rfl
| succ n ih =>
  rw [list_succ, List.map_cons castSucc, ih]
  simp [Function.comp_def, succ_castSucc]
state_before: n : Nat
⊢ 0 :: List.map succ (list n) = List.map castSucc (list n) ++ [last n]
state_after: no goals

tactic: rfl
state_before: case zero

⊢ 0 :: List.map succ (list 0) = List.map castSucc (list 0) ++ [last 0]
state_after: no goals

tactic: rw [list_succ, List.map_cons castSucc, ih]
state_before: case succ
n : Nat
ih : 0 :: List.map succ (list n) = List.map castSucc (list n) ++ [last n]
⊢ 0 :: List.map succ (list (n + 1)) = List.map castSucc (list (n + 1)) ++ [last (n + 1)]
state_after: case succ
n : Nat
ih : 0 :: List.map succ (list n) = List.map castSucc (list n) ++ [last n]
⊢ 0 :: List.map succ (List.map castSucc (list n) ++ [last n]) =
    castSucc 0 :: List.map castSucc (List.map succ (list n)) ++ [last (n + 1)]

tactic: simp [Function.comp_def, succ_castSucc]
state_before: case succ
n : Nat
ih : 0 :: List.map succ (list n) = List.map castSucc (list n) ++ [last n]
⊢ 0 :: List.map succ (List.map castSucc (list n) ++ [last n]) =
    castSucc 0 :: List.map castSucc (List.map succ (list n)) ++ [last (n + 1)]
state_after: no goals
Theorem: SimpleGraph.ComponentCompl.hom_refl
File: Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean

tactic: change C.map _ = C
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C : G.ComponentCompl L
⊢ hom ⋯ C = C
state_after: V : Type u
G : SimpleGraph V
K L L' M : Set V
C : G.ComponentCompl L
⊢ ConnectedComponent.map (induceHom Hom.id ⋯) C = C

tactic: erw [induceHom_id G Lᶜ, ConnectedComponent.map_id]
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C : G.ComponentCompl L
⊢ ConnectedComponent.map (induceHom Hom.id ⋯) C = C
state_after: no goals
Theorem: IntermediateField.Lifts.exists_lift_of_splits
File: Mathlib/FieldTheory/Extension.lean

tactic: rwa [← x.emb.comp_algebraMap] at h2
state_before: F : Type u_1
E : Type u_2
K : Type u_3
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Field K
inst✝¹ : Algebra F E
inst✝ : Algebra F K
S : Set E
x : Lifts F E K
s : E
h1 : IsIntegral F s
h2 : Splits (algebraMap F K) (minpoly F s)
⊢ Splits (x.emb.comp (algebraMap F ↥x.carrier)) (minpoly F s)
state_after: no goals
Theorem: WeierstrassCurve.Ψ_two
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

tactic: erw [Ψ_ofNat, preΨ'_two, one_mul, if_pos even_two]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
⊢ W.Ψ 2 = W.ψ₂
state_after: no goals
Theorem: MeasureTheory.densityToFinite_ae_lt_top
File: Mathlib/MeasureTheory/Measure/WithDensityFinite.lean

tactic: refine ae_of_forall_measure_lt_top_ae_restrict _ (fun s _ hμs ↦ ?_)
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
⊢ ∀ᵐ (x : α) ∂μ, μ.densityToFinite x < ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ ∀ᵐ (x : α) ∂μ.restrict s, μ.densityToFinite x < ⊤

tactic: suffices ∀ᵐ x ∂μ.toFinite.restrict s, μ.densityToFinite x < ∞ from
  (absolutelyContinuous_toFinite μ).restrict _ this
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ ∀ᵐ (x : α) ∂μ.restrict s, μ.densityToFinite x < ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ ∀ᵐ (x : α) ∂μ.toFinite.restrict s, μ.densityToFinite x < ⊤

tactic: refine ae_lt_top (measurable_densityToFinite μ) ?_
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ ∀ᵐ (x : α) ∂μ.toFinite.restrict s, μ.densityToFinite x < ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ ∫⁻ (x : α) in s, μ.densityToFinite x ∂μ.toFinite ≠ ⊤

tactic: rw [← withDensity_apply', withDensity_densitytoFinite]
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ ∫⁻ (x : α) in s, μ.densityToFinite x ∂μ.toFinite ≠ ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ μ s ≠ ⊤

tactic: exact hμs.ne
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
x✝ : MeasurableSet s
hμs : μ s < ⊤
⊢ μ s ≠ ⊤
state_after: no goals
Theorem: continuousSMul_inf
File: Mathlib/Topology/Algebra/MulAction.lean

tactic: refine continuousSMul_iInf fun b => ?_
state_before: ι : Sort u_1
M : Type u_2
X : Type u_3
inst✝³ : TopologicalSpace M
inst✝² : SMul M X
t₁ t₂ : TopologicalSpace X
inst✝¹ : ContinuousSMul M X
inst✝ : ContinuousSMul M X
⊢ ContinuousSMul M X
state_after: ι : Sort u_1
M : Type u_2
X : Type u_3
inst✝³ : TopologicalSpace M
inst✝² : SMul M X
t₁ t₂ : TopologicalSpace X
inst✝¹ : ContinuousSMul M X
inst✝ : ContinuousSMul M X
b : Bool
⊢ ContinuousSMul M X

tactic: cases b <;> assumption
state_before: ι : Sort u_1
M : Type u_2
X : Type u_3
inst✝³ : TopologicalSpace M
inst✝² : SMul M X
t₁ t₂ : TopologicalSpace X
inst✝¹ : ContinuousSMul M X
inst✝ : ContinuousSMul M X
b : Bool
⊢ ContinuousSMul M X
state_after: no goals
Theorem: SimpleGraph.girth_anti
File: Mathlib/Combinatorics/SimpleGraph/Girth.lean

tactic: simp
state_before: α : Type u_1
G✝ : SimpleGraph α
n : ℕ∞
G H : SimpleGraph α
h : G ≤ H
a : α
w : G.Walk a a
hw : w.IsCycle
⊢ ↑(Walk.mapLe h w).length ≤ ↑w.length
state_after: no goals
Theorem: Polynomial.degree_div_le
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

tactic: by_cases hq : q = 0
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
⊢ (p / q).degree ≤ p.degree
state_after: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
hq : q = 0
⊢ (p / q).degree ≤ p.degree

case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
hq : ¬q = 0
⊢ (p / q).degree ≤ p.degree

tactic: simp [hq]
state_before: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
hq : q = 0
⊢ (p / q).degree ≤ p.degree
state_after: no goals

tactic: rw [div_def, mul_comm, degree_mul_leadingCoeff_inv _ hq]
state_before: case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
hq : ¬q = 0
⊢ (p / q).degree ≤ p.degree
state_after: case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
hq : ¬q = 0
⊢ (p /ₘ (q * C q.leadingCoeff⁻¹)).degree ≤ p.degree

tactic: exact degree_divByMonic_le _ _
state_before: case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
hq : ¬q = 0
⊢ (p /ₘ (q * C q.leadingCoeff⁻¹)).degree ≤ p.degree
state_after: no goals
Theorem: CategoryTheory.Limits.imageSubobject_arrow
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [imageSubobjectIso]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
⊢ (imageSubobjectIso f).hom ≫ image.ι f = (imageSubobject f).arrow
state_after: no goals
Theorem: CategoryTheory.monotone_isoClosure
File: Mathlib/CategoryTheory/ClosedUnderIsomorphisms.lean

tactic: rintro X ⟨X', hX', ⟨e⟩⟩
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
P Q : C → Prop
h : P ≤ Q
⊢ isoClosure P ≤ isoClosure Q
state_after: case intro.intro.intro
C : Type u_1
inst✝ : Category.{u_2, u_1} C
P Q : C → Prop
h : P ≤ Q
X X' : C
hX' : P X'
e : X ≅ X'
⊢ isoClosure Q X

tactic: exact ⟨X', h _ hX', ⟨e⟩⟩
state_before: case intro.intro.intro
C : Type u_1
inst✝ : Category.{u_2, u_1} C
P Q : C → Prop
h : P ≤ Q
X X' : C
hX' : P X'
e : X ≅ X'
⊢ isoClosure Q X
state_after: no goals
Theorem: Multiset.prod_le_prod_of_rel_le
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

tactic: induction' h with _ _ _ _ rh _ rt
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
h : Rel (fun x x_1 => x ≤ x_1) s t
⊢ s.prod ≤ t.prod
state_after: case zero
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
⊢ prod 0 ≤ prod 0

case cons
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a a✝¹ b✝ : α
as✝ bs✝ : Multiset α
rh : a✝¹ ≤ b✝
a✝ : Rel (fun x x_1 => x ≤ x_1) as✝ bs✝
rt : as✝.prod ≤ bs✝.prod
⊢ (a✝¹ ::ₘ as✝).prod ≤ (b✝ ::ₘ bs✝).prod

tactic: rfl
state_before: case zero
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
⊢ prod 0 ≤ prod 0
state_after: no goals

tactic: rw [prod_cons, prod_cons]
state_before: case cons
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a a✝¹ b✝ : α
as✝ bs✝ : Multiset α
rh : a✝¹ ≤ b✝
a✝ : Rel (fun x x_1 => x ≤ x_1) as✝ bs✝
rt : as✝.prod ≤ bs✝.prod
⊢ (a✝¹ ::ₘ as✝).prod ≤ (b✝ ::ₘ bs✝).prod
state_after: case cons
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a a✝¹ b✝ : α
as✝ bs✝ : Multiset α
rh : a✝¹ ≤ b✝
a✝ : Rel (fun x x_1 => x ≤ x_1) as✝ bs✝
rt : as✝.prod ≤ bs✝.prod
⊢ a✝¹ * as✝.prod ≤ b✝ * bs✝.prod

tactic: exact mul_le_mul' rh rt
state_before: case cons
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a a✝¹ b✝ : α
as✝ bs✝ : Multiset α
rh : a✝¹ ≤ b✝
a✝ : Rel (fun x x_1 => x ≤ x_1) as✝ bs✝
rt : as✝.prod ≤ bs✝.prod
⊢ a✝¹ * as✝.prod ≤ b✝ * bs✝.prod
state_after: no goals
Theorem: OnePoint.isOpen_image_coe
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: rw [isOpen_iff_of_not_mem infty_not_mem_image_coe, preimage_image_eq _ coe_injective]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s✝ : Set (OnePoint X)
t s : Set X
⊢ IsOpen (some '' s) ↔ IsOpen s
state_after: no goals
Theorem: List.getElem_eq_getElem?
File: Mathlib/Data/List/Basic.lean

tactic: simp [getElem?_eq_getElem, h]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
i : ℕ
h : i < l.length
⊢ l[i]?.isSome = true
state_after: no goals

tactic: simp [getElem_eq_iff]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
i : ℕ
h : i < l.length
⊢ l[i] = l[i]?.get ⋯
state_after: no goals
Theorem: Polynomial.coeff_mul
File: Mathlib/Algebra/Polynomial/Coeff.lean

tactic: rcases p with ⟨p⟩
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
n : ℕ
⊢ (p * q).coeff n = ∑ x ∈ antidiagonal n, p.coeff x.1 * q.coeff x.2
state_after: case ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r q : R[X]
n : ℕ
p : R[ℕ]
⊢ ({ toFinsupp := p } * q).coeff n = ∑ x ∈ antidiagonal n, { toFinsupp := p }.coeff x.1 * q.coeff x.2

tactic: rcases q with ⟨q⟩
state_before: case ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r q : R[X]
n : ℕ
p : R[ℕ]
⊢ ({ toFinsupp := p } * q).coeff n = ∑ x ∈ antidiagonal n, { toFinsupp := p }.coeff x.1 * q.coeff x.2
state_after: case ofFinsupp.ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r : R[X]
n : ℕ
p q : R[ℕ]
⊢ ({ toFinsupp := p } * { toFinsupp := q }).coeff n =
    ∑ x ∈ antidiagonal n, { toFinsupp := p }.coeff x.1 * { toFinsupp := q }.coeff x.2

tactic: simp_rw [← ofFinsupp_mul, coeff]
state_before: case ofFinsupp.ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r : R[X]
n : ℕ
p q : R[ℕ]
⊢ ({ toFinsupp := p } * { toFinsupp := q }).coeff n =
    ∑ x ∈ antidiagonal n, { toFinsupp := p }.coeff x.1 * { toFinsupp := q }.coeff x.2
state_after: case ofFinsupp.ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r : R[X]
n : ℕ
p q : R[ℕ]
⊢ (p * q) n = ∑ x ∈ antidiagonal n, p x.1 * q x.2

tactic: exact AddMonoidAlgebra.mul_apply_antidiagonal p q n _ Finset.mem_antidiagonal
state_before: case ofFinsupp.ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r : R[X]
n : ℕ
p q : R[ℕ]
⊢ (p * q) n = ∑ x ∈ antidiagonal n, p x.1 * q x.2
state_after: no goals
Theorem: VitaliFamily.fineSubfamilyOn_of_frequently
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

tactic: intro x hx ε εpos
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v✝ v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : ∀ x ∈ s, ∃ᶠ (a : Set α) in v.filterAt x, a ∈ f x
⊢ v.FineSubfamilyOn f s
state_after: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v✝ v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : ∀ x ∈ s, ∃ᶠ (a : Set α) in v.filterAt x, a ∈ f x
x : α
hx : x ∈ s
ε : ℝ
εpos : ε > 0
⊢ ∃ a ∈ v.setsAt x ∩ f x, a ⊆ closedBall x ε

tactic: obtain ⟨a, av, ha, af⟩ : ∃ (a : Set α) , a ∈ v.setsAt x ∧ a ⊆ closedBall x ε ∧ a ∈ f x :=
  v.frequently_filterAt_iff.1 (h x hx) ε εpos
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v✝ v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : ∀ x ∈ s, ∃ᶠ (a : Set α) in v.filterAt x, a ∈ f x
x : α
hx : x ∈ s
ε : ℝ
εpos : ε > 0
⊢ ∃ a ∈ v.setsAt x ∩ f x, a ⊆ closedBall x ε
state_after: case intro.intro.intro
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v✝ v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : ∀ x ∈ s, ∃ᶠ (a : Set α) in v.filterAt x, a ∈ f x
x : α
hx : x ∈ s
ε : ℝ
εpos : ε > 0
a : Set α
av : a ∈ v.setsAt x
ha : a ⊆ closedBall x ε
af : a ∈ f x
⊢ ∃ a ∈ v.setsAt x ∩ f x, a ⊆ closedBall x ε

tactic: exact ⟨a, ⟨av, af⟩, ha⟩
state_before: case intro.intro.intro
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v✝ v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : ∀ x ∈ s, ∃ᶠ (a : Set α) in v.filterAt x, a ∈ f x
x : α
hx : x ∈ s
ε : ℝ
εpos : ε > 0
a : Set α
av : a ∈ v.setsAt x
ha : a ⊆ closedBall x ε
af : a ∈ f x
⊢ ∃ a ∈ v.setsAt x ∩ f x, a ⊆ closedBall x ε
state_after: no goals
Theorem: PartialEquiv.EqOnSource.target_eq
File: Mathlib/Logic/Equiv/PartialEquiv.lean

tactic: simp only [← image_source_eq_target, ← source_eq h, h.2.image_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e'✝ : PartialEquiv β γ
e e' : PartialEquiv α β
h : e ≈ e'
⊢ e.target = e'.target
state_after: no goals
Theorem: PadicInt.exists_pow_neg_lt_rat
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: obtain ⟨k, hk⟩ := @exists_pow_neg_lt p _ ε (mod_cast hε)
state_before: p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
⊢ ∃ k, ↑p ^ (-↑k) < ε
state_after: case intro
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
k : ℕ
hk : ↑p ^ (-↑k) < ↑ε
⊢ ∃ k, ↑p ^ (-↑k) < ε

tactic: use k
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
k : ℕ
hk : ↑p ^ (-↑k) < ↑ε
⊢ ∃ k, ↑p ^ (-↑k) < ε
state_after: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
k : ℕ
hk : ↑p ^ (-↑k) < ↑ε
⊢ ↑p ^ (-↑k) < ε

tactic: rw [show (p : ℝ) = (p : ℚ) by simp] at hk
state_before: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
k : ℕ
hk : ↑p ^ (-↑k) < ↑ε
⊢ ↑p ^ (-↑k) < ε
state_after: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
k : ℕ
hk : ↑↑p ^ (-↑k) < ↑ε
⊢ ↑p ^ (-↑k) < ε

tactic: exact mod_cast hk
state_before: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
k : ℕ
hk : ↑↑p ^ (-↑k) < ↑ε
⊢ ↑p ^ (-↑k) < ε
state_after: no goals

tactic: simp
state_before: p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
k : ℕ
hk : ↑p ^ (-↑k) < ↑ε
⊢ ↑p = ↑↑p
state_after: no goals