1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Set.nontrivial_of_einfsep_lt_top
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: rcases einfsep_lt_top.1 hs with ⟨_, hx, _, hy, hxy, _⟩
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
hs : s.einfsep < ⊤
⊢ s.Nontrivial
state_after: case intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
hs : s.einfsep < ⊤
w✝¹ : α
hx : w✝¹ ∈ s
w✝ : α
hy : w✝ ∈ s
hxy : w✝¹ ≠ w✝
right✝ : edist w✝¹ w✝ < ⊤
⊢ s.Nontrivial

tactic: exact ⟨_, hx, _, hy, hxy⟩
state_before: case intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
hs : s.einfsep < ⊤
w✝¹ : α
hx : w✝¹ ∈ s
w✝ : α
hy : w✝ ∈ s
hxy : w✝¹ ≠ w✝
right✝ : edist w✝¹ w✝ < ⊤
⊢ s.Nontrivial
state_after: no goals
Theorem: SmoothBumpFunction.isOpen_support
File: Mathlib/Geometry/Manifold/BumpFunction.lean

tactic: rw [support_eq_inter_preimage]
state_before: E : Type uE
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : FiniteDimensional ℝ E
H : Type uH
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
c : M
f : SmoothBumpFunction I c
x : M
⊢ IsOpen (support ↑f)
state_after: E : Type uE
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : FiniteDimensional ℝ E
H : Type uH
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
c : M
f : SmoothBumpFunction I c
x : M
⊢ IsOpen ((chartAt H c).source ∩ ↑(extChartAt I c) ⁻¹' ball (↑(extChartAt I c) c) f.rOut)

tactic: exact isOpen_extChartAt_preimage I c isOpen_ball
state_before: E : Type uE
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : FiniteDimensional ℝ E
H : Type uH
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
c : M
f : SmoothBumpFunction I c
x : M
⊢ IsOpen ((chartAt H c).source ∩ ↑(extChartAt I c) ⁻¹' ball (↑(extChartAt I c) c) f.rOut)
state_after: no goals
Theorem: Mathlib.Tactic.Abel.term_add_const
File: Mathlib/Tactic/Abel.lean

tactic: simp [h.symm, term, add_assoc]
state_before: α : Type u_1
inst✝ : AddCommMonoid α
n : ℕ
x a k a' : α
h : a + k = a'
⊢ term n x a + k = term n x a'
state_after: no goals
Theorem: AddLECancellable.add_tsub_cancel_right
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [add_comm]
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
⊢ a + b = a + b
state_after: no goals
Theorem: Stream'.mem_of_mem_even
File: Mathlib/Data/Stream/Init.lean

tactic: rw [h, get_even]
state_before: α : Type u
β : Type v
δ : Type w
a : α
s : Stream' α
x✝ : a ∈ s.even
n : ℕ
h : (fun b => a = b) (s.even.get n)
⊢ (fun b => a = b) (s.get (2 * n))
state_after: no goals
Theorem: CategoryTheory.Sieve.functorPushforward_comp
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: ext
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
R : Sieve X
⊢ functorPushforward (F ⋙ G) R = functorPushforward G (functorPushforward F R)
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
R : Sieve X
Y✝ : E
f✝ : Y✝ ⟶ (F ⋙ G).obj X
⊢ (functorPushforward (F ⋙ G) R).arrows f✝ ↔ (functorPushforward G (functorPushforward F R)).arrows f✝

tactic: simp [R.arrows.functorPushforward_comp F G]
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
R : Sieve X
Y✝ : E
f✝ : Y✝ ⟶ (F ⋙ G).obj X
⊢ (functorPushforward (F ⋙ G) R).arrows f✝ ↔ (functorPushforward G (functorPushforward F R)).arrows f✝
state_after: no goals
Theorem: Real.strictMonoOn_logb_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rintro x (hx : x < 0) y (hy : y < 0) hxy
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
⊢ StrictMonoOn (logb b) (Iio 0)
state_after: b x✝ y✝ : ℝ
b_pos : 0 < b
b_lt_one : b < 1
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x < y
⊢ logb b x < logb b y

tactic: rw [← logb_abs y, ← logb_abs x]
state_before: b x✝ y✝ : ℝ
b_pos : 0 < b
b_lt_one : b < 1
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x < y
⊢ logb b x < logb b y
state_after: b x✝ y✝ : ℝ
b_pos : 0 < b
b_lt_one : b < 1
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x < y
⊢ logb b |x| < logb b |y|

tactic: refine logb_lt_logb_of_base_lt_one b_pos b_lt_one (abs_pos.2 hy.ne) ?_
state_before: b x✝ y✝ : ℝ
b_pos : 0 < b
b_lt_one : b < 1
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x < y
⊢ logb b |x| < logb b |y|
state_after: b x✝ y✝ : ℝ
b_pos : 0 < b
b_lt_one : b < 1
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x < y
⊢ |y| < |x|

tactic: rwa [abs_of_neg hy, abs_of_neg hx, neg_lt_neg_iff]
state_before: b x✝ y✝ : ℝ
b_pos : 0 < b
b_lt_one : b < 1
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x < y
⊢ |y| < |x|
state_after: no goals
Theorem: FiniteDimensional.finrank_fin_fun
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

tactic: simp
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹³ : Ring R
inst✝¹² : CommRing S
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup M'
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : Module R M
inst✝⁷ : Module R M'
inst✝⁶ : Module R M₁
inst✝⁵ : StrongRankCondition R
inst✝⁴ : Module.Free R M
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module R (φ i)
inst✝¹ : ∀ (i : η), Module.Free R (φ i)
inst✝ : Fintype η
n : ℕ
⊢ finrank R (Fin n → R) = n
state_after: no goals
Theorem: List.zipWith_nil
File: Mathlib/Data/List/Basic.lean

tactic: cases l <;> rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β → γ
l : List α
⊢ zipWith f l [] = []
state_after: no goals
Theorem: Fin.succ_le_castSucc_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [le_castSucc_iff, succ_lt_succ_iff]
state_before: n m : ℕ
a b : Fin n
⊢ a.succ ≤ b.castSucc ↔ a < b
state_after: no goals
Theorem: SetTheory.PGame.zero_lf_le
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [lf_iff_exists_le]
state_before: xl xr : Type u
x : PGame
⊢ 0 ⧏ x ↔ ∃ i, 0 ≤ x.moveLeft i
state_after: xl xr : Type u
x : PGame
⊢ ((∃ i, 0 ≤ x.moveLeft i) ∨ ∃ j, moveRight 0 j ≤ x) ↔ ∃ i, 0 ≤ x.moveLeft i

tactic: simp
state_before: xl xr : Type u
x : PGame
⊢ ((∃ i, 0 ≤ x.moveLeft i) ∨ ∃ j, moveRight 0 j ≤ x) ↔ ∃ i, 0 ≤ x.moveLeft i
state_after: no goals
Theorem: one_pow
File: Mathlib/Algebra/Group/Defs.lean

tactic: rw [pow_succ, one_pow, one_mul]
state_before: G : Type u_1
M : Type u_2
inst✝ : Monoid M
a b c : M
m n✝ n : ℕ
⊢ 1 ^ (n + 1) = 1
state_after: no goals
Theorem: Nat.div_le_div_right
File: Mathlib/Data/Nat/Defs.lean

tactic: simp [hc]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : a ≤ b
hc : c = 0
⊢ a / c ≤ b / c
state_after: no goals
Theorem: IsometryEquiv.image_sphere
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: rw [← h.preimage_symm, h.symm.preimage_sphere, symm_symm]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
h✝ h : α ≃ᵢ β
x : α
r : ℝ
⊢ ⇑h '' Metric.sphere x r = Metric.sphere (h x) r
state_after: no goals
Theorem: Localization.mulEquivOfQuotient_symm_mk
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [mk_eq_monoidOf_mk'_apply]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x : M
y : ↥S
⊢ (mulEquivOfQuotient f).symm (f.mk' x y) = mk x y
state_after: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x : M
y : ↥S
⊢ (mulEquivOfQuotient f).symm (f.mk' x y) = (monoidOf S).mk' x y

tactic: exact mulEquivOfQuotient_symm_mk' _ _
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x : M
y : ↥S
⊢ (mulEquivOfQuotient f).symm (f.mk' x y) = (monoidOf S).mk' x y
state_after: no goals
Theorem: Ordnode.Valid'.balanceR
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [Valid'.dual_iff, dual_balanceR]
state_before: α : Type u_1
inst✝ : Preorder α
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
hl : Valid' o₁ l ↑x
hr : Valid' (↑x) r o₂
H : (∃ l', Raised l.size l' ∧ BalancedSz l' r.size) ∨ ∃ r', Raised r' r.size ∧ BalancedSz l.size r'
⊢ Valid' o₁ (l.balanceR x r) o₂
state_after: α : Type u_1
inst✝ : Preorder α
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
hl : Valid' o₁ l ↑x
hr : Valid' (↑x) r o₂
H : (∃ l', Raised l.size l' ∧ BalancedSz l' r.size) ∨ ∃ r', Raised r' r.size ∧ BalancedSz l.size r'
⊢ Valid' o₂ (r.dual.balanceL x l.dual) o₁

tactic: exact hr.dual.balanceL hl.dual (balance_sz_dual H)
state_before: α : Type u_1
inst✝ : Preorder α
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
hl : Valid' o₁ l ↑x
hr : Valid' (↑x) r o₂
H : (∃ l', Raised l.size l' ∧ BalancedSz l' r.size) ∨ ∃ r', Raised r' r.size ∧ BalancedSz l.size r'
⊢ Valid' o₂ (r.dual.balanceL x l.dual) o₁
state_after: no goals
Theorem: Matrix.vecMulVec_eq
File: Mathlib/Data/Matrix/RowCol.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝² : Mul α
inst✝¹ : AddCommMonoid α
inst✝ : Unique ι
w : m → α
v : n → α
⊢ vecMulVec w v = col ι w * row ι v
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝² : Mul α
inst✝¹ : AddCommMonoid α
inst✝ : Unique ι
w : m → α
v : n → α
i✝ : m
j✝ : n
⊢ vecMulVec w v i✝ j✝ = (col ι w * row ι v) i✝ j✝

tactic: simp [vecMulVec, mul_apply]
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝² : Mul α
inst✝¹ : AddCommMonoid α
inst✝ : Unique ι
w : m → α
v : n → α
i✝ : m
j✝ : n
⊢ vecMulVec w v i✝ j✝ = (col ι w * row ι v) i✝ j✝
state_after: no goals
Theorem: lineDerivWithin_of_mem_nhds
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

tactic: apply derivWithin_of_mem_nhds
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ : E → F
f' : F
s t : Set E
x v : E
L : E →L[𝕜] F
h : s ∈ 𝓝 x
⊢ lineDerivWithin 𝕜 f s x v = lineDeriv 𝕜 f x v
state_after: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ : E → F
f' : F
s t : Set E
x v : E
L : E →L[𝕜] F
h : s ∈ 𝓝 x
⊢ (fun t => x + t • v) ⁻¹' s ∈ 𝓝 0

tactic: apply (Continuous.continuousAt _).preimage_mem_nhds (by simpa using h)
state_before: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ : E → F
f' : F
s t : Set E
x v : E
L : E →L[𝕜] F
h : s ∈ 𝓝 x
⊢ (fun t => x + t • v) ⁻¹' s ∈ 𝓝 0
state_after: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ : E → F
f' : F
s t : Set E
x v : E
L : E →L[𝕜] F
h : s ∈ 𝓝 x
⊢ Continuous fun t => x + t • v

tactic: fun_prop
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ : E → F
f' : F
s t : Set E
x v : E
L : E →L[𝕜] F
h : s ∈ 𝓝 x
⊢ Continuous fun t => x + t • v
state_after: no goals

tactic: simpa using h
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ : E → F
f' : F
s t : Set E
x v : E
L : E →L[𝕜] F
h : s ∈ 𝓝 x
⊢ s ∈ 𝓝 (x + 0 • v)
state_after: no goals
Theorem: hasSum_iff_tendsto_nat_of_nonneg
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: lift f to ℕ → ℝ≥0 using hf
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ
hf : ∀ (i : ℕ), 0 ≤ f i
r : ℝ
⊢ HasSum f r ↔ Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop (𝓝 r)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : ℝ
f : ℕ → ℝ≥0
⊢ HasSum (fun i => ↑(f i)) r ↔ Tendsto (fun n => ∑ i ∈ Finset.range n, (fun i => ↑(f i)) i) atTop (𝓝 r)

tactic: simp only [HasSum, ← NNReal.coe_sum, NNReal.tendsto_coe']
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : ℝ
f : ℕ → ℝ≥0
⊢ HasSum (fun i => ↑(f i)) r ↔ Tendsto (fun n => ∑ i ∈ Finset.range n, (fun i => ↑(f i)) i) atTop (𝓝 r)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : ℝ
f : ℕ → ℝ≥0
⊢ (∃ (hx : 0 ≤ r), Tendsto (fun a => ∑ a ∈ a, f a) atTop (𝓝 ⟨r, hx⟩)) ↔
    ∃ (hx : 0 ≤ r), Tendsto (fun a => ∑ a ∈ Finset.range a, f a) atTop (𝓝 ⟨r, hx⟩)

tactic: exact exists_congr fun hr => NNReal.hasSum_iff_tendsto_nat
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : ℝ
f : ℕ → ℝ≥0
⊢ (∃ (hx : 0 ≤ r), Tendsto (fun a => ∑ a ∈ a, f a) atTop (𝓝 ⟨r, hx⟩)) ↔
    ∃ (hx : 0 ≤ r), Tendsto (fun a => ∑ a ∈ Finset.range a, f a) atTop (𝓝 ⟨r, hx⟩)
state_after: no goals
Theorem: Finmap.lookup_singleton_eq
File: Mathlib/Data/Finmap.lean

tactic: rw [singleton, lookup_toFinmap, AList.singleton, AList.lookup, dlookup_cons_eq]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
⊢ lookup a (singleton a b) = some b
state_after: no goals
Theorem: LipschitzWith.prod_mk_right
File: Mathlib/Topology/EMetricSpace/Lipschitz.lean

tactic: simpa only [max_eq_left zero_le_one] using LipschitzWith.id.prod (LipschitzWith.const b)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
x y : α
r : ℝ≥0∞
b : β
⊢ LipschitzWith 1 fun a => (a, b)
state_after: no goals
Theorem: EReal.sign_coe
File: Mathlib/Data/Real/EReal.lean

tactic: simp only [sign, OrderHom.coe_mk, EReal.coe_pos, EReal.coe_neg']
state_before: x : ℝ
⊢ sign ↑x = sign x
state_after: no goals
Theorem: Batteries.RBSet.upperBoundP?_exists
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: simp [upperBoundP?, t.2.out.1.upperBound?_exists, mem_toList, mem_iff_mem_toList]
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBSet α cmp
inst✝¹ : TransCmp cmp
inst✝ : IsCut cmp cut
⊢ (∃ x, t.upperBoundP? cut = some x) ↔ ∃ x, x ∈ t ∧ cut x ≠ Ordering.gt
state_after: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBSet α cmp
inst✝¹ : TransCmp cmp
inst✝ : IsCut cmp cut
⊢ (∃ x, x ∈ t.val ∧ ¬cut x = Ordering.gt) ↔ ∃ x, (∃ y, y ∈ t.val ∧ cmp x y = Ordering.eq) ∧ ¬cut x = Ordering.gt

tactic: exact ⟨
  fun ⟨x, h1, h2⟩ => ⟨x, ⟨x, h1, OrientedCmp.cmp_refl⟩, h2⟩,
  fun ⟨x, ⟨y, h1, h2⟩, eq⟩ => ⟨y, h1, IsCut.congr (cut := cut) h2 ▸ eq⟩⟩
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBSet α cmp
inst✝¹ : TransCmp cmp
inst✝ : IsCut cmp cut
⊢ (∃ x, x ∈ t.val ∧ ¬cut x = Ordering.gt) ↔ ∃ x, (∃ y, y ∈ t.val ∧ cmp x y = Ordering.eq) ∧ ¬cut x = Ordering.gt
state_after: no goals
Theorem: MulChar.injective_ringHomComp
File: Mathlib/NumberTheory/MulChar/Basic.lean

tactic: simpa only [Function.Injective, ext_iff, ringHomComp, coe_mk, MonoidHom.coe_mk, OneHom.coe_mk]
  using fun χ χ' h a ↦ hf (h a)
state_before: R : Type u_1
inst✝² : CommMonoid R
R' : Type u_2
inst✝¹ : CommRing R'
R'' : Type u_3
inst✝ : CommRing R''
f : R' →+* R''
hf : Function.Injective ⇑f
⊢ Function.Injective fun x => x.ringHomComp f
state_after: no goals
Theorem: Algebra.TensorProduct.productMap_left_apply
File: Mathlib/RingTheory/TensorProduct/Basic.lean

tactic: simp
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Semiring B
inst✝³ : CommSemiring S
inst✝² : Algebra R A
inst✝¹ : Algebra R B
inst✝ : Algebra R S
f : A →ₐ[R] S
g : B →ₐ[R] S
a : A
⊢ (productMap f g) (a ⊗ₜ[R] 1) = f a
state_after: no goals
Theorem: LieModule.chainBotCoeff_neg
File: Mathlib/Algebra/Lie/Weights/Chain.lean

tactic: rw [← chainTopCoeff_neg, neg_neg]
state_before: R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
⊢ chainBotCoeff (-α) β = chainTopCoeff α β
state_after: no goals
Theorem: Set.SurjOn.comp_right
File: Mathlib/Data/Set/Function.lean

tactic: rwa [SurjOn, image_comp g f, image_preimage_eq _ hf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
s : Set β
t : Set γ
hf : Surjective f
hg : SurjOn g s t
⊢ SurjOn (g ∘ f) (f ⁻¹' s) t
state_after: no goals
Theorem: PowerSeries.monomial_zero_eq_C_apply
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp
state_before: R : Type u_1
inst✝ : Semiring R
a : R
⊢ (monomial R 0) a = (C R) a
state_after: no goals
Theorem: Irreducible.normalizedFactors_pow
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [UniqueFactorizationMonoid.normalizedFactors_pow, normalizedFactors_irreducible hp,
  Multiset.nsmul_singleton]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
p : α
hp : Irreducible p
k : ℕ
⊢ normalizedFactors (p ^ k) = Multiset.replicate k (normalize p)
state_after: no goals
Theorem: Primrec₂.nat_iff
File: Mathlib/Computability/Primrec.lean

tactic: have :
  ∀ (a : Option α) (b : Option β),
    Option.map (fun p : α × β => f p.1 p.2)
        (Option.bind a fun a : α => Option.map (Prod.mk a) b) =
      Option.bind a fun a => Option.map (f a) b := fun a b => by
        cases a <;> cases b <;> rfl
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f : α → β → σ
⊢ Primrec₂ f ↔ Nat.Primrec (Nat.unpaired fun m n => encode ((decode m).bind fun a => Option.map (f a) (decode n)))
state_after: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f : α → β → σ
this :
  ∀ (a : Option α) (b : Option β),
    Option.map (fun p => f p.1 p.2) (a.bind fun a => Option.map (Prod.mk a) b) = a.bind fun a => Option.map (f a) b
⊢ Primrec₂ f ↔ Nat.Primrec (Nat.unpaired fun m n => encode ((decode m).bind fun a => Option.map (f a) (decode n)))

tactic: simp [Primrec₂, Primrec, this]
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f : α → β → σ
this :
  ∀ (a : Option α) (b : Option β),
    Option.map (fun p => f p.1 p.2) (a.bind fun a => Option.map (Prod.mk a) b) = a.bind fun a => Option.map (f a) b
⊢ Primrec₂ f ↔ Nat.Primrec (Nat.unpaired fun m n => encode ((decode m).bind fun a => Option.map (f a) (decode n)))
state_after: no goals

tactic: cases a <;> cases b <;> rfl
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f : α → β → σ
a : Option α
b : Option β
⊢ Option.map (fun p => f p.1 p.2) (a.bind fun a => Option.map (Prod.mk a) b) = a.bind fun a => Option.map (f a) b
state_after: no goals
Theorem: CauSeq.pow_equiv_pow
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

tactic: induction' n with n ih
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 : CauSeq β abv
hf : f1 ≈ f2
n : ℕ
⊢ f1 ^ n ≈ f2 ^ n
state_after: case zero
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 : CauSeq β abv
hf : f1 ≈ f2
⊢ f1 ^ 0 ≈ f2 ^ 0

case succ
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 : CauSeq β abv
hf : f1 ≈ f2
n : ℕ
ih : f1 ^ n ≈ f2 ^ n
⊢ f1 ^ (n + 1) ≈ f2 ^ (n + 1)

tactic: simp only [Nat.zero_eq, pow_zero, Setoid.refl]
state_before: case zero
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 : CauSeq β abv
hf : f1 ≈ f2
⊢ f1 ^ 0 ≈ f2 ^ 0
state_after: no goals

tactic: simpa only [pow_succ'] using mul_equiv_mul hf ih
state_before: case succ
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 : CauSeq β abv
hf : f1 ≈ f2
n : ℕ
ih : f1 ^ n ≈ f2 ^ n
⊢ f1 ^ (n + 1) ≈ f2 ^ (n + 1)
state_after: no goals
Theorem: WeierstrassCurve.ofJ_c₄
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

tactic: simp only [ofJ, c₄, b₂, b₄]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
j : R
⊢ (ofJ j).c₄ = j * (j - 1728) ^ 3
state_after: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
j : R
⊢ ((j - 1728) ^ 2 + 4 * 0) ^ 2 - 24 * (2 * (-36 * (j - 1728) ^ 3) + (j - 1728) * 0) = j * (j - 1728) ^ 3

tactic: ring1
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
j : R
⊢ ((j - 1728) ^ 2 + 4 * 0) ^ 2 - 24 * (2 * (-36 * (j - 1728) ^ 3) + (j - 1728) * 0) = j * (j - 1728) ^ 3
state_after: no goals
Theorem: Polynomial.reverse_mul_X
File: Mathlib/Algebra/Polynomial/Reverse.lean

tactic: nontriviality R
state_before: R : Type u_1
inst✝ : Semiring R
f p : R[X]
⊢ (p * X).reverse = p.reverse
state_after: R : Type u_1
inst✝ : Semiring R
f p : R[X]
a✝ : Nontrivial R
⊢ (p * X).reverse = p.reverse

tactic: rcases eq_or_ne p 0 with rfl | hp
state_before: R : Type u_1
inst✝ : Semiring R
f p : R[X]
a✝ : Nontrivial R
⊢ (p * X).reverse = p.reverse
state_after: case inl
R : Type u_1
inst✝ : Semiring R
f : R[X]
a✝ : Nontrivial R
⊢ (0 * X).reverse = reverse 0

case inr
R : Type u_1
inst✝ : Semiring R
f p : R[X]
a✝ : Nontrivial R
hp : p ≠ 0
⊢ (p * X).reverse = p.reverse

tactic: simp
state_before: case inl
R : Type u_1
inst✝ : Semiring R
f : R[X]
a✝ : Nontrivial R
⊢ (0 * X).reverse = reverse 0
state_after: no goals

tactic: simp [reverse, hp]
state_before: case inr
R : Type u_1
inst✝ : Semiring R
f p : R[X]
a✝ : Nontrivial R
hp : p ≠ 0
⊢ (p * X).reverse = p.reverse
state_after: no goals
Theorem: neg_div'
File: Mathlib/Algebra/Field/Basic.lean

tactic: simp [neg_div]
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b✝ a b : K
⊢ -(b / a) = -b / a
state_after: no goals
Theorem: Relation.TransGen.lift'
File: Mathlib/Logic/Relation.lean

tactic: simpa [transGen_idem] using hab.lift f h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝ b✝ c d : α
p : β → β → Prop
a b : α
f : α → β
h : ∀ (a b : α), r a b → TransGen p (f a) (f b)
hab : TransGen r a b
⊢ TransGen p (f a) (f b)
state_after: no goals
Theorem: ModularGroup.T_mul_apply_one
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

tactic: simpa using T_pow_mul_apply_one 1 g
state_before: g : SL(2, ℤ)
⊢ ↑(T * g) 1 = ↑g 1
state_after: no goals