1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Real.cos_one_le
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp
state_before: ⊢ |1| ≤ 1
state_after: no goals

tactic: norm_num
state_before: ⊢ |1| ^ 4 * (5 / 96) + (1 - 1 ^ 2 / 2) ≤ 2 / 3
state_after: no goals
Theorem: WeierstrassCurve.map_b₈
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

tactic: simp only [b₈, map_a₁, map_a₂, map_a₃, map_a₄, map_a₆]
state_before: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ (W.map φ).b₈ = φ W.b₈
state_after: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ φ W.a₁ ^ 2 * φ W.a₆ + 4 * φ W.a₂ * φ W.a₆ - φ W.a₁ * φ W.a₃ * φ W.a₄ + φ W.a₂ * φ W.a₃ ^ 2 - φ W.a₄ ^ 2 =
    φ (W.a₁ ^ 2 * W.a₆ + 4 * W.a₂ * W.a₆ - W.a₁ * W.a₃ * W.a₄ + W.a₂ * W.a₃ ^ 2 - W.a₄ ^ 2)

tactic: map_simp
state_before: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ φ W.a₁ ^ 2 * φ W.a₆ + 4 * φ W.a₂ * φ W.a₆ - φ W.a₁ * φ W.a₃ * φ W.a₄ + φ W.a₂ * φ W.a₃ ^ 2 - φ W.a₄ ^ 2 =
    φ (W.a₁ ^ 2 * W.a₆ + 4 * W.a₂ * W.a₆ - W.a₁ * W.a₃ * W.a₄ + W.a₂ * W.a₃ ^ 2 - W.a₄ ^ 2)
state_after: no goals
Theorem: Sum.LiftRel.isRight_right
File: Mathlib/Data/Sum/Basic.lean

tactic: cases h
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
x : α ⊕ β
y : γ ⊕ δ
a : α
b : β
c : γ
d : δ
h : LiftRel r s (inr b) y
⊢ y.isRight = true
state_after: case inr
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
x : α ⊕ β
a : α
b : β
c : γ
d d✝ : δ
a✝ : s b d✝
⊢ (inr d✝).isRight = true

tactic: rfl
state_before: case inr
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
x : α ⊕ β
a : α
b : β
c : γ
d d✝ : δ
a✝ : s b d✝
⊢ (inr d✝).isRight = true
state_after: no goals
Theorem: MultilinearMap.map_sub
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: rw [sub_eq_add_neg, sub_eq_add_neg, MultilinearMap.map_add, map_neg]
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✝⁵ : Semiring R
inst✝⁴ : (i : ι) → AddCommGroup (M₁ i)
inst✝³ : AddCommGroup M₂
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f : MultilinearMap R M₁ M₂
inst✝ : DecidableEq ι
m : (i : ι) → M₁ i
i : ι
x y : M₁ i
⊢ f (update m i (x - y)) = f (update m i x) - f (update m i y)
state_after: no goals
Theorem: CoxeterSystem.length_alternatingWord
File: Mathlib/GroupTheory/Coxeter/Basic.lean

tactic: induction' m with m ih generalizing i i'
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
i i' : B
m : ℕ
⊢ (alternatingWord i i' m).length = m
state_after: case zero
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
i i' : B
⊢ (alternatingWord i i' 0).length = 0

case succ
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
m : ℕ
ih : ∀ (i i' : B), (alternatingWord i i' m).length = m
i i' : B
⊢ (alternatingWord i i' (m + 1)).length = m + 1

tactic: dsimp [alternatingWord]
state_before: case zero
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
i i' : B
⊢ (alternatingWord i i' 0).length = 0
state_after: no goals

tactic: simpa [alternatingWord] using ih i' i
state_before: case succ
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
m : ℕ
ih : ∀ (i i' : B), (alternatingWord i i' m).length = m
i i' : B
⊢ (alternatingWord i i' (m + 1)).length = m + 1
state_after: no goals
Theorem: Prod.counit_comp_inl
File: Mathlib/RingTheory/Coalgebra/Basic.lean

tactic: ext
state_before: R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : Module R A
inst✝² : Module R B
inst✝¹ : Coalgebra R A
inst✝ : Coalgebra R B
⊢ counit ∘ₗ inl R A B = counit
state_after: case h
R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : Module R A
inst✝² : Module R B
inst✝¹ : Coalgebra R A
inst✝ : Coalgebra R B
x✝ : A
⊢ (counit ∘ₗ inl R A B) x✝ = counit x✝

tactic: simp
state_before: case h
R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : Module R A
inst✝² : Module R B
inst✝¹ : Coalgebra R A
inst✝ : Coalgebra R B
x✝ : A
⊢ (counit ∘ₗ inl R A B) x✝ = counit x✝
state_after: no goals
Theorem: Vector.head_map
File: Mathlib/Data/Vector/Basic.lean

tactic: obtain ⟨a, v', h⟩ := Vector.exists_eq_cons v
state_before: n : ℕ
α : Type u_1
β : Type u_2
v : Vector α (n + 1)
f : α → β
⊢ (map f v).head = f v.head
state_after: case intro.intro
n : ℕ
α : Type u_1
β : Type u_2
v : Vector α (n + 1)
f : α → β
a : α
v' : Vector α n
h : v = a ::ᵥ v'
⊢ (map f v).head = f v.head

tactic: rw [h, map_cons, head_cons, head_cons]
state_before: case intro.intro
n : ℕ
α : Type u_1
β : Type u_2
v : Vector α (n + 1)
f : α → β
a : α
v' : Vector α n
h : v = a ::ᵥ v'
⊢ (map f v).head = f v.head
state_after: no goals
Theorem: Real.hasDerivAt_mul_log
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

tactic: rw [← deriv_mul_log hx, hasDerivAt_deriv_iff]
state_before: x : ℝ
hx : x ≠ 0
⊢ HasDerivAt (fun x => x * log x) (log x + 1) x
state_after: x : ℝ
hx : x ≠ 0
⊢ DifferentiableAt ℝ (fun x => x * log x) x

tactic: refine DifferentiableOn.differentiableAt differentiableOn_mul_log ?_
state_before: x : ℝ
hx : x ≠ 0
⊢ DifferentiableAt ℝ (fun x => x * log x) x
state_after: x : ℝ
hx : x ≠ 0
⊢ {0}ᶜ ∈ 𝓝 x

tactic: simp [hx]
state_before: x : ℝ
hx : x ≠ 0
⊢ {0}ᶜ ∈ 𝓝 x
state_after: no goals
Theorem: Convex.openSegment_closure_interior_subset_interior
File: Mathlib/Analysis/Convex/Topology.lean

tactic: rintro _ ⟨a, b, ha, hb, hab, rfl⟩
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousConstSMul 𝕜 E
s : Set E
hs : Convex 𝕜 s
x y : E
hx : x ∈ closure s
hy : y ∈ interior s
⊢ openSegment 𝕜 x y ⊆ interior s
state_after: case intro.intro.intro.intro.intro
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousConstSMul 𝕜 E
s : Set E
hs : Convex 𝕜 s
x y : E
hx : x ∈ closure s
hy : y ∈ interior s
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • x + b • y ∈ interior s

tactic: exact hs.combo_closure_interior_mem_interior hx hy ha.le hb hab
state_before: case intro.intro.intro.intro.intro
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousConstSMul 𝕜 E
s : Set E
hs : Convex 𝕜 s
x y : E
hx : x ∈ closure s
hy : y ∈ interior s
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • x + b • y ∈ interior s
state_after: no goals
Theorem: MeasureTheory.FiniteMeasure.testAgainstNN_zero
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: simpa only [zero_mul] using μ.testAgainstNN_const 0
state_before: Ω : Type u_1
inst✝⁵ : MeasurableSpace Ω
R : Type u_2
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : TopologicalSpace Ω
μ : FiniteMeasure Ω
⊢ μ.testAgainstNN 0 = 0
state_after: no goals
Theorem: DiscreteQuotient.comap_mono
File: Mathlib/Topology/DiscreteQuotient.lean

tactic: tauto
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
g : C(Y, Z)
f : C(X, Y)
A B : DiscreteQuotient Y
h : A ≤ B
⊢ comap f A ≤ comap f B
state_after: no goals
Theorem: map_le_nonZeroDivisors_of_injective
File: Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean

tactic: cases subsingleton_or_nontrivial M
state_before: M₀ : Type u_1
inst✝⁸ : MonoidWithZero M₀
M : Type u_2
M' : Type u_3
M₁ : Type u_4
R : Type u_5
R' : Type u_6
F : Type u_7
inst✝⁷ : MonoidWithZero M
inst✝⁶ : MonoidWithZero M'
inst✝⁵ : CommMonoidWithZero M₁
inst✝⁴ : Ring R
inst✝³ : CommRing R'
inst✝² : FunLike F M M'
inst✝¹ : NoZeroDivisors M'
inst✝ : MonoidWithZeroHomClass F M M'
f : F
hf : Function.Injective ⇑f
S : Submonoid M
hS : S ≤ M⁰
⊢ Submonoid.map f S ≤ M'⁰
state_after: case inl
M₀ : Type u_1
inst✝⁸ : MonoidWithZero M₀
M : Type u_2
M' : Type u_3
M₁ : Type u_4
R : Type u_5
R' : Type u_6
F : Type u_7
inst✝⁷ : MonoidWithZero M
inst✝⁶ : MonoidWithZero M'
inst✝⁵ : CommMonoidWithZero M₁
inst✝⁴ : Ring R
inst✝³ : CommRing R'
inst✝² : FunLike F M M'
inst✝¹ : NoZeroDivisors M'
inst✝ : MonoidWithZeroHomClass F M M'
f : F
hf : Function.Injective ⇑f
S : Submonoid M
hS : S ≤ M⁰
h✝ : Subsingleton M
⊢ Submonoid.map f S ≤ M'⁰

case inr
M₀ : Type u_1
inst✝⁸ : MonoidWithZero M₀
M : Type u_2
M' : Type u_3
M₁ : Type u_4
R : Type u_5
R' : Type u_6
F : Type u_7
inst✝⁷ : MonoidWithZero M
inst✝⁶ : MonoidWithZero M'
inst✝⁵ : CommMonoidWithZero M₁
inst✝⁴ : Ring R
inst✝³ : CommRing R'
inst✝² : FunLike F M M'
inst✝¹ : NoZeroDivisors M'
inst✝ : MonoidWithZeroHomClass F M M'
f : F
hf : Function.Injective ⇑f
S : Submonoid M
hS : S ≤ M⁰
h✝ : Nontrivial M
⊢ Submonoid.map f S ≤ M'⁰

tactic: simp [Subsingleton.elim S ⊥]
state_before: case inl
M₀ : Type u_1
inst✝⁸ : MonoidWithZero M₀
M : Type u_2
M' : Type u_3
M₁ : Type u_4
R : Type u_5
R' : Type u_6
F : Type u_7
inst✝⁷ : MonoidWithZero M
inst✝⁶ : MonoidWithZero M'
inst✝⁵ : CommMonoidWithZero M₁
inst✝⁴ : Ring R
inst✝³ : CommRing R'
inst✝² : FunLike F M M'
inst✝¹ : NoZeroDivisors M'
inst✝ : MonoidWithZeroHomClass F M M'
f : F
hf : Function.Injective ⇑f
S : Submonoid M
hS : S ≤ M⁰
h✝ : Subsingleton M
⊢ Submonoid.map f S ≤ M'⁰
state_after: no goals

tactic: exact le_nonZeroDivisors_of_noZeroDivisors fun h ↦
  let ⟨x, hx, hx0⟩ := h
  zero_ne_one (hS (hf (hx0.trans (map_zero f).symm) ▸ hx : 0 ∈ S) 1 (mul_zero 1)).symm
state_before: case inr
M₀ : Type u_1
inst✝⁸ : MonoidWithZero M₀
M : Type u_2
M' : Type u_3
M₁ : Type u_4
R : Type u_5
R' : Type u_6
F : Type u_7
inst✝⁷ : MonoidWithZero M
inst✝⁶ : MonoidWithZero M'
inst✝⁵ : CommMonoidWithZero M₁
inst✝⁴ : Ring R
inst✝³ : CommRing R'
inst✝² : FunLike F M M'
inst✝¹ : NoZeroDivisors M'
inst✝ : MonoidWithZeroHomClass F M M'
f : F
hf : Function.Injective ⇑f
S : Submonoid M
hS : S ≤ M⁰
h✝ : Nontrivial M
⊢ Submonoid.map f S ≤ M'⁰
state_after: no goals
Theorem: Complex.div_ofReal_re
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [div_ofReal]
state_before: z : ℂ
x : ℝ
⊢ (z / ↑x).re = z.re / x
state_after: no goals
Theorem: Filter.countableGenerate_isGreatest
File: Mathlib/Order/Filter/CountableInter.lean

tactic: refine ⟨⟨inferInstance, fun s => CountableGenerateSets.basic⟩, ?_⟩
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
⊢ IsGreatest {f | CountableInterFilter f ∧ g ⊆ f.sets} (countableGenerate g)
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
⊢ countableGenerate g ∈ upperBounds {f | CountableInterFilter f ∧ g ⊆ f.sets}

tactic: rintro f ⟨fct, hf⟩
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
⊢ countableGenerate g ∈ upperBounds {f | CountableInterFilter f ∧ g ⊆ f.sets}
state_after: case intro
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
f : Filter α
fct : CountableInterFilter f
hf : g ⊆ f.sets
⊢ f ≤ countableGenerate g

tactic: rwa [@le_countableGenerate_iff_of_countableInterFilter _ _ _ fct]
state_before: case intro
ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝ : CountableInterFilter l
g : Set (Set α)
f : Filter α
fct : CountableInterFilter f
hf : g ⊆ f.sets
⊢ f ≤ countableGenerate g
state_after: no goals
Theorem: Polynomial.units_coeff_zero_smul
File: Mathlib/Algebra/Polynomial/RingDivision.lean

tactic: rw [← Polynomial.C_mul', ← Polynomial.eq_C_of_degree_eq_zero (degree_coe_units c)]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q : R[X]
c : R[X]ˣ
p : R[X]
⊢ (↑c).coeff 0 • p = ↑c * p
state_after: no goals
Theorem: Set.preimage_const_mul_Icc_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simpa only [mul_comm] using preimage_mul_const_Icc_of_neg a b h
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : c < 0
⊢ (fun x => c * x) ⁻¹' Icc a b = Icc (b / c) (a / c)
state_after: no goals
Theorem: NNReal.closedBall_zero_eq_Icc'
File: Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
c : ℝ≥0
⊢ closedBall 0 ↑c = Icc 0 c
state_after: case h
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
c x : ℝ≥0
⊢ x ∈ closedBall 0 ↑c ↔ x ∈ Icc 0 c

tactic: simp
state_before: case h
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
c x : ℝ≥0
⊢ x ∈ closedBall 0 ↑c ↔ x ∈ Icc 0 c
state_after: no goals
Theorem: Primrec.list_head?
File: Mathlib/Computability/Primrec.lean

tactic: cases l <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
l : List α
⊢ (List.casesOn (id l) none fun b l_1 => some (l, b, l_1).2.1) = l.head?
state_after: no goals
Theorem: Nat.digits_def'
File: Mathlib/Data/Nat/Digits.lean

tactic: decide
state_before: n n✝ : ℕ
h : 1 < 0
⊢ ¬1 < 0
state_after: no goals

tactic: decide
state_before: n n✝ : ℕ
h : 1 < 1
⊢ ¬1 < 1
state_after: no goals

tactic: simp
state_before: n n✝ b : ℕ
x✝ : 1 < b + 2
⊢ 2 ≤ b + 2
state_after: no goals
Theorem: HasFPowerSeriesAt.eq_formalMultilinearSeries
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: simpa only [sub_self] using h₁.sub h₂
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
p₁ p₂ : FormalMultilinearSeries 𝕜 𝕜 E
f : 𝕜 → E
x : 𝕜
h₁ : HasFPowerSeriesAt f p₁ x
h₂ : HasFPowerSeriesAt f p₂ x
⊢ HasFPowerSeriesAt 0 (p₁ - p₂) ?m.1102091
state_after: no goals
Theorem: summable_geometric_iff_norm_lt_one
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: refine ⟨fun h ↦ ?_, summable_geometric_of_norm_lt_one⟩
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
⊢ (Summable fun n => ξ ^ n) ↔ ‖ξ‖ < 1
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : Summable fun n => ξ ^ n
⊢ ‖ξ‖ < 1

tactic: obtain ⟨k : ℕ, hk : dist (ξ ^ k) 0 < 1⟩ :=
  (h.tendsto_cofinite_zero.eventually (ball_mem_nhds _ zero_lt_one)).exists
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : Summable fun n => ξ ^ n
⊢ ‖ξ‖ < 1
state_after: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : Summable fun n => ξ ^ n
k : ℕ
hk : dist (ξ ^ k) 0 < 1
⊢ ‖ξ‖ < 1

tactic: simp only [norm_pow, dist_zero_right] at hk
state_before: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : Summable fun n => ξ ^ n
k : ℕ
hk : dist (ξ ^ k) 0 < 1
⊢ ‖ξ‖ < 1
state_after: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : Summable fun n => ξ ^ n
k : ℕ
hk : ‖ξ‖ ^ k < 1
⊢ ‖ξ‖ < 1

tactic: rw [← one_pow k] at hk
state_before: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : Summable fun n => ξ ^ n
k : ℕ
hk : ‖ξ‖ ^ k < 1
⊢ ‖ξ‖ < 1
state_after: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : Summable fun n => ξ ^ n
k : ℕ
hk : ‖ξ‖ ^ k < 1 ^ k
⊢ ‖ξ‖ < 1

tactic: exact lt_of_pow_lt_pow_left _ zero_le_one hk
state_before: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : Summable fun n => ξ ^ n
k : ℕ
hk : ‖ξ‖ ^ k < 1 ^ k
⊢ ‖ξ‖ < 1
state_after: no goals
Theorem: SimpleGraph.complete_graph_degree
File: Mathlib/Combinatorics/SimpleGraph/Finite.lean

tactic: erw [degree, neighborFinset_eq_filter, filter_ne, card_erase_of_mem (mem_univ v), card_univ]
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableEq V
v : V
⊢ ⊤.degree v = Fintype.card V - 1
state_after: no goals
Theorem: Order.Ideal.eq_sup_of_le_sup
File: Mathlib/Order/Ideal.lean

tactic: refine ⟨x ⊓ i, I.lower inf_le_right hi, x ⊓ j, J.lower inf_le_right hj, ?_⟩
state_before: P : Type u_1
inst✝ : DistribLattice P
I J : Ideal P
x i j : P
hi : i ∈ I
hj : j ∈ J
hx : x ≤ i ⊔ j
⊢ ∃ i' ∈ I, ∃ j' ∈ J, x = i' ⊔ j'
state_after: P : Type u_1
inst✝ : DistribLattice P
I J : Ideal P
x i j : P
hi : i ∈ I
hj : j ∈ J
hx : x ≤ i ⊔ j
⊢ x = x ⊓ i ⊔ x ⊓ j

tactic: calc
  x = x ⊓ (i ⊔ j) := left_eq_inf.mpr hx
  _ = x ⊓ i ⊔ x ⊓ j := inf_sup_left _ _ _
state_before: P : Type u_1
inst✝ : DistribLattice P
I J : Ideal P
x i j : P
hi : i ∈ I
hj : j ∈ J
hx : x ≤ i ⊔ j
⊢ x = x ⊓ i ⊔ x ⊓ j
state_after: no goals
Theorem: Fin.tail_update_succ
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: ext j
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
⊢ tail (update q i.succ y) = update (tail q) i y
state_after: case h
m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
j : Fin n
⊢ tail (update q i.succ y) j = update (tail q) i y j

tactic: by_cases h : j = i
state_before: case h
m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
j : Fin n
⊢ tail (update q i.succ y) j = update (tail q) i y j
state_after: case pos
m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
j : Fin n
h : j = i
⊢ tail (update q i.succ y) j = update (tail q) i y j

case neg
m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
j : Fin n
h : ¬j = i
⊢ tail (update q i.succ y) j = update (tail q) i y j

tactic: rw [h]
state_before: case pos
m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
j : Fin n
h : j = i
⊢ tail (update q i.succ y) j = update (tail q) i y j
state_after: case pos
m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
j : Fin n
h : j = i
⊢ tail (update q i.succ y) i = update (tail q) i y i

tactic: simp [tail]
state_before: case pos
m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
j : Fin n
h : j = i
⊢ tail (update q i.succ y) i = update (tail q) i y i
state_after: no goals

tactic: simp [tail, (Fin.succ_injective n).ne h, h]
state_before: case neg
m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
j : Fin n
h : ¬j = i
⊢ tail (update q i.succ y) j = update (tail q) i y j
state_after: no goals
Theorem: List.Nodup.isCycleOn_formPerm
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: refine ⟨l.formPerm.bijOn fun _ => List.formPerm_mem_iff_mem, fun a ha b hb => ?_⟩
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
⊢ l.formPerm.IsCycleOn {a | a ∈ l}
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : a ∈ {a | a ∈ l}
b : α
hb : b ∈ {a | a ∈ l}
⊢ l.formPerm.SameCycle a b

tactic: rw [Set.mem_setOf, ← List.indexOf_lt_length] at ha hb
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : a ∈ {a | a ∈ l}
b : α
hb : b ∈ {a | a ∈ l}
⊢ l.formPerm.SameCycle a b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ l.formPerm.SameCycle a b

tactic: rw [← List.indexOf_get ha, ← List.indexOf_get hb]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ l.formPerm.SameCycle a b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ l.formPerm.SameCycle (l.get ⟨indexOf a l, ha⟩) (l.get ⟨indexOf b l, hb⟩)

tactic: refine ⟨l.indexOf b - l.indexOf a, ?_⟩
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ l.formPerm.SameCycle (l.get ⟨indexOf a l, ha⟩) (l.get ⟨indexOf b l, hb⟩)
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ (l.formPerm ^ (↑(indexOf b l) - ↑(indexOf a l))) (l.get ⟨indexOf a l, ha⟩) = l.get ⟨indexOf b l, hb⟩

tactic: simp only [sub_eq_neg_add, zpow_add, zpow_neg, Equiv.Perm.inv_eq_iff_eq, zpow_natCast,
  Equiv.Perm.coe_mul, List.formPerm_pow_apply_get _ h, Function.comp]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ (l.formPerm ^ (↑(indexOf b l) - ↑(indexOf a l))) (l.get ⟨indexOf a l, ha⟩) = l.get ⟨indexOf b l, hb⟩
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ l.get ⟨(indexOf a l + indexOf b l) % l.length, ⋯⟩ = l.get ⟨(indexOf b l + indexOf a l) % l.length, ⋯⟩

tactic: rw [add_comm]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ l.get ⟨(indexOf a l + indexOf b l) % l.length, ⋯⟩ = l.get ⟨(indexOf b l + indexOf a l) % l.length, ⋯⟩
state_after: no goals