ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: rank_pos_iff_exists_ne_zero
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

Proof steps:
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
⊢ 0 < Module.rank R M ↔ ∃ x, x ≠ 0
state_after: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
⊢ ¬0 < Module.rank R M ↔ ¬∃ x, x ≠ 0
tactic: rw [← not_iff_not]
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
⊢ ¬0 < Module.rank R M ↔ ¬∃ x, x ≠ 0
state_after: no goals
tactic: simpa using rank_zero_iff_forall_zero
Theorem: AkraBazziRecurrence.eventually_r_pos
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ᶠ (n : ℕ) in atTop, ∀ (i : α), 0 < r i n
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ (i : α), ∀ᶠ (x : ℕ) in atTop, 0 < r i x
tactic: rw [Filter.eventually_all]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ (i : α), ∀ᶠ (x : ℕ) in atTop, 0 < r i x
state_after: no goals
tactic: exact fun i => (R.tendsto_atTop_r i).eventually_gt_atTop 0
Theorem: Ordinal.sup_typein_limit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
ho : ∀ a < o, succ a < o
⊢ ∀ a < o, succ a < o
state_after: no goals
tactic: assumption
Theorem: Ideal.comap_bot_le_of_injective
File: Mathlib/RingTheory/Ideal/Maps.lean

Proof steps:
state_before: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
ι : Sort u_3
hf : Function.Injective ⇑f
⊢ comap f ⊥ ≤ I
state_after: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
ι : Sort u_3
hf : Function.Injective ⇑f
x : R
hx : x ∈ comap f ⊥
⊢ x ∈ ⊥
tactic: refine le_trans (fun x hx => ?_) bot_le
state_before: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
ι : Sort u_3
hf : Function.Injective ⇑f
x : R
hx : x ∈ comap f ⊥
⊢ x ∈ ⊥
state_after: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
ι : Sort u_3
hf : Function.Injective ⇑f
x : R
hx : f x = f 0
⊢ x ∈ ⊥
tactic: rw [mem_comap, Submodule.mem_bot, ← map_zero f] at hx
state_before: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
ι : Sort u_3
hf : Function.Injective ⇑f
x : R
hx : f x = f 0
⊢ x ∈ ⊥
state_after: no goals
tactic: exact Eq.symm (hf hx) ▸ Submodule.zero_mem ⊥
Theorem: Finset.add_sum_erase
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
f : α → β
a : α
h : a ∈ s
⊢ f a * ∏ x ∈ s.erase a, f x = ∏ x ∈ s, f x
state_after: no goals
tactic: rw [← prod_insert (not_mem_erase a s), insert_erase h]
Theorem: Differentiable.apply_eq_apply_of_bounded
File: Mathlib/Analysis/Complex/Liouville.lean

Proof steps:
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Bornology.IsBounded (range f)
z w : E
⊢ f z = f w
state_after: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Bornology.IsBounded (range f)
z w : E
g : ℂ → F := f ∘ fun t => t • (w - z) + z
⊢ f z = f w
tactic: set g : ℂ → F := f ∘ fun t : ℂ => t • (w - z) + z
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Bornology.IsBounded (range f)
z w : E
g : ℂ → F := f ∘ fun t => t • (w - z) + z
⊢ f z = f w
state_after: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Bornology.IsBounded (range f)
z w : E
g : ℂ → F := f ∘ fun t => t • (w - z) + z
⊢ g 0 = g 1
tactic: suffices g 0 = g 1 by simpa [g]
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Bornology.IsBounded (range f)
z w : E
g : ℂ → F := f ∘ fun t => t • (w - z) + z
⊢ g 0 = g 1
state_after: case hf
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Bornology.IsBounded (range f)
z w : E
g : ℂ → F := f ∘ fun t => t • (w - z) + z
⊢ Differentiable ℂ g

case hb
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Bornology.IsBounded (range f)
z w : E
g : ℂ → F := f ∘ fun t => t • (w - z) + z
⊢ Bornology.IsBounded (range g)
tactic: apply liouville_theorem_aux
state_before: case hf
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Bornology.IsBounded (range f)
z w : E
g : ℂ → F := f ∘ fun t => t • (w - z) + z
⊢ Differentiable ℂ g

case hb
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Bornology.IsBounded (range f)
z w : E
g : ℂ → F := f ∘ fun t => t • (w - z) + z
⊢ Bornology.IsBounded (range g)
state_after: no goals
tactic: exacts [hf.comp ((differentiable_id.smul_const (w - z)).add_const z),
    hb.subset (range_comp_subset_range _ _)]
Theorem: LinearMap.curry_uncurryLeft
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin n.succ) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
f : M 0 →ₗ[R] MultilinearMap R (fun i => M i.succ) M₂
⊢ f.uncurryLeft.curryLeft = f
state_after: case h.H
R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin n.succ) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
f : M 0 →ₗ[R] MultilinearMap R (fun i => M i.succ) M₂
m : M 0
x : (i : Fin n) → M i.succ
⊢ (f.uncurryLeft.curryLeft m) x = (f m) x
tactic: ext m x
state_before: case h.H
R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin n.succ) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
f : M 0 →ₗ[R] MultilinearMap R (fun i => M i.succ) M₂
m : M 0
x : (i : Fin n) → M i.succ
⊢ (f.uncurryLeft.curryLeft m) x = (f m) x
state_after: case h.H
R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin n.succ) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
f : M 0 →ₗ[R] MultilinearMap R (fun i => M i.succ) M₂
m : M 0
x : (i : Fin n) → M i.succ
⊢ (f (cons m x 0)) x = (f m) x
tactic: simp only [tail_cons, LinearMap.uncurryLeft_apply, MultilinearMap.curryLeft_apply]
state_before: case h.H
R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin n.succ) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
f : M 0 →ₗ[R] MultilinearMap R (fun i => M i.succ) M₂
m : M 0
x : (i : Fin n) → M i.succ
⊢ (f (cons m x 0)) x = (f m) x
state_after: no goals
tactic: rw [cons_zero]
Theorem: sub_sub_eq_add_sub
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
⊢ a / (b / c) = a * c / b
state_after: no goals
tactic: simp
Theorem: Function.Periodic.int_mul
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝ : Ring α
h : Periodic f c
n : ℤ
⊢ Periodic f (↑n * c)
state_after: no goals
tactic: simpa only [zsmul_eq_mul] using h.zsmul n
Theorem: tprod_eq_mulSingle
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
f : β → α
b : β
hf : ∀ (b' : β), b' ≠ b → f b' = 1
⊢ ∏' (b : β), f b = f b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
f : β → α
b : β
hf : ∀ (b' : β), b' ≠ b → f b' = 1
⊢ ∀ b_1 ∉ {b}, f b_1 = 1
tactic: rw [tprod_eq_prod (s := {b}), prod_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
f : β → α
b : β
hf : ∀ (b' : β), b' ≠ b → f b' = 1
⊢ ∀ b_1 ∉ {b}, f b_1 = 1
state_after: no goals
tactic: exact fun b' hb' ↦ hf b' (by simpa using hb')
Theorem: Real.list_prod_map_rpow'
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ
hl : ∀ i ∈ l, 0 ≤ f i
r : ℝ
⊢ (List.map (fun x => f x ^ r) l).prod = (List.map f l).prod ^ r
state_after: w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ
hl : ∀ i ∈ l, 0 ≤ f i
r : ℝ
⊢ (List.map (fun x => f x ^ r) l).prod = (List.map ((fun x => x ^ r) ∘ f) l).prod

w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ
hl : ∀ i ∈ l, 0 ≤ f i
r : ℝ
⊢ ∀ x ∈ List.map f l, 0 ≤ x
tactic: rw [← Real.list_prod_map_rpow (l.map f) _ r, List.map_map]
state_before: w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ
hl : ∀ i ∈ l, 0 ≤ f i
r : ℝ
⊢ ∀ x ∈ List.map f l, 0 ≤ x
state_after: no goals
tactic: simpa using hl
Theorem: Polynomial.derivative_X_add_C
File: Mathlib/Algebra/Polynomial/Derivative.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
c : R
⊢ derivative (X + C c) = 1
state_after: no goals
tactic: rw [derivative_add, derivative_X, derivative_C, add_zero]
Theorem: Multiset.sum_nonneg
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
l : List α
hl : ∀ x ∈ ⟦l⟧, 1 ≤ x
⊢ 1 ≤ prod ⟦l⟧
state_after: no goals
tactic: simpa using List.one_le_prod_of_one_le hl
Theorem: AddMonoidAlgebra.mem_span_support
File: Mathlib/Algebra/MonoidAlgebra/Support.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
inst✝¹ : Semiring k
inst✝ : AddZeroClass G
f : k[G]
⊢ f ∈ Submodule.span k (⇑(of k G) '' ↑f.support)
state_after: no goals
tactic: erw [of, MonoidHom.coe_mk, ← Finsupp.supported_eq_span_single, Finsupp.mem_supported]
Theorem: Subgroup.index_ker
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
f : G →* G'
⊢ f.ker.index = Nat.card ↑(Set.range ⇑f)
state_after: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
f : G →* G'
⊢ Nat.card ↥f.range = Nat.card ↑(Set.range ⇑f)
tactic: rw [← MonoidHom.comap_bot, index_comap, relindex_bot_left]
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
f : G →* G'
⊢ Nat.card ↥f.range = Nat.card ↑(Set.range ⇑f)
state_after: no goals
tactic: rfl
Theorem: FreeGroup.Red.not_step_singleton
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
a : α
b : Bool
⊢ ¬Step [(a, b)] L
state_after: no goals
tactic: simp [Step.cons_left_iff, not_step_nil]
Theorem: finite_zmultiples
File: Mathlib/Data/ZMod/Quotient.lean

Proof steps:
state_before: n : ℕ
A : Type u_1
R : Type u_2
inst✝² : AddGroup A
inst✝¹ : Ring R
α : Type u_3
inst✝ : Group α
a : α
⊢ (↑(zpowers a)).Finite ↔ IsOfFinOrder a
state_after: no goals
tactic: simp only [← orderOf_pos_iff, ← Nat.card_zpowers, Nat.card_pos_iff, ← SetLike.coe_sort_coe,
    nonempty_coe_sort, Nat.card_pos_iff, Set.finite_coe_iff, Subgroup.coe_nonempty, true_and]
Theorem: MvPolynomial.vars_map
File: Mathlib/Algebra/MvPolynomial/Variables.lean

Proof steps:
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
inst✝ : CommSemiring S
f : R →+* S
⊢ ((map f) p).vars ⊆ p.vars
state_after: no goals
tactic: classical simp [vars_def, degrees_map]
Theorem: seq_bind_eq
File: Mathlib/Control/Basic.lean

Proof steps:
state_before: α β γ : Type u
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : m α
g : β → m γ
f : α → β
⊢ f <$> x >>= g = x >>= g ∘ f
state_after: α β γ : Type u
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : m α
g : β → m γ
f : α → β
⊢ (x >>= fun x => pure (f x) >>= g) = x >>= g ∘ f
tactic: rw [← bind_pure_comp, bind_assoc]
state_before: α β γ : Type u
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : m α
g : β → m γ
f : α → β
⊢ (x >>= fun x => pure (f x) >>= g) = x >>= g ∘ f
state_after: no goals
tactic: simp [pure_bind, Function.comp_def]
Theorem: ZMod.pow_card_pow
File: Mathlib/FieldTheory/Finite/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
n p : ℕ
inst✝ : Fact (Nat.Prime p)
x : ZMod p
⊢ x ^ p ^ n = x
state_after: case zero
K : Type u_1
R : Type u_2
p : ℕ
inst✝ : Fact (Nat.Prime p)
x : ZMod p
⊢ x ^ p ^ 0 = x

case succ
K : Type u_1
R : Type u_2
p : ℕ
inst✝ : Fact (Nat.Prime p)
x : ZMod p
n : ℕ
ih : x ^ p ^ n = x
⊢ x ^ p ^ (n + 1) = x
tactic: induction' n with n ih
Theorem: Mathlib.Tactic.Ring.neg_mul
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a a' a₁✝ a₂✝ a₃✝ b✝ b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : Ring R
a₁ : R
a₂ : ℕ
a₃ b : R
x✝ : -a₃ = b
⊢ -(a₁ ^ a₂ * a₃) = a₁ ^ a₂ * b
state_after: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a a' a₁✝ a₂✝ a₃✝ b b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : Ring R
a₁ : R
a₂ : ℕ
a₃ : R
⊢ -(a₁ ^ a₂ * a₃) = a₁ ^ a₂ * -a₃
tactic: subst_vars
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a a' a₁✝ a₂✝ a₃✝ b b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : Ring R
a₁ : R
a₂ : ℕ
a₃ : R
⊢ -(a₁ ^ a₂ * a₃) = a₁ ^ a₂ * -a₃
state_after: no goals
tactic: simp
Theorem: Nat.modEq_zero_iff_dvd
File: Mathlib/Data/Nat/ModEq.lean

Proof steps:
state_before: m n a b c d : ℕ
⊢ a ≡ 0 [MOD n] ↔ n ∣ a
state_after: no goals
tactic: rw [ModEq, zero_mod, dvd_iff_mod_eq_zero]
Theorem: MeasureTheory.AEEqFun.compMeasurable_eq_mk
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹⁰ : MeasurableSpace α
μ ν : Measure α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : TopologicalSpace γ
inst✝⁷ : TopologicalSpace δ
inst✝⁶ : MeasurableSpace β
inst✝⁵ : PseudoMetrizableSpace β
inst✝⁴ : BorelSpace β
inst✝³ : MeasurableSpace γ
inst✝² : PseudoMetrizableSpace γ
inst✝¹ : OpensMeasurableSpace γ
inst✝ : SecondCountableTopology γ
g : β → γ
hg : Measurable g
f : α →ₘ[μ] β
⊢ compMeasurable g hg f = mk (g ∘ ↑f) ⋯
state_after: no goals
tactic: rw [← compMeasurable_mk g hg f f.aestronglyMeasurable, mk_coeFn]
Theorem: Fin.insertNth_apply_succAbove
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
i : Fin (n + 1)
x : α i
p : (j : Fin n) → α (i.succAbove j)
j : Fin n
⊢ i.insertNth x p (i.succAbove j) = p j
state_after: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
i : Fin (n + 1)
x : α i
p : (j : Fin n) → α (i.succAbove j)
j : Fin n
⊢ (if h : j.castSucc < i then ⋯ ▸ p ((i.succAbove j).castPred ⋯) else ⋯ ▸ p ((i.succAbove j).pred ⋯)) = p j
tactic: simp only [insertNth, succAboveCases, dif_neg (succAbove_ne _ _), succAbove_lt_iff_castSucc_lt]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
i : Fin (n + 1)
x : α i
p : (j : Fin n) → α (i.succAbove j)
j : Fin n
⊢ (if h : j.castSucc < i then ⋯ ▸ p ((i.succAbove j).castPred ⋯) else ⋯ ▸ p ((i.succAbove j).pred ⋯)) = p j
state_after: case pos
m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
i : Fin (n + 1)
x : α i
p : (j : Fin n) → α (i.succAbove j)
j : Fin n
hlt : j.castSucc < i
⊢ ⋯ ▸ p ((i.succAbove j).castPred ⋯) = p j

case neg
m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
i : Fin (n + 1)
x : α i
p : (j : Fin n) → α (i.succAbove j)
j : Fin n
hlt : ¬j.castSucc < i
⊢ ⋯ ▸ p ((i.succAbove j).pred ⋯) = p j
tactic: split_ifs with hlt
Theorem: Asymptotics.IsEquivalent.tendsto_atBot
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : NormedLinearOrderedField β
u v : α → β
l : Filter α
inst✝ : OrderTopology β
huv : u ~[l] v
hu : Tendsto u l atBot
⊢ Tendsto v l atBot
state_after: case h.e'_3
α : Type u_1
β : Type u_2
inst✝¹ : NormedLinearOrderedField β
u v : α → β
l : Filter α
inst✝ : OrderTopology β
huv : u ~[l] v
hu : Tendsto u l atBot
⊢ v = Neg.neg ∘ fun x => -v x
tactic: convert tendsto_neg_atTop_atBot.comp (huv.neg.tendsto_atTop <| tendsto_neg_atBot_atTop.comp hu)
state_before: case h.e'_3
α : Type u_1
β : Type u_2
inst✝¹ : NormedLinearOrderedField β
u v : α → β
l : Filter α
inst✝ : OrderTopology β
huv : u ~[l] v
hu : Tendsto u l atBot
⊢ v = Neg.neg ∘ fun x => -v x
state_after: case h.e'_3.h
α : Type u_1
β : Type u_2
inst✝¹ : NormedLinearOrderedField β
u v : α → β
l : Filter α
inst✝ : OrderTopology β
huv : u ~[l] v
hu : Tendsto u l atBot
x✝ : α
⊢ v x✝ = (Neg.neg ∘ fun x => -v x) x✝
tactic: ext
state_before: case h.e'_3.h
α : Type u_1
β : Type u_2
inst✝¹ : NormedLinearOrderedField β
u v : α → β
l : Filter α
inst✝ : OrderTopology β
huv : u ~[l] v
hu : Tendsto u l atBot
x✝ : α
⊢ v x✝ = (Neg.neg ∘ fun x => -v x) x✝
state_after: no goals
tactic: simp
Theorem: HomogeneousIdeal.toIdeal_injective
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

Proof steps:
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : SetLike σ A
inst✝³ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : GradedRing 𝒜
I : Ideal A
x✝¹ x✝ : HomogeneousIdeal 𝒜
x : Submodule A A
hx : Ideal.IsHomogeneous 𝒜 x
y : Submodule A A
hy : Ideal.IsHomogeneous 𝒜 y
h : x = y
⊢ { toSubmodule := x, is_homogeneous' := hx } = { toSubmodule := y, is_homogeneous' := hy }
state_after: no goals
tactic: simp [h]
Theorem: YoungDiagram.transposeOrderIso_symm_apply
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

Proof steps:
state_before: x✝ : YoungDiagram
⊢ x✝.transpose.transpose = x✝
state_after: no goals
tactic: simp
state_before: x✝ : YoungDiagram
⊢ x✝.transpose.transpose = x✝
state_after: no goals
tactic: simp
state_before: ⊢ ∀ {a b : YoungDiagram},
    { toFun := transpose, invFun := transpose, left_inv := ⋯, right_inv := ⋯ } a ≤
        { toFun := transpose, invFun := transpose, left_inv := ⋯, right_inv := ⋯ } b ↔
      a ≤ b
state_after: no goals
tactic: simp
Theorem: tendsto_zero_iff_abs_tendsto_zero
File: Mathlib/Topology/Algebra/Order/Group.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
inst✝² : TopologicalSpace G
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderTopology G
l : Filter α
f✝ g f : α → G
⊢ Tendsto f l (𝓝 0) ↔ Tendsto (abs ∘ f) l (𝓝 0)
state_after: α : Type u_1
G : Type u_2
inst✝² : TopologicalSpace G
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderTopology G
l : Filter α
f✝ g f : α → G
h : Tendsto (abs ∘ f) l (𝓝 0)
⊢ Tendsto f l (𝓝 0)
tactic: refine ⟨fun h => (abs_zero : |(0 : G)| = 0) ▸ h.abs, fun h => ?_⟩
state_before: α : Type u_1
G : Type u_2
inst✝² : TopologicalSpace G
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderTopology G
l : Filter α
f✝ g f : α → G
h : Tendsto (abs ∘ f) l (𝓝 0)
⊢ Tendsto f l (𝓝 0)
state_after: α : Type u_1
G : Type u_2
inst✝² : TopologicalSpace G
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderTopology G
l : Filter α
f✝ g f : α → G
h : Tendsto (abs ∘ f) l (𝓝 0)
this : Tendsto (fun a => -|f a|) l (𝓝 0)
⊢ Tendsto f l (𝓝 0)
tactic: have : Tendsto (fun a => -|f a|) l (𝓝 0) := (neg_zero : -(0 : G) = 0) ▸ h.neg
state_before: α : Type u_1
G : Type u_2
inst✝² : TopologicalSpace G
inst✝¹ : LinearOrderedAddCommGroup G
inst✝ : OrderTopology G
l : Filter α
f✝ g f : α → G
h : Tendsto (abs ∘ f) l (𝓝 0)
this : Tendsto (fun a => -|f a|) l (𝓝 0)
⊢ Tendsto f l (𝓝 0)
state_after: no goals
tactic: exact
    tendsto_of_tendsto_of_tendsto_of_le_of_le this h (fun x => neg_abs_le <| f x) fun x =>
      le_abs_self <| f x