1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: RelSeries.ext
File: Mathlib/Order/RelSeries.lean

tactic: rw [length_eq]
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
x y : RelSeries r
length_eq : x.length = y.length
⊢ x.length + 1 = y.length + 1
state_after: no goals

tactic: rcases x with ⟨nx, fx⟩
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
x y : RelSeries r
length_eq : x.length = y.length
toFun_eq : x.toFun = y.toFun ∘ Fin.cast ⋯
⊢ x = y
state_after: case mk
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
y : RelSeries r
nx : ℕ
fx : Fin (nx + 1) → α
step✝ : ∀ (i : Fin nx), r (fx i.castSucc) (fx i.succ)
length_eq : { length := nx, toFun := fx, step := step✝ }.length = y.length
toFun_eq : { length := nx, toFun := fx, step := step✝ }.toFun = y.toFun ∘ Fin.cast ⋯
⊢ { length := nx, toFun := fx, step := step✝ } = y

tactic: dsimp only at length_eq toFun_eq
state_before: case mk
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
y : RelSeries r
nx : ℕ
fx : Fin (nx + 1) → α
step✝ : ∀ (i : Fin nx), r (fx i.castSucc) (fx i.succ)
length_eq : { length := nx, toFun := fx, step := step✝ }.length = y.length
toFun_eq : { length := nx, toFun := fx, step := step✝ }.toFun = y.toFun ∘ Fin.cast ⋯
⊢ { length := nx, toFun := fx, step := step✝ } = y
state_after: case mk
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
y : RelSeries r
nx : ℕ
fx : Fin (nx + 1) → α
step✝ : ∀ (i : Fin nx), r (fx i.castSucc) (fx i.succ)
length_eq : nx = y.length
toFun_eq : fx = y.toFun ∘ Fin.cast ⋯
⊢ { length := nx, toFun := fx, step := step✝ } = y

tactic: subst length_eq toFun_eq
state_before: case mk
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
y : RelSeries r
nx : ℕ
fx : Fin (nx + 1) → α
step✝ : ∀ (i : Fin nx), r (fx i.castSucc) (fx i.succ)
length_eq : nx = y.length
toFun_eq : fx = y.toFun ∘ Fin.cast ⋯
⊢ { length := nx, toFun := fx, step := step✝ } = y
state_after: case mk
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
y : RelSeries r
step✝ : ∀ (i : Fin y.length), r ((y.toFun ∘ Fin.cast ⋯) i.castSucc) ((y.toFun ∘ Fin.cast ⋯) i.succ)
⊢ { length := y.length, toFun := y.toFun ∘ Fin.cast ⋯, step := step✝ } = y

tactic: rfl
state_before: case mk
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
y : RelSeries r
step✝ : ∀ (i : Fin y.length), r ((y.toFun ∘ Fin.cast ⋯) i.castSucc) ((y.toFun ∘ Fin.cast ⋯) i.succ)
⊢ { length := y.length, toFun := y.toFun ∘ Fin.cast ⋯, step := step✝ } = y
state_after: no goals
Theorem: geom_sum_Ico_le_of_lt_one
File: Mathlib/Algebra/GeomSum.lean

tactic: rcases le_or_lt m n with (hmn | hmn)
state_before: α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
⊢ ∑ i ∈ Ico m n, x ^ i ≤ x ^ m / (1 - x)
state_after: case inl
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : m ≤ n
⊢ ∑ i ∈ Ico m n, x ^ i ≤ x ^ m / (1 - x)

case inr
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : n < m
⊢ ∑ i ∈ Ico m n, x ^ i ≤ x ^ m / (1 - x)

tactic: rw [geom_sum_Ico' h'x.ne hmn]
state_before: case inl
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : m ≤ n
⊢ ∑ i ∈ Ico m n, x ^ i ≤ x ^ m / (1 - x)
state_after: case inl
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : m ≤ n
⊢ (x ^ m - x ^ n) / (1 - x) ≤ x ^ m / (1 - x)

tactic: apply div_le_div (pow_nonneg hx _) _ (sub_pos.2 h'x) le_rfl
state_before: case inl
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : m ≤ n
⊢ (x ^ m - x ^ n) / (1 - x) ≤ x ^ m / (1 - x)
state_after: α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : m ≤ n
⊢ x ^ m - x ^ n ≤ x ^ m

tactic: simpa using pow_nonneg hx _
state_before: α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : m ≤ n
⊢ x ^ m - x ^ n ≤ x ^ m
state_after: no goals

tactic: rw [Ico_eq_empty, sum_empty]
state_before: case inr
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : n < m
⊢ ∑ i ∈ Ico m n, x ^ i ≤ x ^ m / (1 - x)
state_after: case inr
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : n < m
⊢ 0 ≤ x ^ m / (1 - x)

case inr
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : n < m
⊢ ¬m < n

tactic: apply div_nonneg (pow_nonneg hx _)
state_before: case inr
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : n < m
⊢ 0 ≤ x ^ m / (1 - x)
state_after: case inr
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : n < m
⊢ 0 ≤ 1 - x

tactic: simpa using h'x.le
state_before: case inr
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : n < m
⊢ 0 ≤ 1 - x
state_after: no goals

tactic: simpa using hmn.le
state_before: case inr
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : n < m
⊢ ¬m < n
state_after: no goals
Theorem: Nat.fib_succ_eq_sum_choose
File: Mathlib/Data/Nat/Fib/Basic.lean

tactic: rw [fib_add_two, h1, h2, Finset.Nat.antidiagonal_succ_succ', Finset.Nat.antidiagonal_succ']
state_before: n : ℕ
h1 : fib (n + 1) = ∑ p ∈ Finset.antidiagonal n, p.1.choose p.2
h2 : fib (n.succ + 1) = ∑ p ∈ Finset.antidiagonal n.succ, p.1.choose p.2
⊢ fib (n.succ.succ + 1) = ∑ p ∈ Finset.antidiagonal n.succ.succ, p.1.choose p.2
state_after: n : ℕ
h1 : fib (n + 1) = ∑ p ∈ Finset.antidiagonal n, p.1.choose p.2
h2 : fib (n.succ + 1) = ∑ p ∈ Finset.antidiagonal n.succ, p.1.choose p.2
⊢ ∑ p ∈ Finset.antidiagonal n, p.1.choose p.2 +
      ∑
        p ∈
          Finset.cons (n + 1, 0)
            (Finset.map ((Function.Embedding.refl ℕ).prodMap { toFun := succ, inj' := succ_injective })
              (Finset.antidiagonal n))
            ⋯,
        p.1.choose p.2 =
    ∑
      p ∈
        Finset.cons (0, n + 2)
          (Finset.cons (n + 2, 0)
            (Finset.map ({ toFun := succ, inj' := succ_injective }.prodMap { toFun := succ, inj' := succ_injective })
              (Finset.antidiagonal n))
            ⋯)
          ⋯,
      p.1.choose p.2

tactic: simp [choose_succ_succ, Finset.sum_add_distrib, add_left_comm]
state_before: n : ℕ
h1 : fib (n + 1) = ∑ p ∈ Finset.antidiagonal n, p.1.choose p.2
h2 : fib (n.succ + 1) = ∑ p ∈ Finset.antidiagonal n.succ, p.1.choose p.2
⊢ ∑ p ∈ Finset.antidiagonal n, p.1.choose p.2 +
      ∑
        p ∈
          Finset.cons (n + 1, 0)
            (Finset.map ((Function.Embedding.refl ℕ).prodMap { toFun := succ, inj' := succ_injective })
              (Finset.antidiagonal n))
            ⋯,
        p.1.choose p.2 =
    ∑
      p ∈
        Finset.cons (0, n + 2)
          (Finset.cons (n + 2, 0)
            (Finset.map ({ toFun := succ, inj' := succ_injective }.prodMap { toFun := succ, inj' := succ_injective })
              (Finset.antidiagonal n))
            ⋯)
          ⋯,
      p.1.choose p.2
state_after: no goals
Theorem: MulAction.stabilizer_op_subgroup
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

tactic: simp_rw [SetLike.ext_iff, mem_stabilizer_set]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Subgroup G
⊢ stabilizer Gᵐᵒᵖ ↑s = s.op
state_after: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Subgroup G
⊢ ∀ (x : Gᵐᵒᵖ), (∀ (b : G), x • b ∈ ↑s ↔ b ∈ ↑s) ↔ x ∈ s.op

tactic: simp? says simp only [smul_eq_mul_unop, SetLike.mem_coe, Subgroup.mem_op]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Subgroup G
⊢ ∀ (x : Gᵐᵒᵖ), (∀ (b : G), x • b ∈ ↑s ↔ b ∈ ↑s) ↔ x ∈ s.op
state_after: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Subgroup G
⊢ ∀ (x : Gᵐᵒᵖ), (∀ (b : G), b * unop x ∈ s ↔ b ∈ s) ↔ unop x ∈ s

tactic: refine fun a ↦ ⟨fun h ↦ ?_, fun ha b ↦ s.mul_mem_cancel_right ha⟩
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Subgroup G
⊢ ∀ (x : Gᵐᵒᵖ), (∀ (b : G), b * unop x ∈ s ↔ b ∈ s) ↔ unop x ∈ s
state_after: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a✝ : G
s : Subgroup G
a : Gᵐᵒᵖ
h : ∀ (b : G), b * unop a ∈ s ↔ b ∈ s
⊢ unop a ∈ s

tactic: simpa only [op_smul_eq_mul, SetLike.mem_coe, one_mul] using (h 1).2 s.one_mem
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a✝ : G
s : Subgroup G
a : Gᵐᵒᵖ
h : ∀ (b : G), b * unop a ∈ s ↔ b ∈ s
⊢ unop a ∈ s
state_after: no goals

tactic: simp only [smul_eq_mul_unop, SetLike.mem_coe, Subgroup.mem_op]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Subgroup G
⊢ ∀ (x : Gᵐᵒᵖ), (∀ (b : G), x • b ∈ ↑s ↔ b ∈ ↑s) ↔ x ∈ s.op
state_after: G : Type u_1
H : Type u_2
α : Type u_3
inst✝² : Group G
inst✝¹ : Group H
inst✝ : MulAction G α
a : G
s : Subgroup G
⊢ ∀ (x : Gᵐᵒᵖ), (∀ (b : G), b * unop x ∈ s ↔ b ∈ s) ↔ unop x ∈ s
Theorem: Ordnode.all_balanceL
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [balanceL_eq_balance' hl hr sl sr H, all_balance']
state_before: α : Type u_1
P : α → Prop
l : Ordnode α
x : α
r : Ordnode α
hl : l.Balanced
hr : r.Balanced
sl : l.Sized
sr : r.Sized
H : (∃ l', Raised l' l.size ∧ BalancedSz l' r.size) ∨ ∃ r', Raised r.size r' ∧ BalancedSz l.size r'
⊢ All P (l.balanceL x r) ↔ All P l ∧ P x ∧ All P r
state_after: no goals
Theorem: FractionalIdeal.canonicalEquiv_coeIdeal
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

tactic: ext
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
I : Ideal R
⊢ (canonicalEquiv S P P') ↑I = ↑I
state_after: case a
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
I : Ideal R
x✝ : P'
⊢ x✝ ∈ (canonicalEquiv S P P') ↑I ↔ x✝ ∈ ↑I

tactic: simp [IsLocalization.map_eq]
state_before: case a
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_3
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type u_4
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
I : Ideal R
x✝ : P'
⊢ x✝ ∈ (canonicalEquiv S P P') ↑I ↔ x✝ ∈ ↑I
state_after: no goals
Theorem: CategoryTheory.Limits.Concrete.cokernel_funext
File: Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean

tactic: ext x
state_before: C✝ : Type u
inst✝⁴ : Category.{v, u} C✝
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
inst✝¹ : ConcreteCategory C
M N K : C
f : M ⟶ N
inst✝ : HasCokernel f
g h : cokernel f ⟶ K
w : ∀ (n : (forget C).obj N), g ((cokernel.π f) n) = h ((cokernel.π f) n)
⊢ g = h
state_after: case h.w
C✝ : Type u
inst✝⁴ : Category.{v, u} C✝
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
inst✝¹ : ConcreteCategory C
M N K : C
f : M ⟶ N
inst✝ : HasCokernel f
g h : cokernel f ⟶ K
w : ∀ (n : (forget C).obj N), g ((cokernel.π f) n) = h ((cokernel.π f) n)
x : (forget C).obj N
⊢ (coequalizer.π f 0 ≫ g) x = (coequalizer.π f 0 ≫ h) x

tactic: simpa using w x
state_before: case h.w
C✝ : Type u
inst✝⁴ : Category.{v, u} C✝
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
inst✝¹ : ConcreteCategory C
M N K : C
f : M ⟶ N
inst✝ : HasCokernel f
g h : cokernel f ⟶ K
w : ∀ (n : (forget C).obj N), g ((cokernel.π f) n) = h ((cokernel.π f) n)
x : (forget C).obj N
⊢ (coequalizer.π f 0 ≫ g) x = (coequalizer.π f 0 ≫ h) x
state_after: no goals
Theorem: Module.Flat.auxRTensorBaseChange_eq
File: Mathlib/RingTheory/Flat/Stability.lean

tactic: ext
state_before: R : Type u
S : Type v
M : Type w
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal S
⊢ Module.Flat.auxRTensorBaseChange R S M I = rTensor (S ⊗[R] M) (Submodule.subtype I)
state_after: case a.h.a.h.h
R : Type u
S : Type v
M : Type w
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal S
x✝¹ : ↥I
x✝ : M
⊢ ((AlgebraTensorModule.curry ((AlgebraTensorModule.curry (Module.Flat.auxRTensorBaseChange R S M I)) x✝¹)) 1) x✝ =
    ((AlgebraTensorModule.curry ((AlgebraTensorModule.curry (rTensor (S ⊗[R] M) (Submodule.subtype I))) x✝¹)) 1) x✝

tactic: simp
state_before: case a.h.a.h.h
R : Type u
S : Type v
M : Type w
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal S
x✝¹ : ↥I
x✝ : M
⊢ ((AlgebraTensorModule.curry ((AlgebraTensorModule.curry (Module.Flat.auxRTensorBaseChange R S M I)) x✝¹)) 1) x✝ =
    ((AlgebraTensorModule.curry ((AlgebraTensorModule.curry (rTensor (S ⊗[R] M) (Submodule.subtype I))) x✝¹)) 1) x✝
state_after: no goals
Theorem: List.eraseIdx_append_of_lt_length
File: .lake/packages/batteries/Batteries/Data/List/EraseIdx.lean

tactic: rw [eraseIdx_eq_take_drop_succ, take_append_of_le_length, drop_append_of_le_length,
  eraseIdx_eq_take_drop_succ, append_assoc]
state_before: α : Type u
β : Type v
l : List α
k : Nat
hk : k < l.length
l' : List α
⊢ (l ++ l').eraseIdx k = l.eraseIdx k ++ l'
state_after: α : Type u
β : Type v
l : List α
k : Nat
hk : k < l.length
l' : List α
⊢ k + 1 ≤ l.length

α : Type u
β : Type v
l : List α
k : Nat
hk : k < l.length
l' : List α
⊢ k ≤ l.length

tactic: all_goals omega
state_before: α : Type u
β : Type v
l : List α
k : Nat
hk : k < l.length
l' : List α
⊢ k + 1 ≤ l.length

α : Type u
β : Type v
l : List α
k : Nat
hk : k < l.length
l' : List α
⊢ k ≤ l.length
state_after: no goals

tactic: omega
state_before: α : Type u
β : Type v
l : List α
k : Nat
hk : k < l.length
l' : List α
⊢ k ≤ l.length
state_after: no goals
Theorem: IsDedekindDomain.HeightOneSpectrum.int_valuation_le_pow_iff_dvd
File: Mathlib/RingTheory/DedekindDomain/AdicValuation.lean

tactic: rw [intValuationDef]
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
n : ℕ
⊢ v.intValuationDef r ≤ ↑(ofAdd (-↑n)) ↔ v.asIdeal ^ n ∣ Ideal.span {r}
state_after: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
n : ℕ
⊢ (if r = 0 then 0 else ↑(ofAdd (-↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {r})).factors)))) ≤
      ↑(ofAdd (-↑n)) ↔
    v.asIdeal ^ n ∣ Ideal.span {r}

tactic: split_ifs with hr
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
n : ℕ
⊢ (if r = 0 then 0 else ↑(ofAdd (-↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {r})).factors)))) ≤
      ↑(ofAdd (-↑n)) ↔
    v.asIdeal ^ n ∣ Ideal.span {r}
state_after: case pos
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
n : ℕ
hr : r = 0
⊢ 0 ≤ ↑(ofAdd (-↑n)) ↔ v.asIdeal ^ n ∣ Ideal.span {r}

case neg
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
n : ℕ
hr : ¬r = 0
⊢ ↑(ofAdd (-↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {r})).factors))) ≤ ↑(ofAdd (-↑n)) ↔
    v.asIdeal ^ n ∣ Ideal.span {r}

tactic: simp_rw [hr, Ideal.dvd_span_singleton, zero_le', Submodule.zero_mem]
state_before: case pos
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
n : ℕ
hr : r = 0
⊢ 0 ≤ ↑(ofAdd (-↑n)) ↔ v.asIdeal ^ n ∣ Ideal.span {r}
state_after: no goals

tactic: rw [WithZero.coe_le_coe, ofAdd_le, neg_le_neg_iff, Int.ofNat_le, Ideal.dvd_span_singleton, ←
  Associates.le_singleton_iff,
  Associates.prime_pow_dvd_iff_le (Associates.mk_ne_zero'.mpr hr)
    (by apply v.associates_irreducible)]
state_before: case neg
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
n : ℕ
hr : ¬r = 0
⊢ ↑(ofAdd (-↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {r})).factors))) ≤ ↑(ofAdd (-↑n)) ↔
    v.asIdeal ^ n ∣ Ideal.span {r}
state_after: no goals

tactic: apply v.associates_irreducible
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
n : ℕ
hr : ¬r = 0
⊢ Irreducible (Associates.mk v.asIdeal)
state_after: no goals
Theorem: Int.odd_pow
File: Mathlib/Algebra/Ring/Int.lean

tactic: rw [← not_iff_not, ← even_iff_not_odd, not_or, ← even_iff_not_odd, even_pow]
state_before: m n✝ : ℤ
n : ℕ
⊢ Odd (m ^ n) ↔ Odd m ∨ n = 0
state_after: no goals
Theorem: wbtw_rotate_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [wbtw_comm, wbtw_swap_right_iff, eq_comm]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y z : P
⊢ Wbtw R x y z ∧ Wbtw R z x y ↔ x = y
state_after: no goals
Theorem: sbtw_iff_right_ne_and_left_mem_image_Ioi
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [sbtw_comm, sbtw_iff_left_ne_and_right_mem_image_Ioi]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y z : P
⊢ Sbtw R x y z ↔ z ≠ y ∧ x ∈ ⇑(lineMap z y) '' Set.Ioi 1
state_after: no goals
Theorem: ContinuousLinearMap.comp_hasFiniteFPowerSeriesOnBall
File: Mathlib/Analysis/Analytic/CPolynomial.lean

tactic: rw [compFormalMultilinearSeries_apply, h.finite m hm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g✝ : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
n m✝ : ℕ
g : F →L[𝕜] G
h : HasFiniteFPowerSeriesOnBall f p x n r
m : ℕ
hm : n ≤ m
⊢ g.compFormalMultilinearSeries p m = 0
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g✝ : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
n m✝ : ℕ
g : F →L[𝕜] G
h : HasFiniteFPowerSeriesOnBall f p x n r
m : ℕ
hm : n ≤ m
⊢ g.compContinuousMultilinearMap 0 = 0

tactic: ext
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g✝ : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
n m✝ : ℕ
g : F →L[𝕜] G
h : HasFiniteFPowerSeriesOnBall f p x n r
m : ℕ
hm : n ≤ m
⊢ g.compContinuousMultilinearMap 0 = 0
state_after: case H
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g✝ : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
n m✝ : ℕ
g : F →L[𝕜] G
h : HasFiniteFPowerSeriesOnBall f p x n r
m : ℕ
hm : n ≤ m
x✝ : Fin m → E
⊢ (g.compContinuousMultilinearMap 0) x✝ = 0 x✝

tactic: exact map_zero g
state_before: case H
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g✝ : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
n m✝ : ℕ
g : F →L[𝕜] G
h : HasFiniteFPowerSeriesOnBall f p x n r
m : ℕ
hm : n ≤ m
x✝ : Fin m → E
⊢ (g.compContinuousMultilinearMap 0) x✝ = 0 x✝
state_after: no goals
Theorem: NumberField.mixedEmbedding.normAtPlace_smul
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean

tactic: rw [normAtPlace, MonoidWithZeroHom.coe_mk, ZeroHom.coe_mk]
state_before: K : Type u_1
inst✝ : Field K
w : InfinitePlace K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
c : ℝ
⊢ (normAtPlace w) (c • x) = |c| * (normAtPlace w) x
state_after: K : Type u_1
inst✝ : Field K
w : InfinitePlace K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
c : ℝ
⊢ (if hw : w.IsReal then ‖(c • x).1 ⟨w, hw⟩‖ else ‖(c • x).2 ⟨w, ⋯⟩‖) =
    |c| * if hw : w.IsReal then ‖x.1 ⟨w, hw⟩‖ else ‖x.2 ⟨w, ⋯⟩‖

tactic: split_ifs
state_before: K : Type u_1
inst✝ : Field K
w : InfinitePlace K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
c : ℝ
⊢ (if hw : w.IsReal then ‖(c • x).1 ⟨w, hw⟩‖ else ‖(c • x).2 ⟨w, ⋯⟩‖) =
    |c| * if hw : w.IsReal then ‖x.1 ⟨w, hw⟩‖ else ‖x.2 ⟨w, ⋯⟩‖
state_after: case pos
K : Type u_1
inst✝ : Field K
w : InfinitePlace K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
c : ℝ
h✝ : w.IsReal
⊢ ‖(c • x).1 ⟨w, h✝⟩‖ = |c| * ‖x.1 ⟨w, h✝⟩‖

case neg
K : Type u_1
inst✝ : Field K
w : InfinitePlace K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
c : ℝ
h✝ : ¬w.IsReal
⊢ ‖(c • x).2 ⟨w, ⋯⟩‖ = |c| * ‖x.2 ⟨w, ⋯⟩‖

tactic: rw [Prod.smul_fst, Pi.smul_apply, norm_smul, Real.norm_eq_abs]
state_before: case pos
K : Type u_1
inst✝ : Field K
w : InfinitePlace K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
c : ℝ
h✝ : w.IsReal
⊢ ‖(c • x).1 ⟨w, h✝⟩‖ = |c| * ‖x.1 ⟨w, h✝⟩‖
state_after: no goals

tactic: rw [Prod.smul_snd, Pi.smul_apply, norm_smul, Real.norm_eq_abs, Complex.norm_eq_abs]
state_before: case neg
K : Type u_1
inst✝ : Field K
w : InfinitePlace K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
c : ℝ
h✝ : ¬w.IsReal
⊢ ‖(c • x).2 ⟨w, ⋯⟩‖ = |c| * ‖x.2 ⟨w, ⋯⟩‖
state_after: no goals
Theorem: MeasureTheory.average_mem_openSegment_compl_self
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: simpa only [union_compl_self, restrict_univ] using
  average_union_mem_openSegment aedisjoint_compl_right hs.compl hs₀ hsc₀ (measure_ne_top _ _)
    (measure_ne_top _ _) hfi.integrableOn hfi.integrableOn
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ ν : Measure α
s✝ t : Set α
f✝ g : α → E
inst✝ : IsFiniteMeasure μ
f : α → E
s : Set α
hs : NullMeasurableSet s μ
hs₀ : μ s ≠ 0
hsc₀ : μ sᶜ ≠ 0
hfi : Integrable f μ
⊢ ⨍ (x : α), f x ∂μ ∈ openSegment ℝ (⨍ (x : α) in s, f x ∂μ) (⨍ (x : α) in sᶜ, f x ∂μ)
state_after: no goals
Theorem: CochainComplex.mappingCone.inl_v_descShortComplex_f
File: Mathlib/Algebra/Homology/HomotopyCategory/ShortExact.lean

tactic: simp [descShortComplex]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : ShortComplex (CochainComplex C ℤ)
hS : S.ShortExact
i j : ℤ
h : i + -1 = j
⊢ (inl S.f).v i j h ≫ (descShortComplex S).f j = 0
state_after: no goals